
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 1f 01 00 	mov    0x11fed(%rip),%rax        # 412ff8 <__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 1f 01 00    	pushq  0x11fe2(%rip)        # 413008 <_GLOBAL_OFFSET_TABLE_+0x8>
  401026:	ff 25 e4 1f 01 00    	jmpq   *0x11fe4(%rip)        # 413010 <_GLOBAL_OFFSET_TABLE_+0x10>
  40102c:	0f 1f 40 00          	nopl   0x0(%rax)

0000000000401030 <printf@plt>:
  401030:	ff 25 e2 1f 01 00    	jmpq   *0x11fe2(%rip)        # 413018 <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 1f 01 00    	jmpq   *0x11fda(%rip)        # 413020 <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 1f 01 00    	jmpq   *0x11fd2(%rip)        # 413028 <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 1f 01 00    	jmpq   *0x11fca(%rip)        # 413030 <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 1f 01 00    	jmpq   *0x11fc2(%rip)        # 413038 <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 1f 01 00    	jmpq   *0x11fba(%rip)        # 413040 <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 1f 01 00    	jmpq   *0x11fb2(%rip)        # 413048 <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 1f 01 00    	jmpq   *0x11faa(%rip)        # 413050 <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 1f 01 00    	jmpq   *0x11fa2(%rip)        # 413058 <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 1f 01 00    	jmpq   *0x11f9a(%rip)        # 413060 <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 1f 01 00    	jmpq   *0x11f92(%rip)        # 413068 <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 1f 01 00    	jmpq   *0x11f8a(%rip)        # 413070 <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 1f 01 00    	jmpq   *0x11f82(%rip)        # 413078 <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 1f 01 00    	jmpq   *0x11f7a(%rip)        # 413080 <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 1f 01 00    	jmpq   *0x11f72(%rip)        # 413088 <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 1f 01 00    	jmpq   *0x11f6a(%rip)        # 413090 <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 1f 01 00    	jmpq   *0x11f62(%rip)        # 413098 <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 1f 01 00    	jmpq   *0x11f5a(%rip)        # 4130a0 <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 1f 01 00    	jmpq   *0x11f52(%rip)        # 4130a8 <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 1f 01 00    	jmpq   *0x11f4a(%rip)        # 4130b0 <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 1f 01 00    	jmpq   *0x11f42(%rip)        # 4130b8 <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 9a 02 00 00    	jle    401423 <main+0x2a3>
{
  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:	49 89 f7             	mov    %rsi,%r15
  401197:	41 56                	push   %r14
  401199:	41 55                	push   %r13
  40119b:	41 54                	push   %r12
  40119d:	41 89 fc             	mov    %edi,%r12d
  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 7f 10          	mov    0x10(%r15),%rdi
  4011b4:	31 f6                	xor    %esi,%esi
  4011b6:	ba 0a 00 00 00       	mov    $0xa,%edx
  4011bb:	49 89 c5             	mov    %rax,%r13
  4011be:	e8 7d fe ff ff       	callq  401040 <strtoll@plt>
  4011c3:	49 8b 7f 18          	mov    0x18(%r15),%rdi
  4011c7:	31 f6                	xor    %esi,%esi
  4011c9:	ba 0a 00 00 00       	mov    $0xa,%edx
  4011ce:	48 89 c3             	mov    %rax,%rbx
  4011d1:	e8 6a 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)
  4011d6:	48 85 c0             	test   %rax,%rax
  4011d9:	0f 8e 1d 02 00 00    	jle    4013fc <main+0x27c>
    int arg = par__arg;
#else
    arg = par__arg;
#endif
    next_board_num = par__next_board_num;
    past_end_board = 1 + par__end_board;
  4011df:	48 83 c3 01          	add    $0x1,%rbx
    next_board_num_lock = initial_mutex_constant;
  4011e3:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  4011e7:	48 c7 05 8e 1f 01 00 	movq   $0x0,0x11f8e(%rip)        # 413180 <next_board_num_lock+0x20>
  4011ee:	00 00 00 00 
  4011f2:	c5 f8 29 05 66 1f 01 	vmovaps %xmm0,0x11f66(%rip)        # 413160 <next_board_num_lock>
  4011f9:	00 
  4011fa:	c5 f8 29 05 6e 1f 01 	vmovaps %xmm0,0x11f6e(%rip)        # 413170 <next_board_num_lock+0x10>
  401201:	00 
    total_num_iters_lock = initial_mutex_constant;
  401202:	c5 f8 29 05 16 1f 01 	vmovaps %xmm0,0x11f16(%rip)        # 413120 <total_num_iters_lock>
  401209:	00 
  40120a:	c5 f8 29 05 1e 1f 01 	vmovaps %xmm0,0x11f1e(%rip)        # 413130 <total_num_iters_lock+0x10>
  401211:	00 
  401212:	48 c7 05 23 1f 01 00 	movq   $0x0,0x11f23(%rip)        # 413140 <total_num_iters_lock+0x20>
  401219:	00 00 00 00 
    next_board_num = par__next_board_num;
  40121d:	4c 89 2d 2c 1f 01 00 	mov    %r13,0x11f2c(%rip)        # 413150 <next_board_num>
    past_end_board = 1 + par__end_board;
  401224:	48 89 1d 1d 1f 01 00 	mov    %rbx,0x11f1d(%rip)        # 413148 <past_end_board>
    stop_at = par__stop_at;
  40122b:	48 89 05 ce 1e 01 00 	mov    %rax,0x11ece(%rip)        # 413100 <stop_at>

    size_t num_workers = 3;
    for (; arg < argc; ++arg)
  401232:	41 83 fc 04          	cmp    $0x4,%r12d
  401236:	0f 84 8a 01 00 00    	je     4013c6 <main+0x246>
    int arg = par__arg;
  40123c:	bb 04 00 00 00       	mov    $0x4,%ebx
    size_t num_workers = 3;
  401241:	41 bd 03 00 00 00    	mov    $0x3,%r13d
  401247:	41 be 7e f1 40 00    	mov    $0x40f17e,%r14d
  40124d:	eb 1f                	jmp    40126e <main+0xee>
  40124f:	90                   	nop
  return strtol (__nptr, (char **) NULL, 10);
  401250:	ba 0a 00 00 00       	mov    $0xa,%edx
  401255:	31 f6                	xor    %esi,%esi
  401257:	48 89 c7             	mov    %rax,%rdi
  40125a:	e8 d1 fe ff ff       	callq  401130 <strtol@plt>
    for (; arg < argc; ++arg)
  40125f:	83 c3 01             	add    $0x1,%ebx
  401262:	49 89 c5             	mov    %rax,%r13
  401265:	41 39 dc             	cmp    %ebx,%r12d
  401268:	0f 8e 82 00 00 00    	jle    4012f0 <main+0x170>
#include "fcs_err.h"

static const char *try_argv_param(
    const int argc, char **const argv, int *const arg, const char *const flag)
{
    if (!strcmp(argv[*arg], flag))
  40126e:	48 63 c3             	movslq %ebx,%rax
  401271:	b9 0e 00 00 00       	mov    $0xe,%ecx
  401276:	4c 89 f7             	mov    %r14,%rdi
  401279:	4c 8d 04 c5 00 00 00 	lea    0x0(,%rax,8),%r8
  401280:	00 
  401281:	49 8b 04 c7          	mov    (%r15,%rax,8),%rax
  401285:	48 89 c6             	mov    %rax,%rsi
  401288:	f3 a6                	repz cmpsb %es:(%rdi),%ds:(%rsi)
  40128a:	75 16                	jne    4012a2 <main+0x122>
    {
        if (++(*arg) == argc)
  40128c:	83 c3 01             	add    $0x1,%ebx
  40128f:	41 39 dc             	cmp    %ebx,%r12d
  401292:	0f 84 7a 01 00 00    	je     401412 <main+0x292>
        {
            fc_solve_err("%s came without an argument!\n", flag);
        }
        return argv[*arg];
  401298:	4b 8b 44 07 08       	mov    0x8(%r15,%r8,1),%rax
    {
        const char *param;
        if ((param = TRY_P("--num-workers")))
  40129d:	48 85 c0             	test   %rax,%rax
  4012a0:	75 ae                	jne    401250 <main+0xd0>
    if (!strcmp(argv[*arg], flag))
  4012a2:	bf aa f1 40 00       	mov    $0x40f1aa,%edi
  4012a7:	b9 0e 00 00 00       	mov    $0xe,%ecx
  4012ac:	48 89 c6             	mov    %rax,%rsi
  4012af:	f3 a6                	repz cmpsb %es:(%rdi),%ds:(%rsi)
  4012b1:	75 3d                	jne    4012f0 <main+0x170>
        if (++(*arg) == argc)
  4012b3:	83 c3 01             	add    $0x1,%ebx
  4012b6:	41 39 dc             	cmp    %ebx,%r12d
  4012b9:	0f 84 68 01 00 00    	je     401427 <main+0x2a7>
        return argv[*arg];
  4012bf:	48 63 c3             	movslq %ebx,%rax
  4012c2:	49 8b 3c c7          	mov    (%r15,%rax,8),%rdi
        {
            num_workers = (size_t)atol(param);
        }
        else if ((param = TRY_P("--worker-step")))
  4012c6:	48 85 ff             	test   %rdi,%rdi
  4012c9:	74 25                	je     4012f0 <main+0x170>
  return strtoll (__nptr, (char **) NULL, 10);
  4012cb:	ba 0a 00 00 00       	mov    $0xa,%edx
  4012d0:	31 f6                	xor    %esi,%esi
    for (; arg < argc; ++arg)
  4012d2:	83 c3 01             	add    $0x1,%ebx
  4012d5:	e8 66 fd ff ff       	callq  401040 <strtoll@plt>
        {
            board_num_step = atoll(param);
  4012da:	48 89 05 ef 1d 01 00 	mov    %rax,0x11def(%rip)        # 4130d0 <board_num_step>
    for (; arg < argc; ++arg)
  4012e1:	41 39 dc             	cmp    %ebx,%r12d
  4012e4:	7f 88                	jg     40126e <main+0xee>
  4012e6:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  4012ed:	00 00 00 
#endif

static inline fcs_portable_time fcs_get_time(void)
{
    fcs_portable_time ret;
    FCS_GET_TIME(ret);
  4012f0:	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];
  4012f4:	49 89 e7             	mov    %rsp,%r15
  4012f7:	48 8d 70 10          	lea    0x10(%rax),%rsi
  4012fb:	48 89 c7             	mov    %rax,%rdi
  4012fe:	e8 5d 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),
  401303:	48 8b 55 b8          	mov    -0x48(%rbp),%rdx
  401307:	bf b8 f1 40 00       	mov    $0x40f1b8,%edi
  40130c:	31 c0                	xor    %eax,%eax
  40130e:	48 8b 75 b0          	mov    -0x50(%rbp),%rsi
  401312:	e8 19 fd ff ff       	callq  401030 <printf@plt>
  401317:	4a 8d 04 ed 16 00 00 	lea    0x16(,%r13,8),%rax
  40131e:	00 
  40131f:	48 83 e0 f0          	and    $0xfffffffffffffff0,%rax
  401323:	48 29 c4             	sub    %rax,%rsp
  401326:	49 89 e6             	mov    %rsp,%r14
    for (size_t idx = 0; idx < num_workers; ++idx)
  401329:	4d 85 ed             	test   %r13,%r13
  40132c:	74 56                	je     401384 <main+0x204>
  40132e:	4d 89 f4             	mov    %r14,%r12
    pthread_t workers[num_workers];
  401331:	31 db                	xor    %ebx,%ebx
  401333:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40133a:	00 00 00 00 
  40133e:	66 90                	xchg   %ax,%ax
    {
        const int check =
  401340:	31 c9                	xor    %ecx,%ecx
  401342:	31 f6                	xor    %esi,%esi
  401344:	ba 80 db 40 00       	mov    $0x40db80,%edx
  401349:	4c 89 e7             	mov    %r12,%rdi
  40134c:	e8 5f fd ff ff       	callq  4010b0 <pthread_create@plt>
            pthread_create(&workers[idx], NULL, worker_thread, NULL);
        if (check)
  401351:	85 c0                	test   %eax,%eax
  401353:	0f 85 a8 00 00 00    	jne    401401 <main+0x281>
    for (size_t idx = 0; idx < num_workers; ++idx)
  401359:	48 83 c3 01          	add    $0x1,%rbx
  40135d:	49 83 c4 08          	add    $0x8,%r12
  401361:	4c 39 eb             	cmp    %r13,%rbx
  401364:	72 da                	jb     401340 <main+0x1c0>
                (unsigned long)idx, check);
        }
    }

    // Wait for all threads to finish.
    for (size_t idx = 0; idx < num_workers; ++idx)
  401366:	31 db                	xor    %ebx,%ebx
  401368:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40136f:	00 
    {
        pthread_join(workers[idx], NULL);
  401370:	49 8b 3c de          	mov    (%r14,%rbx,8),%rdi
  401374:	31 f6                	xor    %esi,%esi
    for (size_t idx = 0; idx < num_workers; ++idx)
  401376:	48 83 c3 01          	add    $0x1,%rbx
        pthread_join(workers[idx], NULL);
  40137a:	e8 11 fd ff ff       	callq  401090 <pthread_join@plt>
    for (size_t idx = 0; idx < num_workers; ++idx)
  40137f:	4c 39 eb             	cmp    %r13,%rbx
  401382:	72 ec                	jb     401370 <main+0x1f0>
    FCS_GET_TIME(ret);
  401384:	48 8d 45 90          	lea    -0x70(%rbp),%rax
    }
    fc_solve_print_finished(total_num_iters);
  401388:	48 8b 1d 79 1d 01 00 	mov    0x11d79(%rip),%rbx        # 413108 <total_num_iters>
  40138f:	48 8d 70 10          	lea    0x10(%rax),%rsi
  401393:	48 89 c7             	mov    %rax,%rdi
  401396:	e8 c5 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"),
  40139b:	48 8b 55 98          	mov    -0x68(%rbp),%rdx
  40139f:	bf a8 f2 40 00       	mov    $0x40f2a8,%edi
  4013a4:	31 c0                	xor    %eax,%eax
  4013a6:	48 8b 75 90          	mov    -0x70(%rbp),%rsi
  4013aa:	48 89 d9             	mov    %rbx,%rcx
  4013ad:	e8 7e 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(
  4013b2:	31 c0                	xor    %eax,%eax
  4013b4:	4c 89 fc             	mov    %r15,%rsp
        argc, argv, arg, next_board_num, end_board, stop_at);
}
  4013b7:	48 8d 65 d8          	lea    -0x28(%rbp),%rsp
  4013bb:	5b                   	pop    %rbx
  4013bc:	41 5c                	pop    %r12
  4013be:	41 5d                	pop    %r13
  4013c0:	41 5e                	pop    %r14
  4013c2:	41 5f                	pop    %r15
  4013c4:	5d                   	pop    %rbp
  4013c5:	c3                   	retq   
    FCS_GET_TIME(ret);
  4013c6:	48 8d 45 b0          	lea    -0x50(%rbp),%rax
    pthread_t workers[num_workers];
  4013ca:	49 89 e7             	mov    %rsp,%r15
    size_t num_workers = 3;
  4013cd:	41 bd 03 00 00 00    	mov    $0x3,%r13d
  4013d3:	48 8d 70 10          	lea    0x10(%rax),%rsi
  4013d7:	48 89 c7             	mov    %rax,%rdi
  4013da:	e8 81 fd ff ff       	callq  401160 <gettimeofday@plt>
    printf("Started at " FCS_T_FMT "\n", FCS_TIME_GET_SEC(mytime),
  4013df:	48 8b 55 b8          	mov    -0x48(%rbp),%rdx
  4013e3:	bf b8 f1 40 00       	mov    $0x40f1b8,%edi
  4013e8:	31 c0                	xor    %eax,%eax
  4013ea:	48 8b 75 b0          	mov    -0x50(%rbp),%rsi
    pthread_t workers[num_workers];
  4013ee:	4c 8d 75 b0          	lea    -0x50(%rbp),%r14
  4013f2:	e8 39 fc ff ff       	callq  401030 <printf@plt>
  4013f7:	e9 32 ff ff ff       	jmpq   40132e <main+0x1ae>
        return -1;
  4013fc:	83 c8 ff             	or     $0xffffffff,%eax
  4013ff:	eb b6                	jmp    4013b7 <main+0x237>
            fc_solve_err(
  401401:	89 c2                	mov    %eax,%edx
  401403:	48 89 de             	mov    %rbx,%rsi
  401406:	bf 68 f2 40 00       	mov    $0x40f268,%edi
  40140b:	31 c0                	xor    %eax,%eax
  40140d:	e8 4e da 00 00       	callq  40ee60 <fc_solve_err>
            fc_solve_err("%s came without an argument!\n", flag);
  401412:	be 7e f1 40 00       	mov    $0x40f17e,%esi
  401417:	bf 8c f1 40 00       	mov    $0x40f18c,%edi
  40141c:	31 c0                	xor    %eax,%eax
  40141e:	e8 3d da 00 00       	callq  40ee60 <fc_solve_err>
  401423:	83 c8 ff             	or     $0xffffffff,%eax
}
  401426:	c3                   	retq   
  401427:	be aa f1 40 00       	mov    $0x40f1aa,%esi
  40142c:	bf 8c f1 40 00       	mov    $0x40f18c,%edi
  401431:	31 c0                	xor    %eax,%eax
  401433:	e8 28 da 00 00       	callq  40ee60 <fc_solve_err>
  401438:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40143f:	00 

0000000000401440 <_start>:
  401440:	31 ed                	xor    %ebp,%ebp
  401442:	49 89 d1             	mov    %rdx,%r9
  401445:	5e                   	pop    %rsi
  401446:	48 89 e2             	mov    %rsp,%rdx
  401449:	48 83 e4 f0          	and    $0xfffffffffffffff0,%rsp
  40144d:	50                   	push   %rax
  40144e:	54                   	push   %rsp
  40144f:	49 c7 c0 70 ef 40 00 	mov    $0x40ef70,%r8
  401456:	48 c7 c1 10 ef 40 00 	mov    $0x40ef10,%rcx
  40145d:	48 c7 c7 80 11 40 00 	mov    $0x401180,%rdi
  401464:	ff 15 86 1b 01 00    	callq  *0x11b86(%rip)        # 412ff0 <__libc_start_main@GLIBC_2.2.5>
  40146a:	f4                   	hlt    
  40146b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)

0000000000401470 <deregister_tm_clones>:
  401470:	55                   	push   %rbp
  401471:	b8 d8 30 41 00       	mov    $0x4130d8,%eax
  401476:	48 3d d8 30 41 00    	cmp    $0x4130d8,%rax
  40147c:	48 89 e5             	mov    %rsp,%rbp
  40147f:	74 17                	je     401498 <deregister_tm_clones+0x28>
  401481:	b8 00 00 00 00       	mov    $0x0,%eax
  401486:	48 85 c0             	test   %rax,%rax
  401489:	74 0d                	je     401498 <deregister_tm_clones+0x28>
  40148b:	5d                   	pop    %rbp
  40148c:	bf d8 30 41 00       	mov    $0x4130d8,%edi
  401491:	ff e0                	jmpq   *%rax
  401493:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
  401498:	5d                   	pop    %rbp
  401499:	c3                   	retq   
  40149a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)

00000000004014a0 <register_tm_clones>:
  4014a0:	be d8 30 41 00       	mov    $0x4130d8,%esi
  4014a5:	55                   	push   %rbp
  4014a6:	48 81 ee d8 30 41 00 	sub    $0x4130d8,%rsi
  4014ad:	48 89 e5             	mov    %rsp,%rbp
  4014b0:	48 c1 fe 03          	sar    $0x3,%rsi
  4014b4:	48 89 f0             	mov    %rsi,%rax
  4014b7:	48 c1 e8 3f          	shr    $0x3f,%rax
  4014bb:	48 01 c6             	add    %rax,%rsi
  4014be:	48 d1 fe             	sar    %rsi
  4014c1:	74 15                	je     4014d8 <register_tm_clones+0x38>
  4014c3:	b8 00 00 00 00       	mov    $0x0,%eax
  4014c8:	48 85 c0             	test   %rax,%rax
  4014cb:	74 0b                	je     4014d8 <register_tm_clones+0x38>
  4014cd:	5d                   	pop    %rbp
  4014ce:	bf d8 30 41 00       	mov    $0x4130d8,%edi
  4014d3:	ff e0                	jmpq   *%rax
  4014d5:	0f 1f 00             	nopl   (%rax)
  4014d8:	5d                   	pop    %rbp
  4014d9:	c3                   	retq   
  4014da:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)

00000000004014e0 <__do_global_dtors_aux>:
  4014e0:	80 3d 01 1c 01 00 00 	cmpb   $0x0,0x11c01(%rip)        # 4130e8 <completed.6972>
  4014e7:	75 17                	jne    401500 <__do_global_dtors_aux+0x20>
  4014e9:	55                   	push   %rbp
  4014ea:	48 89 e5             	mov    %rsp,%rbp
  4014ed:	e8 7e ff ff ff       	callq  401470 <deregister_tm_clones>
  4014f2:	c6 05 ef 1b 01 00 01 	movb   $0x1,0x11bef(%rip)        # 4130e8 <completed.6972>
  4014f9:	5d                   	pop    %rbp
  4014fa:	c3                   	retq   
  4014fb:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
  401500:	f3 c3                	repz retq 
  401502:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  401509:	00 00 00 00 
  40150d:	0f 1f 00             	nopl   (%rax)

0000000000401510 <frame_dummy>:
  401510:	55                   	push   %rbp
  401511:	48 89 e5             	mov    %rsp,%rbp
  401514:	5d                   	pop    %rbp
  401515:	eb 89                	jmp    4014a0 <register_tm_clones>
  401517:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40151e:	00 00 

0000000000401520 <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)
{
  401520:	41 57                	push   %r15
  401522:	41 56                	push   %r14
  401524:	41 55                	push   %r13
  401526:	41 54                	push   %r12
  401528:	55                   	push   %rbp
  401529:	53                   	push   %rbx
  40152a:	48 83 ec 18          	sub    $0x18,%rsp
    if (HT_INSTANCE(hard_thread)->next_soft_thread_id == MAX_NUM_SCANS)
  40152e:	83 bf 48 05 00 00 20 	cmpl   $0x20,0x548(%rdi)
  401535:	0f 84 d5 01 00 00    	je     401710 <fc_solve_new_soft_thread+0x1f0>
    {
        return NULL;
    }

    HT_FIELD(hard_thread, soft_threads) =
        SREALLOC(HT_FIELD(hard_thread, soft_threads),
  40153b:	48 8b 87 20 05 00 00 	mov    0x520(%rdi),%rax
  401542:	48 89 fb             	mov    %rdi,%rbx
  401545:	48 8b bf c0 00 00 00 	mov    0xc0(%rdi),%rdi
  40154c:	48 83 c0 01          	add    $0x1,%rax
  401550:	48 89 c6             	mov    %rax,%rsi
  401553:	48 c1 e6 06          	shl    $0x6,%rsi
  401557:	48 29 c6             	sub    %rax,%rsi
  40155a:	48 c1 e6 03          	shl    $0x3,%rsi
  40155e:	e8 0d fc 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)++])));
  401563:	48 8b 8b 20 05 00 00 	mov    0x520(%rbx),%rcx
                    SMALLOC1(soft_thread->by_depth_moves_order.by_depth_moves),
  40156a:	bf 18 00 00 00       	mov    $0x18,%edi
        .id = (HT_INSTANCE(hard_thread)->next_soft_thread_id)++,
  40156f:	44 8b a3 48 05 00 00 	mov    0x548(%rbx),%r12d
    HT_FIELD(hard_thread, soft_threads) =
  401576:	48 89 83 c0 00 00 00 	mov    %rax,0xc0(%rbx)
             soft_threads)[HT_FIELD(hard_thread, num_soft_threads)++])));
  40157d:	48 8d 51 01          	lea    0x1(%rcx),%rdx
  401581:	48 89 93 20 05 00 00 	mov    %rdx,0x520(%rbx)
  401588:	48 89 ca             	mov    %rcx,%rdx
  40158b:	48 c1 e2 06          	shl    $0x6,%rdx
  40158f:	48 29 ca             	sub    %rcx,%rdx
        (ret = &(HT_FIELD(hard_thread,
  401592:	48 8d 2c d0          	lea    (%rax,%rdx,8),%rbp
        .id = (HT_INSTANCE(hard_thread)->next_soft_thread_id)++,
  401596:	41 8d 44 24 01       	lea    0x1(%r12),%eax
  40159b:	89 83 48 05 00 00    	mov    %eax,0x548(%rbx)
                    SMALLOC1(soft_thread->by_depth_moves_order.by_depth_moves),
  4015a1:	e8 4a fb ff ff       	callq  4010f0 <malloc@plt>
    *soft_thread = (fcs_soft_thread){
  4015a6:	b9 3f 00 00 00       	mov    $0x3f,%ecx
  4015ab:	48 89 ef             	mov    %rbp,%rdi
                    SMALLOC1(soft_thread->by_depth_moves_order.by_depth_moves),
  4015ae:	49 89 c6             	mov    %rax,%r14
    *soft_thread = (fcs_soft_thread){
  4015b1:	31 c0                	xor    %eax,%eax
  4015b3:	f3 48 ab             	rep stos %rax,%es:(%rdi)
  4015b6:	48 8b 05 03 f7 00 00 	mov    0xf703(%rip),%rax        # 410cc0 <fc_solve_is_parent_buf+0xe00>
  4015bd:	48 c7 45 10 01 00 00 	movq   $0x1,0x10(%rbp)
  4015c4:	00 
  4015c5:	44 89 65 08          	mov    %r12d,0x8(%rbp)
  4015c9:	48 89 5d 00          	mov    %rbx,0x0(%rbp)
  4015cd:	4c 89 75 18          	mov    %r14,0x18(%rbp)
  4015d1:	48 89 85 a8 01 00 00 	mov    %rax,0x1a8(%rbp)
  4015d8:	48 8b 05 e9 f6 00 00 	mov    0xf6e9(%rip),%rax        # 410cc8 <fc_solve_is_parent_buf+0xe08>
  4015df:	c7 45 48 18 00 00 00 	movl   $0x18,0x48(%rbp)
  4015e6:	48 c7 85 e8 01 00 00 	movq   $0x32,0x1e8(%rbp)
  4015ed:	32 00 00 00 
  4015f1:	48 89 85 b8 01 00 00 	mov    %rax,0x1b8(%rbp)
  4015f8:	48 8b 05 d1 f6 00 00 	mov    0xf6d1(%rip),%rax        # 410cd0 <fc_solve_is_parent_buf+0xe10>
  4015ff:	48 89 85 c8 01 00 00 	mov    %rax,0x1c8(%rbp)
extern void fc_solve_free_soft_thread_by_depth_move_array(
    fcs_soft_thread *const soft_thread);

static inline fcs_moves_order moves_order_dup(fcs_moves_order *const orig)
{
    const_SLOT(num, orig);
  401606:	48 8b 83 30 05 00 00 	mov    0x530(%rbx),%rax
    fcs_moves_order ret = (fcs_moves_order){.num = num,
        .groups = memdup(orig->groups,
  40160d:	48 8b 9b 38 05 00 00 	mov    0x538(%rbx),%rbx
            sizeof(orig->groups[0]) *
                ((num & (~(MOVES_GROW_BY - 1))) + MOVES_GROW_BY))};
  401614:	49 89 c4             	mov    %rax,%r12
    const_SLOT(num, orig);
  401617:	48 89 44 24 08       	mov    %rax,0x8(%rsp)
                ((num & (~(MOVES_GROW_BY - 1))) + MOVES_GROW_BY))};
  40161c:	49 83 e4 f0          	and    $0xfffffffffffffff0,%r12
        .groups = memdup(orig->groups,
  401620:	4d 69 e4 e8 00 00 00 	imul   $0xe8,%r12,%r12
  401627:	49 81 c4 80 0e 00 00 	add    $0xe80,%r12
    void *const dest = malloc(my_size);
  40162e:	4c 89 e7             	mov    %r12,%rdi
  401631:	e8 ba fa ff ff       	callq  4010f0 <malloc@plt>
  401636:	49 89 c5             	mov    %rax,%r13
    if (dest == NULL)
  401639:	48 85 c0             	test   %rax,%rax
  40163c:	74 0e                	je     40164c <fc_solve_new_soft_thread+0x12c>
    memcpy(dest, src, my_size);
  40163e:	4c 89 e2             	mov    %r12,%rdx
  401641:	48 89 de             	mov    %rbx,%rsi
  401644:	48 89 c7             	mov    %rax,%rdi
  401647:	e8 94 fa ff ff       	callq  4010e0 <memcpy@plt>

    for (size_t i = 0; i < num; ++i)
  40164c:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
  401651:	48 85 c0             	test   %rax,%rax
  401654:	74 5c                	je     4016b2 <fc_solve_new_soft_thread+0x192>
  401656:	4c 69 e0 e8 00 00 00 	imul   $0xe8,%rax,%r12
  40165d:	4c 89 eb             	mov    %r13,%rbx
  401660:	4b 8d 04 2c          	lea    (%r12,%r13,1),%rax
  401664:	48 89 04 24          	mov    %rax,(%rsp)
  401668:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40166f:	00 
    {
        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));
  401670:	48 8b 43 08          	mov    0x8(%rbx),%rax
        ret.groups[i].move_funcs = memdup(ret.groups[i].move_funcs,
  401674:	4c 8b 3b             	mov    (%rbx),%r15
                ((ret.groups[i].num & (~(MOVES_GROW_BY - 1))) + MOVES_GROW_BY));
  401677:	48 83 e0 f0          	and    $0xfffffffffffffff0,%rax
        ret.groups[i].move_funcs = memdup(ret.groups[i].move_funcs,
  40167b:	4c 8d 24 c5 80 00 00 	lea    0x80(,%rax,8),%r12
  401682:	00 
    void *const dest = malloc(my_size);
  401683:	4c 89 e7             	mov    %r12,%rdi
  401686:	e8 65 fa ff ff       	callq  4010f0 <malloc@plt>
    if (dest == NULL)
  40168b:	48 85 c0             	test   %rax,%rax
  40168e:	74 60                	je     4016f0 <fc_solve_new_soft_thread+0x1d0>
    memcpy(dest, src, my_size);
  401690:	4c 89 e2             	mov    %r12,%rdx
  401693:	4c 89 fe             	mov    %r15,%rsi
  401696:	48 89 c7             	mov    %rax,%rdi
  401699:	e8 42 fa ff ff       	callq  4010e0 <memcpy@plt>
  40169e:	48 81 c3 e8 00 00 00 	add    $0xe8,%rbx
        ret.groups[i].move_funcs = memdup(ret.groups[i].move_funcs,
  4016a5:	48 89 83 18 ff ff ff 	mov    %rax,-0xe8(%rbx)
    for (size_t i = 0; i < num; ++i)
  4016ac:	48 3b 1c 24          	cmp    (%rsp),%rbx
  4016b0:	75 be                	jne    401670 <fc_solve_new_soft_thread+0x150>
    soft_thread->by_depth_moves_order.by_depth_moves[0] =
  4016b2:	48 b8 ff ff ff ff ff 	movabs $0x7fffffffffffffff,%rax
  4016b9:	ff ff 7f 
  4016bc:	4d 89 6e 10          	mov    %r13,0x10(%r14)
  4016c0:	49 89 06             	mov    %rax,(%r14)
  4016c3:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
  4016c8:	49 89 46 08          	mov    %rax,0x8(%r14)
}

static inline void fc_solve_reset_soft_thread(
    fcs_soft_thread *const soft_thread)
{
    STRUCT_CLEAR_FLAG(soft_thread, FCS_SOFT_THREAD_IS_FINISHED);
  4016cc:	c6 85 e0 01 00 00 00 	movb   $0x0,0x1e0(%rbp)
    STRUCT_CLEAR_FLAG(soft_thread, FCS_SOFT_THREAD_INITIALIZED);
  4016d3:	c6 85 e1 01 00 00 00 	movb   $0x0,0x1e1(%rbp)

    return ret;
}
  4016da:	48 83 c4 18          	add    $0x18,%rsp
  4016de:	48 89 e8             	mov    %rbp,%rax
  4016e1:	5b                   	pop    %rbx
  4016e2:	5d                   	pop    %rbp
  4016e3:	41 5c                	pop    %r12
  4016e5:	41 5d                	pop    %r13
  4016e7:	41 5e                	pop    %r14
  4016e9:	41 5f                	pop    %r15
  4016eb:	c3                   	retq   
  4016ec:	0f 1f 40 00          	nopl   0x0(%rax)
        ret.groups[i].move_funcs = memdup(ret.groups[i].move_funcs,
  4016f0:	48 c7 03 00 00 00 00 	movq   $0x0,(%rbx)
  4016f7:	48 81 c3 e8 00 00 00 	add    $0xe8,%rbx
    for (size_t i = 0; i < num; ++i)
  4016fe:	48 39 1c 24          	cmp    %rbx,(%rsp)
  401702:	0f 85 68 ff ff ff    	jne    401670 <fc_solve_new_soft_thread+0x150>
  401708:	eb a8                	jmp    4016b2 <fc_solve_new_soft_thread+0x192>
  40170a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
        return NULL;
  401710:	31 ed                	xor    %ebp,%ebp
  401712:	eb c6                	jmp    4016da <fc_solve_new_soft_thread+0x1ba>
  401714:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40171b:	00 00 00 00 
  40171f:	90                   	nop

0000000000401720 <fc_solve_finish_instance>:
{
  401720:	41 57                	push   %r15
  401722:	49 89 ff             	mov    %rdi,%r15
  401725:	41 56                	push   %r14
  401727:	41 55                	push   %r13
  401729:	41 54                	push   %r12
  40172b:	55                   	push   %rbp
  40172c:	53                   	push   %rbx
  40172d:	48 83 ec 18          	sub    $0x18,%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;
  401731:	49 8b 57 38          	mov    0x38(%r15),%rdx
    meta_allocator *const meta = allocator->meta;
  401735:	48 8b 7f 58          	mov    0x58(%rdi),%rdi
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  401739:	48 8b 02             	mov    (%rdx),%rax
    var_AUTO(bin, meta->recycle_bin);
  40173c:	48 8b 37             	mov    (%rdi),%rsi
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40173f:	48 85 c0             	test   %rax,%rax
  401742:	75 12                	jne    401756 <fc_solve_finish_instance+0x36>
  401744:	e9 95 01 00 00       	jmpq   4018de <fc_solve_finish_instance+0x1be>
  401749:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
  401750:	48 89 c2             	mov    %rax,%rdx
  401753:	48 89 c8             	mov    %rcx,%rax
         iter = iter_next, iter_next = OLD_LIST_NEXT(iter))
    {
        OLD_LIST_NEXT(iter) = bin;
  401756:	48 89 32             	mov    %rsi,(%rdx)
         iter = iter_next, iter_next = OLD_LIST_NEXT(iter))
  401759:	48 8b 08             	mov    (%rax),%rcx
  40175c:	48 89 d6             	mov    %rdx,%rsi
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40175f:	48 85 c9             	test   %rcx,%rcx
  401762:	75 ec                	jne    401750 <fc_solve_finish_instance+0x30>
        bin = iter;
    }

    OLD_LIST_NEXT(iter) = bin;
  401764:	48 89 10             	mov    %rdx,(%rax)
    meta->recycle_bin = iter;
  401767:	48 89 07             	mov    %rax,(%rdi)
}

static inline void fc_solve_hash_free(hash_table *const hash)
{
    fc_solve_compact_allocator_finish(&(hash->allocator));
    free(hash->entries);
  40176a:	49 8b 7f 10          	mov    0x10(%r15),%rdi
  40176e:	e8 dd f8 ff ff       	callq  401050 <free@plt>
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  401773:	49 8b 97 88 00 00 00 	mov    0x88(%r15),%rdx
    hash->entries = NULL;
  40177a:	49 c7 47 10 00 00 00 	movq   $0x0,0x10(%r15)
  401781:	00 
    meta_allocator *const meta = allocator->meta;
  401782:	49 8b bf a8 00 00 00 	mov    0xa8(%r15),%rdi
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  401789:	48 8b 02             	mov    (%rdx),%rax
    var_AUTO(bin, meta->recycle_bin);
  40178c:	48 8b 37             	mov    (%rdi),%rsi
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40178f:	48 85 c0             	test   %rax,%rax
  401792:	75 12                	jne    4017a6 <fc_solve_finish_instance+0x86>
  401794:	e9 50 01 00 00       	jmpq   4018e9 <fc_solve_finish_instance+0x1c9>
  401799:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
  4017a0:	48 89 c2             	mov    %rax,%rdx
  4017a3:	48 89 c8             	mov    %rcx,%rax
        OLD_LIST_NEXT(iter) = bin;
  4017a6:	48 89 32             	mov    %rsi,(%rdx)
         iter = iter_next, iter_next = OLD_LIST_NEXT(iter))
  4017a9:	48 8b 08             	mov    (%rax),%rcx
  4017ac:	48 89 d6             	mov    %rdx,%rsi
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  4017af:	48 85 c9             	test   %rcx,%rcx
  4017b2:	75 ec                	jne    4017a0 <fc_solve_finish_instance+0x80>
    OLD_LIST_NEXT(iter) = bin;
  4017b4:	48 89 10             	mov    %rdx,(%rax)
    meta->recycle_bin = iter;
  4017b7:	48 89 07             	mov    %rax,(%rdi)
    free(hash->entries);
  4017ba:	49 8b 7f 60          	mov    0x60(%r15),%rdi
  4017be:	e8 8d f8 ff ff       	callq  401050 <free@plt>
    const int_fast32_t num_soft_threads =
  4017c3:	49 8b 87 20 05 00 00 	mov    0x520(%r15),%rax
    hash->entries = NULL;
  4017ca:	49 c7 47 60 00 00 00 	movq   $0x0,0x60(%r15)
  4017d1:	00 
  4017d2:	48 89 44 24 08       	mov    %rax,0x8(%rsp)
        if (st_idx < num_soft_threads)
  4017d7:	48 85 c0             	test   %rax,%rax
  4017da:	0f 8e ef 00 00 00    	jle    4018cf <fc_solve_finish_instance+0x1af>
    for (int_fast32_t st_idx = 0; st_idx <= num_soft_threads; ++st_idx)
  4017e0:	48 c7 04 24 00 00 00 	movq   $0x0,(%rsp)
  4017e7:	00 
  4017e8:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  4017ef:	00 
            soft_thread = &(instance->hard_thread.soft_threads[st_idx]);
  4017f0:	48 8b 34 24          	mov    (%rsp),%rsi
  4017f4:	49 8b 97 c0 00 00 00 	mov    0xc0(%r15),%rdx
  4017fb:	48 89 f0             	mov    %rsi,%rax
  4017fe:	48 c1 e0 06          	shl    $0x6,%rax
  401802:	48 29 f0             	sub    %rsi,%rax
  401805:	4c 8d 34 c2          	lea    (%rdx,%rax,8),%r14
    fcs_soft_dfs_stack_item *const soft_dfs_info =
  401809:	4d 8b 66 30          	mov    0x30(%r14),%r12
    if (!soft_dfs_info)
  40180d:	4d 85 e4             	test   %r12,%r12
  401810:	0f 84 a5 00 00 00    	je     4018bb <fc_solve_finish_instance+0x19b>
        info_ptr + DFS_VAR(soft_thread, depth);
  401816:	49 8b 46 38          	mov    0x38(%r14),%rax
    for (; info_ptr < max_info_ptr; ++info_ptr)
  40181a:	4d 89 e5             	mov    %r12,%r13
        info_ptr + DFS_VAR(soft_thread, depth);
  40181d:	48 8d 14 80          	lea    (%rax,%rax,4),%rdx
  401821:	48 8d 2c 50          	lea    (%rax,%rdx,2),%rbp
        info_ptr + DFS_VAR(soft_thread, dfs_max_depth);
  401825:	49 8b 46 28          	mov    0x28(%r14),%rax
        info_ptr + DFS_VAR(soft_thread, depth);
  401829:	48 c1 e5 04          	shl    $0x4,%rbp
    const fcs_soft_dfs_stack_item *const max_info_ptr =
  40182d:	4c 01 e5             	add    %r12,%rbp
        info_ptr + DFS_VAR(soft_thread, dfs_max_depth);
  401830:	48 8d 14 80          	lea    (%rax,%rax,4),%rdx
  401834:	48 8d 1c 50          	lea    (%rax,%rdx,2),%rbx
  401838:	48 c1 e3 04          	shl    $0x4,%rbx
    const fcs_soft_dfs_stack_item *const dfs_max_info_ptr =
  40183c:	4c 01 e3             	add    %r12,%rbx
    for (; info_ptr < max_info_ptr; ++info_ptr)
  40183f:	49 39 ec             	cmp    %rbp,%r12
  401842:	73 2a                	jae    40186e <fc_solve_finish_instance+0x14e>
  401844:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40184b:	00 00 00 00 
  40184f:	90                   	nop
        free(info_ptr->derived_states_list.states);
  401850:	49 8b 7d 10          	mov    0x10(%r13),%rdi
    for (; info_ptr < max_info_ptr; ++info_ptr)
  401854:	49 81 c5 b0 00 00 00 	add    $0xb0,%r13
        free(info_ptr->derived_states_list.states);
  40185b:	e8 f0 f7 ff ff       	callq  401050 <free@plt>
        free(info_ptr->derived_states_random_indexes);
  401860:	49 8b 7d 88          	mov    -0x78(%r13),%rdi
  401864:	e8 e7 f7 ff ff       	callq  401050 <free@plt>
    for (; info_ptr < max_info_ptr; ++info_ptr)
  401869:	4c 39 ed             	cmp    %r13,%rbp
  40186c:	77 e2                	ja     401850 <fc_solve_finish_instance+0x130>
    for (; info_ptr < dfs_max_info_ptr; ++info_ptr)
  40186e:	49 39 dd             	cmp    %rbx,%r13
  401871:	73 30                	jae    4018a3 <fc_solve_finish_instance+0x183>
  401873:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40187a:	00 00 00 00 
  40187e:	66 90                	xchg   %ax,%ax
        if (likely(info_ptr->derived_states_list.states))
  401880:	49 8b 7d 10          	mov    0x10(%r13),%rdi
  401884:	48 85 ff             	test   %rdi,%rdi
  401887:	74 0e                	je     401897 <fc_solve_finish_instance+0x177>
            free(info_ptr->derived_states_list.states);
  401889:	e8 c2 f7 ff ff       	callq  401050 <free@plt>
            free(info_ptr->derived_states_random_indexes);
  40188e:	49 8b 7d 38          	mov    0x38(%r13),%rdi
  401892:	e8 b9 f7 ff ff       	callq  401050 <free@plt>
    for (; info_ptr < dfs_max_info_ptr; ++info_ptr)
  401897:	49 81 c5 b0 00 00 00 	add    $0xb0,%r13
  40189e:	4c 39 eb             	cmp    %r13,%rbx
  4018a1:	77 dd                	ja     401880 <fc_solve_finish_instance+0x160>
    free(soft_dfs_info);
  4018a3:	4c 89 e7             	mov    %r12,%rdi
  4018a6:	e8 a5 f7 ff ff       	callq  401050 <free@plt>
    DFS_VAR(soft_thread, soft_dfs_info) = NULL;
  4018ab:	49 c7 46 30 00 00 00 	movq   $0x0,0x30(%r14)
  4018b2:	00 
    DFS_VAR(soft_thread, dfs_max_depth) = 0;
  4018b3:	49 c7 46 28 00 00 00 	movq   $0x0,0x28(%r14)
  4018ba:	00 
    for (int_fast32_t st_idx = 0; st_idx <= num_soft_threads; ++st_idx)
  4018bb:	48 83 04 24 01       	addq   $0x1,(%rsp)
  4018c0:	48 8b 04 24          	mov    (%rsp),%rax
        if (st_idx < num_soft_threads)
  4018c4:	48 39 44 24 08       	cmp    %rax,0x8(%rsp)
  4018c9:	0f 85 21 ff ff ff    	jne    4017f0 <fc_solve_finish_instance+0xd0>
}
  4018cf:	48 83 c4 18          	add    $0x18,%rsp
  4018d3:	5b                   	pop    %rbx
  4018d4:	5d                   	pop    %rbp
  4018d5:	41 5c                	pop    %r12
  4018d7:	41 5d                	pop    %r13
  4018d9:	41 5e                	pop    %r14
  4018db:	41 5f                	pop    %r15
  4018dd:	c3                   	retq   
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  4018de:	48 89 d0             	mov    %rdx,%rax
    var_AUTO(bin, meta->recycle_bin);
  4018e1:	48 89 f2             	mov    %rsi,%rdx
  4018e4:	e9 7b fe ff ff       	jmpq   401764 <fc_solve_finish_instance+0x44>
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  4018e9:	48 89 d0             	mov    %rdx,%rax
    var_AUTO(bin, meta->recycle_bin);
  4018ec:	48 89 f2             	mov    %rsi,%rdx
  4018ef:	e9 c0 fe ff ff       	jmpq   4017b4 <fc_solve_finish_instance+0x94>
  4018f4:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4018fb:	00 00 00 00 
  4018ff:	90                   	nop

0000000000401900 <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))
{
  401900:	53                   	push   %rbx
  401901:	48 89 fb             	mov    %rdi,%rbx
  401904:	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)))
  401908:	48 8b bf b0 00 00 00 	mov    0xb0(%rdi),%rdi
  40190f:	48 85 ff             	test   %rdi,%rdi
    if ((HT_FIELD(hard_thread, allocated_from_list) =
  401912:	0f 95 83 18 05 00 00 	setne  0x518(%rbx)
  401919:	0f 85 a1 00 00 00    	jne    4019c0 <fc_solve_sfs_check_state_begin+0xc0>
    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)
  40191f:	48 8b bb e8 00 00 00 	mov    0xe8(%rbx),%rdi
  401926:	48 8b 83 e0 00 00 00 	mov    0xe0(%rbx),%rax
  40192d:	48 29 f8             	sub    %rdi,%rax
  401930:	48 83 f8 5f          	cmp    $0x5f,%rax
  401934:	0f 86 96 00 00 00    	jbe    4019d0 <fc_solve_sfs_check_state_begin+0xd0>
    {
        fc_solve_compact_allocator_extend(allocator);
    }
    else
    {
        allocator->rollback_ptr = allocator->ptr;
  40193a:	48 89 bb f0 00 00 00 	mov    %rdi,0xf0(%rbx)
    }
    allocator->ptr += how_much;
  401941:	48 8d 47 60          	lea    0x60(%rdi),%rax
  401945:	48 89 83 e8 00 00 00 	mov    %rax,0xe8(%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);
  40194c:	c5 fa 6f 02          	vmovdqu (%rdx),%xmm0
} fcs_kv_state;

static inline fcs_kv_state FCS_STATE_keyval_pair_to_kv(
    fcs_state_keyval_pair *const s)
{
    return (const fcs_kv_state){.key = &(s->s), .val = &(s->info)};
  401950:	48 8d 47 48          	lea    0x48(%rdi),%rax
}

static inline void FCS_STATE_collectible_to_kv(
    fcs_kv_state *const ret, fcs_collectible_state *const s)
{
    *ret = FCS_STATE_keyval_pair_to_kv(s);
  401954:	48 89 3e             	mov    %rdi,(%rsi)
    return (const fcs_kv_state){.key = &(s->s), .val = &(s->info)};
  401957:	48 89 46 08          	mov    %rax,0x8(%rsi)
  40195b:	c5 f8 11 07          	vmovups %xmm0,(%rdi)
  40195f:	c5 fa 6f 42 10       	vmovdqu 0x10(%rdx),%xmm0
  401964:	c5 f8 11 47 10       	vmovups %xmm0,0x10(%rdi)
  401969:	c5 fa 6f 42 20       	vmovdqu 0x20(%rdx),%xmm0
  40196e:	c5 f8 11 47 20       	vmovups %xmm0,0x20(%rdi)
  401973:	c5 fa 6f 42 30       	vmovdqu 0x30(%rdx),%xmm0
  401978:	c5 f8 11 47 30       	vmovups %xmm0,0x30(%rdi)
  40197d:	48 8b 42 40          	mov    0x40(%rdx),%rax
  401981:	c5 fa 6f 01          	vmovdqu (%rcx),%xmm0
  401985:	c5 f8 11 47 48       	vmovups %xmm0,0x48(%rdi)
  40198a:	48 89 47 40          	mov    %rax,0x40(%rdi)
  40198e:	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))++;
  401992:	83 47 50 01          	addl   $0x1,0x50(%rdi)
    FCS_S_PARENT(raw_ptr_new_state) = INFO_STATE_PTR(&raw_state_raw);
  401996:	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;
  40199a:	c6 47 56 00          	movb   $0x0,0x56(%rdi)
    fcs_duplicate_kv_state(out_new_state_out, &raw_state_raw);
  40199e:	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;
  4019a2:	31 c0                	xor    %eax,%eax
  4019a4:	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;
}
  4019a8:	31 c0                	xor    %eax,%eax
    fcs_duplicate_kv_state(out_new_state_out, &raw_state_raw);
  4019aa:	c7 47 5c 00 00 00 00 	movl   $0x0,0x5c(%rdi)
    memset(&(FCS_S_SCAN_VISITED(raw_ptr_new_state)), '\0',
  4019b1:	c7 47 57 00 00 00 00 	movl   $0x0,0x57(%rdi)
}
  4019b8:	48 83 c4 20          	add    $0x20,%rsp
  4019bc:	5b                   	pop    %rbx
  4019bd:	c3                   	retq   
  4019be:	66 90                	xchg   %ax,%ax
            FCS_S_NEXT(instance->list_of_vacant_states);
  4019c0:	48 8b 47 48          	mov    0x48(%rdi),%rax
        instance->list_of_vacant_states =
  4019c4:	48 89 83 b0 00 00 00 	mov    %rax,0xb0(%rbx)
  4019cb:	e9 7c ff ff ff       	jmpq   40194c <fc_solve_sfs_check_state_begin+0x4c>
    char *const new_data = meta_request_new_buffer(allocator->meta);
  4019d0:	48 8b bb f8 00 00 00 	mov    0xf8(%rbx),%rdi
    char *const ret = meta_alloc->recycle_bin;
  4019d7:	48 8b 07             	mov    (%rdi),%rax
    if (ret)
  4019da:	48 85 c0             	test   %rax,%rax
  4019dd:	74 41                	je     401a20 <fc_solve_sfs_check_state_begin+0x120>
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  4019df:	4c 8b 00             	mov    (%rax),%r8
  4019e2:	4c 89 07             	mov    %r8,(%rdi)
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  4019e5:	48 8b bb d8 00 00 00 	mov    0xd8(%rbx),%rdi
  4019ec:	48 89 38             	mov    %rdi,(%rax)
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  4019ef:	48 8d 78 08          	lea    0x8(%rax),%rdi
    allocator->old_list = new_data;
  4019f3:	48 89 83 d8 00 00 00 	mov    %rax,0xd8(%rbx)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  4019fa:	48 05 80 fe 00 00    	add    $0xfe80,%rax
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  401a00:	48 89 bb f0 00 00 00 	mov    %rdi,0xf0(%rbx)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  401a07:	48 89 83 e0 00 00 00 	mov    %rax,0xe0(%rbx)
  401a0e:	e9 2e ff ff ff       	jmpq   401941 <fc_solve_sfs_check_state_begin+0x41>
  401a13:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  401a1a:	00 00 00 00 
  401a1e:	66 90                	xchg   %ax,%ax
        return malloc(ALLOCED_SIZE);
  401a20:	bf 80 fe 00 00       	mov    $0xfe80,%edi
  401a25:	48 89 4c 24 18       	mov    %rcx,0x18(%rsp)
  401a2a:	48 89 54 24 10       	mov    %rdx,0x10(%rsp)
  401a2f:	48 89 74 24 08       	mov    %rsi,0x8(%rsp)
  401a34:	e8 b7 f6 ff ff       	callq  4010f0 <malloc@plt>
  401a39:	48 8b 4c 24 18       	mov    0x18(%rsp),%rcx
  401a3e:	48 8b 54 24 10       	mov    0x10(%rsp),%rdx
  401a43:	48 8b 74 24 08       	mov    0x8(%rsp),%rsi
  401a48:	eb 9b                	jmp    4019e5 <fc_solve_sfs_check_state_begin+0xe5>
  401a4a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)

0000000000401a50 <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)
{
  401a50:	41 57                	push   %r15
  401a52:	49 89 ff             	mov    %rdi,%r15
  401a55:	41 56                	push   %r14
    fcs_cards_column *current_stack = new_state_key->columns;
  401a57:	45 31 f6             	xor    %r14d,%r14d
{
  401a5a:	41 55                	push   %r13
        h64 = XXH_rotl64(h64, 11) * PRIME64_1;
        p++;
    }

    h64 ^= h64 >> 33;
    h64 *= PRIME64_2;
  401a5c:	49 bd 4f eb d4 27 3d 	movabs $0xc2b2ae3d27d4eb4f,%r13
  401a63:	ae b2 c2 
  401a66:	41 54                	push   %r12
  401a68:	55                   	push   %rbp
        h64 = XXH_rotl64(h64, 11) * PRIME64_1;
  401a69:	48 bd 87 ca eb 85 b1 	movabs $0x9e3779b185ebca87,%rbp
  401a70:	79 37 9e 
  401a73:	53                   	push   %rbx
  401a74:	48 83 ec 48          	sub    $0x48,%rsp
    register fcs_state *const new_state_key = new_state->key;
  401a78:	48 8b 1e             	mov    (%rsi),%rbx
    register fcs_state_extra_info *const new_state_info = new_state->val;
  401a7b:	48 8b 46 08          	mov    0x8(%rsi),%rax
{
  401a7f:	48 89 74 24 30       	mov    %rsi,0x30(%rsp)
  401a84:	48 89 54 24 38       	mov    %rdx,0x38(%rsp)
    register fcs_state *const new_state_key = new_state->key;
  401a89:	48 89 5c 24 08       	mov    %rbx,0x8(%rsp)
    register fcs_state_extra_info *const new_state_info = new_state->val;
  401a8e:	48 89 44 24 10       	mov    %rax,0x10(%rsp)
  401a93:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  401a9a:	00 00 00 00 
  401a9e:	66 90                	xchg   %ax,%ax
        if (!(new_state_info->stacks_copy_on_write_flags & (1 << i)))
  401aa0:	48 8b 44 24 10       	mov    0x10(%rsp),%rax
  401aa5:	8b 40 14             	mov    0x14(%rax),%eax
  401aa8:	44 0f a3 f0          	bt     %r14d,%eax
  401aac:	0f 83 47 03 00 00    	jae    401df9 <fc_solve_check_and_add_state+0x3a9>
        var_AUTO(column, fcs_state_get_col(*(new_state_key), i));
  401ab2:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
    if ((size_t)(allocator->max_ptr - allocator->ptr) < how_much)
  401ab7:	49 8b 97 e8 00 00 00 	mov    0xe8(%r15),%rdx
  401abe:	4a 8b 34 f0          	mov    (%rax,%r14,8),%rsi
  401ac2:	49 8b 87 e0 00 00 00 	mov    0xe0(%r15),%rax
        const int col_len = (fcs_col_len(column) + 1);
  401ac9:	0f be 1e             	movsbl (%rsi),%ebx
  401acc:	48 29 d0             	sub    %rdx,%rax
  401acf:	83 c3 01             	add    $0x1,%ebx
            (char *)fcs_compact_alloc_ptr(stacks_allocator, col_len);
  401ad2:	48 63 db             	movslq %ebx,%rbx
        ((sizeof(char *) - ((how_much_proto) & (sizeof(char *) - 1))) &
  401ad5:	49 89 dc             	mov    %rbx,%r12
  401ad8:	49 f7 dc             	neg    %r12
  401adb:	41 83 e4 07          	and    $0x7,%r12d
    const size_t how_much =
  401adf:	49 01 dc             	add    %rbx,%r12
    if ((size_t)(allocator->max_ptr - allocator->ptr) < how_much)
  401ae2:	49 39 c4             	cmp    %rax,%r12
  401ae5:	0f 87 c2 08 00 00    	ja     4023ad <fc_solve_check_and_add_state+0x95d>
        allocator->rollback_ptr = allocator->ptr;
  401aeb:	49 89 97 f0 00 00 00 	mov    %rdx,0xf0(%r15)
    allocator->ptr += how_much;
  401af2:	49 01 d4             	add    %rdx,%r12
  401af5:	4d 89 a7 e8 00 00 00 	mov    %r12,0xe8(%r15)
        memcpy(new_ptr, column, col_len);
  401afc:	48 83 fb 08          	cmp    $0x8,%rbx
  401b00:	0f 83 8a 08 00 00    	jae    402390 <fc_solve_check_and_add_state+0x940>
  401b06:	f6 c3 04             	test   $0x4,%bl
  401b09:	0f 85 51 0b 00 00    	jne    402660 <fc_solve_check_and_add_state+0xc10>
  401b0f:	48 85 db             	test   %rbx,%rbx
  401b12:	74 0e                	je     401b22 <fc_solve_check_and_add_state+0xd2>
  401b14:	0f b6 06             	movzbl (%rsi),%eax
  401b17:	88 02                	mov    %al,(%rdx)
  401b19:	f6 c3 02             	test   $0x2,%bl
  401b1c:	0f 85 59 0b 00 00    	jne    40267b <fc_solve_check_and_add_state+0xc2b>
        *(current_stack) = new_ptr;
  401b22:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
    const BYTE* bEnd = p + len;
  401b27:	4c 8d 14 1a          	lea    (%rdx,%rbx,1),%r10
        column = fcs_state_get_col(*new_state_key, i);
  401b2b:	49 89 d0             	mov    %rdx,%r8
        *(current_stack) = new_ptr;
  401b2e:	4a 89 14 f0          	mov    %rdx,(%rax,%r14,8)
        h64  = seed + PRIME64_5;
  401b32:	48 b8 c5 67 56 16 2f 	movabs $0x27d4eb2f165667c5,%rax
  401b39:	eb d4 27 
    if (len>=32) {
  401b3c:	48 83 fb 1f          	cmp    $0x1f,%rbx
  401b40:	0f 86 08 01 00 00    	jbe    401c4e <fc_solve_check_and_add_state+0x1fe>
        const BYTE* const limit = bEnd - 32;
  401b46:	4d 8d 5a e0          	lea    -0x20(%r10),%r11
        U64 v3 = seed + 0;
  401b4a:	31 ff                	xor    %edi,%edi
        U64 v2 = seed + PRIME64_2;
  401b4c:	4d 89 e9             	mov    %r13,%r9
        U64 v4 = seed - PRIME64_1;
  401b4f:	48 b9 79 35 14 7a 4e 	movabs $0x61c8864e7a143579,%rcx
  401b56:	86 c8 61 
        U64 v1 = seed + PRIME64_1 + PRIME64_2;
  401b59:	48 b8 d6 b5 c0 ad ee 	movabs $0x60ea27eeadc0b5d6,%rax
  401b60:	27 ea 60 
  401b63:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  401b6a:	00 00 00 00 
  401b6e:	66 90                	xchg   %ax,%ax
    acc += input * PRIME64_2;
  401b70:	48 8b 32             	mov    (%rdx),%rsi
  401b73:	48 83 c2 20          	add    $0x20,%rdx
  401b77:	49 0f af f5          	imul   %r13,%rsi
  401b7b:	48 01 f0             	add    %rsi,%rax
  401b7e:	48 8b 72 e8          	mov    -0x18(%rdx),%rsi
    acc  = XXH_rotl64(acc, 31);
  401b82:	48 c1 c0 1f          	rol    $0x1f,%rax
    acc *= PRIME64_1;
  401b86:	48 0f af c5          	imul   %rbp,%rax
    acc += input * PRIME64_2;
  401b8a:	49 0f af f5          	imul   %r13,%rsi
  401b8e:	49 01 f1             	add    %rsi,%r9
  401b91:	48 8b 72 f0          	mov    -0x10(%rdx),%rsi
    acc  = XXH_rotl64(acc, 31);
  401b95:	49 c1 c1 1f          	rol    $0x1f,%r9
    acc *= PRIME64_1;
  401b99:	4c 0f af cd          	imul   %rbp,%r9
    acc += input * PRIME64_2;
  401b9d:	49 0f af f5          	imul   %r13,%rsi
  401ba1:	48 01 f7             	add    %rsi,%rdi
  401ba4:	48 8b 72 f8          	mov    -0x8(%rdx),%rsi
    acc  = XXH_rotl64(acc, 31);
  401ba8:	48 c1 c7 1f          	rol    $0x1f,%rdi
    acc *= PRIME64_1;
  401bac:	48 0f af fd          	imul   %rbp,%rdi
    acc += input * PRIME64_2;
  401bb0:	49 0f af f5          	imul   %r13,%rsi
  401bb4:	48 01 f1             	add    %rsi,%rcx
    acc  = XXH_rotl64(acc, 31);
  401bb7:	48 c1 c1 1f          	rol    $0x1f,%rcx
    acc *= PRIME64_1;
  401bbb:	48 0f af cd          	imul   %rbp,%rcx
        } while (p<=limit);
  401bbf:	49 39 d3             	cmp    %rdx,%r11
  401bc2:	73 ac                	jae    401b70 <fc_solve_check_and_add_state+0x120>
    acc += input * PRIME64_2;
  401bc4:	48 89 c6             	mov    %rax,%rsi
        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
  401bc7:	4d 89 cb             	mov    %r9,%r11
  401bca:	48 d1 c0             	rol    %rax
    acc += input * PRIME64_2;
  401bcd:	49 0f af f5          	imul   %r13,%rsi
        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
  401bd1:	49 c1 c3 07          	rol    $0x7,%r11
    acc += input * PRIME64_2;
  401bd5:	4d 0f af cd          	imul   %r13,%r9
        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
  401bd9:	4c 01 d8             	add    %r11,%rax
  401bdc:	49 89 fb             	mov    %rdi,%r11
    acc += input * PRIME64_2;
  401bdf:	49 0f af fd          	imul   %r13,%rdi
        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
  401be3:	49 c1 c3 0c          	rol    $0xc,%r11
  401be7:	49 01 c3             	add    %rax,%r11
  401bea:	48 89 c8             	mov    %rcx,%rax
  401bed:	48 c1 c0 12          	rol    $0x12,%rax
    acc  = XXH_rotl64(acc, 31);
  401bf1:	48 c1 c6 1f          	rol    $0x1f,%rsi
        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
  401bf5:	4c 01 d8             	add    %r11,%rax
    acc *= PRIME64_1;
  401bf8:	48 0f af f5          	imul   %rbp,%rsi
    acc  = XXH_rotl64(acc, 31);
  401bfc:	49 c1 c1 1f          	rol    $0x1f,%r9
    acc *= PRIME64_1;
  401c00:	4c 0f af cd          	imul   %rbp,%r9
    acc  = XXH_rotl64(acc, 31);
  401c04:	48 c1 c7 1f          	rol    $0x1f,%rdi
    acc *= PRIME64_1;
  401c08:	48 0f af fd          	imul   %rbp,%rdi
    acc ^= val;
  401c0c:	48 31 f0             	xor    %rsi,%rax
    acc  = acc * PRIME64_1 + PRIME64_4;
  401c0f:	48 be 63 ae b2 c2 77 	movabs $0x85ebca77c2b2ae63,%rsi
  401c16:	ca eb 85 
  401c19:	48 0f af c5          	imul   %rbp,%rax
  401c1d:	48 01 f0             	add    %rsi,%rax
    acc ^= val;
  401c20:	4c 31 c8             	xor    %r9,%rax
    acc  = acc * PRIME64_1 + PRIME64_4;
  401c23:	48 0f af c5          	imul   %rbp,%rax
  401c27:	48 01 f0             	add    %rsi,%rax
    acc ^= val;
  401c2a:	48 31 c7             	xor    %rax,%rdi
    acc += input * PRIME64_2;
  401c2d:	48 89 c8             	mov    %rcx,%rax
  401c30:	49 0f af c5          	imul   %r13,%rax
    acc  = acc * PRIME64_1 + PRIME64_4;
  401c34:	48 0f af fd          	imul   %rbp,%rdi
    acc  = XXH_rotl64(acc, 31);
  401c38:	48 c1 c0 1f          	rol    $0x1f,%rax
    acc *= PRIME64_1;
  401c3c:	48 0f af c5          	imul   %rbp,%rax
    acc  = acc * PRIME64_1 + PRIME64_4;
  401c40:	48 8d 0c 37          	lea    (%rdi,%rsi,1),%rcx
    acc ^= val;
  401c44:	48 31 c8             	xor    %rcx,%rax
    acc  = acc * PRIME64_1 + PRIME64_4;
  401c47:	48 0f af c5          	imul   %rbp,%rax
  401c4b:	48 01 f0             	add    %rsi,%rax
    while (p+8<=bEnd) {
  401c4e:	48 8d 7a 08          	lea    0x8(%rdx),%rdi
    h64 += (U64) len;
  401c52:	48 01 d8             	add    %rbx,%rax
    while (p+8<=bEnd) {
  401c55:	4c 39 d7             	cmp    %r10,%rdi
  401c58:	77 58                	ja     401cb2 <fc_solve_check_and_add_state+0x262>
        h64  = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4;
  401c5a:	48 be 63 ae b2 c2 77 	movabs $0x85ebca77c2b2ae63,%rsi
  401c61:	ca eb 85 
  401c64:	4c 89 d1             	mov    %r10,%rcx
  401c67:	49 89 c3             	mov    %rax,%r11
  401c6a:	48 29 d1             	sub    %rdx,%rcx
  401c6d:	4c 8d 49 f8          	lea    -0x8(%rcx),%r9
  401c71:	4c 89 c9             	mov    %r9,%rcx
  401c74:	48 83 e1 f8          	and    $0xfffffffffffffff8,%rcx
  401c78:	48 01 f9             	add    %rdi,%rcx
  401c7b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
    acc += input * PRIME64_2;
  401c80:	48 8b 02             	mov    (%rdx),%rax
  401c83:	48 83 c2 08          	add    $0x8,%rdx
  401c87:	49 0f af c5          	imul   %r13,%rax
    acc  = XXH_rotl64(acc, 31);
  401c8b:	48 c1 c0 1f          	rol    $0x1f,%rax
    acc *= PRIME64_1;
  401c8f:	48 0f af c5          	imul   %rbp,%rax
        h64 ^= k1;
  401c93:	4c 31 d8             	xor    %r11,%rax
        h64  = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4;
  401c96:	48 c1 c0 1b          	rol    $0x1b,%rax
  401c9a:	48 0f af c5          	imul   %rbp,%rax
  401c9e:	4c 8d 1c 30          	lea    (%rax,%rsi,1),%r11
    while (p+8<=bEnd) {
  401ca2:	48 39 d1             	cmp    %rdx,%rcx
  401ca5:	75 d9                	jne    401c80 <fc_solve_check_and_add_state+0x230>
  401ca7:	49 83 e1 f8          	and    $0xfffffffffffffff8,%r9
  401cab:	4c 89 d8             	mov    %r11,%rax
  401cae:	4a 8d 14 0f          	lea    (%rdi,%r9,1),%rdx
    if (p+4<=bEnd) {
  401cb2:	48 8d 4a 04          	lea    0x4(%rdx),%rcx
  401cb6:	49 39 ca             	cmp    %rcx,%r10
  401cb9:	72 21                	jb     401cdc <fc_solve_check_and_add_state+0x28c>
        h64 ^= (U64)(XXH_get32bits(p)) * PRIME64_1;
  401cbb:	8b 1a                	mov    (%rdx),%ebx
        h64 = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3;
  401cbd:	48 89 ca             	mov    %rcx,%rdx
        h64 ^= (U64)(XXH_get32bits(p)) * PRIME64_1;
  401cc0:	48 0f af dd          	imul   %rbp,%rbx
  401cc4:	48 31 d8             	xor    %rbx,%rax
        h64 = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3;
  401cc7:	48 bb f9 79 37 9e b1 	movabs $0x165667b19e3779f9,%rbx
  401cce:	67 56 16 
  401cd1:	48 c1 c0 17          	rol    $0x17,%rax
  401cd5:	49 0f af c5          	imul   %r13,%rax
  401cd9:	48 01 d8             	add    %rbx,%rax
  401cdc:	48 89 c1             	mov    %rax,%rcx
    while (p<bEnd) {
  401cdf:	49 39 d2             	cmp    %rdx,%r10
  401ce2:	76 34                	jbe    401d18 <fc_solve_check_and_add_state+0x2c8>
  401ce4:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  401ceb:	00 00 00 00 
  401cef:	90                   	nop
        h64 ^= (*p) * PRIME64_5;
  401cf0:	0f b6 02             	movzbl (%rdx),%eax
        p++;
  401cf3:	48 83 c2 01          	add    $0x1,%rdx
        h64 ^= (*p) * PRIME64_5;
  401cf7:	48 bb c5 67 56 16 2f 	movabs $0x27d4eb2f165667c5,%rbx
  401cfe:	eb d4 27 
  401d01:	48 0f af c3          	imul   %rbx,%rax
  401d05:	48 31 c8             	xor    %rcx,%rax
        h64 = XXH_rotl64(h64, 11) * PRIME64_1;
  401d08:	48 c1 c0 0b          	rol    $0xb,%rax
  401d0c:	48 0f af c5          	imul   %rbp,%rax
  401d10:	48 89 c1             	mov    %rax,%rcx
    while (p<bEnd) {
  401d13:	49 39 d2             	cmp    %rdx,%r10
  401d16:	75 d8                	jne    401cf0 <fc_solve_check_and_add_state+0x2a0>
    h64 ^= h64 >> 33;
  401d18:	49 89 c4             	mov    %rax,%r12
        (hash->entries + (hash_value & (hash->size_bitmask)));
  401d1b:	49 8b 5f 60          	mov    0x60(%r15),%rbx
  401d1f:	49 c1 ec 21          	shr    $0x21,%r12
  401d23:	49 31 c4             	xor    %rax,%r12
    h64 *= PRIME64_2;
  401d26:	4d 0f af e5          	imul   %r13,%r12
  401d2a:	48 89 5c 24 28       	mov    %rbx,0x28(%rsp)
    h64 ^= h64 >> 29;
  401d2f:	4c 89 e0             	mov    %r12,%rax
  401d32:	48 c1 e8 1d          	shr    $0x1d,%rax
  401d36:	49 31 c4             	xor    %rax,%r12
    h64 *= PRIME64_3;
  401d39:	48 b8 f9 79 37 9e b1 	movabs $0x165667b19e3779f9,%rax
  401d40:	67 56 16 
  401d43:	4c 0f af e0          	imul   %rax,%r12
    h64 ^= h64 >> 32;
  401d47:	4c 89 e0             	mov    %r12,%rax
  401d4a:	48 c1 e8 20          	shr    $0x20,%rax
  401d4e:	49 31 c4             	xor    %rax,%r12
  401d51:	49 63 47 70          	movslq 0x70(%r15),%rax
  401d55:	4c 21 e0             	and    %r12,%rax
    typeof(hash->entries[0]) *const list =
  401d58:	48 8d 04 c3          	lea    (%rbx,%rax,8),%rax
    if (list->first_item == NULL)
  401d5c:	48 8b 18             	mov    (%rax),%rbx
  401d5f:	48 85 db             	test   %rbx,%rbx
  401d62:	0f 84 8c 06 00 00    	je     4023f4 <fc_solve_check_and_add_state+0x9a4>
    const_SLOT(hash_type, hash);
  401d68:	45 8b 4f 68          	mov    0x68(%r15),%r9d
  401d6c:	4c 89 74 24 18       	mov    %r14,0x18(%rsp)
  401d71:	4c 89 e1             	mov    %r12,%rcx
  401d74:	4d 89 c6             	mov    %r8,%r14
  401d77:	4c 89 7c 24 20       	mov    %r15,0x20(%rsp)
  401d7c:	45 89 cf             	mov    %r9d,%r15d
  401d7f:	eb 1f                	jmp    401da0 <fc_solve_check_and_add_state+0x350>
  401d81:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  401d88:	00 00 00 00 
  401d8c:	0f 1f 40 00          	nopl   0x0(%rax)
            item = item->next;
  401d90:	48 8b 43 10          	mov    0x10(%rbx),%rax
        while (item != NULL)
  401d94:	48 85 c0             	test   %rax,%rax
  401d97:	0f 84 60 05 00 00    	je     4022fd <fc_solve_check_and_add_state+0x8ad>
  401d9d:	48 89 c3             	mov    %rax,%rbx
            if ((item->hash_value == hash_value)
  401da0:	48 39 4b 08          	cmp    %rcx,0x8(%rbx)
  401da4:	75 ea                	jne    401d90 <fc_solve_check_and_add_state+0x340>
  401da6:	4c 8b 23             	mov    (%rbx),%r12
                && MY_HASH_COMPARE())
  401da9:	45 85 ff             	test   %r15d,%r15d
  401dac:	0f 84 de 04 00 00    	je     402290 <fc_solve_check_and_add_state+0x840>
#endif

static inline int fc_solve_state_compare(
    const void *const s1, const void *const s2)
{
    return memcmp(s1, s2, sizeof(fcs_state));
  401db2:	ba 48 00 00 00       	mov    $0x48,%edx
  401db7:	4c 89 f6             	mov    %r14,%rsi
  401dba:	4c 89 e7             	mov    %r12,%rdi
  401dbd:	48 89 0c 24          	mov    %rcx,(%rsp)
  401dc1:	e8 ba f2 ff ff       	callq  401080 <memcmp@plt>
  401dc6:	48 8b 0c 24          	mov    (%rsp),%rcx
  401dca:	85 c0                	test   %eax,%eax
  401dcc:	0f 94 c0             	sete   %al
  401dcf:	84 c0                	test   %al,%al
  401dd1:	74 bd                	je     401d90 <fc_solve_check_and_add_state+0x340>
  401dd3:	4c 8b 74 24 18       	mov    0x18(%rsp),%r14
  401dd8:	4c 8b 7c 24 20       	mov    0x20(%rsp),%r15
        REPLACE_WITH_CACHED(cached_stack);
  401ddd:	4d 85 e4             	test   %r12,%r12
  401de0:	74 17                	je     401df9 <fc_solve_check_and_add_state+0x3a9>
    return allocator->rollback_ptr;
}

static inline void fcs_compact_alloc_release(compact_allocator *const allocator)
{
    allocator->ptr = allocator->rollback_ptr;
  401de2:	49 8b 87 f0 00 00 00 	mov    0xf0(%r15),%rax
  401de9:	49 89 87 e8 00 00 00 	mov    %rax,0xe8(%r15)
  401df0:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
  401df5:	4e 89 24 f0          	mov    %r12,(%rax,%r14,8)
  401df9:	49 83 c6 01          	add    $0x1,%r14
    for (int i = 0; i < LOCAL_STACKS_NUM; ++i, ++current_stack)
  401dfd:	49 83 fe 08          	cmp    $0x8,%r14
  401e01:	0f 85 99 fc ff ff    	jne    401aa0 <fc_solve_check_and_add_state+0x50>
#define instance hard_thread
#else
    fcs_instance *const instance = hard_thread->instance;
#endif
    fc_solve_cache_stacks(hard_thread, new_state);
    fc_solve_canonize_state(new_state_key PASS_FREECELLS(INSTANCE_FREECELLS_NUM)
  401e07:	48 8b 44 24 30       	mov    0x30(%rsp),%rax
    fcs_state *const ptr_state_key FREECELLS_AND_STACKS_ARGS())
{
#define state_key (ptr_state_key)
    /* Insertion-sort the columns */

    for (size_t b = 1; b < STACKS_NUM__VAL; b++)
  401e0c:	41 bc 01 00 00 00    	mov    $0x1,%r12d
  401e12:	48 8b 18             	mov    (%rax),%rbx
  401e15:	4c 8d 6b 08          	lea    0x8(%rbx),%r13
  401e19:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
    {
        const int min_len = min(s1[0], s2[0]);
        for (int a = 1; a <= min_len; a++)
        {
            const int ret = fc_solve_card_compare(s1[a], s2[a]);
            if (ret != 0)
  401e20:	4d 89 e8             	mov    %r13,%r8
  401e23:	4d 89 e3             	mov    %r12,%r11
  401e26:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  401e2d:	00 00 00 
    {
        size_t c = b;
        while ((c > 0) && ((STACK_COMPARE(GET_STACK(c), GET_STACK(c - 1))) < 0))
  401e30:	49 8b 70 f8          	mov    -0x8(%r8),%rsi
  401e34:	49 83 eb 01          	sub    $0x1,%r11
  401e38:	49 8b 38             	mov    (%r8),%rdi
        const int min_len = min(s1[0], s2[0]);
  401e3b:	44 0f be 16          	movsbl (%rsi),%r10d
  401e3f:	44 0f b6 0f          	movzbl (%rdi),%r9d
  401e43:	45 38 ca             	cmp    %r9b,%r10b
  401e46:	41 0f be c1          	movsbl %r9b,%eax
  401e4a:	41 0f 4e c2          	cmovle %r10d,%eax
        for (int a = 1; a <= min_len; a++)
  401e4e:	84 c0                	test   %al,%al
  401e50:	7e 37                	jle    401e89 <fc_solve_check_and_add_state+0x439>
            const int ret = fc_solve_card_compare(s1[a], s2[a]);
  401e52:	0f be 57 01          	movsbl 0x1(%rdi),%edx
  401e56:	0f be 4e 01          	movsbl 0x1(%rsi),%ecx
            if (ret != 0)
  401e5a:	29 ca                	sub    %ecx,%edx
  401e5c:	0f 85 0e 04 00 00    	jne    402270 <fc_solve_check_and_add_state+0x820>
  401e62:	8d 68 ff             	lea    -0x1(%rax),%ebp
  401e65:	b8 02 00 00 00       	mov    $0x2,%eax
  401e6a:	48 83 c5 02          	add    $0x2,%rbp
  401e6e:	eb 14                	jmp    401e84 <fc_solve_check_and_add_state+0x434>
            const int ret = fc_solve_card_compare(s1[a], s2[a]);
  401e70:	0f be 14 07          	movsbl (%rdi,%rax,1),%edx
  401e74:	0f be 0c 06          	movsbl (%rsi,%rax,1),%ecx
  401e78:	48 83 c0 01          	add    $0x1,%rax
            if (ret != 0)
  401e7c:	29 ca                	sub    %ecx,%edx
  401e7e:	0f 85 ec 03 00 00    	jne    402270 <fc_solve_check_and_add_state+0x820>
        for (int a = 1; a <= min_len; a++)
  401e84:	48 39 c5             	cmp    %rax,%rbp
  401e87:	75 e7                	jne    401e70 <fc_solve_check_and_add_state+0x420>
     * 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])
  401e89:	45 38 ca             	cmp    %r9b,%r10b
  401e8c:	7e 0f                	jle    401e9d <fc_solve_check_and_add_state+0x44d>
        {
            {
                DECLARE_TEMP_STACK();
                COPY_STACK(temp_stack, GET_STACK(c));
                COPY_STACK(GET_STACK(c), GET_STACK(c - 1));
  401e8e:	49 89 30             	mov    %rsi,(%r8)
  401e91:	49 83 e8 08          	sub    $0x8,%r8
                COPY_STACK(GET_STACK(c - 1), temp_stack);
  401e95:	49 89 38             	mov    %rdi,(%r8)
        while ((c > 0) && ((STACK_COMPARE(GET_STACK(c), GET_STACK(c - 1))) < 0))
  401e98:	4d 85 db             	test   %r11,%r11
  401e9b:	75 93                	jne    401e30 <fc_solve_check_and_add_state+0x3e0>
    for (size_t b = 1; b < STACKS_NUM__VAL; b++)
  401e9d:	49 83 c4 01          	add    $0x1,%r12
  401ea1:	49 83 c5 08          	add    $0x8,%r13
  401ea5:	49 83 fc 08          	cmp    $0x8,%r12
  401ea9:	0f 85 71 ff ff ff    	jne    401e20 <fc_solve_check_and_add_state+0x3d0>
    for (size_t b = 1; b < FREECELLS_NUM__VAL; b++)
    {
        size_t c = b;

        while ((c > 0) && ((fc_solve_card_compare(
                               GET_FREECELL(c), GET_FREECELL(c - 1))) < 0))
  401eaf:	0f be 73 41          	movsbl 0x41(%rbx),%esi
  401eb3:	0f be 4b 40          	movsbl 0x40(%rbx),%ecx
  401eb7:	89 f2                	mov    %esi,%edx
        while ((c > 0) && ((fc_solve_card_compare(
  401eb9:	39 ce                	cmp    %ecx,%esi
  401ebb:	79 09                	jns    401ec6 <fc_solve_check_and_add_state+0x476>
        {
            const fcs_card temp_freecell = GET_FREECELL(c);
            GET_FREECELL(c) = GET_FREECELL(c - 1);
  401ebd:	88 4b 41             	mov    %cl,0x41(%rbx)
  401ec0:	89 ca                	mov    %ecx,%edx
            GET_FREECELL(c - 1) = temp_freecell;
  401ec2:	40 88 73 40          	mov    %sil,0x40(%rbx)
                               GET_FREECELL(c), GET_FREECELL(c - 1))) < 0))
  401ec6:	0f be 4b 42          	movsbl 0x42(%rbx),%ecx
        while ((c > 0) && ((fc_solve_card_compare(
  401eca:	0f be f2             	movsbl %dl,%esi
                               GET_FREECELL(c), GET_FREECELL(c - 1))) < 0))
  401ecd:	89 c8                	mov    %ecx,%eax
        while ((c > 0) && ((fc_solve_card_compare(
  401ecf:	39 f1                	cmp    %esi,%ecx
  401ed1:	79 17                	jns    401eea <fc_solve_check_and_add_state+0x49a>
                               GET_FREECELL(c), GET_FREECELL(c - 1))) < 0))
  401ed3:	0f be 7b 40          	movsbl 0x40(%rbx),%edi
            GET_FREECELL(c) = GET_FREECELL(c - 1);
  401ed7:	88 53 42             	mov    %dl,0x42(%rbx)
            GET_FREECELL(c - 1) = temp_freecell;
  401eda:	88 4b 41             	mov    %cl,0x41(%rbx)
        while ((c > 0) && ((fc_solve_card_compare(
  401edd:	39 f9                	cmp    %edi,%ecx
  401edf:	79 07                	jns    401ee8 <fc_solve_check_and_add_state+0x498>
            GET_FREECELL(c) = GET_FREECELL(c - 1);
  401ee1:	40 88 7b 41          	mov    %dil,0x41(%rbx)
            GET_FREECELL(c - 1) = temp_freecell;
  401ee5:	88 4b 40             	mov    %cl,0x40(%rbx)
  401ee8:	89 d0                	mov    %edx,%eax
                               GET_FREECELL(c), GET_FREECELL(c - 1))) < 0))
  401eea:	0f be 4b 43          	movsbl 0x43(%rbx),%ecx
        while ((c > 0) && ((fc_solve_card_compare(
  401eee:	0f be f0             	movsbl %al,%esi
  401ef1:	39 f1                	cmp    %esi,%ecx
  401ef3:	79 24                	jns    401f19 <fc_solve_check_and_add_state+0x4c9>
                               GET_FREECELL(c), GET_FREECELL(c - 1))) < 0))
  401ef5:	0f be 73 41          	movsbl 0x41(%rbx),%esi
            GET_FREECELL(c) = GET_FREECELL(c - 1);
  401ef9:	88 43 43             	mov    %al,0x43(%rbx)
            GET_FREECELL(c - 1) = temp_freecell;
  401efc:	88 4b 42             	mov    %cl,0x42(%rbx)
        while ((c > 0) && ((fc_solve_card_compare(
  401eff:	39 f1                	cmp    %esi,%ecx
  401f01:	79 16                	jns    401f19 <fc_solve_check_and_add_state+0x4c9>
            GET_FREECELL(c) = GET_FREECELL(c - 1);
  401f03:	40 88 73 42          	mov    %sil,0x42(%rbx)
                               GET_FREECELL(c), GET_FREECELL(c - 1))) < 0))
  401f07:	0f be 73 40          	movsbl 0x40(%rbx),%esi
            GET_FREECELL(c - 1) = temp_freecell;
  401f0b:	88 4b 41             	mov    %cl,0x41(%rbx)
        while ((c > 0) && ((fc_solve_card_compare(
  401f0e:	39 f1                	cmp    %esi,%ecx
  401f10:	79 07                	jns    401f19 <fc_solve_check_and_add_state+0x4c9>
            GET_FREECELL(c) = GET_FREECELL(c - 1);
  401f12:	40 88 73 41          	mov    %sil,0x41(%rbx)
            GET_FREECELL(c - 1) = temp_freecell;
  401f16:	88 4b 40             	mov    %cl,0x40(%rbx)
    acc += input * PRIME64_2;
  401f19:	4c 8b 53 10          	mov    0x10(%rbx),%r10
    const BYTE* bEnd = p + len;
  401f1d:	48 8d 4b 48          	lea    0x48(%rbx),%rcx
    acc += input * PRIME64_2;
  401f21:	48 ba 4f eb d4 27 3d 	movabs $0xc2b2ae3d27d4eb4f,%rdx
  401f28:	ae b2 c2 
  401f2b:	48 be d6 b5 c0 ad ee 	movabs $0x60ea27eeadc0b5d6,%rsi
  401f32:	27 ea 60 
  401f35:	48 bf 79 35 14 7a 4e 	movabs $0x61c8864e7a143579,%rdi
  401f3c:	86 c8 61 
  401f3f:	48 8b 03             	mov    (%rbx),%rax
  401f42:	4c 8b 43 08          	mov    0x8(%rbx),%r8
  401f46:	4c 8b 4b 18          	mov    0x18(%rbx),%r9
  401f4a:	4c 0f af d2          	imul   %rdx,%r10
  401f4e:	48 0f af c2          	imul   %rdx,%rax
  401f52:	4c 0f af c2          	imul   %rdx,%r8
  401f56:	4c 0f af ca          	imul   %rdx,%r9
    acc  = XXH_rotl64(acc, 31);
  401f5a:	49 c1 c2 1f          	rol    $0x1f,%r10
    acc *= PRIME64_1;
  401f5e:	4d 89 d3             	mov    %r10,%r11
    acc += input * PRIME64_2;
  401f61:	4c 8b 53 20          	mov    0x20(%rbx),%r10
  401f65:	48 01 f0             	add    %rsi,%rax
    acc *= PRIME64_1;
  401f68:	48 be 87 ca eb 85 b1 	movabs $0x9e3779b185ebca87,%rsi
  401f6f:	79 37 9e 
  401f72:	4c 0f af de          	imul   %rsi,%r11
    acc  = XXH_rotl64(acc, 31);
  401f76:	48 c1 c0 1f          	rol    $0x1f,%rax
    acc += input * PRIME64_2;
  401f7a:	49 01 d0             	add    %rdx,%r8
    acc *= PRIME64_1;
  401f7d:	48 0f af c6          	imul   %rsi,%rax
    acc  = XXH_rotl64(acc, 31);
  401f81:	49 c1 c0 1f          	rol    $0x1f,%r8
    acc += input * PRIME64_2;
  401f85:	49 01 f9             	add    %rdi,%r9
    acc *= PRIME64_1;
  401f88:	4c 0f af c6          	imul   %rsi,%r8
    acc  = XXH_rotl64(acc, 31);
  401f8c:	49 c1 c1 1f          	rol    $0x1f,%r9
    acc += input * PRIME64_2;
  401f90:	4c 0f af d2          	imul   %rdx,%r10
    acc *= PRIME64_1;
  401f94:	4c 0f af ce          	imul   %rsi,%r9
            v4 = XXH64_round(v4, XXH_get64bits(p)); p+=8;
  401f98:	48 8d 7b 20          	lea    0x20(%rbx),%rdi
    acc += input * PRIME64_2;
  401f9c:	4c 01 d0             	add    %r10,%rax
  401f9f:	4c 8b 53 28          	mov    0x28(%rbx),%r10
    acc  = XXH_rotl64(acc, 31);
  401fa3:	48 c1 c0 1f          	rol    $0x1f,%rax
    acc *= PRIME64_1;
  401fa7:	48 0f af c6          	imul   %rsi,%rax
    acc += input * PRIME64_2;
  401fab:	4c 0f af d2          	imul   %rdx,%r10
  401faf:	4d 01 d0             	add    %r10,%r8
  401fb2:	4c 8b 53 30          	mov    0x30(%rbx),%r10
    acc  = XXH_rotl64(acc, 31);
  401fb6:	49 c1 c0 1f          	rol    $0x1f,%r8
    acc *= PRIME64_1;
  401fba:	4c 0f af c6          	imul   %rsi,%r8
    acc += input * PRIME64_2;
  401fbe:	4c 0f af d2          	imul   %rdx,%r10
        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
  401fc2:	4c 89 c5             	mov    %r8,%rbp
    acc += input * PRIME64_2;
  401fc5:	4d 01 da             	add    %r11,%r10
  401fc8:	4c 8b 5b 38          	mov    0x38(%rbx),%r11
    acc  = XXH_rotl64(acc, 31);
  401fcc:	49 c1 c2 1f          	rol    $0x1f,%r10
    acc *= PRIME64_1;
  401fd0:	4c 0f af d6          	imul   %rsi,%r10
    acc += input * PRIME64_2;
  401fd4:	4c 0f af da          	imul   %rdx,%r11
  401fd8:	4d 01 d9             	add    %r11,%r9
  401fdb:	49 89 c3             	mov    %rax,%r11
  401fde:	4c 0f af da          	imul   %rdx,%r11
    acc  = XXH_rotl64(acc, 31);
  401fe2:	49 c1 c1 1f          	rol    $0x1f,%r9
    acc *= PRIME64_1;
  401fe6:	4c 0f af ce          	imul   %rsi,%r9
    acc  = XXH_rotl64(acc, 31);
  401fea:	49 c1 c3 1f          	rol    $0x1f,%r11
        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
  401fee:	48 c1 c5 07          	rol    $0x7,%rbp
    acc *= PRIME64_1;
  401ff2:	4c 0f af de          	imul   %rsi,%r11
        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
  401ff6:	48 d1 c0             	rol    %rax
  401ff9:	48 01 e8             	add    %rbp,%rax
  401ffc:	4c 89 d5             	mov    %r10,%rbp
    acc += input * PRIME64_2;
  401fff:	4c 0f af d2          	imul   %rdx,%r10
        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
  402003:	48 c1 c5 0c          	rol    $0xc,%rbp
  402007:	48 01 e8             	add    %rbp,%rax
  40200a:	4c 89 cd             	mov    %r9,%rbp
    acc += input * PRIME64_2;
  40200d:	4c 0f af ca          	imul   %rdx,%r9
        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
  402011:	48 c1 c5 12          	rol    $0x12,%rbp
  402015:	48 01 e8             	add    %rbp,%rax
    acc ^= val;
  402018:	4c 31 d8             	xor    %r11,%rax
    acc += input * PRIME64_2;
  40201b:	4d 89 c3             	mov    %r8,%r11
    acc  = acc * PRIME64_1 + PRIME64_4;
  40201e:	49 b8 63 ae b2 c2 77 	movabs $0x85ebca77c2b2ae63,%r8
  402025:	ca eb 85 
    acc += input * PRIME64_2;
  402028:	4c 0f af da          	imul   %rdx,%r11
    acc  = XXH_rotl64(acc, 31);
  40202c:	49 c1 c2 1f          	rol    $0x1f,%r10
    acc  = acc * PRIME64_1 + PRIME64_4;
  402030:	48 0f af c6          	imul   %rsi,%rax
    acc *= PRIME64_1;
  402034:	4c 0f af d6          	imul   %rsi,%r10
    acc  = XXH_rotl64(acc, 31);
  402038:	49 c1 c1 1f          	rol    $0x1f,%r9
    acc *= PRIME64_1;
  40203c:	4c 0f af ce          	imul   %rsi,%r9
    acc  = XXH_rotl64(acc, 31);
  402040:	49 c1 c3 1f          	rol    $0x1f,%r11
    acc *= PRIME64_1;
  402044:	4c 0f af de          	imul   %rsi,%r11
    acc  = acc * PRIME64_1 + PRIME64_4;
  402048:	4c 01 c0             	add    %r8,%rax
    acc ^= val;
  40204b:	4c 31 d8             	xor    %r11,%rax
    acc  = acc * PRIME64_1 + PRIME64_4;
  40204e:	48 0f af c6          	imul   %rsi,%rax
  402052:	4c 01 c0             	add    %r8,%rax
    acc ^= val;
  402055:	4c 31 d0             	xor    %r10,%rax
    acc  = acc * PRIME64_1 + PRIME64_4;
  402058:	48 0f af c6          	imul   %rsi,%rax
  40205c:	4c 01 c0             	add    %r8,%rax
    acc ^= val;
  40205f:	4c 31 c8             	xor    %r9,%rax
    h64 += (U64) len;
  402062:	49 b9 ab ae b2 c2 77 	movabs $0x85ebca77c2b2aeab,%r9
  402069:	ca eb 85 
    acc  = acc * PRIME64_1 + PRIME64_4;
  40206c:	48 0f af c6          	imul   %rsi,%rax
    h64 += (U64) len;
  402070:	4c 01 c8             	add    %r9,%rax
    acc += input * PRIME64_2;
  402073:	4c 8b 4b 40          	mov    0x40(%rbx),%r9
  402077:	4c 0f af ca          	imul   %rdx,%r9
    acc  = XXH_rotl64(acc, 31);
  40207b:	49 c1 c1 1f          	rol    $0x1f,%r9
    acc *= PRIME64_1;
  40207f:	4c 0f af ce          	imul   %rsi,%r9
        h64 ^= k1;
  402083:	4c 31 c8             	xor    %r9,%rax
    while (p+8<=bEnd) {
  402086:	4c 8d 4b 50          	lea    0x50(%rbx),%r9
        h64  = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4;
  40208a:	48 c1 c0 1b          	rol    $0x1b,%rax
  40208e:	48 0f af c6          	imul   %rsi,%rax
  402092:	4c 01 c0             	add    %r8,%rax
    while (p+8<=bEnd) {
  402095:	4c 39 c9             	cmp    %r9,%rcx
  402098:	72 69                	jb     402103 <fc_solve_check_and_add_state+0x6b3>
    acc += input * PRIME64_2;
  40209a:	4c 8b 4f 28          	mov    0x28(%rdi),%r9
  40209e:	4c 0f af ca          	imul   %rdx,%r9
    acc  = XXH_rotl64(acc, 31);
  4020a2:	49 c1 c1 1f          	rol    $0x1f,%r9
    acc *= PRIME64_1;
  4020a6:	4c 0f af ce          	imul   %rsi,%r9
        h64 ^= k1;
  4020aa:	4c 31 c8             	xor    %r9,%rax
    while (p+8<=bEnd) {
  4020ad:	4c 8d 4b 58          	lea    0x58(%rbx),%r9
        h64  = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4;
  4020b1:	48 c1 c0 1b          	rol    $0x1b,%rax
  4020b5:	48 0f af c6          	imul   %rsi,%rax
  4020b9:	4c 01 c0             	add    %r8,%rax
    while (p+8<=bEnd) {
  4020bc:	4c 39 c9             	cmp    %r9,%rcx
  4020bf:	72 42                	jb     402103 <fc_solve_check_and_add_state+0x6b3>
    acc += input * PRIME64_2;
  4020c1:	4c 8b 4f 30          	mov    0x30(%rdi),%r9
  4020c5:	4c 0f af ca          	imul   %rdx,%r9
    acc  = XXH_rotl64(acc, 31);
  4020c9:	49 c1 c1 1f          	rol    $0x1f,%r9
    acc *= PRIME64_1;
  4020cd:	4c 0f af ce          	imul   %rsi,%r9
        h64 ^= k1;
  4020d1:	4c 31 c8             	xor    %r9,%rax
    while (p+8<=bEnd) {
  4020d4:	4c 8d 4b 60          	lea    0x60(%rbx),%r9
        h64  = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4;
  4020d8:	48 c1 c0 1b          	rol    $0x1b,%rax
  4020dc:	48 0f af c6          	imul   %rsi,%rax
  4020e0:	4c 01 c0             	add    %r8,%rax
    while (p+8<=bEnd) {
  4020e3:	4c 39 c9             	cmp    %r9,%rcx
  4020e6:	72 1b                	jb     402103 <fc_solve_check_and_add_state+0x6b3>
    acc += input * PRIME64_2;
  4020e8:	48 0f af 57 38       	imul   0x38(%rdi),%rdx
    acc  = XXH_rotl64(acc, 31);
  4020ed:	48 c1 c2 1f          	rol    $0x1f,%rdx
    acc *= PRIME64_1;
  4020f1:	48 0f af d6          	imul   %rsi,%rdx
        h64 ^= k1;
  4020f5:	48 31 d0             	xor    %rdx,%rax
        h64  = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4;
  4020f8:	48 c1 c0 1b          	rol    $0x1b,%rax
  4020fc:	48 0f af c6          	imul   %rsi,%rax
  402100:	4c 01 c0             	add    %r8,%rax
    if (p+4<=bEnd) {
  402103:	48 8d 79 04          	lea    0x4(%rcx),%rdi
  402107:	48 89 ce             	mov    %rcx,%rsi
  40210a:	48 39 f9             	cmp    %rdi,%rcx
  40210d:	0f 83 15 01 00 00    	jae    402228 <fc_solve_check_and_add_state+0x7d8>
        h64 ^= (*p) * PRIME64_5;
  402113:	49 b8 c5 67 56 16 2f 	movabs $0x27d4eb2f165667c5,%r8
  40211a:	eb d4 27 
  40211d:	48 89 c2             	mov    %rax,%rdx
        h64 = XXH_rotl64(h64, 11) * PRIME64_1;
  402120:	48 bf 87 ca eb 85 b1 	movabs $0x9e3779b185ebca87,%rdi
  402127:	79 37 9e 
    while (p<bEnd) {
  40212a:	48 39 f1             	cmp    %rsi,%rcx
  40212d:	76 1f                	jbe    40214e <fc_solve_check_and_add_state+0x6fe>
  40212f:	90                   	nop
        h64 ^= (*p) * PRIME64_5;
  402130:	0f b6 06             	movzbl (%rsi),%eax
        p++;
  402133:	48 83 c6 01          	add    $0x1,%rsi
        h64 ^= (*p) * PRIME64_5;
  402137:	49 0f af c0          	imul   %r8,%rax
  40213b:	48 31 d0             	xor    %rdx,%rax
        h64 = XXH_rotl64(h64, 11) * PRIME64_1;
  40213e:	48 c1 c0 0b          	rol    $0xb,%rax
  402142:	48 0f af c7          	imul   %rdi,%rax
  402146:	48 89 c2             	mov    %rax,%rdx
    while (p<bEnd) {
  402149:	48 39 f1             	cmp    %rsi,%rcx
  40214c:	75 e2                	jne    402130 <fc_solve_check_and_add_state+0x6e0>
    h64 ^= h64 >> 33;
  40214e:	49 89 c5             	mov    %rax,%r13
        (hash->entries + (hash_value & (hash->size_bitmask)));
  402151:	49 8b 6f 10          	mov    0x10(%r15),%rbp
  402155:	49 c1 ed 21          	shr    $0x21,%r13
  402159:	4c 31 e8             	xor    %r13,%rax
    h64 *= PRIME64_2;
  40215c:	49 bd 4f eb d4 27 3d 	movabs $0xc2b2ae3d27d4eb4f,%r13
  402163:	ae b2 c2 
  402166:	4c 0f af e8          	imul   %rax,%r13
    h64 ^= h64 >> 29;
  40216a:	4c 89 e8             	mov    %r13,%rax
  40216d:	48 c1 e8 1d          	shr    $0x1d,%rax
  402171:	49 31 c5             	xor    %rax,%r13
    h64 *= PRIME64_3;
  402174:	48 b8 f9 79 37 9e b1 	movabs $0x165667b19e3779f9,%rax
  40217b:	67 56 16 
  40217e:	4c 0f af e8          	imul   %rax,%r13
    h64 ^= h64 >> 32;
  402182:	4c 89 e8             	mov    %r13,%rax
  402185:	48 c1 e8 20          	shr    $0x20,%rax
  402189:	49 31 c5             	xor    %rax,%r13
  40218c:	49 63 47 20          	movslq 0x20(%r15),%rax
  402190:	4c 21 e8             	and    %r13,%rax
    typeof(hash->entries[0]) *const list =
  402193:	48 8d 44 c5 00       	lea    0x0(%rbp,%rax,8),%rax
    if (list->first_item == NULL)
  402198:	4c 8b 30             	mov    (%rax),%r14
  40219b:	4d 85 f6             	test   %r14,%r14
  40219e:	0f 84 2a 04 00 00    	je     4025ce <fc_solve_check_and_add_state+0xb7e>
    const_SLOT(hash_type, hash);
  4021a4:	41 8b 47 18          	mov    0x18(%r15),%eax
  4021a8:	89 04 24             	mov    %eax,(%rsp)
  4021ab:	4c 89 e8             	mov    %r13,%rax
  4021ae:	49 89 dd             	mov    %rbx,%r13
  4021b1:	48 89 c3             	mov    %rax,%rbx
  4021b4:	eb 1a                	jmp    4021d0 <fc_solve_check_and_add_state+0x780>
  4021b6:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  4021bd:	00 00 00 
            item = item->next;
  4021c0:	49 8b 46 10          	mov    0x10(%r14),%rax
        while (item != NULL)
  4021c4:	48 85 c0             	test   %rax,%rax
  4021c7:	0f 84 e0 02 00 00    	je     4024ad <fc_solve_check_and_add_state+0xa5d>
  4021cd:	49 89 c6             	mov    %rax,%r14
            if ((item->hash_value == hash_value)
  4021d0:	49 39 5e 08          	cmp    %rbx,0x8(%r14)
  4021d4:	75 ea                	jne    4021c0 <fc_solve_check_and_add_state+0x770>
                && MY_HASH_COMPARE())
  4021d6:	8b 04 24             	mov    (%rsp),%eax
  4021d9:	4d 8b 26             	mov    (%r14),%r12
  4021dc:	85 c0                	test   %eax,%eax
  4021de:	0f 84 5f 02 00 00    	je     402443 <fc_solve_check_and_add_state+0x9f3>
    return memcmp(s1, s2, sizeof(fcs_state));
  4021e4:	ba 48 00 00 00       	mov    $0x48,%edx
  4021e9:	4c 89 ee             	mov    %r13,%rsi
  4021ec:	4c 89 e7             	mov    %r12,%rdi
  4021ef:	e8 8c ee ff ff       	callq  401080 <memcmp@plt>
  4021f4:	85 c0                	test   %eax,%eax
  4021f6:	0f 94 c0             	sete   %al
  4021f9:	84 c0                	test   %al,%al
  4021fb:	74 c3                	je     4021c0 <fc_solve_check_and_add_state+0x770>
    if (existing_void)
  4021fd:	4d 85 e4             	test   %r12,%r12
  402200:	0f 84 fd 02 00 00    	je     402503 <fc_solve_check_and_add_state+0xab3>
    *ret = FCS_STATE_keyval_pair_to_kv(s);
  402206:	48 8b 44 24 38       	mov    0x38(%rsp),%rax
    return (const fcs_kv_state){.key = &(s->s), .val = &(s->info)};
  40220b:	49 8d 4c 24 48       	lea    0x48(%r12),%rcx
    *ret = FCS_STATE_keyval_pair_to_kv(s);
  402210:	4c 89 20             	mov    %r12,(%rax)
    return (const fcs_kv_state){.key = &(s->s), .val = &(s->info)};
  402213:	48 89 48 08          	mov    %rcx,0x8(%rax)
    }
    return HANDLE_existing_void(val);
#else
#error Unknown FCS_STATE_STORAGE. Please define it to a valid value.
#endif
}
  402217:	48 83 c4 48          	add    $0x48,%rsp
        return FALSE;
  40221b:	31 c0                	xor    %eax,%eax
}
  40221d:	5b                   	pop    %rbx
  40221e:	5d                   	pop    %rbp
  40221f:	41 5c                	pop    %r12
  402221:	41 5d                	pop    %r13
  402223:	41 5e                	pop    %r14
  402225:	41 5f                	pop    %r15
  402227:	c3                   	retq   
        h64 ^= (U64)(XXH_get32bits(p)) * PRIME64_1;
  402228:	48 be 87 ca eb 85 b1 	movabs $0x9e3779b185ebca87,%rsi
  40222f:	79 37 9e 
  402232:	8b 11                	mov    (%rcx),%edx
  402234:	48 0f af d6          	imul   %rsi,%rdx
        h64 = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3;
  402238:	48 89 fe             	mov    %rdi,%rsi
        h64 ^= (U64)(XXH_get32bits(p)) * PRIME64_1;
  40223b:	48 31 d0             	xor    %rdx,%rax
        h64 = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3;
  40223e:	48 ba 4f eb d4 27 3d 	movabs $0xc2b2ae3d27d4eb4f,%rdx
  402245:	ae b2 c2 
  402248:	48 c1 c0 17          	rol    $0x17,%rax
  40224c:	48 0f af c2          	imul   %rdx,%rax
  402250:	48 ba f9 79 37 9e b1 	movabs $0x165667b19e3779f9,%rdx
  402257:	67 56 16 
  40225a:	48 01 d0             	add    %rdx,%rax
  40225d:	e9 b1 fe ff ff       	jmpq   402113 <fc_solve_check_and_add_state+0x6c3>
  402262:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  402269:	00 00 00 00 
  40226d:	0f 1f 00             	nopl   (%rax)
        while ((c > 0) && ((STACK_COMPARE(GET_STACK(c), GET_STACK(c - 1))) < 0))
  402270:	85 d2                	test   %edx,%edx
  402272:	0f 88 16 fc ff ff    	js     401e8e <fc_solve_check_and_add_state+0x43e>
    for (size_t b = 1; b < STACKS_NUM__VAL; b++)
  402278:	49 83 c4 01          	add    $0x1,%r12
  40227c:	49 83 c5 08          	add    $0x8,%r13
  402280:	49 83 fc 08          	cmp    $0x8,%r12
  402284:	0f 85 96 fb ff ff    	jne    401e20 <fc_solve_check_and_add_state+0x3d0>
  40228a:	e9 20 fc ff ff       	jmpq   401eaf <fc_solve_check_and_add_state+0x45f>
  40228f:	90                   	nop
        const int min_len = min(s1[0], s2[0]);
  402290:	45 0f be 1e          	movsbl (%r14),%r11d
  402294:	45 0f b6 14 24       	movzbl (%r12),%r10d
  402299:	45 38 d3             	cmp    %r10b,%r11b
  40229c:	41 0f be c2          	movsbl %r10b,%eax
  4022a0:	41 0f 4e c3          	cmovle %r11d,%eax
        for (int a = 1; a <= min_len; a++)
  4022a4:	84 c0                	test   %al,%al
  4022a6:	7e 44                	jle    4022ec <fc_solve_check_and_add_state+0x89c>
            if (ret != 0)
  4022a8:	41 0f b6 7e 01       	movzbl 0x1(%r14),%edi
  4022ad:	41 38 7c 24 01       	cmp    %dil,0x1(%r12)
  4022b2:	0f 85 d8 fa ff ff    	jne    401d90 <fc_solve_check_and_add_state+0x340>
  4022b8:	8d 78 ff             	lea    -0x1(%rax),%edi
  4022bb:	b8 02 00 00 00       	mov    $0x2,%eax
  4022c0:	48 83 c7 02          	add    $0x2,%rdi
  4022c4:	eb 21                	jmp    4022e7 <fc_solve_check_and_add_state+0x897>
  4022c6:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  4022cd:	00 00 00 
            const int ret = fc_solve_card_compare(s1[a], s2[a]);
  4022d0:	41 0f b6 34 06       	movzbl (%r14,%rax,1),%esi
  4022d5:	41 0f b6 14 04       	movzbl (%r12,%rax,1),%edx
  4022da:	48 83 c0 01          	add    $0x1,%rax
            if (ret != 0)
  4022de:	40 38 d6             	cmp    %dl,%sil
  4022e1:	0f 85 a9 fa ff ff    	jne    401d90 <fc_solve_check_and_add_state+0x340>
        for (int a = 1; a <= min_len; a++)
  4022e7:	48 39 c7             	cmp    %rax,%rdi
  4022ea:	75 e4                	jne    4022d0 <fc_solve_check_and_add_state+0x880>
    if (s1[0] < s2[0])
  4022ec:	45 38 d3             	cmp    %r10b,%r11b
  4022ef:	0f 8f 9b fa ff ff    	jg     401d90 <fc_solve_check_and_add_state+0x340>
  4022f5:	0f 9d c0             	setge  %al
  4022f8:	e9 d2 fa ff ff       	jmpq   401dcf <fc_solve_check_and_add_state+0x37f>
  4022fd:	4d 89 f0             	mov    %r14,%r8
  402300:	4c 8b 7c 24 20       	mov    0x20(%rsp),%r15
  402305:	49 89 cc             	mov    %rcx,%r12
        item_placeholder = &(last_item->next);
  402308:	48 83 c3 10          	add    $0x10,%rbx
  40230c:	4c 8b 74 24 18       	mov    0x18(%rsp),%r14
    if ((size_t)(allocator->max_ptr - allocator->ptr) < how_much)
  402311:	49 8b 97 98 00 00 00 	mov    0x98(%r15),%rdx
  402318:	49 8b 87 90 00 00 00 	mov    0x90(%r15),%rax
  40231f:	48 29 d0             	sub    %rdx,%rax
  402322:	48 83 f8 17          	cmp    $0x17,%rax
  402326:	0f 86 d0 00 00 00    	jbe    4023fc <fc_solve_check_and_add_state+0x9ac>
        allocator->rollback_ptr = allocator->ptr;
  40232c:	49 89 97 a0 00 00 00 	mov    %rdx,0xa0(%r15)
    allocator->ptr += how_much;
  402333:	48 8d 42 18          	lea    0x18(%rdx),%rax
  402337:	49 89 87 98 00 00 00 	mov    %rax,0x98(%r15)
    if ((++(hash->num_elems)) > hash->max_num_elems_before_resize)
  40233e:	49 8b 47 78          	mov    0x78(%r15),%rax
    *(*(item_placeholder) = item) = (typeof(*item)){
  402342:	48 89 13             	mov    %rdx,(%rbx)
  402345:	4c 89 02             	mov    %r8,(%rdx)
  402348:	4c 89 62 08          	mov    %r12,0x8(%rdx)
    if ((++(hash->num_elems)) > hash->max_num_elems_before_resize)
  40234c:	48 83 c0 01          	add    $0x1,%rax
    *(*(item_placeholder) = item) = (typeof(*item)){
  402350:	48 c7 42 10 00 00 00 	movq   $0x0,0x10(%rdx)
  402357:	00 
    if ((++(hash->num_elems)) > hash->max_num_elems_before_resize)
  402358:	49 89 47 78          	mov    %rax,0x78(%r15)
  40235c:	49 3b 87 80 00 00 00 	cmp    0x80(%r15),%rax
  402363:	0f 8e 90 fa ff ff    	jle    401df9 <fc_solve_check_and_add_state+0x3a9>
    const int old_size = hash->size;
  402369:	41 8b 57 6c          	mov    0x6c(%r15),%edx
    const int new_size = old_size << 1;
  40236d:	44 8d 24 12          	lea    (%rdx,%rdx,1),%r12d
    if (new_size < old_size)
  402371:	44 39 e2             	cmp    %r12d,%edx
  402374:	0f 8e b7 01 00 00    	jle    402531 <fc_solve_check_and_add_state+0xae1>
        hash->max_num_elems_before_resize = FCS_INT_LIMIT_MAX;
  40237a:	48 b8 ff ff ff ff ff 	movabs $0x7fffffffffffffff,%rax
  402381:	ff ff 7f 
  402384:	49 89 87 80 00 00 00 	mov    %rax,0x80(%r15)
  40238b:	e9 69 fa ff ff       	jmpq   401df9 <fc_solve_check_and_add_state+0x3a9>
        memcpy(new_ptr, column, col_len);
  402390:	48 8b 44 1e f8       	mov    -0x8(%rsi,%rbx,1),%rax
  402395:	48 8d 4b ff          	lea    -0x1(%rbx),%rcx
  402399:	48 89 d7             	mov    %rdx,%rdi
  40239c:	48 c1 e9 03          	shr    $0x3,%rcx
  4023a0:	48 89 44 1a f8       	mov    %rax,-0x8(%rdx,%rbx,1)
  4023a5:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  4023a8:	e9 75 f7 ff ff       	jmpq   401b22 <fc_solve_check_and_add_state+0xd2>
    char *const new_data = meta_request_new_buffer(allocator->meta);
  4023ad:	49 8b 97 f8 00 00 00 	mov    0xf8(%r15),%rdx
    char *const ret = meta_alloc->recycle_bin;
  4023b4:	48 8b 02             	mov    (%rdx),%rax
    if (ret)
  4023b7:	48 85 c0             	test   %rax,%rax
  4023ba:	0f 84 72 02 00 00    	je     402632 <fc_solve_check_and_add_state+0xbe2>
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  4023c0:	48 8b 08             	mov    (%rax),%rcx
  4023c3:	48 89 0a             	mov    %rcx,(%rdx)
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  4023c6:	49 8b 97 d8 00 00 00 	mov    0xd8(%r15),%rdx
  4023cd:	48 89 10             	mov    %rdx,(%rax)
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  4023d0:	48 8d 50 08          	lea    0x8(%rax),%rdx
    allocator->old_list = new_data;
  4023d4:	49 89 87 d8 00 00 00 	mov    %rax,0xd8(%r15)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  4023db:	48 05 80 fe 00 00    	add    $0xfe80,%rax
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  4023e1:	49 89 97 f0 00 00 00 	mov    %rdx,0xf0(%r15)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  4023e8:	49 89 87 e0 00 00 00 	mov    %rax,0xe0(%r15)
  4023ef:	e9 fe f6 ff ff       	jmpq   401af2 <fc_solve_check_and_add_state+0xa2>
        item_placeholder = &(list->first_item);
  4023f4:	48 89 c3             	mov    %rax,%rbx
  4023f7:	e9 15 ff ff ff       	jmpq   402311 <fc_solve_check_and_add_state+0x8c1>
    char *const new_data = meta_request_new_buffer(allocator->meta);
  4023fc:	49 8b 97 a8 00 00 00 	mov    0xa8(%r15),%rdx
    char *const ret = meta_alloc->recycle_bin;
  402403:	48 8b 02             	mov    (%rdx),%rax
    if (ret)
  402406:	48 85 c0             	test   %rax,%rax
  402409:	0f 84 3a 02 00 00    	je     402649 <fc_solve_check_and_add_state+0xbf9>
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  40240f:	48 8b 08             	mov    (%rax),%rcx
  402412:	48 89 0a             	mov    %rcx,(%rdx)
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  402415:	49 8b 97 88 00 00 00 	mov    0x88(%r15),%rdx
  40241c:	48 89 10             	mov    %rdx,(%rax)
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40241f:	48 8d 50 08          	lea    0x8(%rax),%rdx
    allocator->old_list = new_data;
  402423:	49 89 87 88 00 00 00 	mov    %rax,0x88(%r15)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40242a:	48 05 80 fe 00 00    	add    $0xfe80,%rax
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  402430:	49 89 97 a0 00 00 00 	mov    %rdx,0xa0(%r15)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  402437:	49 89 87 90 00 00 00 	mov    %rax,0x90(%r15)
  40243e:	e9 f0 fe ff ff       	jmpq   402333 <fc_solve_check_and_add_state+0x8e3>
        const int min_len = min(s1[0], s2[0]);
  402443:	45 0f be 4d 00       	movsbl 0x0(%r13),%r9d
  402448:	41 0f b6 3c 24       	movzbl (%r12),%edi
  40244d:	41 38 f9             	cmp    %dil,%r9b
  402450:	40 0f be c7          	movsbl %dil,%eax
  402454:	41 0f 4e c1          	cmovle %r9d,%eax
        for (int a = 1; a <= min_len; a++)
  402458:	84 c0                	test   %al,%al
  40245a:	7e 40                	jle    40249c <fc_solve_check_and_add_state+0xa4c>
            if (ret != 0)
  40245c:	41 0f b6 74 24 01    	movzbl 0x1(%r12),%esi
  402462:	41 38 75 01          	cmp    %sil,0x1(%r13)
  402466:	0f 85 54 fd ff ff    	jne    4021c0 <fc_solve_check_and_add_state+0x770>
  40246c:	8d 70 ff             	lea    -0x1(%rax),%esi
  40246f:	b8 02 00 00 00       	mov    $0x2,%eax
  402474:	48 83 c6 02          	add    $0x2,%rsi
  402478:	eb 1d                	jmp    402497 <fc_solve_check_and_add_state+0xa47>
  40247a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
            const int ret = fc_solve_card_compare(s1[a], s2[a]);
  402480:	41 0f b6 4c 05 00    	movzbl 0x0(%r13,%rax,1),%ecx
  402486:	41 0f b6 14 04       	movzbl (%r12,%rax,1),%edx
  40248b:	48 83 c0 01          	add    $0x1,%rax
            if (ret != 0)
  40248f:	38 d1                	cmp    %dl,%cl
  402491:	0f 85 29 fd ff ff    	jne    4021c0 <fc_solve_check_and_add_state+0x770>
        for (int a = 1; a <= min_len; a++)
  402497:	48 39 c6             	cmp    %rax,%rsi
  40249a:	75 e4                	jne    402480 <fc_solve_check_and_add_state+0xa30>
    if (s1[0] < s2[0])
  40249c:	41 38 f9             	cmp    %dil,%r9b
  40249f:	0f 8f 1b fd ff ff    	jg     4021c0 <fc_solve_check_and_add_state+0x770>
  4024a5:	0f 9d c0             	setge  %al
  4024a8:	e9 4c fd ff ff       	jmpq   4021f9 <fc_solve_check_and_add_state+0x7a9>
  4024ad:	48 89 d8             	mov    %rbx,%rax
        item_placeholder = &(last_item->next);
  4024b0:	49 83 c6 10          	add    $0x10,%r14
  4024b4:	4c 89 eb             	mov    %r13,%rbx
  4024b7:	49 89 c5             	mov    %rax,%r13
    if ((size_t)(allocator->max_ptr - allocator->ptr) < how_much)
  4024ba:	49 8b 57 48          	mov    0x48(%r15),%rdx
  4024be:	49 8b 47 40          	mov    0x40(%r15),%rax
  4024c2:	48 29 d0             	sub    %rdx,%rax
  4024c5:	48 83 f8 17          	cmp    $0x17,%rax
  4024c9:	0f 86 2b 01 00 00    	jbe    4025fa <fc_solve_check_and_add_state+0xbaa>
        allocator->rollback_ptr = allocator->ptr;
  4024cf:	49 89 57 50          	mov    %rdx,0x50(%r15)
    allocator->ptr += how_much;
  4024d3:	48 8d 42 18          	lea    0x18(%rdx),%rax
  4024d7:	49 89 47 48          	mov    %rax,0x48(%r15)
    if ((++(hash->num_elems)) > hash->max_num_elems_before_resize)
  4024db:	49 8b 47 28          	mov    0x28(%r15),%rax
    *(*(item_placeholder) = item) = (typeof(*item)){
  4024df:	49 89 16             	mov    %rdx,(%r14)
  4024e2:	48 89 1a             	mov    %rbx,(%rdx)
  4024e5:	4c 89 6a 08          	mov    %r13,0x8(%rdx)
    if ((++(hash->num_elems)) > hash->max_num_elems_before_resize)
  4024e9:	48 83 c0 01          	add    $0x1,%rax
    *(*(item_placeholder) = item) = (typeof(*item)){
  4024ed:	48 c7 42 10 00 00 00 	movq   $0x0,0x10(%rdx)
  4024f4:	00 
    if ((++(hash->num_elems)) > hash->max_num_elems_before_resize)
  4024f5:	49 89 47 28          	mov    %rax,0x28(%r15)
  4024f9:	49 3b 47 30          	cmp    0x30(%r15),%rax
  4024fd:	0f 8f d3 00 00 00    	jg     4025d6 <fc_solve_check_and_add_state+0xb86>
  402503:	48 8b 44 24 30       	mov    0x30(%rsp),%rax
  402508:	48 8b 40 08          	mov    0x8(%rax),%rax
  40250c:	48 8b 00             	mov    (%rax),%rax
    if (likely(parent_state))
  40250f:	48 85 c0             	test   %rax,%rax
  402512:	0f 84 59 01 00 00    	je     402671 <fc_solve_check_and_add_state+0xc21>
        (FCS_S_NUM_ACTIVE_CHILDREN(parent_state))++;
  402518:	66 83 40 54 01       	addw   $0x1,0x54(%rax)
  40251d:	b8 01 00 00 00       	mov    $0x1,%eax
}
  402522:	48 83 c4 48          	add    $0x48,%rsp
  402526:	5b                   	pop    %rbx
  402527:	5d                   	pop    %rbp
  402528:	41 5c                	pop    %r12
  40252a:	41 5d                	pop    %r13
  40252c:	41 5e                	pop    %r14
  40252e:	41 5f                	pop    %r15
  402530:	c3                   	retq   
        calloc(new_size, sizeof(new_entries[0]));
  402531:	49 63 c4             	movslq %r12d,%rax
    hash_table_entry *const new_entries =
  402534:	be 08 00 00 00       	mov    $0x8,%esi
  402539:	89 54 24 18          	mov    %edx,0x18(%rsp)
        calloc(new_size, sizeof(new_entries[0]));
  40253d:	48 89 04 24          	mov    %rax,(%rsp)
    const int new_size_bitmask = new_size - 1;
  402541:	41 8d 5c 24 ff       	lea    -0x1(%r12),%ebx
    hash_table_entry *const new_entries =
  402546:	48 89 c7             	mov    %rax,%rdi
  402549:	e8 b2 eb ff ff       	callq  401100 <calloc@plt>
    for (int i = 0; i < old_size; i++)
  40254e:	8b 54 24 18          	mov    0x18(%rsp),%edx
  402552:	85 d2                	test   %edx,%edx
  402554:	7e 45                	jle    40259b <fc_solve_check_and_add_state+0xb4b>
  402556:	48 8b 74 24 28       	mov    0x28(%rsp),%rsi
  40255b:	83 ea 01             	sub    $0x1,%edx
  40255e:	4c 8d 44 d6 08       	lea    0x8(%rsi,%rdx,8),%r8
  402563:	48 89 f7             	mov    %rsi,%rdi
        hash_item *item = entries[i].first_item;
  402566:	48 8b 17             	mov    (%rdi),%rdx
        while (item != NULL)
  402569:	48 85 d2             	test   %rdx,%rdx
  40256c:	74 24                	je     402592 <fc_solve_check_and_add_state+0xb42>
  40256e:	66 90                	xchg   %ax,%ax
            const int place = item->hash_value & new_size_bitmask;
  402570:	8b 4a 08             	mov    0x8(%rdx),%ecx
            hash_item *const next_item = item->next;
  402573:	48 8b 72 10          	mov    0x10(%rdx),%rsi
            const int place = item->hash_value & new_size_bitmask;
  402577:	21 d9                	and    %ebx,%ecx
            item->next = new_entries[place].first_item;
  402579:	48 63 c9             	movslq %ecx,%rcx
  40257c:	48 8d 0c c8          	lea    (%rax,%rcx,8),%rcx
  402580:	4c 8b 09             	mov    (%rcx),%r9
  402583:	4c 89 4a 10          	mov    %r9,0x10(%rdx)
            new_entries[place].first_item = item;
  402587:	48 89 11             	mov    %rdx,(%rcx)
  40258a:	48 89 f2             	mov    %rsi,%rdx
        while (item != NULL)
  40258d:	48 85 f6             	test   %rsi,%rsi
  402590:	75 de                	jne    402570 <fc_solve_check_and_add_state+0xb20>
  402592:	48 83 c7 08          	add    $0x8,%rdi
    for (int i = 0; i < old_size; i++)
  402596:	49 39 f8             	cmp    %rdi,%r8
  402599:	75 cb                	jne    402566 <fc_solve_check_and_add_state+0xb16>
    free(hash->entries);
  40259b:	48 8b 7c 24 28       	mov    0x28(%rsp),%rdi
  4025a0:	48 89 44 24 18       	mov    %rax,0x18(%rsp)
  4025a5:	e8 a6 ea ff ff       	callq  401050 <free@plt>
    hash->entries = new_entries;
  4025aa:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
    hash->size = new_size;
  4025af:	45 89 67 6c          	mov    %r12d,0x6c(%r15)
    hash->size_bitmask = new_size_bitmask;
  4025b3:	41 89 5f 70          	mov    %ebx,0x70(%r15)
    hash->entries = new_entries;
  4025b7:	49 89 47 60          	mov    %rax,0x60(%r15)
    hash->max_num_elems_before_resize = (new_size << 1);
  4025bb:	48 8b 04 24          	mov    (%rsp),%rax
  4025bf:	48 01 c0             	add    %rax,%rax
  4025c2:	49 89 87 80 00 00 00 	mov    %rax,0x80(%r15)
  4025c9:	e9 2b f8 ff ff       	jmpq   401df9 <fc_solve_check_and_add_state+0x3a9>
        item_placeholder = &(list->first_item);
  4025ce:	49 89 c6             	mov    %rax,%r14
  4025d1:	e9 e4 fe ff ff       	jmpq   4024ba <fc_solve_check_and_add_state+0xa6a>
    const int old_size = hash->size;
  4025d6:	41 8b 57 1c          	mov    0x1c(%r15),%edx
    const int new_size = old_size << 1;
  4025da:	44 8d 2c 12          	lea    (%rdx,%rdx,1),%r13d
    if (new_size < old_size)
  4025de:	44 39 ea             	cmp    %r13d,%edx
  4025e1:	0f 8e a3 00 00 00    	jle    40268a <fc_solve_check_and_add_state+0xc3a>
        hash->max_num_elems_before_resize = FCS_INT_LIMIT_MAX;
  4025e7:	48 b8 ff ff ff ff ff 	movabs $0x7fffffffffffffff,%rax
  4025ee:	ff ff 7f 
  4025f1:	49 89 47 30          	mov    %rax,0x30(%r15)
  4025f5:	e9 09 ff ff ff       	jmpq   402503 <fc_solve_check_and_add_state+0xab3>
    char *const new_data = meta_request_new_buffer(allocator->meta);
  4025fa:	49 8b 57 58          	mov    0x58(%r15),%rdx
    char *const ret = meta_alloc->recycle_bin;
  4025fe:	48 8b 02             	mov    (%rdx),%rax
    if (ret)
  402601:	48 85 c0             	test   %rax,%rax
  402604:	0f 84 00 01 00 00    	je     40270a <fc_solve_check_and_add_state+0xcba>
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  40260a:	48 8b 08             	mov    (%rax),%rcx
  40260d:	48 89 0a             	mov    %rcx,(%rdx)
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  402610:	49 8b 57 38          	mov    0x38(%r15),%rdx
  402614:	48 89 10             	mov    %rdx,(%rax)
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  402617:	48 8d 50 08          	lea    0x8(%rax),%rdx
    allocator->old_list = new_data;
  40261b:	49 89 47 38          	mov    %rax,0x38(%r15)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40261f:	48 05 80 fe 00 00    	add    $0xfe80,%rax
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  402625:	49 89 57 50          	mov    %rdx,0x50(%r15)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  402629:	49 89 47 40          	mov    %rax,0x40(%r15)
  40262d:	e9 a1 fe ff ff       	jmpq   4024d3 <fc_solve_check_and_add_state+0xa83>
        return malloc(ALLOCED_SIZE);
  402632:	bf 80 fe 00 00       	mov    $0xfe80,%edi
  402637:	48 89 34 24          	mov    %rsi,(%rsp)
  40263b:	e8 b0 ea ff ff       	callq  4010f0 <malloc@plt>
  402640:	48 8b 34 24          	mov    (%rsp),%rsi
  402644:	e9 7d fd ff ff       	jmpq   4023c6 <fc_solve_check_and_add_state+0x976>
  402649:	bf 80 fe 00 00       	mov    $0xfe80,%edi
  40264e:	4c 89 04 24          	mov    %r8,(%rsp)
  402652:	e8 99 ea ff ff       	callq  4010f0 <malloc@plt>
  402657:	4c 8b 04 24          	mov    (%rsp),%r8
  40265b:	e9 b5 fd ff ff       	jmpq   402415 <fc_solve_check_and_add_state+0x9c5>
        memcpy(new_ptr, column, col_len);
  402660:	8b 06                	mov    (%rsi),%eax
  402662:	89 02                	mov    %eax,(%rdx)
  402664:	8b 44 1e fc          	mov    -0x4(%rsi,%rbx,1),%eax
  402668:	89 44 1a fc          	mov    %eax,-0x4(%rdx,%rbx,1)
  40266c:	e9 b1 f4 ff ff       	jmpq   401b22 <fc_solve_check_and_add_state+0xd2>
    if (likely(parent_state))
  402671:	b8 01 00 00 00       	mov    $0x1,%eax
  402676:	e9 a7 fe ff ff       	jmpq   402522 <fc_solve_check_and_add_state+0xad2>
        memcpy(new_ptr, column, col_len);
  40267b:	0f b7 44 1e fe       	movzwl -0x2(%rsi,%rbx,1),%eax
  402680:	66 89 44 1a fe       	mov    %ax,-0x2(%rdx,%rbx,1)
  402685:	e9 98 f4 ff ff       	jmpq   401b22 <fc_solve_check_and_add_state+0xd2>
  40268a:	89 14 24             	mov    %edx,(%rsp)
    const int new_size_bitmask = new_size - 1;
  40268d:	45 8d 65 ff          	lea    -0x1(%r13),%r12d
        calloc(new_size, sizeof(new_entries[0]));
  402691:	49 63 dd             	movslq %r13d,%rbx
    hash_table_entry *const new_entries =
  402694:	be 08 00 00 00       	mov    $0x8,%esi
  402699:	48 89 df             	mov    %rbx,%rdi
  40269c:	e8 5f ea ff ff       	callq  401100 <calloc@plt>
    for (int i = 0; i < old_size; i++)
  4026a1:	8b 14 24             	mov    (%rsp),%edx
    hash_table_entry *const new_entries =
  4026a4:	49 89 c6             	mov    %rax,%r14
    for (int i = 0; i < old_size; i++)
  4026a7:	85 d2                	test   %edx,%edx
  4026a9:	7e 3f                	jle    4026ea <fc_solve_check_and_add_state+0xc9a>
  4026ab:	83 ea 01             	sub    $0x1,%edx
  4026ae:	48 89 e8             	mov    %rbp,%rax
  4026b1:	4c 8d 44 d5 08       	lea    0x8(%rbp,%rdx,8),%r8
        hash_item *item = entries[i].first_item;
  4026b6:	48 8b 10             	mov    (%rax),%rdx
        while (item != NULL)
  4026b9:	48 85 d2             	test   %rdx,%rdx
  4026bc:	74 23                	je     4026e1 <fc_solve_check_and_add_state+0xc91>
            const int place = item->hash_value & new_size_bitmask;
  4026be:	8b 4a 08             	mov    0x8(%rdx),%ecx
            hash_item *const next_item = item->next;
  4026c1:	48 8b 72 10          	mov    0x10(%rdx),%rsi
            const int place = item->hash_value & new_size_bitmask;
  4026c5:	44 21 e1             	and    %r12d,%ecx
            item->next = new_entries[place].first_item;
  4026c8:	48 63 c9             	movslq %ecx,%rcx
  4026cb:	49 8d 0c ce          	lea    (%r14,%rcx,8),%rcx
  4026cf:	48 8b 39             	mov    (%rcx),%rdi
  4026d2:	48 89 7a 10          	mov    %rdi,0x10(%rdx)
            new_entries[place].first_item = item;
  4026d6:	48 89 11             	mov    %rdx,(%rcx)
  4026d9:	48 89 f2             	mov    %rsi,%rdx
        while (item != NULL)
  4026dc:	48 85 f6             	test   %rsi,%rsi
  4026df:	75 dd                	jne    4026be <fc_solve_check_and_add_state+0xc6e>
  4026e1:	48 83 c0 08          	add    $0x8,%rax
    for (int i = 0; i < old_size; i++)
  4026e5:	4c 39 c0             	cmp    %r8,%rax
  4026e8:	75 cc                	jne    4026b6 <fc_solve_check_and_add_state+0xc66>
    free(hash->entries);
  4026ea:	48 89 ef             	mov    %rbp,%rdi
  4026ed:	48 01 db             	add    %rbx,%rbx
  4026f0:	e8 5b e9 ff ff       	callq  401050 <free@plt>
    hash->entries = new_entries;
  4026f5:	4d 89 77 10          	mov    %r14,0x10(%r15)
    hash->size = new_size;
  4026f9:	45 89 6f 1c          	mov    %r13d,0x1c(%r15)
    hash->size_bitmask = new_size_bitmask;
  4026fd:	45 89 67 20          	mov    %r12d,0x20(%r15)
  402701:	49 89 5f 30          	mov    %rbx,0x30(%r15)
  402705:	e9 f9 fd ff ff       	jmpq   402503 <fc_solve_check_and_add_state+0xab3>
  40270a:	bf 80 fe 00 00       	mov    $0xfe80,%edi
  40270f:	e8 dc e9 ff ff       	callq  4010f0 <malloc@plt>
  402714:	e9 f7 fe ff ff       	jmpq   402610 <fc_solve_check_and_add_state+0xbc0>
  402719:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)

0000000000402720 <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)
{
  402720:	41 57                	push   %r15
  402722:	48 89 d1             	mov    %rdx,%rcx
#define EMPTY
    tests_define_accessors__generic(EMPTY);
    STACKS__SET_PARAMS();

    sfs_check_state_begin();
  402725:	48 89 f2             	mov    %rsi,%rdx
{
  402728:	41 56                	push   %r14
  40272a:	41 55                	push   %r13
  40272c:	41 54                	push   %r12
    bool cards_were_moved = FALSE;
  40272e:	45 31 e4             	xor    %r12d,%r12d
{
  402731:	55                   	push   %rbp
  402732:	48 89 fd             	mov    %rdi,%rbp
  402735:	53                   	push   %rbx
  402736:	48 83 ec 38          	sub    $0x38,%rsp
    tests_define_accessors__generic(EMPTY);
  40273a:	48 8b 3f             	mov    (%rdi),%rdi
    sfs_check_state_begin();
  40273d:	48 8d 74 24 10       	lea    0x10(%rsp),%rsi
    tests_define_accessors__generic(EMPTY);
  402742:	48 8d 9f 00 01 00 00 	lea    0x100(%rdi),%rbx
    sfs_check_state_begin();
  402749:	e8 b2 f1 ff ff       	callq  401900 <fc_solve_sfs_check_state_begin>
  40274e:	48 8b 7c 24 10       	mov    0x10(%rsp),%rdi
    bool cards_were_moved = FALSE;
  402753:	31 c0                	xor    %eax,%eax
    bool num_cards_moved;
    do
    {
        num_cards_moved = FALSE;
  402755:	45 31 d2             	xor    %r10d,%r10d
  402758:	eb 14                	jmp    40276e <fc_solve_sfs_raymond_prune+0x4e>
  40275a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
  402760:	48 83 c0 01          	add    $0x1,%rax
        for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  402764:	48 83 f8 08          	cmp    $0x8,%rax
  402768:	0f 84 02 01 00 00    	je     402870 <fc_solve_sfs_raymond_prune+0x150>
        {
            const_AUTO(col, fcs_state_get_col(new_state_key, stack_idx));
  40276e:	48 63 d0             	movslq %eax,%rdx
  402771:	4c 63 c0             	movslq %eax,%r8
  402774:	48 8b 34 d7          	mov    (%rdi,%rdx,8),%rsi
            const int cards_num = fcs_col_len(col);
  402778:	0f be 16             	movsbl (%rsi),%edx
  40277b:	89 d1                	mov    %edx,%ecx

            if (!cards_num)
  40277d:	85 d2                	test   %edx,%edx
  40277f:	74 df                	je     402760 <fc_solve_sfs_raymond_prune+0x40>
            {
                continue;
            }
            /* Get the top card in the stack */
            const fcs_card card = fcs_col_get_card(col, cards_num - 1);
  402781:	83 ea 01             	sub    $0x1,%edx
  402784:	48 63 d2             	movslq %edx,%rdx
  402787:	44 0f b6 4c 16 01    	movzbl 0x1(%rsi,%rdx,1),%r9d
    const int_fast32_t suit = fcs_card_suit(card);
  40278d:	4c 89 ca             	mov    %r9,%rdx
    const int_fast32_t rank = fcs_card_rank(card);
  402790:	45 89 cb             	mov    %r9d,%r11d
    const int_fast32_t suit = fcs_card_suit(card);
  402793:	83 e2 03             	and    $0x3,%edx
    const int_fast32_t rank = fcs_card_rank(card);
  402796:	41 c0 fb 02          	sar    $0x2,%r11b
        if (fcs_foundation_value(*ptr_state, ret_val) == rank_min_1)
  40279a:	4c 0f be 6c 17 44    	movsbq 0x44(%rdi,%rdx,1),%r13
    const int_fast32_t rank = fcs_card_rank(card);
  4027a0:	4d 0f be db          	movsbq %r11b,%r11
    const int_fast32_t rank_min_1 = rank - 1;
  4027a4:	4d 8d 73 ff          	lea    -0x1(%r11),%r14
        if (fcs_foundation_value(*ptr_state, ret_val) == rank_min_1)
  4027a8:	4d 39 ee             	cmp    %r13,%r14
  4027ab:	75 b3                	jne    402760 <fc_solve_sfs_raymond_prune+0x40>
  4027ad:	45 89 ce             	mov    %r9d,%r14d
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  4027b0:	45 89 cd             	mov    %r9d,%r13d
                if (fcs_foundation_value(*ptr_state, f) <
  4027b3:	4c 0f be 7f 44       	movsbq 0x44(%rdi),%r15
    const int_fast32_t rank_min_2 = rank - 2;
  4027b8:	49 83 eb 02          	sub    $0x2,%r11
  4027bc:	41 83 e6 01          	and    $0x1,%r14d
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  4027c0:	41 f7 d5             	not    %r13d
  4027c3:	44 88 74 24 0f       	mov    %r14b,0xf(%rsp)
  4027c8:	41 83 e5 01          	and    $0x1,%r13d
                    rank_min_2 -
  4027cc:	4d 89 de             	mov    %r11,%r14
  4027cf:	4d 29 ee             	sub    %r13,%r14
                if (fcs_foundation_value(*ptr_state, f) <
  4027d2:	4d 39 f7             	cmp    %r14,%r15
  4027d5:	7c 89                	jl     402760 <fc_solve_sfs_raymond_prune+0x40>
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  4027d7:	4c 0f be 74 24 0f    	movsbq 0xf(%rsp),%r14
                    rank_min_2 -
  4027dd:	4d 89 df             	mov    %r11,%r15
                if (fcs_foundation_value(*ptr_state, f) <
  4027e0:	4c 0f be 6f 45       	movsbq 0x45(%rdi),%r13
                    rank_min_2 -
  4027e5:	4d 29 f7             	sub    %r14,%r15
                if (fcs_foundation_value(*ptr_state, f) <
  4027e8:	4d 39 fd             	cmp    %r15,%r13
  4027eb:	0f 8c 6f ff ff ff    	jl     402760 <fc_solve_sfs_raymond_prune+0x40>
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  4027f1:	45 89 cd             	mov    %r9d,%r13d
                if (fcs_foundation_value(*ptr_state, f) <
  4027f4:	4c 0f be 77 46       	movsbq 0x46(%rdi),%r14
                    rank_min_2 -
  4027f9:	4d 89 df             	mov    %r11,%r15
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  4027fc:	41 83 f5 fd          	xor    $0xfffffffd,%r13d
  402800:	41 83 e5 01          	and    $0x1,%r13d
                    rank_min_2 -
  402804:	4d 29 ef             	sub    %r13,%r15
                if (fcs_foundation_value(*ptr_state, f) <
  402807:	4d 39 fe             	cmp    %r15,%r14
  40280a:	0f 8c 50 ff ff ff    	jl     402760 <fc_solve_sfs_raymond_prune+0x40>
  402810:	4c 0f be 6f 47       	movsbq 0x47(%rdi),%r13
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402815:	41 83 e1 01          	and    $0x1,%r9d
                    rank_min_2 -
  402819:	4d 29 cb             	sub    %r9,%r11
                if (fcs_foundation_value(*ptr_state, f) <
  40281c:	4d 39 dd             	cmp    %r11,%r13
  40281f:	0f 8c 3b ff ff ff    	jl     402760 <fc_solve_sfs_raymond_prune+0x40>
                continue;
            }
            /* We can safely move it. */
            num_cards_moved = TRUE;

            my_copy_stack(stack_idx);
  402825:	4c 8b 4c 24 18       	mov    0x18(%rsp),%r9
  40282a:	45 8b 51 14          	mov    0x14(%r9),%r10d
  40282e:	45 0f a3 c2          	bt     %r8d,%r10d
  402832:	0f 83 88 01 00 00    	jae    4029c0 <fc_solve_sfs_raymond_prune+0x2a0>

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);
  402838:	83 e9 01             	sub    $0x1,%ecx
  40283b:	48 83 c0 01          	add    $0x1,%rax
            num_cards_moved = TRUE;
  40283f:	41 ba 01 00 00 00    	mov    $0x1,%r10d
  402845:	88 0e                	mov    %cl,(%rsi)
  402847:	48 0f be c9          	movsbq %cl,%rcx
  40284b:	c6 44 0e 01 00       	movb   $0x0,0x1(%rsi,%rcx,1)
            fcs_state_pop_col_top(&new_state_key, stack_idx);
            fcs_increment_foundation(new_state_key, dest_foundation);
  402850:	48 8b 7c 24 10       	mov    0x10(%rsp),%rdi
  402855:	80 44 17 44 01       	addb   $0x1,0x44(%rdi,%rdx,1)
        for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  40285a:	48 83 f8 08          	cmp    $0x8,%rax
  40285e:	0f 85 0a ff ff ff    	jne    40276e <fc_solve_sfs_raymond_prune+0x4e>
  402864:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40286b:	00 00 00 00 
  40286f:	90                   	nop

#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);
  402870:	0f b6 47 40          	movzbl 0x40(%rdi),%eax
            if (fcs_card_is_empty(card))
  402874:	84 c0                	test   %al,%al
  402876:	0f 85 f4 03 00 00    	jne    402c70 <fc_solve_sfs_raymond_prune+0x550>
            const fcs_card card = fcs_freecell_card(new_state_key, fc);
  40287c:	0f b6 57 41          	movzbl 0x41(%rdi),%edx
  402880:	0f b6 47 42          	movzbl 0x42(%rdi),%eax
  402884:	0f b6 4f 43          	movzbl 0x43(%rdi),%ecx
            if (fcs_card_is_empty(card))
  402888:	84 d2                	test   %dl,%dl
  40288a:	0f 85 f0 02 00 00    	jne    402b80 <fc_solve_sfs_raymond_prune+0x460>
  402890:	84 c0                	test   %al,%al
  402892:	0f 85 c8 01 00 00    	jne    402a60 <fc_solve_sfs_raymond_prune+0x340>
  402898:	84 c9                	test   %cl,%cl
  40289a:	75 74                	jne    402910 <fc_solve_sfs_raymond_prune+0x1f0>
            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)
  40289c:	45 84 d2             	test   %r10b,%r10b
  40289f:	0f 85 0a 01 00 00    	jne    4029af <fc_solve_sfs_raymond_prune+0x28f>
        }
    } while (num_cards_moved);

    if (!cards_were_moved)
    {
        return NULL;
  4028a5:	31 c0                	xor    %eax,%eax
    if (!cards_were_moved)
  4028a7:	45 84 e4             	test   %r12b,%r12b
  4028aa:	74 4f                	je     4028fb <fc_solve_sfs_raymond_prune+0x1db>
    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);
  4028ac:	48 8b 5d 00          	mov    0x0(%rbp),%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(
  4028b0:	48 8d 54 24 20       	lea    0x20(%rsp),%rdx
  4028b5:	48 8d 74 24 10       	lea    0x10(%rsp),%rsi
  4028ba:	48 89 df             	mov    %rbx,%rdi
  4028bd:	e8 8e f1 ff ff       	callq  401a50 <fc_solve_check_and_add_state>
  4028c2:	84 c0                	test   %al,%al
  4028c4:	0f 85 55 04 00 00    	jne    402d1f <fc_solve_sfs_raymond_prune+0x5ff>
            hard_thread, raw_ptr_new_state_raw, &existing_state))
    {
        if (HT_FIELD(hard_thread, allocated_from_list))
  4028ca:	80 bb 18 05 00 00 00 	cmpb   $0x0,0x518(%rbx)
  4028d1:	0f 84 60 04 00 00    	je     402d37 <fc_solve_sfs_raymond_prune+0x617>
        {
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  4028d7:	48 8b 93 b0 00 00 00 	mov    0xb0(%rbx),%rdx
  4028de:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
  4028e3:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  4028e6:	48 8b 44 24 10       	mov    0x10(%rsp),%rax
  4028eb:	48 89 83 b0 00 00 00 	mov    %rax,0xb0(%rbx)
  4028f2:	48 8b 44 24 20       	mov    0x20(%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)
    const int_fast32_t suit = fcs_card_suit(card);
  402910:	49 89 c8             	mov    %rcx,%r8
    const int_fast32_t rank = fcs_card_rank(card);
  402913:	89 c8                	mov    %ecx,%eax
    const int_fast32_t suit = fcs_card_suit(card);
  402915:	41 83 e0 03          	and    $0x3,%r8d
    const int_fast32_t rank = fcs_card_rank(card);
  402919:	c0 f8 02             	sar    $0x2,%al
        if (fcs_foundation_value(*ptr_state, ret_val) == rank_min_1)
  40291c:	4a 0f be 54 07 44    	movsbq 0x44(%rdi,%r8,1),%rdx
    const int_fast32_t rank = fcs_card_rank(card);
  402922:	48 0f be c0          	movsbq %al,%rax
    const int_fast32_t rank_min_1 = rank - 1;
  402926:	48 8d 70 ff          	lea    -0x1(%rax),%rsi
        if (fcs_foundation_value(*ptr_state, ret_val) == rank_min_1)
  40292a:	49 89 d1             	mov    %rdx,%r9
  40292d:	48 39 d6             	cmp    %rdx,%rsi
  402930:	0f 85 66 ff ff ff    	jne    40289c <fc_solve_sfs_raymond_prune+0x17c>
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402936:	89 ce                	mov    %ecx,%esi
                if (fcs_foundation_value(*ptr_state, f) <
  402938:	4c 0f be 5f 44       	movsbq 0x44(%rdi),%r11
    const int_fast32_t rank_min_2 = rank - 2;
  40293d:	48 83 e8 02          	sub    $0x2,%rax
  402941:	89 ca                	mov    %ecx,%edx
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402943:	f7 d6                	not    %esi
                    rank_min_2 -
  402945:	49 89 c7             	mov    %rax,%r15
  402948:	83 e2 01             	and    $0x1,%edx
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  40294b:	83 e6 01             	and    $0x1,%esi
                    rank_min_2 -
  40294e:	49 29 f7             	sub    %rsi,%r15
                if (fcs_foundation_value(*ptr_state, f) <
  402951:	4d 39 fb             	cmp    %r15,%r11
  402954:	0f 8c 42 ff ff ff    	jl     40289c <fc_solve_sfs_raymond_prune+0x17c>
  40295a:	48 0f be 77 45       	movsbq 0x45(%rdi),%rsi
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  40295f:	48 0f be d2          	movsbq %dl,%rdx
                    rank_min_2 -
  402963:	49 89 c7             	mov    %rax,%r15
  402966:	49 29 d7             	sub    %rdx,%r15
                if (fcs_foundation_value(*ptr_state, f) <
  402969:	4c 39 fe             	cmp    %r15,%rsi
  40296c:	0f 8c 2a ff ff ff    	jl     40289c <fc_solve_sfs_raymond_prune+0x17c>
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402972:	89 ca                	mov    %ecx,%edx
                if (fcs_foundation_value(*ptr_state, f) <
  402974:	48 0f be 77 46       	movsbq 0x46(%rdi),%rsi
                    rank_min_2 -
  402979:	49 89 c7             	mov    %rax,%r15
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  40297c:	83 f2 fd             	xor    $0xfffffffd,%edx
  40297f:	83 e2 01             	and    $0x1,%edx
                    rank_min_2 -
  402982:	49 29 d7             	sub    %rdx,%r15
                if (fcs_foundation_value(*ptr_state, f) <
  402985:	4c 39 fe             	cmp    %r15,%rsi
  402988:	0f 8c 0e ff ff ff    	jl     40289c <fc_solve_sfs_raymond_prune+0x17c>
  40298e:	48 0f be 57 47       	movsbq 0x47(%rdi),%rdx
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402993:	83 e1 01             	and    $0x1,%ecx
                    rank_min_2 -
  402996:	48 29 c8             	sub    %rcx,%rax
                if (fcs_foundation_value(*ptr_state, f) <
  402999:	48 39 c2             	cmp    %rax,%rdx
  40299c:	0f 8c fa fe ff ff    	jl     40289c <fc_solve_sfs_raymond_prune+0x17c>
            fcs_increment_foundation(new_state_key, dest_foundation);
  4029a2:	41 8d 41 01          	lea    0x1(%r9),%eax
            fcs_empty_freecell(new_state_key, fc);
  4029a6:	c6 47 43 00          	movb   $0x0,0x43(%rdi)
            fcs_increment_foundation(new_state_key, dest_foundation);
  4029aa:	42 88 44 07 44       	mov    %al,0x44(%rdi,%r8,1)
  4029af:	41 bc 01 00 00 00    	mov    $0x1,%r12d
  4029b5:	e9 99 fd ff ff       	jmpq   402753 <fc_solve_sfs_raymond_prune+0x33>
  4029ba:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
            my_copy_stack(stack_idx);
  4029c0:	44 89 c1             	mov    %r8d,%ecx
  4029c3:	41 bf 01 00 00 00    	mov    $0x1,%r15d
  4029c9:	41 d3 e7             	shl    %cl,%r15d
  4029cc:	45 09 fa             	or     %r15d,%r10d
  4029cf:	45 89 51 14          	mov    %r10d,0x14(%r9)
  4029d3:	0f be 0e             	movsbl (%rsi),%ecx
  4029d6:	49 89 c2             	mov    %rax,%r10
  4029d9:	49 c1 e2 07          	shl    $0x7,%r10
  4029dd:	4e 8d 0c 13          	lea    (%rbx,%r10,1),%r9
  4029e1:	83 c1 01             	add    $0x1,%ecx
  4029e4:	48 63 c9             	movslq %ecx,%rcx
  4029e7:	48 83 f9 08          	cmp    $0x8,%rcx
  4029eb:	73 33                	jae    402a20 <fc_solve_sfs_raymond_prune+0x300>
  4029ed:	f6 c1 04             	test   $0x4,%cl
  4029f0:	0f 85 69 03 00 00    	jne    402d5f <fc_solve_sfs_raymond_prune+0x63f>
  4029f6:	48 85 c9             	test   %rcx,%rcx
  4029f9:	74 14                	je     402a0f <fc_solve_sfs_raymond_prune+0x2ef>
  4029fb:	0f b6 3e             	movzbl (%rsi),%edi
  4029fe:	41 88 39             	mov    %dil,(%r9)
  402a01:	48 8b 7c 24 10       	mov    0x10(%rsp),%rdi
  402a06:	f6 c1 02             	test   $0x2,%cl
  402a09:	0f 85 3b 03 00 00    	jne    402d4a <fc_solve_sfs_raymond_prune+0x62a>
  402a0f:	4e 89 0c c7          	mov    %r9,(%rdi,%r8,8)
  402a13:	4c 89 ce             	mov    %r9,%rsi
  402a16:	42 0f b6 0c 13       	movzbl (%rbx,%r10,1),%ecx
  402a1b:	e9 18 fe ff ff       	jmpq   402838 <fc_solve_sfs_raymond_prune+0x118>
  402a20:	48 8b 7c 0e f8       	mov    -0x8(%rsi,%rcx,1),%rdi
  402a25:	49 89 7c 09 f8       	mov    %rdi,-0x8(%r9,%rcx,1)
  402a2a:	48 83 e9 01          	sub    $0x1,%rcx
  402a2e:	4c 89 cf             	mov    %r9,%rdi
  402a31:	48 c1 e9 03          	shr    $0x3,%rcx
  402a35:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  402a38:	4c 89 ce             	mov    %r9,%rsi
  402a3b:	48 8b 7c 24 10       	mov    0x10(%rsp),%rdi
  402a40:	4e 89 0c c7          	mov    %r9,(%rdi,%r8,8)
  402a44:	42 0f b6 0c 13       	movzbl (%rbx,%r10,1),%ecx
  402a49:	e9 ea fd ff ff       	jmpq   402838 <fc_solve_sfs_raymond_prune+0x118>
            num_cards_moved = TRUE;
  402a4e:	41 ba 01 00 00 00    	mov    $0x1,%r10d
  402a54:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  402a5b:	00 00 00 00 
  402a5f:	90                   	nop
    const int_fast32_t suit = fcs_card_suit(card);
  402a60:	49 89 c0             	mov    %rax,%r8
    const int_fast32_t rank = fcs_card_rank(card);
  402a63:	89 c2                	mov    %eax,%edx
    const int_fast32_t suit = fcs_card_suit(card);
  402a65:	41 83 e0 03          	and    $0x3,%r8d
    const int_fast32_t rank = fcs_card_rank(card);
  402a69:	c0 fa 02             	sar    $0x2,%dl
        if (fcs_foundation_value(*ptr_state, ret_val) == rank_min_1)
  402a6c:	4e 0f be 4c 07 44    	movsbq 0x44(%rdi,%r8,1),%r9
    const int_fast32_t rank = fcs_card_rank(card);
  402a72:	48 0f be d2          	movsbq %dl,%rdx
    const int_fast32_t rank_min_1 = rank - 1;
  402a76:	4c 8d 5a ff          	lea    -0x1(%rdx),%r11
        if (fcs_foundation_value(*ptr_state, ret_val) == rank_min_1)
  402a7a:	4c 89 ce             	mov    %r9,%rsi
  402a7d:	4d 39 cb             	cmp    %r9,%r11
  402a80:	0f 85 12 fe ff ff    	jne    402898 <fc_solve_sfs_raymond_prune+0x178>
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402a86:	41 89 c1             	mov    %eax,%r9d
                if (fcs_foundation_value(*ptr_state, f) <
  402a89:	4c 0f be 6f 44       	movsbq 0x44(%rdi),%r13
    const int_fast32_t rank_min_2 = rank - 2;
  402a8e:	48 83 ea 02          	sub    $0x2,%rdx
  402a92:	41 89 c3             	mov    %eax,%r11d
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402a95:	41 f7 d1             	not    %r9d
                    rank_min_2 -
  402a98:	49 89 d7             	mov    %rdx,%r15
  402a9b:	41 83 e3 01          	and    $0x1,%r11d
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402a9f:	41 83 e1 01          	and    $0x1,%r9d
                    rank_min_2 -
  402aa3:	4d 29 cf             	sub    %r9,%r15
                if (fcs_foundation_value(*ptr_state, f) <
  402aa6:	4d 39 fd             	cmp    %r15,%r13
  402aa9:	0f 8c e9 fd ff ff    	jl     402898 <fc_solve_sfs_raymond_prune+0x178>
  402aaf:	4c 0f be 6f 45       	movsbq 0x45(%rdi),%r13
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402ab4:	4d 0f be db          	movsbq %r11b,%r11
                    rank_min_2 -
  402ab8:	49 89 d1             	mov    %rdx,%r9
  402abb:	4d 29 d9             	sub    %r11,%r9
                if (fcs_foundation_value(*ptr_state, f) <
  402abe:	4d 39 cd             	cmp    %r9,%r13
  402ac1:	0f 8c d1 fd ff ff    	jl     402898 <fc_solve_sfs_raymond_prune+0x178>
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402ac7:	41 89 c1             	mov    %eax,%r9d
                if (fcs_foundation_value(*ptr_state, f) <
  402aca:	4c 0f be 5f 46       	movsbq 0x46(%rdi),%r11
                    rank_min_2 -
  402acf:	49 89 d7             	mov    %rdx,%r15
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402ad2:	41 83 f1 fd          	xor    $0xfffffffd,%r9d
  402ad6:	41 83 e1 01          	and    $0x1,%r9d
                    rank_min_2 -
  402ada:	4d 29 cf             	sub    %r9,%r15
                if (fcs_foundation_value(*ptr_state, f) <
  402add:	4d 39 fb             	cmp    %r15,%r11
  402ae0:	0f 8c b2 fd ff ff    	jl     402898 <fc_solve_sfs_raymond_prune+0x178>
  402ae6:	4c 0f be 4f 47       	movsbq 0x47(%rdi),%r9
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402aeb:	83 e0 01             	and    $0x1,%eax
                    rank_min_2 -
  402aee:	48 29 c2             	sub    %rax,%rdx
                if (fcs_foundation_value(*ptr_state, f) <
  402af1:	49 39 d1             	cmp    %rdx,%r9
  402af4:	0f 8c 9e fd ff ff    	jl     402898 <fc_solve_sfs_raymond_prune+0x178>
            fcs_increment_foundation(new_state_key, dest_foundation);
  402afa:	8d 46 01             	lea    0x1(%rsi),%eax
            fcs_empty_freecell(new_state_key, fc);
  402afd:	c6 47 42 00          	movb   $0x0,0x42(%rdi)
            fcs_increment_foundation(new_state_key, dest_foundation);
  402b01:	42 88 44 07 44       	mov    %al,0x44(%rdi,%r8,1)
            if (fcs_card_is_empty(card))
  402b06:	84 c9                	test   %cl,%cl
  402b08:	0f 84 a1 fe ff ff    	je     4029af <fc_solve_sfs_raymond_prune+0x28f>
    const int_fast32_t suit = fcs_card_suit(card);
  402b0e:	49 89 c8             	mov    %rcx,%r8
    const int_fast32_t rank = fcs_card_rank(card);
  402b11:	89 c8                	mov    %ecx,%eax
    const int_fast32_t suit = fcs_card_suit(card);
  402b13:	41 83 e0 03          	and    $0x3,%r8d
    const int_fast32_t rank = fcs_card_rank(card);
  402b17:	c0 f8 02             	sar    $0x2,%al
        if (fcs_foundation_value(*ptr_state, ret_val) == rank_min_1)
  402b1a:	4a 0f be 54 07 44    	movsbq 0x44(%rdi,%r8,1),%rdx
    const int_fast32_t rank = fcs_card_rank(card);
  402b20:	48 0f be c0          	movsbq %al,%rax
    const int_fast32_t rank_min_1 = rank - 1;
  402b24:	48 8d 70 ff          	lea    -0x1(%rax),%rsi
        if (fcs_foundation_value(*ptr_state, ret_val) == rank_min_1)
  402b28:	49 89 d1             	mov    %rdx,%r9
  402b2b:	48 39 d6             	cmp    %rdx,%rsi
  402b2e:	0f 85 7b fe ff ff    	jne    4029af <fc_solve_sfs_raymond_prune+0x28f>
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402b34:	89 ce                	mov    %ecx,%esi
    const int_fast32_t rank_min_2 = rank - 2;
  402b36:	48 83 e8 02          	sub    $0x2,%rax
  402b3a:	89 ca                	mov    %ecx,%edx
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402b3c:	f7 d6                	not    %esi
                    rank_min_2 -
  402b3e:	49 89 c2             	mov    %rax,%r10
  402b41:	83 e2 01             	and    $0x1,%edx
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402b44:	83 e6 01             	and    $0x1,%esi
                    rank_min_2 -
  402b47:	49 29 f2             	sub    %rsi,%r10
                if (fcs_foundation_value(*ptr_state, f) <
  402b4a:	48 0f be 77 44       	movsbq 0x44(%rdi),%rsi
  402b4f:	49 39 f2             	cmp    %rsi,%r10
  402b52:	0f 8f 57 fe ff ff    	jg     4029af <fc_solve_sfs_raymond_prune+0x28f>
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402b58:	48 0f be d2          	movsbq %dl,%rdx
                    rank_min_2 -
  402b5c:	48 89 c6             	mov    %rax,%rsi
  402b5f:	48 29 d6             	sub    %rdx,%rsi
                if (fcs_foundation_value(*ptr_state, f) <
  402b62:	48 0f be 57 45       	movsbq 0x45(%rdi),%rdx
  402b67:	48 39 d6             	cmp    %rdx,%rsi
  402b6a:	0f 8f 3f fe ff ff    	jg     4029af <fc_solve_sfs_raymond_prune+0x28f>
  402b70:	41 ba 01 00 00 00    	mov    $0x1,%r10d
  402b76:	e9 f7 fd ff ff       	jmpq   402972 <fc_solve_sfs_raymond_prune+0x252>
  402b7b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
    const int_fast32_t suit = fcs_card_suit(card);
  402b80:	49 89 d1             	mov    %rdx,%r9
    const int_fast32_t rank = fcs_card_rank(card);
  402b83:	89 d6                	mov    %edx,%esi
    const int_fast32_t suit = fcs_card_suit(card);
  402b85:	41 83 e1 03          	and    $0x3,%r9d
    const int_fast32_t rank = fcs_card_rank(card);
  402b89:	40 c0 fe 02          	sar    $0x2,%sil
        if (fcs_foundation_value(*ptr_state, ret_val) == rank_min_1)
  402b8d:	4e 0f be 5c 0f 44    	movsbq 0x44(%rdi,%r9,1),%r11
    const int_fast32_t rank = fcs_card_rank(card);
  402b93:	48 0f be f6          	movsbq %sil,%rsi
    const int_fast32_t rank_min_1 = rank - 1;
  402b97:	4c 8d 6e ff          	lea    -0x1(%rsi),%r13
        if (fcs_foundation_value(*ptr_state, ret_val) == rank_min_1)
  402b9b:	4d 89 d8             	mov    %r11,%r8
  402b9e:	4d 39 dd             	cmp    %r11,%r13
  402ba1:	0f 85 e9 fc ff ff    	jne    402890 <fc_solve_sfs_raymond_prune+0x170>
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402ba7:	41 89 d3             	mov    %edx,%r11d
                if (fcs_foundation_value(*ptr_state, f) <
  402baa:	4c 0f be 77 44       	movsbq 0x44(%rdi),%r14
    const int_fast32_t rank_min_2 = rank - 2;
  402baf:	48 83 ee 02          	sub    $0x2,%rsi
  402bb3:	41 89 d5             	mov    %edx,%r13d
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402bb6:	41 f7 d3             	not    %r11d
                    rank_min_2 -
  402bb9:	49 89 f7             	mov    %rsi,%r15
  402bbc:	41 83 e5 01          	and    $0x1,%r13d
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402bc0:	41 83 e3 01          	and    $0x1,%r11d
                    rank_min_2 -
  402bc4:	4d 29 df             	sub    %r11,%r15
                if (fcs_foundation_value(*ptr_state, f) <
  402bc7:	4d 39 fe             	cmp    %r15,%r14
  402bca:	0f 8c c0 fc ff ff    	jl     402890 <fc_solve_sfs_raymond_prune+0x170>
  402bd0:	4c 0f be 77 45       	movsbq 0x45(%rdi),%r14
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402bd5:	4d 0f be dd          	movsbq %r13b,%r11
                    rank_min_2 -
  402bd9:	49 89 f7             	mov    %rsi,%r15
  402bdc:	4d 29 df             	sub    %r11,%r15
                if (fcs_foundation_value(*ptr_state, f) <
  402bdf:	4d 39 fe             	cmp    %r15,%r14
  402be2:	0f 8c a8 fc ff ff    	jl     402890 <fc_solve_sfs_raymond_prune+0x170>
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402be8:	41 89 d3             	mov    %edx,%r11d
                if (fcs_foundation_value(*ptr_state, f) <
  402beb:	4c 0f be 6f 46       	movsbq 0x46(%rdi),%r13
                    rank_min_2 -
  402bf0:	49 89 f7             	mov    %rsi,%r15
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402bf3:	41 83 f3 fd          	xor    $0xfffffffd,%r11d
  402bf7:	41 83 e3 01          	and    $0x1,%r11d
                    rank_min_2 -
  402bfb:	4d 29 df             	sub    %r11,%r15
                if (fcs_foundation_value(*ptr_state, f) <
  402bfe:	4d 39 fd             	cmp    %r15,%r13
  402c01:	0f 8c 89 fc ff ff    	jl     402890 <fc_solve_sfs_raymond_prune+0x170>
  402c07:	4c 0f be 5f 47       	movsbq 0x47(%rdi),%r11
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402c0c:	83 e2 01             	and    $0x1,%edx
                    rank_min_2 -
  402c0f:	48 29 d6             	sub    %rdx,%rsi
                if (fcs_foundation_value(*ptr_state, f) <
  402c12:	49 39 f3             	cmp    %rsi,%r11
  402c15:	0f 8c 75 fc ff ff    	jl     402890 <fc_solve_sfs_raymond_prune+0x170>
            fcs_increment_foundation(new_state_key, dest_foundation);
  402c1b:	41 8d 50 01          	lea    0x1(%r8),%edx
            fcs_empty_freecell(new_state_key, fc);
  402c1f:	c6 47 41 00          	movb   $0x0,0x41(%rdi)
            fcs_increment_foundation(new_state_key, dest_foundation);
  402c23:	42 88 54 0f 44       	mov    %dl,0x44(%rdi,%r9,1)
            if (fcs_card_is_empty(card))
  402c28:	84 c0                	test   %al,%al
  402c2a:	0f 85 1e fe ff ff    	jne    402a4e <fc_solve_sfs_raymond_prune+0x32e>
  402c30:	84 c9                	test   %cl,%cl
  402c32:	0f 84 77 fd ff ff    	je     4029af <fc_solve_sfs_raymond_prune+0x28f>
    const int_fast32_t suit = fcs_card_suit(card);
  402c38:	49 89 c8             	mov    %rcx,%r8
    const int_fast32_t rank = fcs_card_rank(card);
  402c3b:	89 c8                	mov    %ecx,%eax
    const int_fast32_t suit = fcs_card_suit(card);
  402c3d:	41 83 e0 03          	and    $0x3,%r8d
    const int_fast32_t rank = fcs_card_rank(card);
  402c41:	c0 f8 02             	sar    $0x2,%al
        if (fcs_foundation_value(*ptr_state, ret_val) == rank_min_1)
  402c44:	4a 0f be 74 07 44    	movsbq 0x44(%rdi,%r8,1),%rsi
    const int_fast32_t rank = fcs_card_rank(card);
  402c4a:	48 0f be c0          	movsbq %al,%rax
    const int_fast32_t rank_min_1 = rank - 1;
  402c4e:	48 8d 50 ff          	lea    -0x1(%rax),%rdx
        if (fcs_foundation_value(*ptr_state, ret_val) == rank_min_1)
  402c52:	49 89 f1             	mov    %rsi,%r9
  402c55:	48 39 d6             	cmp    %rdx,%rsi
  402c58:	0f 84 d6 fe ff ff    	je     402b34 <fc_solve_sfs_raymond_prune+0x414>
  402c5e:	e9 4c fd ff ff       	jmpq   4029af <fc_solve_sfs_raymond_prune+0x28f>
  402c63:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  402c6a:	00 00 00 00 
  402c6e:	66 90                	xchg   %ax,%ax
    const int_fast32_t suit = fcs_card_suit(card);
  402c70:	48 89 c6             	mov    %rax,%rsi
    const int_fast32_t rank = fcs_card_rank(card);
  402c73:	89 c2                	mov    %eax,%edx
    const int_fast32_t suit = fcs_card_suit(card);
  402c75:	83 e6 03             	and    $0x3,%esi
    const int_fast32_t rank = fcs_card_rank(card);
  402c78:	c0 fa 02             	sar    $0x2,%dl
        if (fcs_foundation_value(*ptr_state, ret_val) == rank_min_1)
  402c7b:	4c 0f be 44 37 44    	movsbq 0x44(%rdi,%rsi,1),%r8
    const int_fast32_t rank = fcs_card_rank(card);
  402c81:	48 0f be d2          	movsbq %dl,%rdx
    const int_fast32_t rank_min_1 = rank - 1;
  402c85:	4c 8d 4a ff          	lea    -0x1(%rdx),%r9
        if (fcs_foundation_value(*ptr_state, ret_val) == rank_min_1)
  402c89:	4c 89 c1             	mov    %r8,%rcx
  402c8c:	4d 39 c1             	cmp    %r8,%r9
  402c8f:	0f 85 e7 fb ff ff    	jne    40287c <fc_solve_sfs_raymond_prune+0x15c>
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402c95:	41 89 c0             	mov    %eax,%r8d
                if (fcs_foundation_value(*ptr_state, f) <
  402c98:	4c 0f be 5f 44       	movsbq 0x44(%rdi),%r11
    const int_fast32_t rank_min_2 = rank - 2;
  402c9d:	48 83 ea 02          	sub    $0x2,%rdx
  402ca1:	41 89 c1             	mov    %eax,%r9d
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402ca4:	41 f7 d0             	not    %r8d
                    rank_min_2 -
  402ca7:	49 89 d7             	mov    %rdx,%r15
  402caa:	41 83 e1 01          	and    $0x1,%r9d
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402cae:	41 83 e0 01          	and    $0x1,%r8d
                    rank_min_2 -
  402cb2:	4d 29 c7             	sub    %r8,%r15
                if (fcs_foundation_value(*ptr_state, f) <
  402cb5:	4d 39 fb             	cmp    %r15,%r11
  402cb8:	0f 8c be fb ff ff    	jl     40287c <fc_solve_sfs_raymond_prune+0x15c>
  402cbe:	4c 0f be 5f 45       	movsbq 0x45(%rdi),%r11
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402cc3:	4d 0f be c9          	movsbq %r9b,%r9
                    rank_min_2 -
  402cc7:	49 89 d0             	mov    %rdx,%r8
  402cca:	4d 29 c8             	sub    %r9,%r8
                if (fcs_foundation_value(*ptr_state, f) <
  402ccd:	4d 39 c3             	cmp    %r8,%r11
  402cd0:	0f 8c a6 fb ff ff    	jl     40287c <fc_solve_sfs_raymond_prune+0x15c>
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402cd6:	41 89 c0             	mov    %eax,%r8d
                if (fcs_foundation_value(*ptr_state, f) <
  402cd9:	4c 0f be 4f 46       	movsbq 0x46(%rdi),%r9
                    rank_min_2 -
  402cde:	49 89 d7             	mov    %rdx,%r15
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402ce1:	41 83 f0 fd          	xor    $0xfffffffd,%r8d
  402ce5:	41 83 e0 01          	and    $0x1,%r8d
                    rank_min_2 -
  402ce9:	4d 29 c7             	sub    %r8,%r15
                if (fcs_foundation_value(*ptr_state, f) <
  402cec:	4d 39 f9             	cmp    %r15,%r9
  402cef:	0f 8c 87 fb ff ff    	jl     40287c <fc_solve_sfs_raymond_prune+0x15c>
  402cf5:	4c 0f be 47 47       	movsbq 0x47(%rdi),%r8
                                : ((f & 0x1) == (fcs_card_suit(card) & 0x1))))
  402cfa:	83 e0 01             	and    $0x1,%eax
                    rank_min_2 -
  402cfd:	48 29 c2             	sub    %rax,%rdx
                if (fcs_foundation_value(*ptr_state, f) <
  402d00:	49 39 d0             	cmp    %rdx,%r8
  402d03:	0f 8c 73 fb ff ff    	jl     40287c <fc_solve_sfs_raymond_prune+0x15c>
            fcs_increment_foundation(new_state_key, dest_foundation);
  402d09:	8d 41 01             	lea    0x1(%rcx),%eax
            fcs_empty_freecell(new_state_key, fc);
  402d0c:	c6 47 40 00          	movb   $0x0,0x40(%rdi)
            num_cards_moved = TRUE;
  402d10:	41 ba 01 00 00 00    	mov    $0x1,%r10d
            fcs_increment_foundation(new_state_key, dest_foundation);
  402d16:	88 44 37 44          	mov    %al,0x44(%rdi,%rsi,1)
  402d1a:	e9 5d fb ff ff       	jmpq   40287c <fc_solve_sfs_raymond_prune+0x15c>
#endif
        return FCS_STATE_kv_to_collectible(&existing_state);
    }
    else
    {
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  402d1f:	48 8b 44 24 10       	mov    0x10(%rsp),%rax
    FCS_S_VISITED(ptr_next_state) |= FCS_VISITED_GENERATED_BY_PRUNING;
  402d24:	80 48 56 10          	orb    $0x10,0x56(%rax)
}
  402d28:	48 83 c4 38          	add    $0x38,%rsp
  402d2c:	5b                   	pop    %rbx
  402d2d:	5d                   	pop    %rbp
  402d2e:	41 5c                	pop    %r12
  402d30:	41 5d                	pop    %r13
  402d32:	41 5e                	pop    %r14
  402d34:	41 5f                	pop    %r15
  402d36:	c3                   	retq   
    allocator->ptr = allocator->rollback_ptr;
  402d37:	48 8b 83 f0 00 00 00 	mov    0xf0(%rbx),%rax
  402d3e:	48 89 83 e8 00 00 00 	mov    %rax,0xe8(%rbx)
  402d45:	e9 a8 fb ff ff       	jmpq   4028f2 <fc_solve_sfs_raymond_prune+0x1d2>
            my_copy_stack(stack_idx);
  402d4a:	0f b7 74 0e fe       	movzwl -0x2(%rsi,%rcx,1),%esi
  402d4f:	66 41 89 74 09 fe    	mov    %si,-0x2(%r9,%rcx,1)
  402d55:	48 8b 7c 24 10       	mov    0x10(%rsp),%rdi
  402d5a:	e9 b0 fc ff ff       	jmpq   402a0f <fc_solve_sfs_raymond_prune+0x2ef>
  402d5f:	8b 3e                	mov    (%rsi),%edi
  402d61:	41 89 39             	mov    %edi,(%r9)
  402d64:	8b 74 0e fc          	mov    -0x4(%rsi,%rcx,1),%esi
  402d68:	41 89 74 09 fc       	mov    %esi,-0x4(%r9,%rcx,1)
  402d6d:	48 8b 7c 24 10       	mov    0x10(%rsp),%rdi
  402d72:	4c 89 ce             	mov    %r9,%rsi
  402d75:	4e 89 0c c7          	mov    %r9,(%rdi,%r8,8)
  402d79:	42 0f b6 0c 13       	movzbl (%rbx,%r10,1),%ecx
  402d7e:	e9 b5 fa ff ff       	jmpq   402838 <fc_solve_sfs_raymond_prune+0x118>
  402d83:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  402d8a:	00 00 00 00 
  402d8e:	66 90                	xchg   %ax,%ax

0000000000402d90 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack>:
    if (soft_thread->num_vacant_stacks == 0)
  402d90:	80 bf e3 01 00 00 00 	cmpb   $0x0,0x1e3(%rdi)
  402d97:	0f 84 a3 02 00 00    	je     403040 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x2b0>
{
  402d9d:	41 57                	push   %r15
  402d9f:	41 56                	push   %r14
  402da1:	49 89 ce             	mov    %rcx,%r14
  402da4:	41 55                	push   %r13
  402da6:	41 54                	push   %r12
  402da8:	55                   	push   %rbp
  402da9:	53                   	push   %rbx
  402daa:	48 83 ec 48          	sub    $0x48,%rsp
        if (fcs_state_col_is_empty(state, ret))
  402dae:	48 8b 06             	mov    (%rsi),%rax
  402db1:	80 38 00             	cmpb   $0x0,(%rax)
  402db4:	0f 84 66 03 00 00    	je     403120 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x390>
  402dba:	48 8b 46 08          	mov    0x8(%rsi),%rax
  402dbe:	80 38 00             	cmpb   $0x0,(%rax)
  402dc1:	0f 84 b9 03 00 00    	je     403180 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x3f0>
  402dc7:	48 8b 46 10          	mov    0x10(%rsi),%rax
  402dcb:	80 38 00             	cmpb   $0x0,(%rax)
  402dce:	0f 84 bc 03 00 00    	je     403190 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x400>
  402dd4:	48 8b 46 18          	mov    0x18(%rsi),%rax
  402dd8:	80 38 00             	cmpb   $0x0,(%rax)
  402ddb:	0f 84 bf 03 00 00    	je     4031a0 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x410>
  402de1:	48 8b 46 20          	mov    0x20(%rsi),%rax
  402de5:	80 38 00             	cmpb   $0x0,(%rax)
  402de8:	0f 84 c2 03 00 00    	je     4031b0 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x420>
  402dee:	48 8b 46 28          	mov    0x28(%rsi),%rax
  402df2:	80 38 00             	cmpb   $0x0,(%rax)
  402df5:	0f 84 c5 03 00 00    	je     4031c0 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x430>
  402dfb:	48 8b 46 30          	mov    0x30(%rsi),%rax
  402dff:	80 38 00             	cmpb   $0x0,(%rax)
  402e02:	0f 84 c8 03 00 00    	je     4031d0 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x440>
  402e08:	4c 8b 46 38          	mov    0x38(%rsi),%r8
  402e0c:	48 c7 c0 80 ff ff ff 	mov    $0xffffffffffffff80,%rax
    return -1;
  402e13:	b9 ff ff ff ff       	mov    $0xffffffff,%ecx
        if (fcs_state_col_is_empty(state, ret))
  402e18:	c7 44 24 18 00 00 00 	movl   $0x0,0x18(%rsp)
  402e1f:	00 
  402e20:	41 80 38 00          	cmpb   $0x0,(%r8)
  402e24:	0f 84 c6 03 00 00    	je     4031f0 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x460>
    tests_define_accessors();
  402e2a:	4c 8b 3f             	mov    (%rdi),%r15
  402e2d:	49 89 d5             	mov    %rdx,%r13
  402e30:	48 89 f3             	mov    %rsi,%rbx
  402e33:	48 89 7c 24 08       	mov    %rdi,0x8(%rsp)
        my_copy_stack(ds);
  402e38:	31 ed                	xor    %ebp,%ebp
  402e3a:	4d 8d a4 07 00 01 00 	lea    0x100(%r15,%rax,1),%r12
  402e41:	00 
  402e42:	48 63 c1             	movslq %ecx,%rax
  402e45:	48 89 04 24          	mov    %rax,(%rsp)
        const fcs_card card = fcs_freecell_card(state, fc);
  402e49:	44 0f b6 54 2b 40    	movzbl 0x40(%rbx,%rbp,1),%r10d
  402e4f:	48 63 d5             	movslq %ebp,%rdx
        if (fcs_card_is_empty(card) ||
  402e52:	45 84 d2             	test   %r10b,%r10b
  402e55:	0f 84 c3 01 00 00    	je     40301e <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x28e>
                (instance->list_of_vacant_states != NULL)))
  402e5b:	49 8b 8f b0 00 00 00 	mov    0xb0(%r15),%rcx
  402e62:	48 85 c9             	test   %rcx,%rcx
    if ((HT_FIELD(hard_thread, allocated_from_list) =
  402e65:	41 0f 95 87 18 05 00 	setne  0x518(%r15)
  402e6c:	00 
  402e6d:	0f 85 0d 02 00 00    	jne    403080 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x2f0>
    if ((size_t)(allocator->max_ptr - allocator->ptr) < how_much)
  402e73:	49 8b 8f e8 00 00 00 	mov    0xe8(%r15),%rcx
  402e7a:	49 8b 87 e0 00 00 00 	mov    0xe0(%r15),%rax
  402e81:	48 29 c8             	sub    %rcx,%rax
  402e84:	48 83 f8 5f          	cmp    $0x5f,%rax
  402e88:	0f 86 22 02 00 00    	jbe    4030b0 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x320>
        allocator->rollback_ptr = allocator->ptr;
  402e8e:	49 89 8f f0 00 00 00 	mov    %rcx,0xf0(%r15)
    allocator->ptr += how_much;
  402e95:	48 8d 41 60          	lea    0x60(%rcx),%rax
  402e99:	49 89 87 e8 00 00 00 	mov    %rax,0xe8(%r15)
    return (const fcs_kv_state){.key = &(s->s), .val = &(s->info)};
  402ea0:	48 8d 41 48          	lea    0x48(%rcx),%rax
    *ret = FCS_STATE_keyval_pair_to_kv(s);
  402ea4:	c4 e1 f9 6e c9       	vmovq  %rcx,%xmm1
  402ea9:	c4 e3 f1 22 c0 01    	vpinsrq $0x1,%rax,%xmm1,%xmm0
  402eaf:	c5 f8 29 44 24 20    	vmovaps %xmm0,0x20(%rsp)
    fcs_duplicate_kv_state(out_new_state_out, &raw_state_raw);
  402eb5:	c5 fa 6f 03          	vmovdqu (%rbx),%xmm0
  402eb9:	c5 f8 11 01          	vmovups %xmm0,(%rcx)
  402ebd:	c5 fa 6f 43 10       	vmovdqu 0x10(%rbx),%xmm0
  402ec2:	c5 f8 11 41 10       	vmovups %xmm0,0x10(%rcx)
  402ec7:	c5 fa 6f 43 20       	vmovdqu 0x20(%rbx),%xmm0
  402ecc:	c5 f8 11 41 20       	vmovups %xmm0,0x20(%rcx)
  402ed1:	c5 fa 6f 43 30       	vmovdqu 0x30(%rbx),%xmm0
  402ed6:	c5 f8 11 41 30       	vmovups %xmm0,0x30(%rcx)
  402edb:	48 8b 43 40          	mov    0x40(%rbx),%rax
  402edf:	c4 c1 7a 6f 45 00    	vmovdqu 0x0(%r13),%xmm0
  402ee5:	c5 f8 11 41 48       	vmovups %xmm0,0x48(%rcx)
  402eea:	48 89 41 40          	mov    %rax,0x40(%rcx)
  402eee:	49 8b 45 10          	mov    0x10(%r13),%rax
    (FCS_S_DEPTH(raw_ptr_new_state))++;
  402ef2:	83 41 50 01          	addl   $0x1,0x50(%rcx)
    FCS_S_PARENT(raw_ptr_new_state) = INFO_STATE_PTR(&raw_state_raw);
  402ef6:	48 89 59 48          	mov    %rbx,0x48(%rcx)
    FCS_S_VISITED(raw_ptr_new_state) = 0;
  402efa:	c6 41 56 00          	movb   $0x0,0x56(%rcx)
    fcs_duplicate_kv_state(out_new_state_out, &raw_state_raw);
  402efe:	48 89 41 58          	mov    %rax,0x58(%rcx)
    FCS_S_NUM_ACTIVE_CHILDREN(raw_ptr_new_state) = 0;
  402f02:	31 c0                	xor    %eax,%eax
  402f04:	66 89 41 54          	mov    %ax,0x54(%rcx)
        my_copy_stack(ds);
  402f08:	8b 44 24 18          	mov    0x18(%rsp),%eax
    memset(&(FCS_S_SCAN_VISITED(raw_ptr_new_state)), '\0',
  402f0c:	c7 41 57 00 00 00 00 	movl   $0x0,0x57(%rcx)
  402f13:	89 41 5c             	mov    %eax,0x5c(%rcx)
  402f16:	48 8b 04 24          	mov    (%rsp),%rax
  402f1a:	48 8b 34 c1          	mov    (%rcx,%rax,8),%rsi
  402f1e:	0f be 0e             	movsbl (%rsi),%ecx
  402f21:	83 c1 01             	add    $0x1,%ecx
  402f24:	48 63 c9             	movslq %ecx,%rcx
  402f27:	48 83 f9 08          	cmp    $0x8,%rcx
  402f2b:	0f 83 2f 01 00 00    	jae    403060 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x2d0>
  402f31:	f6 c1 04             	test   $0x4,%cl
  402f34:	0f 85 c6 01 00 00    	jne    403100 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x370>
  402f3a:	48 85 c9             	test   %rcx,%rcx
  402f3d:	74 10                	je     402f4f <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x1bf>
  402f3f:	0f b6 06             	movzbl (%rsi),%eax
  402f42:	41 88 04 24          	mov    %al,(%r12)
  402f46:	f6 c1 02             	test   $0x2,%cl
  402f49:	0f 85 91 02 00 00    	jne    4031e0 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x450>
  402f4f:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
    if (!fc_solve_check_and_add_state(
  402f54:	48 8d 74 24 20       	lea    0x20(%rsp),%rsi
  402f59:	48 8b 3c 24          	mov    (%rsp),%rdi
  402f5d:	4c 89 24 f8          	mov    %r12,(%rax,%rdi,8)
        fcs_empty_freecell(new_state_key, fc);
  402f61:	c6 44 10 40 00       	movb   $0x0,0x40(%rax,%rdx,1)

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));
    fcs_col_push_card(col, card);
  402f66:	49 0f be 04 24       	movsbq (%r12),%rax
  402f6b:	8d 50 01             	lea    0x1(%rax),%edx
  402f6e:	41 88 14 24          	mov    %dl,(%r12)
  402f72:	48 8d 54 24 30       	lea    0x30(%rsp),%rdx
  402f77:	45 88 54 04 01       	mov    %r10b,0x1(%r12,%rax,1)
    const_SLOT(hard_thread, soft_thread);
  402f7c:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
  402f81:	48 8b 08             	mov    (%rax),%rcx
    if (!fc_solve_check_and_add_state(
  402f84:	48 89 cf             	mov    %rcx,%rdi
  402f87:	48 89 4c 24 10       	mov    %rcx,0x10(%rsp)
  402f8c:	e8 bf ea ff ff       	callq  401a50 <fc_solve_check_and_add_state>
  402f91:	84 c0                	test   %al,%al
  402f93:	0f 85 b7 00 00 00    	jne    403050 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x2c0>
        if (HT_FIELD(hard_thread, allocated_from_list))
  402f99:	48 8b 4c 24 10       	mov    0x10(%rsp),%rcx
  402f9e:	80 b9 18 05 00 00 00 	cmpb   $0x0,0x518(%rcx)
  402fa5:	0f 84 e5 00 00 00    	je     403090 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x300>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  402fab:	48 8b 91 b0 00 00 00 	mov    0xb0(%rcx),%rdx
  402fb2:	48 8b 44 24 28       	mov    0x28(%rsp),%rax
  402fb7:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  402fba:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  402fbf:	48 89 81 b0 00 00 00 	mov    %rax,0xb0(%rcx)
  402fc6:	48 8b 54 24 30       	mov    0x30(%rsp),%rdx

#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)) &
  402fcb:	49 8b 46 08          	mov    0x8(%r14),%rax
  402fcf:	31 f6                	xor    %esi,%esi
  402fd1:	49 8b 3e             	mov    (%r14),%rdi
  402fd4:	48 85 c0             	test   %rax,%rax
  402fd7:	40 0f 95 c6          	setne  %sil
  402fdb:	48 01 fe             	add    %rdi,%rsi
  402fde:	40 f6 c6 0f          	test   $0xf,%sil
  402fe2:	75 21                	jne    403005 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x275>
            (DERIVED_STATES_LIST_GROW_BY - 1))))
    {
        list->states =
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  402fe4:	48 83 c6 10          	add    $0x10,%rsi
  402fe8:	48 89 c7             	mov    %rax,%rdi
  402feb:	48 89 54 24 10       	mov    %rdx,0x10(%rsp)
  402ff0:	48 c1 e6 04          	shl    $0x4,%rsi
  402ff4:	e8 77 e1 ff ff       	callq  401170 <realloc@plt>
  402ff9:	49 8b 3e             	mov    (%r14),%rdi
  402ffc:	48 8b 54 24 10       	mov    0x10(%rsp),%rdx
        list->states =
  403001:	49 89 46 08          	mov    %rax,0x8(%r14)
                                       DERIVED_STATES_LIST_GROW_BY);
    }
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  403005:	48 8d 4f 01          	lea    0x1(%rdi),%rcx
  403009:	48 c1 e7 04          	shl    $0x4,%rdi
  40300d:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  403011:	48 01 f8             	add    %rdi,%rax
  403014:	49 89 0e             	mov    %rcx,(%r14)
  403017:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  40301b:	48 89 10             	mov    %rdx,(%rax)
  40301e:	48 83 c5 01          	add    $0x1,%rbp
    for (int fc = 0; fc < LOCAL_FREECELLS_NUM; fc++)
  403022:	48 83 fd 04          	cmp    $0x4,%rbp
  403026:	0f 85 1d fe ff ff    	jne    402e49 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0xb9>
}
  40302c:	48 83 c4 48          	add    $0x48,%rsp
  403030:	5b                   	pop    %rbx
  403031:	5d                   	pop    %rbp
  403032:	41 5c                	pop    %r12
  403034:	41 5d                	pop    %r13
  403036:	41 5e                	pop    %r14
  403038:	41 5f                	pop    %r15
  40303a:	c3                   	retq   
  40303b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
  403040:	c3                   	retq   
  403041:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  403048:	00 00 00 00 
  40304c:	0f 1f 40 00          	nopl   0x0(%rax)
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  403050:	48 8b 54 24 20       	mov    0x20(%rsp),%rdx
  403055:	e9 71 ff ff ff       	jmpq   402fcb <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x23b>
  40305a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
        my_copy_stack(ds);
  403060:	48 8b 44 0e f8       	mov    -0x8(%rsi,%rcx,1),%rax
  403065:	4c 89 e7             	mov    %r12,%rdi
  403068:	49 89 44 0c f8       	mov    %rax,-0x8(%r12,%rcx,1)
  40306d:	48 83 e9 01          	sub    $0x1,%rcx
  403071:	48 c1 e9 03          	shr    $0x3,%rcx
  403075:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  403078:	e9 d2 fe ff ff       	jmpq   402f4f <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x1bf>
  40307d:	0f 1f 00             	nopl   (%rax)
            FCS_S_NEXT(instance->list_of_vacant_states);
  403080:	48 8b 41 48          	mov    0x48(%rcx),%rax
        instance->list_of_vacant_states =
  403084:	49 89 87 b0 00 00 00 	mov    %rax,0xb0(%r15)
  40308b:	e9 10 fe ff ff       	jmpq   402ea0 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x110>
    allocator->ptr = allocator->rollback_ptr;
  403090:	48 8b 81 f0 00 00 00 	mov    0xf0(%rcx),%rax
  403097:	48 89 81 e8 00 00 00 	mov    %rax,0xe8(%rcx)
  40309e:	e9 23 ff ff ff       	jmpq   402fc6 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x236>
  4030a3:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4030aa:	00 00 00 00 
  4030ae:	66 90                	xchg   %ax,%ax
    char *const new_data = meta_request_new_buffer(allocator->meta);
  4030b0:	49 8b 8f f8 00 00 00 	mov    0xf8(%r15),%rcx
    char *const ret = meta_alloc->recycle_bin;
  4030b7:	48 8b 01             	mov    (%rcx),%rax
    if (ret)
  4030ba:	48 85 c0             	test   %rax,%rax
  4030bd:	0f 84 8d 00 00 00    	je     403150 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x3c0>
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  4030c3:	48 8b 30             	mov    (%rax),%rsi
  4030c6:	48 89 31             	mov    %rsi,(%rcx)
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  4030c9:	49 8b 8f d8 00 00 00 	mov    0xd8(%r15),%rcx
  4030d0:	48 89 08             	mov    %rcx,(%rax)
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  4030d3:	48 8d 48 08          	lea    0x8(%rax),%rcx
    allocator->old_list = new_data;
  4030d7:	49 89 87 d8 00 00 00 	mov    %rax,0xd8(%r15)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  4030de:	48 05 80 fe 00 00    	add    $0xfe80,%rax
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  4030e4:	49 89 8f f0 00 00 00 	mov    %rcx,0xf0(%r15)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  4030eb:	49 89 87 e0 00 00 00 	mov    %rax,0xe0(%r15)
  4030f2:	e9 9e fd ff ff       	jmpq   402e95 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x105>
  4030f7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  4030fe:	00 00 
  403100:	8b 06                	mov    (%rsi),%eax
  403102:	41 89 04 24          	mov    %eax,(%r12)
  403106:	8b 44 0e fc          	mov    -0x4(%rsi,%rcx,1),%eax
  40310a:	41 89 44 0c fc       	mov    %eax,-0x4(%r12,%rcx,1)
  40310f:	e9 3b fe ff ff       	jmpq   402f4f <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x1bf>
  403114:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40311b:	00 00 00 00 
  40311f:	90                   	nop
    for (int ret = start_from; ret < local_stacks_num; ret++)
  403120:	31 c9                	xor    %ecx,%ecx
  403122:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  403129:	00 00 00 00 
  40312d:	0f 1f 00             	nopl   (%rax)
  403130:	41 bf 01 00 00 00    	mov    $0x1,%r15d
  403136:	89 c8                	mov    %ecx,%eax
  403138:	41 d3 e7             	shl    %cl,%r15d
  40313b:	c1 e0 07             	shl    $0x7,%eax
  40313e:	44 89 7c 24 18       	mov    %r15d,0x18(%rsp)
  403143:	48 98                	cltq   
  403145:	e9 e0 fc ff ff       	jmpq   402e2a <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x9a>
  40314a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
        return malloc(ALLOCED_SIZE);
  403150:	bf 80 fe 00 00       	mov    $0xfe80,%edi
  403155:	89 54 24 1c          	mov    %edx,0x1c(%rsp)
  403159:	44 88 54 24 10       	mov    %r10b,0x10(%rsp)
  40315e:	e8 8d df ff ff       	callq  4010f0 <malloc@plt>
  403163:	48 63 54 24 1c       	movslq 0x1c(%rsp),%rdx
  403168:	44 0f b6 54 24 10    	movzbl 0x10(%rsp),%r10d
  40316e:	e9 56 ff ff ff       	jmpq   4030c9 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x339>
  403173:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40317a:	00 00 00 00 
  40317e:	66 90                	xchg   %ax,%ax
  403180:	b9 01 00 00 00       	mov    $0x1,%ecx
  403185:	eb a9                	jmp    403130 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x3a0>
  403187:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40318e:	00 00 
  403190:	b9 02 00 00 00       	mov    $0x2,%ecx
  403195:	eb 99                	jmp    403130 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x3a0>
  403197:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40319e:	00 00 
  4031a0:	b9 03 00 00 00       	mov    $0x3,%ecx
  4031a5:	eb 89                	jmp    403130 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x3a0>
  4031a7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  4031ae:	00 00 
  4031b0:	b9 04 00 00 00       	mov    $0x4,%ecx
  4031b5:	e9 76 ff ff ff       	jmpq   403130 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x3a0>
  4031ba:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
  4031c0:	b9 05 00 00 00       	mov    $0x5,%ecx
  4031c5:	e9 66 ff ff ff       	jmpq   403130 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x3a0>
  4031ca:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
  4031d0:	b9 06 00 00 00       	mov    $0x6,%ecx
  4031d5:	e9 56 ff ff ff       	jmpq   403130 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x3a0>
  4031da:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
        my_copy_stack(ds);
  4031e0:	0f b7 44 0e fe       	movzwl -0x2(%rsi,%rcx,1),%eax
  4031e5:	66 41 89 44 0c fe    	mov    %ax,-0x2(%r12,%rcx,1)
  4031eb:	e9 5f fd ff ff       	jmpq   402f4f <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x1bf>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4031f0:	b9 07 00 00 00       	mov    $0x7,%ecx
  4031f5:	e9 36 ff ff ff       	jmpq   403130 <fc_solve_sfs_atomic_move_freecell_card_to_empty_stack+0x3a0>
  4031fa:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)

0000000000403200 <fc_solve_sfs_atomic_move_freecell_card_to_parent>:
{
  403200:	41 57                	push   %r15
    tests_define_accessors();
  403202:	45 31 ff             	xor    %r15d,%r15d
    if (!fc_solve_check_and_add_state(
  403205:	49 89 c9             	mov    %rcx,%r9
{
  403208:	41 56                	push   %r14
  40320a:	41 55                	push   %r13
  40320c:	49 89 d5             	mov    %rdx,%r13
  40320f:	41 54                	push   %r12
  403211:	49 89 f4             	mov    %rsi,%r12
  403214:	55                   	push   %rbp
  403215:	53                   	push   %rbx
  403216:	48 83 ec 58          	sub    $0x58,%rsp
    tests_define_accessors();
  40321a:	4c 8b 37             	mov    (%rdi),%r14
{
  40321d:	48 89 7c 24 18       	mov    %rdi,0x18(%rsp)
    tests_define_accessors();
  403222:	49 8d 86 00 01 00 00 	lea    0x100(%r14),%rax
  403229:	48 89 44 24 28       	mov    %rax,0x28(%rsp)
  40322e:	4c 89 f8             	mov    %r15,%rax
  403231:	4d 89 f7             	mov    %r14,%r15
  403234:	49 89 c6             	mov    %rax,%r14
        const fcs_card card = fcs_freecell_card(state, fc);
  403237:	4b 0f be 44 34 40    	movsbq 0x40(%r12,%r14,1),%rax
  40323d:	44 89 74 24 0c       	mov    %r14d,0xc(%rsp)
  403242:	88 44 24 0b          	mov    %al,0xb(%rsp)
        if (fcs_card_is_empty(card))
  403246:	84 c0                	test   %al,%al
  403248:	0f 84 63 02 00 00    	je     4034b1 <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x2b1>
    return fc_solve_is_parent_buf[(size_t)parent][(size_t)child];
  40324e:	4c 89 74 24 20       	mov    %r14,0x20(%rsp)
  403253:	48 8b 6c 24 28       	mov    0x28(%rsp),%rbp
  403258:	4d 89 ee             	mov    %r13,%r14
  40325b:	31 db                	xor    %ebx,%ebx
  40325d:	4d 89 fd             	mov    %r15,%r13
  403260:	48 89 04 24          	mov    %rax,(%rsp)
  403264:	4d 89 e7             	mov    %r12,%r15
  403267:	4d 89 cc             	mov    %r9,%r12
  40326a:	e9 09 01 00 00       	jmpq   403378 <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x178>
  40326f:	90                   	nop
            my_copy_stack(ds);
  403270:	f6 c1 04             	test   $0x4,%cl
  403273:	0f 85 e7 02 00 00    	jne    403560 <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x360>
  403279:	48 85 c9             	test   %rcx,%rcx
  40327c:	74 0f                	je     40328d <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x8d>
  40327e:	0f b6 16             	movzbl (%rsi),%edx
  403281:	88 55 00             	mov    %dl,0x0(%rbp)
  403284:	f6 c1 02             	test   $0x2,%cl
  403287:	0f 85 07 03 00 00    	jne    403594 <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x394>
  40328d:	48 8b 54 24 30       	mov    0x30(%rsp),%rdx
    fcs_col_push_card(col, card);
  403292:	0f b6 74 24 0b       	movzbl 0xb(%rsp),%esi
  403297:	48 89 2c c2          	mov    %rbp,(%rdx,%rax,8)
            fcs_empty_freecell(new_state_key, fc);
  40329b:	48 63 44 24 0c       	movslq 0xc(%rsp),%rax
  4032a0:	c6 44 02 40 00       	movb   $0x0,0x40(%rdx,%rax,1)
  4032a5:	48 0f be 45 00       	movsbq 0x0(%rbp),%rax
  4032aa:	8d 50 01             	lea    0x1(%rax),%edx
  4032ad:	88 55 00             	mov    %dl,0x0(%rbp)
  4032b0:	48 8d 54 24 40       	lea    0x40(%rsp),%rdx
  4032b5:	40 88 74 05 01       	mov    %sil,0x1(%rbp,%rax,1)
    const_SLOT(hard_thread, soft_thread);
  4032ba:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
    if (!fc_solve_check_and_add_state(
  4032bf:	48 8d 74 24 30       	lea    0x30(%rsp),%rsi
    const_SLOT(hard_thread, soft_thread);
  4032c4:	48 8b 08             	mov    (%rax),%rcx
    if (!fc_solve_check_and_add_state(
  4032c7:	48 89 cf             	mov    %rcx,%rdi
  4032ca:	48 89 4c 24 10       	mov    %rcx,0x10(%rsp)
  4032cf:	e8 7c e7 ff ff       	callq  401a50 <fc_solve_check_and_add_state>
  4032d4:	84 c0                	test   %al,%al
  4032d6:	0f 85 f4 01 00 00    	jne    4034d0 <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x2d0>
        if (HT_FIELD(hard_thread, allocated_from_list))
  4032dc:	48 8b 4c 24 10       	mov    0x10(%rsp),%rcx
  4032e1:	80 b9 18 05 00 00 00 	cmpb   $0x0,0x518(%rcx)
  4032e8:	0f 84 02 02 00 00    	je     4034f0 <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x2f0>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  4032ee:	48 8b 91 b0 00 00 00 	mov    0xb0(%rcx),%rdx
  4032f5:	48 8b 44 24 38       	mov    0x38(%rsp),%rax
  4032fa:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  4032fd:	48 8b 44 24 30       	mov    0x30(%rsp),%rax
  403302:	48 89 81 b0 00 00 00 	mov    %rax,0xb0(%rcx)
  403309:	48 8b 54 24 40       	mov    0x40(%rsp),%rdx
    if ((!((list->num_states + (list->states != NULL)) &
  40330e:	49 8b 44 24 08       	mov    0x8(%r12),%rax
  403313:	31 f6                	xor    %esi,%esi
  403315:	49 8b 3c 24          	mov    (%r12),%rdi
  403319:	48 85 c0             	test   %rax,%rax
  40331c:	40 0f 95 c6          	setne  %sil
  403320:	48 01 fe             	add    %rdi,%rsi
  403323:	40 f6 c6 0f          	test   $0xf,%sil
  403327:	75 23                	jne    40334c <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x14c>
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  403329:	48 83 c6 10          	add    $0x10,%rsi
  40332d:	48 89 c7             	mov    %rax,%rdi
  403330:	48 89 54 24 10       	mov    %rdx,0x10(%rsp)
  403335:	48 c1 e6 04          	shl    $0x4,%rsi
  403339:	e8 32 de ff ff       	callq  401170 <realloc@plt>
  40333e:	49 8b 3c 24          	mov    (%r12),%rdi
  403342:	48 8b 54 24 10       	mov    0x10(%rsp),%rdx
        list->states =
  403347:	49 89 44 24 08       	mov    %rax,0x8(%r12)
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  40334c:	48 8d 4f 01          	lea    0x1(%rdi),%rcx
  403350:	48 c1 e7 04          	shl    $0x4,%rdi
  403354:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  403358:	48 01 f8             	add    %rdi,%rax
  40335b:	49 89 0c 24          	mov    %rcx,(%r12)
  40335f:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  403363:	48 89 10             	mov    %rdx,(%rax)
  403366:	48 83 c3 01          	add    $0x1,%rbx
  40336a:	48 83 ed 80          	sub    $0xffffffffffffff80,%rbp
        for (int ds = 0; ds < LOCAL_STACKS_NUM; ds++)
  40336e:	48 83 fb 08          	cmp    $0x8,%rbx
  403372:	0f 84 28 01 00 00    	je     4034a0 <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x2a0>
            var_AUTO(dest_col, fcs_state_get_col(state, ds));
  403378:	49 8b 14 df          	mov    (%r15,%rbx,8),%rdx
  40337c:	89 d9                	mov    %ebx,%ecx
            const_AUTO(l, fcs_col_len(dest_col));
  40337e:	0f be 02             	movsbl (%rdx),%eax
            if (!l)
  403381:	84 c0                	test   %al,%al
  403383:	74 e1                	je     403366 <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x166>
            const fcs_card dest_card = fcs_col_get_card(dest_col, l - 1);
  403385:	83 e8 01             	sub    $0x1,%eax
            if (!fcs_is_parent_card(card, dest_card))
  403388:	48 8b 3c 24          	mov    (%rsp),%rdi
            const fcs_card dest_card = fcs_col_get_card(dest_col, l - 1);
  40338c:	48 98                	cltq   
    return fc_solve_is_parent_buf[(size_t)parent][(size_t)child];
  40338e:	48 0f be 44 02 01    	movsbq 0x1(%rdx,%rax,1),%rax
  403394:	48 c1 e0 06          	shl    $0x6,%rax
            if (!fcs_is_parent_card(card, dest_card))
  403398:	80 bc 38 c0 fe 40 00 	cmpb   $0x0,0x40fec0(%rax,%rdi,1)
  40339f:	00 
  4033a0:	74 c4                	je     403366 <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x166>
                (instance->list_of_vacant_states != NULL)))
  4033a2:	49 8b 95 b0 00 00 00 	mov    0xb0(%r13),%rdx
  4033a9:	48 85 d2             	test   %rdx,%rdx
    if ((HT_FIELD(hard_thread, allocated_from_list) =
  4033ac:	41 0f 95 85 18 05 00 	setne  0x518(%r13)
  4033b3:	00 
  4033b4:	0f 85 26 01 00 00    	jne    4034e0 <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x2e0>
    if ((size_t)(allocator->max_ptr - allocator->ptr) < how_much)
  4033ba:	49 8b 95 e8 00 00 00 	mov    0xe8(%r13),%rdx
  4033c1:	49 8b 85 e0 00 00 00 	mov    0xe0(%r13),%rax
  4033c8:	48 29 d0             	sub    %rdx,%rax
  4033cb:	48 83 f8 5f          	cmp    $0x5f,%rax
  4033cf:	0f 86 3b 01 00 00    	jbe    403510 <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x310>
        allocator->rollback_ptr = allocator->ptr;
  4033d5:	49 89 95 f0 00 00 00 	mov    %rdx,0xf0(%r13)
    allocator->ptr += how_much;
  4033dc:	48 8d 42 60          	lea    0x60(%rdx),%rax
  4033e0:	49 89 85 e8 00 00 00 	mov    %rax,0xe8(%r13)
    return (const fcs_kv_state){.key = &(s->s), .val = &(s->info)};
  4033e7:	48 8d 42 48          	lea    0x48(%rdx),%rax
    *ret = FCS_STATE_keyval_pair_to_kv(s);
  4033eb:	c4 e1 f9 6e ca       	vmovq  %rdx,%xmm1
  4033f0:	c4 e3 f1 22 c0 01    	vpinsrq $0x1,%rax,%xmm1,%xmm0
  4033f6:	c5 f8 29 44 24 30    	vmovaps %xmm0,0x30(%rsp)
    fcs_duplicate_kv_state(out_new_state_out, &raw_state_raw);
  4033fc:	c4 c1 7a 6f 07       	vmovdqu (%r15),%xmm0
  403401:	c5 f8 11 02          	vmovups %xmm0,(%rdx)
  403405:	c4 c1 7a 6f 47 10    	vmovdqu 0x10(%r15),%xmm0
  40340b:	c5 f8 11 42 10       	vmovups %xmm0,0x10(%rdx)
  403410:	c4 c1 7a 6f 47 20    	vmovdqu 0x20(%r15),%xmm0
  403416:	c5 f8 11 42 20       	vmovups %xmm0,0x20(%rdx)
  40341b:	c4 c1 7a 6f 47 30    	vmovdqu 0x30(%r15),%xmm0
  403421:	c5 f8 11 42 30       	vmovups %xmm0,0x30(%rdx)
  403426:	49 8b 47 40          	mov    0x40(%r15),%rax
  40342a:	c4 c1 7a 6f 06       	vmovdqu (%r14),%xmm0
  40342f:	c5 f8 11 42 48       	vmovups %xmm0,0x48(%rdx)
  403434:	48 89 42 40          	mov    %rax,0x40(%rdx)
  403438:	49 8b 46 10          	mov    0x10(%r14),%rax
    (FCS_S_DEPTH(raw_ptr_new_state))++;
  40343c:	83 42 50 01          	addl   $0x1,0x50(%rdx)
    FCS_S_PARENT(raw_ptr_new_state) = INFO_STATE_PTR(&raw_state_raw);
  403440:	4c 89 7a 48          	mov    %r15,0x48(%rdx)
    FCS_S_VISITED(raw_ptr_new_state) = 0;
  403444:	c6 42 56 00          	movb   $0x0,0x56(%rdx)
    fcs_duplicate_kv_state(out_new_state_out, &raw_state_raw);
  403448:	48 89 42 58          	mov    %rax,0x58(%rdx)
    FCS_S_NUM_ACTIVE_CHILDREN(raw_ptr_new_state) = 0;
  40344c:	31 c0                	xor    %eax,%eax
  40344e:	66 89 42 54          	mov    %ax,0x54(%rdx)
            my_copy_stack(ds);
  403452:	b8 01 00 00 00       	mov    $0x1,%eax
  403457:	d3 e0                	shl    %cl,%eax
    memset(&(FCS_S_SCAN_VISITED(raw_ptr_new_state)), '\0',
  403459:	c7 42 57 00 00 00 00 	movl   $0x0,0x57(%rdx)
  403460:	89 42 5c             	mov    %eax,0x5c(%rdx)
  403463:	48 63 c1             	movslq %ecx,%rax
  403466:	48 8b 34 c2          	mov    (%rdx,%rax,8),%rsi
  40346a:	0f be 0e             	movsbl (%rsi),%ecx
  40346d:	83 c1 01             	add    $0x1,%ecx
  403470:	48 63 c9             	movslq %ecx,%rcx
  403473:	48 83 f9 08          	cmp    $0x8,%rcx
  403477:	0f 82 f3 fd ff ff    	jb     403270 <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x70>
  40347d:	48 8b 54 0e f8       	mov    -0x8(%rsi,%rcx,1),%rdx
  403482:	48 89 ef             	mov    %rbp,%rdi
  403485:	48 89 54 0d f8       	mov    %rdx,-0x8(%rbp,%rcx,1)
  40348a:	48 83 e9 01          	sub    $0x1,%rcx
  40348e:	48 c1 e9 03          	shr    $0x3,%rcx
  403492:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  403495:	e9 f3 fd ff ff       	jmpq   40328d <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x8d>
  40349a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
  4034a0:	4d 89 e1             	mov    %r12,%r9
  4034a3:	4d 89 fc             	mov    %r15,%r12
  4034a6:	4d 89 ef             	mov    %r13,%r15
  4034a9:	4d 89 f5             	mov    %r14,%r13
  4034ac:	4c 8b 74 24 20       	mov    0x20(%rsp),%r14
  4034b1:	49 83 c6 01          	add    $0x1,%r14
    for (int fc = 0; fc < LOCAL_FREECELLS_NUM; fc++)
  4034b5:	49 83 fe 04          	cmp    $0x4,%r14
  4034b9:	0f 85 78 fd ff ff    	jne    403237 <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x37>
}
  4034bf:	48 83 c4 58          	add    $0x58,%rsp
  4034c3:	5b                   	pop    %rbx
  4034c4:	5d                   	pop    %rbp
  4034c5:	41 5c                	pop    %r12
  4034c7:	41 5d                	pop    %r13
  4034c9:	41 5e                	pop    %r14
  4034cb:	41 5f                	pop    %r15
  4034cd:	c3                   	retq   
  4034ce:	66 90                	xchg   %ax,%ax
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  4034d0:	48 8b 54 24 30       	mov    0x30(%rsp),%rdx
  4034d5:	e9 34 fe ff ff       	jmpq   40330e <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x10e>
  4034da:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
            FCS_S_NEXT(instance->list_of_vacant_states);
  4034e0:	48 8b 42 48          	mov    0x48(%rdx),%rax
        instance->list_of_vacant_states =
  4034e4:	49 89 85 b0 00 00 00 	mov    %rax,0xb0(%r13)
  4034eb:	e9 f7 fe ff ff       	jmpq   4033e7 <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x1e7>
    allocator->ptr = allocator->rollback_ptr;
  4034f0:	48 8b 81 f0 00 00 00 	mov    0xf0(%rcx),%rax
  4034f7:	48 89 81 e8 00 00 00 	mov    %rax,0xe8(%rcx)
  4034fe:	e9 06 fe ff ff       	jmpq   403309 <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x109>
  403503:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40350a:	00 00 00 00 
  40350e:	66 90                	xchg   %ax,%ax
    char *const new_data = meta_request_new_buffer(allocator->meta);
  403510:	49 8b 95 f8 00 00 00 	mov    0xf8(%r13),%rdx
    char *const ret = meta_alloc->recycle_bin;
  403517:	48 8b 02             	mov    (%rdx),%rax
    if (ret)
  40351a:	48 85 c0             	test   %rax,%rax
  40351d:	74 61                	je     403580 <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x380>
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  40351f:	48 8b 30             	mov    (%rax),%rsi
  403522:	48 89 32             	mov    %rsi,(%rdx)
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  403525:	49 8b 95 d8 00 00 00 	mov    0xd8(%r13),%rdx
  40352c:	48 89 10             	mov    %rdx,(%rax)
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40352f:	48 8d 50 08          	lea    0x8(%rax),%rdx
    allocator->old_list = new_data;
  403533:	49 89 85 d8 00 00 00 	mov    %rax,0xd8(%r13)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40353a:	48 05 80 fe 00 00    	add    $0xfe80,%rax
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  403540:	49 89 95 f0 00 00 00 	mov    %rdx,0xf0(%r13)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  403547:	49 89 85 e0 00 00 00 	mov    %rax,0xe0(%r13)
  40354e:	e9 89 fe ff ff       	jmpq   4033dc <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x1dc>
  403553:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40355a:	00 00 00 00 
  40355e:	66 90                	xchg   %ax,%ax
            my_copy_stack(ds);
  403560:	8b 16                	mov    (%rsi),%edx
  403562:	89 55 00             	mov    %edx,0x0(%rbp)
  403565:	8b 54 0e fc          	mov    -0x4(%rsi,%rcx,1),%edx
  403569:	89 54 0d fc          	mov    %edx,-0x4(%rbp,%rcx,1)
  40356d:	e9 1b fd ff ff       	jmpq   40328d <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x8d>
  403572:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  403579:	00 00 00 00 
  40357d:	0f 1f 00             	nopl   (%rax)
        return malloc(ALLOCED_SIZE);
  403580:	bf 80 fe 00 00       	mov    $0xfe80,%edi
  403585:	89 5c 24 10          	mov    %ebx,0x10(%rsp)
  403589:	e8 62 db ff ff       	callq  4010f0 <malloc@plt>
  40358e:	8b 4c 24 10          	mov    0x10(%rsp),%ecx
  403592:	eb 91                	jmp    403525 <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x325>
  403594:	0f b7 54 0e fe       	movzwl -0x2(%rsi,%rcx,1),%edx
  403599:	66 89 54 0d fe       	mov    %dx,-0x2(%rbp,%rcx,1)
  40359e:	e9 ea fc ff ff       	jmpq   40328d <fc_solve_sfs_atomic_move_freecell_card_to_parent+0x8d>
  4035a3:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4035aa:	00 00 00 00 
  4035ae:	66 90                	xchg   %ax,%ax

00000000004035b0 <fc_solve_sfs_atomic_move_card_to_freecell>:
    if (num_vacant_freecells == 0)
  4035b0:	80 bf e4 01 00 00 00 	cmpb   $0x0,0x1e4(%rdi)
  4035b7:	0f 84 73 02 00 00    	je     403830 <fc_solve_sfs_atomic_move_card_to_freecell+0x280>
{
  4035bd:	41 57                	push   %r15
  4035bf:	41 56                	push   %r14
  4035c1:	41 55                	push   %r13
  4035c3:	41 54                	push   %r12
  4035c5:	55                   	push   %rbp
  4035c6:	53                   	push   %rbx
  4035c7:	48 83 ec 48          	sub    $0x48,%rsp
        if (fcs_freecell_is_empty(state, ds))
  4035cb:	80 7e 40 00          	cmpb   $0x0,0x40(%rsi)
  4035cf:	0f 84 6a 03 00 00    	je     40393f <fc_solve_sfs_atomic_move_card_to_freecell+0x38f>
  4035d5:	80 7e 41 00          	cmpb   $0x0,0x41(%rsi)
  4035d9:	0f 84 6d 03 00 00    	je     40394c <fc_solve_sfs_atomic_move_card_to_freecell+0x39c>
  4035df:	80 7e 42 00          	cmpb   $0x0,0x42(%rsi)
  4035e3:	0f 84 70 03 00 00    	je     403959 <fc_solve_sfs_atomic_move_card_to_freecell+0x3a9>
    for (ds = 0; ds < LOCAL_FREECELLS_NUM; ds++)
  4035e9:	31 c0                	xor    %eax,%eax
  4035eb:	80 7e 43 00          	cmpb   $0x0,0x43(%rsi)
  4035ef:	0f 95 c0             	setne  %al
  4035f2:	83 c0 03             	add    $0x3,%eax
  4035f5:	89 44 24 0c          	mov    %eax,0xc(%rsp)
    tests_define_accessors();
  4035f9:	4c 8b 27             	mov    (%rdi),%r12
  4035fc:	48 89 f3             	mov    %rsi,%rbx
  4035ff:	48 89 3c 24          	mov    %rdi,(%rsp)
  403603:	31 ed                	xor    %ebp,%ebp
    if (!fc_solve_check_and_add_state(
  403605:	49 89 d5             	mov    %rdx,%r13
  403608:	49 89 ce             	mov    %rcx,%r14
  40360b:	49 8d 84 24 00 01 00 	lea    0x100(%r12),%rax
  403612:	00 
  403613:	4d 89 e7             	mov    %r12,%r15
  403616:	48 89 44 24 10       	mov    %rax,0x10(%rsp)
  40361b:	e9 92 00 00 00       	jmpq   4036b2 <fc_solve_sfs_atomic_move_card_to_freecell+0x102>
        if (HT_FIELD(hard_thread, allocated_from_list))
  403620:	41 80 bc 24 18 05 00 	cmpb   $0x0,0x518(%r12)
  403627:	00 00 
  403629:	0f 84 41 02 00 00    	je     403870 <fc_solve_sfs_atomic_move_card_to_freecell+0x2c0>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  40362f:	49 8b 94 24 b0 00 00 	mov    0xb0(%r12),%rdx
  403636:	00 
  403637:	48 8b 44 24 28       	mov    0x28(%rsp),%rax
  40363c:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  40363f:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  403644:	49 89 84 24 b0 00 00 	mov    %rax,0xb0(%r12)
  40364b:	00 
  40364c:	48 8b 54 24 30       	mov    0x30(%rsp),%rdx
    if ((!((list->num_states + (list->states != NULL)) &
  403651:	49 8b 46 08          	mov    0x8(%r14),%rax
  403655:	31 f6                	xor    %esi,%esi
  403657:	49 8b 3e             	mov    (%r14),%rdi
  40365a:	48 85 c0             	test   %rax,%rax
  40365d:	40 0f 95 c6          	setne  %sil
  403661:	48 01 fe             	add    %rdi,%rsi
  403664:	40 f6 c6 0f          	test   $0xf,%sil
  403668:	75 21                	jne    40368b <fc_solve_sfs_atomic_move_card_to_freecell+0xdb>
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  40366a:	48 83 c6 10          	add    $0x10,%rsi
  40366e:	48 89 c7             	mov    %rax,%rdi
  403671:	48 89 54 24 18       	mov    %rdx,0x18(%rsp)
  403676:	48 c1 e6 04          	shl    $0x4,%rsi
  40367a:	e8 f1 da ff ff       	callq  401170 <realloc@plt>
  40367f:	49 8b 3e             	mov    (%r14),%rdi
  403682:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
        list->states =
  403687:	49 89 46 08          	mov    %rax,0x8(%r14)
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  40368b:	48 8d 4f 01          	lea    0x1(%rdi),%rcx
  40368f:	48 c1 e7 04          	shl    $0x4,%rdi
  403693:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  403697:	48 01 f8             	add    %rdi,%rax
  40369a:	49 89 0e             	mov    %rcx,(%r14)
  40369d:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  4036a1:	48 89 10             	mov    %rdx,(%rax)
  4036a4:	48 83 c5 01          	add    $0x1,%rbp
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  4036a8:	48 83 fd 08          	cmp    $0x8,%rbp
  4036ac:	0f 84 de 01 00 00    	je     403890 <fc_solve_sfs_atomic_move_card_to_freecell+0x2e0>
        var_AUTO(col, fcs_state_get_col(state, stack_idx));
  4036b2:	48 8b 14 eb          	mov    (%rbx,%rbp,8),%rdx
  4036b6:	89 e9                	mov    %ebp,%ecx
        const int cards_num = fcs_col_len(col);
  4036b8:	0f be 02             	movsbl (%rdx),%eax
        if (cards_num <= num_cards_in_col_threshold)
  4036bb:	85 c0                	test   %eax,%eax
  4036bd:	7e e5                	jle    4036a4 <fc_solve_sfs_atomic_move_card_to_freecell+0xf4>
        const fcs_card card = fcs_col_get_card(col, cards_num - 1);
  4036bf:	83 e8 01             	sub    $0x1,%eax
  4036c2:	48 98                	cltq   
  4036c4:	44 0f b6 64 02 01    	movzbl 0x1(%rdx,%rax,1),%r12d
                (instance->list_of_vacant_states != NULL)))
  4036ca:	49 8b 97 b0 00 00 00 	mov    0xb0(%r15),%rdx
  4036d1:	48 85 d2             	test   %rdx,%rdx
    if ((HT_FIELD(hard_thread, allocated_from_list) =
  4036d4:	41 0f 95 87 18 05 00 	setne  0x518(%r15)
  4036db:	00 
  4036dc:	0f 85 7e 01 00 00    	jne    403860 <fc_solve_sfs_atomic_move_card_to_freecell+0x2b0>
    if ((size_t)(allocator->max_ptr - allocator->ptr) < how_much)
  4036e2:	49 8b 97 e8 00 00 00 	mov    0xe8(%r15),%rdx
  4036e9:	49 8b 87 e0 00 00 00 	mov    0xe0(%r15),%rax
  4036f0:	48 29 d0             	sub    %rdx,%rax
  4036f3:	48 83 f8 5f          	cmp    $0x5f,%rax
  4036f7:	0f 86 a3 01 00 00    	jbe    4038a0 <fc_solve_sfs_atomic_move_card_to_freecell+0x2f0>
        allocator->rollback_ptr = allocator->ptr;
  4036fd:	49 89 97 f0 00 00 00 	mov    %rdx,0xf0(%r15)
    allocator->ptr += how_much;
  403704:	48 8d 42 60          	lea    0x60(%rdx),%rax
  403708:	49 89 87 e8 00 00 00 	mov    %rax,0xe8(%r15)
    return (const fcs_kv_state){.key = &(s->s), .val = &(s->info)};
  40370f:	48 8d 42 48          	lea    0x48(%rdx),%rax
    *ret = FCS_STATE_keyval_pair_to_kv(s);
  403713:	c4 e1 f9 6e ca       	vmovq  %rdx,%xmm1
  403718:	48 8b 7c 24 10       	mov    0x10(%rsp),%rdi
  40371d:	49 89 eb             	mov    %rbp,%r11
  403720:	c4 e3 f1 22 c0 01    	vpinsrq $0x1,%rax,%xmm1,%xmm0
  403726:	c5 f8 29 44 24 20    	vmovaps %xmm0,0x20(%rsp)
    fcs_duplicate_kv_state(out_new_state_out, &raw_state_raw);
  40372c:	c5 fa 6f 03          	vmovdqu (%rbx),%xmm0
  403730:	49 c1 e3 07          	shl    $0x7,%r11
  403734:	c5 f8 11 02          	vmovups %xmm0,(%rdx)
  403738:	c5 fa 6f 43 10       	vmovdqu 0x10(%rbx),%xmm0
  40373d:	c5 f8 11 42 10       	vmovups %xmm0,0x10(%rdx)
  403742:	c5 fa 6f 43 20       	vmovdqu 0x20(%rbx),%xmm0
  403747:	c5 f8 11 42 20       	vmovups %xmm0,0x20(%rdx)
  40374c:	c5 fa 6f 43 30       	vmovdqu 0x30(%rbx),%xmm0
  403751:	c5 f8 11 42 30       	vmovups %xmm0,0x30(%rdx)
  403756:	48 8b 43 40          	mov    0x40(%rbx),%rax
  40375a:	c4 c1 7a 6f 45 00    	vmovdqu 0x0(%r13),%xmm0
  403760:	c5 f8 11 42 48       	vmovups %xmm0,0x48(%rdx)
  403765:	48 89 42 40          	mov    %rax,0x40(%rdx)
  403769:	49 8b 45 10          	mov    0x10(%r13),%rax
    (FCS_S_DEPTH(raw_ptr_new_state))++;
  40376d:	83 42 50 01          	addl   $0x1,0x50(%rdx)
    FCS_S_PARENT(raw_ptr_new_state) = INFO_STATE_PTR(&raw_state_raw);
  403771:	48 89 5a 48          	mov    %rbx,0x48(%rdx)
    FCS_S_VISITED(raw_ptr_new_state) = 0;
  403775:	c6 42 56 00          	movb   $0x0,0x56(%rdx)
    fcs_duplicate_kv_state(out_new_state_out, &raw_state_raw);
  403779:	48 89 42 58          	mov    %rax,0x58(%rdx)
    FCS_S_NUM_ACTIVE_CHILDREN(raw_ptr_new_state) = 0;
  40377d:	31 c0                	xor    %eax,%eax
  40377f:	66 89 42 54          	mov    %ax,0x54(%rdx)
        my_copy_stack(stack_idx);
  403783:	b8 01 00 00 00       	mov    $0x1,%eax
  403788:	d3 e0                	shl    %cl,%eax
    memset(&(FCS_S_SCAN_VISITED(raw_ptr_new_state)), '\0',
  40378a:	c7 42 57 00 00 00 00 	movl   $0x0,0x57(%rdx)
  403791:	89 42 5c             	mov    %eax,0x5c(%rdx)
  403794:	48 63 c1             	movslq %ecx,%rax
  403797:	48 8b 34 c2          	mov    (%rdx,%rax,8),%rsi
  40379b:	4a 8d 14 1f          	lea    (%rdi,%r11,1),%rdx
  40379f:	0f be 0e             	movsbl (%rsi),%ecx
  4037a2:	83 c1 01             	add    $0x1,%ecx
  4037a5:	48 63 c9             	movslq %ecx,%rcx
  4037a8:	48 83 f9 08          	cmp    $0x8,%rcx
  4037ac:	0f 83 8e 00 00 00    	jae    403840 <fc_solve_sfs_atomic_move_card_to_freecell+0x290>
  4037b2:	f6 c1 04             	test   $0x4,%cl
  4037b5:	0f 85 35 01 00 00    	jne    4038f0 <fc_solve_sfs_atomic_move_card_to_freecell+0x340>
  4037bb:	48 85 c9             	test   %rcx,%rcx
  4037be:	74 0f                	je     4037cf <fc_solve_sfs_atomic_move_card_to_freecell+0x21f>
  4037c0:	0f b6 3e             	movzbl (%rsi),%edi
  4037c3:	40 88 3a             	mov    %dil,(%rdx)
  4037c6:	f6 c1 02             	test   $0x2,%cl
  4037c9:	0f 85 61 01 00 00    	jne    403930 <fc_solve_sfs_atomic_move_card_to_freecell+0x380>
  4037cf:	48 8b 4c 24 20       	mov    0x20(%rsp),%rcx
    if (!fc_solve_check_and_add_state(
  4037d4:	48 8d 74 24 20       	lea    0x20(%rsp),%rsi
  4037d9:	48 89 14 c1          	mov    %rdx,(%rcx,%rax,8)
    fcs_col_pop_top(col);
  4037dd:	43 0f b6 84 1f 00 01 	movzbl 0x100(%r15,%r11,1),%eax
  4037e4:	00 00 
  4037e6:	83 e8 01             	sub    $0x1,%eax
  4037e9:	43 88 84 1f 00 01 00 	mov    %al,0x100(%r15,%r11,1)
  4037f0:	00 
  4037f1:	48 0f be c0          	movsbq %al,%rax
  4037f5:	c6 44 02 01 00       	movb   $0x0,0x1(%rdx,%rax,1)
        fcs_put_card_in_freecell(new_state_key, ds, card);
  4037fa:	48 63 44 24 0c       	movslq 0xc(%rsp),%rax
  4037ff:	48 8b 54 24 20       	mov    0x20(%rsp),%rdx
  403804:	44 88 64 02 40       	mov    %r12b,0x40(%rdx,%rax,1)
    const_SLOT(hard_thread, soft_thread);
  403809:	48 8b 04 24          	mov    (%rsp),%rax
    if (!fc_solve_check_and_add_state(
  40380d:	48 8d 54 24 30       	lea    0x30(%rsp),%rdx
    const_SLOT(hard_thread, soft_thread);
  403812:	4c 8b 20             	mov    (%rax),%r12
    if (!fc_solve_check_and_add_state(
  403815:	4c 89 e7             	mov    %r12,%rdi
  403818:	e8 33 e2 ff ff       	callq  401a50 <fc_solve_check_and_add_state>
  40381d:	84 c0                	test   %al,%al
  40381f:	0f 84 fb fd ff ff    	je     403620 <fc_solve_sfs_atomic_move_card_to_freecell+0x70>
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  403825:	48 8b 54 24 20       	mov    0x20(%rsp),%rdx
  40382a:	e9 22 fe ff ff       	jmpq   403651 <fc_solve_sfs_atomic_move_card_to_freecell+0xa1>
  40382f:	90                   	nop
  403830:	c3                   	retq   
  403831:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  403838:	00 00 00 00 
  40383c:	0f 1f 40 00          	nopl   0x0(%rax)
        my_copy_stack(stack_idx);
  403840:	48 8b 7c 0e f8       	mov    -0x8(%rsi,%rcx,1),%rdi
  403845:	48 89 7c 0a f8       	mov    %rdi,-0x8(%rdx,%rcx,1)
  40384a:	48 83 e9 01          	sub    $0x1,%rcx
  40384e:	48 89 d7             	mov    %rdx,%rdi
  403851:	48 c1 e9 03          	shr    $0x3,%rcx
  403855:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  403858:	e9 72 ff ff ff       	jmpq   4037cf <fc_solve_sfs_atomic_move_card_to_freecell+0x21f>
  40385d:	0f 1f 00             	nopl   (%rax)
            FCS_S_NEXT(instance->list_of_vacant_states);
  403860:	48 8b 42 48          	mov    0x48(%rdx),%rax
        instance->list_of_vacant_states =
  403864:	49 89 87 b0 00 00 00 	mov    %rax,0xb0(%r15)
  40386b:	e9 9f fe ff ff       	jmpq   40370f <fc_solve_sfs_atomic_move_card_to_freecell+0x15f>
    allocator->ptr = allocator->rollback_ptr;
  403870:	49 8b 84 24 f0 00 00 	mov    0xf0(%r12),%rax
  403877:	00 
  403878:	49 89 84 24 e8 00 00 	mov    %rax,0xe8(%r12)
  40387f:	00 
  403880:	e9 c7 fd ff ff       	jmpq   40364c <fc_solve_sfs_atomic_move_card_to_freecell+0x9c>
  403885:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40388c:	00 00 00 00 
}
  403890:	48 83 c4 48          	add    $0x48,%rsp
  403894:	5b                   	pop    %rbx
  403895:	5d                   	pop    %rbp
  403896:	41 5c                	pop    %r12
  403898:	41 5d                	pop    %r13
  40389a:	41 5e                	pop    %r14
  40389c:	41 5f                	pop    %r15
  40389e:	c3                   	retq   
  40389f:	90                   	nop
    char *const new_data = meta_request_new_buffer(allocator->meta);
  4038a0:	49 8b 97 f8 00 00 00 	mov    0xf8(%r15),%rdx
    char *const ret = meta_alloc->recycle_bin;
  4038a7:	48 8b 02             	mov    (%rdx),%rax
    if (ret)
  4038aa:	48 85 c0             	test   %rax,%rax
  4038ad:	74 61                	je     403910 <fc_solve_sfs_atomic_move_card_to_freecell+0x360>
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  4038af:	48 8b 30             	mov    (%rax),%rsi
  4038b2:	48 89 32             	mov    %rsi,(%rdx)
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  4038b5:	49 8b 97 d8 00 00 00 	mov    0xd8(%r15),%rdx
  4038bc:	48 89 10             	mov    %rdx,(%rax)
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  4038bf:	48 8d 50 08          	lea    0x8(%rax),%rdx
    allocator->old_list = new_data;
  4038c3:	49 89 87 d8 00 00 00 	mov    %rax,0xd8(%r15)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  4038ca:	48 05 80 fe 00 00    	add    $0xfe80,%rax
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  4038d0:	49 89 97 f0 00 00 00 	mov    %rdx,0xf0(%r15)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  4038d7:	49 89 87 e0 00 00 00 	mov    %rax,0xe0(%r15)
  4038de:	e9 21 fe ff ff       	jmpq   403704 <fc_solve_sfs_atomic_move_card_to_freecell+0x154>
  4038e3:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4038ea:	00 00 00 00 
  4038ee:	66 90                	xchg   %ax,%ax
        my_copy_stack(stack_idx);
  4038f0:	8b 3e                	mov    (%rsi),%edi
  4038f2:	89 3a                	mov    %edi,(%rdx)
  4038f4:	8b 74 0e fc          	mov    -0x4(%rsi,%rcx,1),%esi
  4038f8:	89 74 0a fc          	mov    %esi,-0x4(%rdx,%rcx,1)
  4038fc:	e9 ce fe ff ff       	jmpq   4037cf <fc_solve_sfs_atomic_move_card_to_freecell+0x21f>
  403901:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  403908:	00 00 00 00 
  40390c:	0f 1f 40 00          	nopl   0x0(%rax)
        return malloc(ALLOCED_SIZE);
  403910:	bf 80 fe 00 00       	mov    $0xfe80,%edi
  403915:	89 6c 24 18          	mov    %ebp,0x18(%rsp)
  403919:	e8 d2 d7 ff ff       	callq  4010f0 <malloc@plt>
  40391e:	8b 4c 24 18          	mov    0x18(%rsp),%ecx
  403922:	eb 91                	jmp    4038b5 <fc_solve_sfs_atomic_move_card_to_freecell+0x305>
  403924:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40392b:	00 00 00 00 
  40392f:	90                   	nop
  403930:	0f b7 74 0e fe       	movzwl -0x2(%rsi,%rcx,1),%esi
  403935:	66 89 74 0a fe       	mov    %si,-0x2(%rdx,%rcx,1)
  40393a:	e9 90 fe ff ff       	jmpq   4037cf <fc_solve_sfs_atomic_move_card_to_freecell+0x21f>
    for (ds = 0; ds < LOCAL_FREECELLS_NUM; ds++)
  40393f:	c7 44 24 0c 00 00 00 	movl   $0x0,0xc(%rsp)
  403946:	00 
  403947:	e9 ad fc ff ff       	jmpq   4035f9 <fc_solve_sfs_atomic_move_card_to_freecell+0x49>
  40394c:	c7 44 24 0c 01 00 00 	movl   $0x1,0xc(%rsp)
  403953:	00 
  403954:	e9 a0 fc ff ff       	jmpq   4035f9 <fc_solve_sfs_atomic_move_card_to_freecell+0x49>
  403959:	c7 44 24 0c 02 00 00 	movl   $0x2,0xc(%rsp)
  403960:	00 
  403961:	e9 93 fc ff ff       	jmpq   4035f9 <fc_solve_sfs_atomic_move_card_to_freecell+0x49>
  403966:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  40396d:	00 00 00 

0000000000403970 <fc_solve_sfs_atomic_move_card_to_parent>:
{
  403970:	41 57                	push   %r15
    if (!fc_solve_check_and_add_state(
  403972:	49 89 d3             	mov    %rdx,%r11
    MOVE_FUNCS__define_common();
  403975:	45 31 ff             	xor    %r15d,%r15d
  403978:	49 89 ca             	mov    %rcx,%r10
{
  40397b:	41 56                	push   %r14
  40397d:	41 55                	push   %r13
  40397f:	41 54                	push   %r12
  403981:	55                   	push   %rbp
  403982:	48 89 f5             	mov    %rsi,%rbp
  403985:	53                   	push   %rbx
  403986:	48 83 ec 68          	sub    $0x68,%rsp
    MOVE_FUNCS__define_common();
  40398a:	4c 8b 37             	mov    (%rdi),%r14
{
  40398d:	48 89 7c 24 28       	mov    %rdi,0x28(%rsp)
    MOVE_FUNCS__define_common();
  403992:	49 8d 86 00 01 00 00 	lea    0x100(%r14),%rax
  403999:	48 89 44 24 38       	mov    %rax,0x38(%rsp)
  40399e:	66 90                	xchg   %ax,%ax
        var_AUTO(col, fcs_state_get_col(state, stack_idx));
  4039a0:	4a 8b 54 fd 00       	mov    0x0(%rbp,%r15,8),%rdx
        const int cards_num = fcs_col_len(col);
  4039a5:	0f be 02             	movsbl (%rdx),%eax
        if (cards_num <= num_cards_in_col_threshold)
  4039a8:	85 c0                	test   %eax,%eax
  4039aa:	0f 8e c5 02 00 00    	jle    403c75 <fc_solve_sfs_atomic_move_card_to_parent+0x305>
        const fcs_card card = fcs_col_get_card(col, cards_num - 1);
  4039b0:	83 e8 01             	sub    $0x1,%eax
            copy_two_stacks(stack_idx, ds);
  4039b3:	be 01 00 00 00       	mov    $0x1,%esi
  4039b8:	44 89 f9             	mov    %r15d,%ecx
  4039bb:	4c 89 7c 24 30       	mov    %r15,0x30(%rsp)
        const fcs_card card = fcs_col_get_card(col, cards_num - 1);
  4039c0:	48 98                	cltq   
            copy_two_stacks(stack_idx, ds);
  4039c2:	d3 e6                	shl    %cl,%esi
  4039c4:	4d 89 fd             	mov    %r15,%r13
        const fcs_card card = fcs_col_get_card(col, cards_num - 1);
  4039c7:	48 0f be 44 02 01    	movsbq 0x1(%rdx,%rax,1),%rax
  4039cd:	49 c1 e5 07          	shl    $0x7,%r13
            copy_two_stacks(stack_idx, ds);
  4039d1:	89 74 24 20          	mov    %esi,0x20(%rsp)
  4039d5:	31 db                	xor    %ebx,%ebx
  4039d7:	4c 03 6c 24 38       	add    0x38(%rsp),%r13
        const fcs_card card = fcs_col_get_card(col, cards_num - 1);
  4039dc:	88 44 24 27          	mov    %al,0x27(%rsp)
    return fc_solve_is_parent_buf[(size_t)parent][(size_t)child];
  4039e0:	48 89 44 24 08       	mov    %rax,0x8(%rsp)
            copy_two_stacks(stack_idx, ds);
  4039e5:	49 63 c7             	movslq %r15d,%rax
  4039e8:	48 89 04 24          	mov    %rax,(%rsp)
  4039ec:	e9 51 01 00 00       	jmpq   403b42 <fc_solve_sfs_atomic_move_card_to_parent+0x1d2>
  4039f1:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4039f8:	00 00 00 00 
  4039fc:	0f 1f 40 00          	nopl   0x0(%rax)
  403a00:	f6 c1 04             	test   $0x4,%cl
  403a03:	0f 85 c7 03 00 00    	jne    403dd0 <fc_solve_sfs_atomic_move_card_to_parent+0x460>
  403a09:	48 85 c9             	test   %rcx,%rcx
  403a0c:	74 10                	je     403a1e <fc_solve_sfs_atomic_move_card_to_parent+0xae>
  403a0e:	0f b6 06             	movzbl (%rsi),%eax
  403a11:	41 88 45 00          	mov    %al,0x0(%r13)
  403a15:	f6 c1 02             	test   $0x2,%cl
  403a18:	0f 85 e9 03 00 00    	jne    403e07 <fc_solve_sfs_atomic_move_card_to_parent+0x497>
  403a1e:	48 8b 34 24          	mov    (%rsp),%rsi
  403a22:	4c 89 e9             	mov    %r13,%rcx
  403a25:	49 63 d4             	movslq %r12d,%rdx
  403a28:	48 8b 44 24 40       	mov    0x40(%rsp),%rax
  403a2d:	4c 89 2c f0          	mov    %r13,(%rax,%rsi,8)
  403a31:	48 8b 74 24 48       	mov    0x48(%rsp),%rsi
  403a36:	8b 7e 14             	mov    0x14(%rsi),%edi
  403a39:	44 0f a3 e7          	bt     %r12d,%edi
  403a3d:	0f 83 7d 02 00 00    	jae    403cc0 <fc_solve_sfs_atomic_move_card_to_parent+0x350>
    fcs_col_pop_top(col);
  403a43:	0f b6 01             	movzbl (%rcx),%eax
  403a46:	48 8d 74 24 40       	lea    0x40(%rsp),%rsi
  403a4b:	4c 89 54 24 18       	mov    %r10,0x18(%rsp)
    fcs_col_push_card(col, card);
  403a50:	0f b6 7c 24 27       	movzbl 0x27(%rsp),%edi
  403a55:	4c 89 5c 24 10       	mov    %r11,0x10(%rsp)
    fcs_col_pop_top(col);
  403a5a:	83 e8 01             	sub    $0x1,%eax
  403a5d:	88 01                	mov    %al,(%rcx)
  403a5f:	48 0f be c0          	movsbq %al,%rax
  403a63:	c6 44 01 01 00       	movb   $0x0,0x1(%rcx,%rax,1)
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  403a68:	48 8b 44 24 40       	mov    0x40(%rsp),%rax
  403a6d:	48 8b 14 d0          	mov    (%rax,%rdx,8),%rdx
    fcs_col_push_card(col, card);
  403a71:	48 0f be 02          	movsbq (%rdx),%rax
  403a75:	8d 48 01             	lea    0x1(%rax),%ecx
  403a78:	88 0a                	mov    %cl,(%rdx)
  403a7a:	40 88 7c 02 01       	mov    %dil,0x1(%rdx,%rax,1)
    const_SLOT(hard_thread, soft_thread);
  403a7f:	48 8b 44 24 28       	mov    0x28(%rsp),%rax
    if (!fc_solve_check_and_add_state(
  403a84:	48 8d 54 24 50       	lea    0x50(%rsp),%rdx
    const_SLOT(hard_thread, soft_thread);
  403a89:	4c 8b 20             	mov    (%rax),%r12
    if (!fc_solve_check_and_add_state(
  403a8c:	4c 89 e7             	mov    %r12,%rdi
  403a8f:	e8 bc df ff ff       	callq  401a50 <fc_solve_check_and_add_state>
  403a94:	4c 8b 5c 24 10       	mov    0x10(%rsp),%r11
  403a99:	84 c0                	test   %al,%al
  403a9b:	4c 8b 54 24 18       	mov    0x18(%rsp),%r10
  403aa0:	0f 85 fa 01 00 00    	jne    403ca0 <fc_solve_sfs_atomic_move_card_to_parent+0x330>
        if (HT_FIELD(hard_thread, allocated_from_list))
  403aa6:	41 80 bc 24 18 05 00 	cmpb   $0x0,0x518(%r12)
  403aad:	00 00 
  403aaf:	0f 84 7b 02 00 00    	je     403d30 <fc_solve_sfs_atomic_move_card_to_parent+0x3c0>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  403ab5:	49 8b 94 24 b0 00 00 	mov    0xb0(%r12),%rdx
  403abc:	00 
  403abd:	48 8b 44 24 48       	mov    0x48(%rsp),%rax
  403ac2:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  403ac5:	48 8b 44 24 40       	mov    0x40(%rsp),%rax
  403aca:	49 89 84 24 b0 00 00 	mov    %rax,0xb0(%r12)
  403ad1:	00 
  403ad2:	4c 8b 64 24 50       	mov    0x50(%rsp),%r12
    if ((!((list->num_states + (list->states != NULL)) &
  403ad7:	49 8b 42 08          	mov    0x8(%r10),%rax
  403adb:	31 f6                	xor    %esi,%esi
  403add:	49 8b 3a             	mov    (%r10),%rdi
  403ae0:	48 85 c0             	test   %rax,%rax
  403ae3:	40 0f 95 c6          	setne  %sil
  403ae7:	48 01 fe             	add    %rdi,%rsi
  403aea:	40 f6 c6 0f          	test   $0xf,%sil
  403aee:	75 2b                	jne    403b1b <fc_solve_sfs_atomic_move_card_to_parent+0x1ab>
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  403af0:	48 83 c6 10          	add    $0x10,%rsi
  403af4:	48 89 c7             	mov    %rax,%rdi
  403af7:	4c 89 54 24 18       	mov    %r10,0x18(%rsp)
  403afc:	48 c1 e6 04          	shl    $0x4,%rsi
  403b00:	4c 89 5c 24 10       	mov    %r11,0x10(%rsp)
  403b05:	e8 66 d6 ff ff       	callq  401170 <realloc@plt>
        list->states =
  403b0a:	4c 8b 54 24 18       	mov    0x18(%rsp),%r10
  403b0f:	4c 8b 5c 24 10       	mov    0x10(%rsp),%r11
  403b14:	49 8b 3a             	mov    (%r10),%rdi
  403b17:	49 89 42 08          	mov    %rax,0x8(%r10)
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  403b1b:	48 8d 57 01          	lea    0x1(%rdi),%rdx
  403b1f:	48 c1 e7 04          	shl    $0x4,%rdi
  403b23:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  403b27:	48 01 f8             	add    %rdi,%rax
  403b2a:	49 89 12             	mov    %rdx,(%r10)
  403b2d:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  403b31:	4c 89 20             	mov    %r12,(%rax)
  403b34:	48 83 c3 01          	add    $0x1,%rbx
        for (int ds = 0; ds < LOCAL_STACKS_NUM; ds++)
  403b38:	48 83 fb 08          	cmp    $0x8,%rbx
  403b3c:	0f 84 2e 01 00 00    	je     403c70 <fc_solve_sfs_atomic_move_card_to_parent+0x300>
  403b42:	41 89 dc             	mov    %ebx,%r12d
            if (ds == stack_idx)
  403b45:	41 39 df             	cmp    %ebx,%r15d
  403b48:	74 ea                	je     403b34 <fc_solve_sfs_atomic_move_card_to_parent+0x1c4>
            var_AUTO(dest_col, fcs_state_get_col(state, ds));
  403b4a:	48 8b 54 dd 00       	mov    0x0(%rbp,%rbx,8),%rdx
            const int dest_cards_num = fcs_col_len(dest_col);
  403b4f:	0f be 02             	movsbl (%rdx),%eax
            if (!dest_cards_num)
  403b52:	84 c0                	test   %al,%al
  403b54:	74 de                	je     403b34 <fc_solve_sfs_atomic_move_card_to_parent+0x1c4>
                fcs_col_get_card(dest_col, fcs_col_len(dest_col) - 1);
  403b56:	83 e8 01             	sub    $0x1,%eax
            if (!fcs_is_parent_card(card, dest_card))
  403b59:	48 8b 7c 24 08       	mov    0x8(%rsp),%rdi
                fcs_col_get_card(dest_col, fcs_col_len(dest_col) - 1);
  403b5e:	48 98                	cltq   
    return fc_solve_is_parent_buf[(size_t)parent][(size_t)child];
  403b60:	48 0f be 44 02 01    	movsbq 0x1(%rdx,%rax,1),%rax
  403b66:	48 c1 e0 06          	shl    $0x6,%rax
            if (!fcs_is_parent_card(card, dest_card))
  403b6a:	80 bc 38 c0 fe 40 00 	cmpb   $0x0,0x40fec0(%rax,%rdi,1)
  403b71:	00 
  403b72:	74 c0                	je     403b34 <fc_solve_sfs_atomic_move_card_to_parent+0x1c4>
                (instance->list_of_vacant_states != NULL)))
  403b74:	49 8b 96 b0 00 00 00 	mov    0xb0(%r14),%rdx
  403b7b:	48 85 d2             	test   %rdx,%rdx
    if ((HT_FIELD(hard_thread, allocated_from_list) =
  403b7e:	41 0f 95 86 18 05 00 	setne  0x518(%r14)
  403b85:	00 
  403b86:	0f 85 24 01 00 00    	jne    403cb0 <fc_solve_sfs_atomic_move_card_to_parent+0x340>
    if ((size_t)(allocator->max_ptr - allocator->ptr) < how_much)
  403b8c:	49 8b 96 e8 00 00 00 	mov    0xe8(%r14),%rdx
  403b93:	49 8b 86 e0 00 00 00 	mov    0xe0(%r14),%rax
  403b9a:	48 29 d0             	sub    %rdx,%rax
  403b9d:	48 83 f8 5f          	cmp    $0x5f,%rax
  403ba1:	0f 86 a9 01 00 00    	jbe    403d50 <fc_solve_sfs_atomic_move_card_to_parent+0x3e0>
        allocator->rollback_ptr = allocator->ptr;
  403ba7:	49 89 96 f0 00 00 00 	mov    %rdx,0xf0(%r14)
    allocator->ptr += how_much;
  403bae:	48 8d 42 60          	lea    0x60(%rdx),%rax
  403bb2:	49 89 86 e8 00 00 00 	mov    %rax,0xe8(%r14)
    return (const fcs_kv_state){.key = &(s->s), .val = &(s->info)};
  403bb9:	48 8d 42 48          	lea    0x48(%rdx),%rax
    *ret = FCS_STATE_keyval_pair_to_kv(s);
  403bbd:	c4 e1 f9 6e ca       	vmovq  %rdx,%xmm1
  403bc2:	c4 e3 f1 22 c0 01    	vpinsrq $0x1,%rax,%xmm1,%xmm0
  403bc8:	c5 f8 29 44 24 40    	vmovaps %xmm0,0x40(%rsp)
    fcs_duplicate_kv_state(out_new_state_out, &raw_state_raw);
  403bce:	c5 fa 6f 45 00       	vmovdqu 0x0(%rbp),%xmm0
  403bd3:	c5 f8 11 02          	vmovups %xmm0,(%rdx)
  403bd7:	c5 fa 6f 45 10       	vmovdqu 0x10(%rbp),%xmm0
  403bdc:	c5 f8 11 42 10       	vmovups %xmm0,0x10(%rdx)
  403be1:	c5 fa 6f 45 20       	vmovdqu 0x20(%rbp),%xmm0
  403be6:	c5 f8 11 42 20       	vmovups %xmm0,0x20(%rdx)
  403beb:	c5 fa 6f 45 30       	vmovdqu 0x30(%rbp),%xmm0
  403bf0:	c5 f8 11 42 30       	vmovups %xmm0,0x30(%rdx)
  403bf5:	48 8b 45 40          	mov    0x40(%rbp),%rax
  403bf9:	c4 c1 7a 6f 03       	vmovdqu (%r11),%xmm0
  403bfe:	c5 f8 11 42 48       	vmovups %xmm0,0x48(%rdx)
  403c03:	48 89 42 40          	mov    %rax,0x40(%rdx)
  403c07:	49 8b 43 10          	mov    0x10(%r11),%rax
    (FCS_S_DEPTH(raw_ptr_new_state))++;
  403c0b:	83 42 50 01          	addl   $0x1,0x50(%rdx)
    FCS_S_PARENT(raw_ptr_new_state) = INFO_STATE_PTR(&raw_state_raw);
  403c0f:	48 89 6a 48          	mov    %rbp,0x48(%rdx)
    FCS_S_VISITED(raw_ptr_new_state) = 0;
  403c13:	c6 42 56 00          	movb   $0x0,0x56(%rdx)
    fcs_duplicate_kv_state(out_new_state_out, &raw_state_raw);
  403c17:	48 89 42 58          	mov    %rax,0x58(%rdx)
    FCS_S_NUM_ACTIVE_CHILDREN(raw_ptr_new_state) = 0;
  403c1b:	31 c0                	xor    %eax,%eax
  403c1d:	66 89 42 54          	mov    %ax,0x54(%rdx)
            copy_two_stacks(stack_idx, ds);
  403c21:	8b 44 24 20          	mov    0x20(%rsp),%eax
    memset(&(FCS_S_SCAN_VISITED(raw_ptr_new_state)), '\0',
  403c25:	c7 42 57 00 00 00 00 	movl   $0x0,0x57(%rdx)
  403c2c:	89 42 5c             	mov    %eax,0x5c(%rdx)
  403c2f:	48 8b 04 24          	mov    (%rsp),%rax
  403c33:	48 8b 34 c2          	mov    (%rdx,%rax,8),%rsi
  403c37:	0f be 0e             	movsbl (%rsi),%ecx
  403c3a:	83 c1 01             	add    $0x1,%ecx
  403c3d:	48 63 c9             	movslq %ecx,%rcx
  403c40:	48 83 f9 08          	cmp    $0x8,%rcx
  403c44:	0f 82 b6 fd ff ff    	jb     403a00 <fc_solve_sfs_atomic_move_card_to_parent+0x90>
  403c4a:	48 8b 44 0e f8       	mov    -0x8(%rsi,%rcx,1),%rax
  403c4f:	4c 89 ef             	mov    %r13,%rdi
  403c52:	49 89 44 0d f8       	mov    %rax,-0x8(%r13,%rcx,1)
  403c57:	48 83 e9 01          	sub    $0x1,%rcx
  403c5b:	48 c1 e9 03          	shr    $0x3,%rcx
  403c5f:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  403c62:	e9 b7 fd ff ff       	jmpq   403a1e <fc_solve_sfs_atomic_move_card_to_parent+0xae>
  403c67:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  403c6e:	00 00 
  403c70:	4c 8b 7c 24 30       	mov    0x30(%rsp),%r15
  403c75:	49 83 c7 01          	add    $0x1,%r15
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  403c79:	49 83 ff 08          	cmp    $0x8,%r15
  403c7d:	0f 85 1d fd ff ff    	jne    4039a0 <fc_solve_sfs_atomic_move_card_to_parent+0x30>
}
  403c83:	48 83 c4 68          	add    $0x68,%rsp
  403c87:	5b                   	pop    %rbx
  403c88:	5d                   	pop    %rbp
  403c89:	41 5c                	pop    %r12
  403c8b:	41 5d                	pop    %r13
  403c8d:	41 5e                	pop    %r14
  403c8f:	41 5f                	pop    %r15
  403c91:	c3                   	retq   
  403c92:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  403c99:	00 00 00 00 
  403c9d:	0f 1f 00             	nopl   (%rax)
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  403ca0:	4c 8b 64 24 40       	mov    0x40(%rsp),%r12
  403ca5:	e9 2d fe ff ff       	jmpq   403ad7 <fc_solve_sfs_atomic_move_card_to_parent+0x167>
  403caa:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
            FCS_S_NEXT(instance->list_of_vacant_states);
  403cb0:	48 8b 42 48          	mov    0x48(%rdx),%rax
        instance->list_of_vacant_states =
  403cb4:	49 89 86 b0 00 00 00 	mov    %rax,0xb0(%r14)
  403cbb:	e9 f9 fe ff ff       	jmpq   403bb9 <fc_solve_sfs_atomic_move_card_to_parent+0x249>
            copy_two_stacks(stack_idx, ds);
  403cc0:	44 89 e1             	mov    %r12d,%ecx
  403cc3:	41 b9 01 00 00 00    	mov    $0x1,%r9d
  403cc9:	49 89 dc             	mov    %rbx,%r12
  403ccc:	41 d3 e1             	shl    %cl,%r9d
  403ccf:	49 c1 e4 07          	shl    $0x7,%r12
  403cd3:	4c 03 64 24 38       	add    0x38(%rsp),%r12
  403cd8:	44 09 cf             	or     %r9d,%edi
  403cdb:	89 7e 14             	mov    %edi,0x14(%rsi)
  403cde:	48 8b 34 d0          	mov    (%rax,%rdx,8),%rsi
  403ce2:	0f be 0e             	movsbl (%rsi),%ecx
  403ce5:	83 c1 01             	add    $0x1,%ecx
  403ce8:	48 63 c9             	movslq %ecx,%rcx
  403ceb:	48 83 f9 08          	cmp    $0x8,%rcx
  403cef:	0f 83 ab 00 00 00    	jae    403da0 <fc_solve_sfs_atomic_move_card_to_parent+0x430>
  403cf5:	f6 c1 04             	test   $0x4,%cl
  403cf8:	0f 85 19 01 00 00    	jne    403e17 <fc_solve_sfs_atomic_move_card_to_parent+0x4a7>
  403cfe:	48 85 c9             	test   %rcx,%rcx
  403d01:	74 15                	je     403d18 <fc_solve_sfs_atomic_move_card_to_parent+0x3a8>
  403d03:	0f b6 06             	movzbl (%rsi),%eax
  403d06:	41 88 04 24          	mov    %al,(%r12)
  403d0a:	48 8b 44 24 40       	mov    0x40(%rsp),%rax
  403d0f:	f6 c1 02             	test   $0x2,%cl
  403d12:	0f 85 18 01 00 00    	jne    403e30 <fc_solve_sfs_atomic_move_card_to_parent+0x4c0>
  403d18:	48 8b 3c 24          	mov    (%rsp),%rdi
  403d1c:	4c 89 24 d0          	mov    %r12,(%rax,%rdx,8)
  403d20:	48 8b 0c f8          	mov    (%rax,%rdi,8),%rcx
  403d24:	e9 1a fd ff ff       	jmpq   403a43 <fc_solve_sfs_atomic_move_card_to_parent+0xd3>
  403d29:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
    allocator->ptr = allocator->rollback_ptr;
  403d30:	49 8b 84 24 f0 00 00 	mov    0xf0(%r12),%rax
  403d37:	00 
  403d38:	49 89 84 24 e8 00 00 	mov    %rax,0xe8(%r12)
  403d3f:	00 
  403d40:	e9 8d fd ff ff       	jmpq   403ad2 <fc_solve_sfs_atomic_move_card_to_parent+0x162>
  403d45:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  403d4c:	00 00 00 00 
    char *const new_data = meta_request_new_buffer(allocator->meta);
  403d50:	49 8b 96 f8 00 00 00 	mov    0xf8(%r14),%rdx
    char *const ret = meta_alloc->recycle_bin;
  403d57:	48 8b 02             	mov    (%rdx),%rax
    if (ret)
  403d5a:	48 85 c0             	test   %rax,%rax
  403d5d:	0f 84 81 00 00 00    	je     403de4 <fc_solve_sfs_atomic_move_card_to_parent+0x474>
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  403d63:	48 8b 08             	mov    (%rax),%rcx
  403d66:	48 89 0a             	mov    %rcx,(%rdx)
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  403d69:	49 8b 96 d8 00 00 00 	mov    0xd8(%r14),%rdx
  403d70:	48 89 10             	mov    %rdx,(%rax)
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  403d73:	48 8d 50 08          	lea    0x8(%rax),%rdx
    allocator->old_list = new_data;
  403d77:	49 89 86 d8 00 00 00 	mov    %rax,0xd8(%r14)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  403d7e:	48 05 80 fe 00 00    	add    $0xfe80,%rax
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  403d84:	49 89 96 f0 00 00 00 	mov    %rdx,0xf0(%r14)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  403d8b:	49 89 86 e0 00 00 00 	mov    %rax,0xe0(%r14)
  403d92:	e9 17 fe ff ff       	jmpq   403bae <fc_solve_sfs_atomic_move_card_to_parent+0x23e>
  403d97:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  403d9e:	00 00 
  403da0:	48 8b 44 0e f8       	mov    -0x8(%rsi,%rcx,1),%rax
  403da5:	4c 89 e7             	mov    %r12,%rdi
  403da8:	49 89 44 0c f8       	mov    %rax,-0x8(%r12,%rcx,1)
  403dad:	48 83 e9 01          	sub    $0x1,%rcx
  403db1:	48 c1 e9 03          	shr    $0x3,%rcx
  403db5:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  403db8:	48 8b 44 24 40       	mov    0x40(%rsp),%rax
  403dbd:	e9 56 ff ff ff       	jmpq   403d18 <fc_solve_sfs_atomic_move_card_to_parent+0x3a8>
  403dc2:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  403dc9:	00 00 00 00 
  403dcd:	0f 1f 00             	nopl   (%rax)
  403dd0:	8b 06                	mov    (%rsi),%eax
  403dd2:	41 89 45 00          	mov    %eax,0x0(%r13)
  403dd6:	8b 44 0e fc          	mov    -0x4(%rsi,%rcx,1),%eax
  403dda:	41 89 44 0d fc       	mov    %eax,-0x4(%r13,%rcx,1)
  403ddf:	e9 3a fc ff ff       	jmpq   403a1e <fc_solve_sfs_atomic_move_card_to_parent+0xae>
        return malloc(ALLOCED_SIZE);
  403de4:	bf 80 fe 00 00       	mov    $0xfe80,%edi
  403de9:	4c 89 54 24 18       	mov    %r10,0x18(%rsp)
  403dee:	4c 89 5c 24 10       	mov    %r11,0x10(%rsp)
  403df3:	e8 f8 d2 ff ff       	callq  4010f0 <malloc@plt>
  403df8:	4c 8b 54 24 18       	mov    0x18(%rsp),%r10
  403dfd:	4c 8b 5c 24 10       	mov    0x10(%rsp),%r11
  403e02:	e9 62 ff ff ff       	jmpq   403d69 <fc_solve_sfs_atomic_move_card_to_parent+0x3f9>
  403e07:	0f b7 44 0e fe       	movzwl -0x2(%rsi,%rcx,1),%eax
  403e0c:	66 41 89 44 0d fe    	mov    %ax,-0x2(%r13,%rcx,1)
  403e12:	e9 07 fc ff ff       	jmpq   403a1e <fc_solve_sfs_atomic_move_card_to_parent+0xae>
  403e17:	8b 06                	mov    (%rsi),%eax
  403e19:	41 89 04 24          	mov    %eax,(%r12)
  403e1d:	8b 44 0e fc          	mov    -0x4(%rsi,%rcx,1),%eax
  403e21:	41 89 44 0c fc       	mov    %eax,-0x4(%r12,%rcx,1)
  403e26:	48 8b 44 24 40       	mov    0x40(%rsp),%rax
  403e2b:	e9 e8 fe ff ff       	jmpq   403d18 <fc_solve_sfs_atomic_move_card_to_parent+0x3a8>
  403e30:	0f b7 44 0e fe       	movzwl -0x2(%rsi,%rcx,1),%eax
  403e35:	66 41 89 44 0c fe    	mov    %ax,-0x2(%r12,%rcx,1)
  403e3b:	48 8b 44 24 40       	mov    0x40(%rsp),%rax
  403e40:	e9 d3 fe ff ff       	jmpq   403d18 <fc_solve_sfs_atomic_move_card_to_parent+0x3a8>
  403e45:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  403e4c:	00 00 00 00 

0000000000403e50 <fc_solve_sfs_atomic_move_card_to_empty_stack>:
    if (soft_thread->num_vacant_stacks == 0)
  403e50:	80 bf e3 01 00 00 00 	cmpb   $0x0,0x1e3(%rdi)
  403e57:	0f 84 13 03 00 00    	je     404170 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x320>
{
  403e5d:	41 57                	push   %r15
  403e5f:	41 56                	push   %r14
  403e61:	41 55                	push   %r13
  403e63:	41 54                	push   %r12
  403e65:	49 89 cc             	mov    %rcx,%r12
  403e68:	55                   	push   %rbp
  403e69:	53                   	push   %rbx
  403e6a:	48 83 ec 58          	sub    $0x58,%rsp
    SET_empty_stack_idx(empty_stack_idx);
  403e6e:	48 8b 06             	mov    (%rsi),%rax
  403e71:	80 38 00             	cmpb   $0x0,(%rax)
  403e74:	0f 84 c5 04 00 00    	je     40433f <fc_solve_sfs_atomic_move_card_to_empty_stack+0x4ef>
  403e7a:	48 8b 46 08          	mov    0x8(%rsi),%rax
  403e7e:	80 38 00             	cmpb   $0x0,(%rax)
  403e81:	0f 84 04 05 00 00    	je     40438b <fc_solve_sfs_atomic_move_card_to_empty_stack+0x53b>
  403e87:	48 8b 46 10          	mov    0x10(%rsi),%rax
  403e8b:	80 38 00             	cmpb   $0x0,(%rax)
  403e8e:	0f 84 fe 04 00 00    	je     404392 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x542>
  403e94:	48 8b 46 18          	mov    0x18(%rsi),%rax
  403e98:	80 38 00             	cmpb   $0x0,(%rax)
  403e9b:	0f 84 f8 04 00 00    	je     404399 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x549>
  403ea1:	48 8b 46 20          	mov    0x20(%rsi),%rax
  403ea5:	80 38 00             	cmpb   $0x0,(%rax)
  403ea8:	0f 84 f2 04 00 00    	je     4043a0 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x550>
  403eae:	48 8b 46 28          	mov    0x28(%rsi),%rax
  403eb2:	80 38 00             	cmpb   $0x0,(%rax)
  403eb5:	0f 84 ec 04 00 00    	je     4043a7 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x557>
  403ebb:	48 8b 46 30          	mov    0x30(%rsi),%rax
  403ebf:	80 38 00             	cmpb   $0x0,(%rax)
  403ec2:	0f 84 e6 04 00 00    	je     4043ae <fc_solve_sfs_atomic_move_card_to_empty_stack+0x55e>
  403ec8:	4c 8b 46 38          	mov    0x38(%rsi),%r8
  403ecc:	b8 00 04 00 00       	mov    $0x400,%eax
  403ed1:	b9 08 00 00 00       	mov    $0x8,%ecx
  403ed6:	c7 44 24 0c 00 01 00 	movl   $0x100,0xc(%rsp)
  403edd:	00 
  403ede:	41 80 38 00          	cmpb   $0x0,(%r8)
  403ee2:	0f 84 cd 04 00 00    	je     4043b5 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x565>
    tests_define_accessors();
  403ee8:	4c 8b 37             	mov    (%rdi),%r14
  403eeb:	48 89 7c 24 18       	mov    %rdi,0x18(%rsp)
        copy_two_stacks(stack_idx, empty_stack_idx);
  403ef0:	45 31 ff             	xor    %r15d,%r15d
    if (!fc_solve_check_and_add_state(
  403ef3:	48 89 d3             	mov    %rdx,%rbx
    tests_define_accessors();
  403ef6:	49 8d be 00 01 00 00 	lea    0x100(%r14),%rdi
        copy_two_stacks(stack_idx, empty_stack_idx);
  403efd:	48 01 f8             	add    %rdi,%rax
    tests_define_accessors();
  403f00:	48 89 7c 24 10       	mov    %rdi,0x10(%rsp)
        copy_two_stacks(stack_idx, empty_stack_idx);
  403f05:	48 89 44 24 20       	mov    %rax,0x20(%rsp)
  403f0a:	48 63 c1             	movslq %ecx,%rax
  403f0d:	48 89 04 24          	mov    %rax,(%rsp)
  403f11:	4c 89 e0             	mov    %r12,%rax
  403f14:	4d 89 f4             	mov    %r14,%r12
  403f17:	49 89 f6             	mov    %rsi,%r14
  403f1a:	49 89 c5             	mov    %rax,%r13
  403f1d:	e9 26 01 00 00       	jmpq   404048 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x1f8>
  403f22:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  403f29:	00 00 00 00 
  403f2d:	0f 1f 00             	nopl   (%rax)
  403f30:	f6 c1 04             	test   $0x4,%cl
  403f33:	0f 85 b7 03 00 00    	jne    4042f0 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x4a0>
  403f39:	48 85 c9             	test   %rcx,%rcx
  403f3c:	74 0f                	je     403f4d <fc_solve_sfs_atomic_move_card_to_empty_stack+0xfd>
  403f3e:	0f b6 3e             	movzbl (%rsi),%edi
  403f41:	40 88 38             	mov    %dil,(%rax)
  403f44:	f6 c1 02             	test   $0x2,%cl
  403f47:	0f 85 e3 03 00 00    	jne    404330 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x4e0>
  403f4d:	48 8b 7c 24 30       	mov    0x30(%rsp),%rdi
  403f52:	48 8b 74 24 38       	mov    0x38(%rsp),%rsi
  403f57:	4a 89 04 df          	mov    %rax,(%rdi,%r11,8)
  403f5b:	8b 4e 14             	mov    0x14(%rsi),%ecx
  403f5e:	85 4c 24 0c          	test   %ecx,0xc(%rsp)
  403f62:	0f 84 48 02 00 00    	je     4041b0 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x360>
    fcs_col_pop_top(col);
  403f68:	0f b6 10             	movzbl (%rax),%edx
  403f6b:	8d 4a ff             	lea    -0x1(%rdx),%ecx
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  403f6e:	48 8b 14 24          	mov    (%rsp),%rdx
    fcs_col_pop_top(col);
  403f72:	88 08                	mov    %cl,(%rax)
  403f74:	48 0f be c9          	movsbq %cl,%rcx
  403f78:	c6 44 08 01 00       	movb   $0x0,0x1(%rax,%rcx,1)
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  403f7d:	48 8b 44 24 30       	mov    0x30(%rsp),%rax
  403f82:	48 8b 0c d0          	mov    (%rax,%rdx,8),%rcx
  403f86:	48 8d 54 24 40       	lea    0x40(%rsp),%rdx
    fcs_col_push_card(col, card);
  403f8b:	48 0f be 01          	movsbq (%rcx),%rax
  403f8f:	8d 70 01             	lea    0x1(%rax),%esi
  403f92:	40 88 31             	mov    %sil,(%rcx)
  403f95:	48 8d 74 24 30       	lea    0x30(%rsp),%rsi
  403f9a:	40 88 6c 01 01       	mov    %bpl,0x1(%rcx,%rax,1)
    const_SLOT(hard_thread, soft_thread);
  403f9f:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
  403fa4:	48 8b 28             	mov    (%rax),%rbp
    if (!fc_solve_check_and_add_state(
  403fa7:	48 89 ef             	mov    %rbp,%rdi
  403faa:	e8 a1 da ff ff       	callq  401a50 <fc_solve_check_and_add_state>
  403faf:	84 c0                	test   %al,%al
  403fb1:	0f 85 c9 01 00 00    	jne    404180 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x330>
        if (HT_FIELD(hard_thread, allocated_from_list))
  403fb7:	80 bd 18 05 00 00 00 	cmpb   $0x0,0x518(%rbp)
  403fbe:	0f 84 3c 02 00 00    	je     404200 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x3b0>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  403fc4:	48 8b 95 b0 00 00 00 	mov    0xb0(%rbp),%rdx
  403fcb:	48 8b 44 24 38       	mov    0x38(%rsp),%rax
  403fd0:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  403fd3:	48 8b 44 24 30       	mov    0x30(%rsp),%rax
  403fd8:	48 89 85 b0 00 00 00 	mov    %rax,0xb0(%rbp)
  403fdf:	48 8b 54 24 40       	mov    0x40(%rsp),%rdx
    if ((!((list->num_states + (list->states != NULL)) &
  403fe4:	49 8b 45 08          	mov    0x8(%r13),%rax
  403fe8:	31 f6                	xor    %esi,%esi
  403fea:	49 8b 7d 00          	mov    0x0(%r13),%rdi
  403fee:	48 85 c0             	test   %rax,%rax
  403ff1:	40 0f 95 c6          	setne  %sil
  403ff5:	48 01 fe             	add    %rdi,%rsi
  403ff8:	40 f6 c6 0f          	test   $0xf,%sil
  403ffc:	75 22                	jne    404020 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x1d0>
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  403ffe:	48 83 c6 10          	add    $0x10,%rsi
  404002:	48 89 c7             	mov    %rax,%rdi
  404005:	48 89 54 24 28       	mov    %rdx,0x28(%rsp)
  40400a:	48 c1 e6 04          	shl    $0x4,%rsi
  40400e:	e8 5d d1 ff ff       	callq  401170 <realloc@plt>
  404013:	49 8b 7d 00          	mov    0x0(%r13),%rdi
  404017:	48 8b 54 24 28       	mov    0x28(%rsp),%rdx
        list->states =
  40401c:	49 89 45 08          	mov    %rax,0x8(%r13)
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  404020:	48 8d 4f 01          	lea    0x1(%rdi),%rcx
  404024:	48 c1 e7 04          	shl    $0x4,%rdi
  404028:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  40402c:	48 01 f8             	add    %rdi,%rax
  40402f:	49 89 4d 00          	mov    %rcx,0x0(%r13)
  404033:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  404037:	48 89 10             	mov    %rdx,(%rax)
  40403a:	49 83 c7 01          	add    $0x1,%r15
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  40403e:	49 83 ff 08          	cmp    $0x8,%r15
  404042:	0f 84 d8 01 00 00    	je     404220 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x3d0>
        var_AUTO(col, fcs_state_get_col(state, stack_idx));
  404048:	4b 8b 14 fe          	mov    (%r14,%r15,8),%rdx
  40404c:	44 89 f9             	mov    %r15d,%ecx
        const int cards_num = fcs_col_len(col);
  40404f:	0f be 02             	movsbl (%rdx),%eax
        if (cards_num <= 1)
  404052:	83 f8 01             	cmp    $0x1,%eax
  404055:	7e e3                	jle    40403a <fc_solve_sfs_atomic_move_card_to_empty_stack+0x1ea>
                (instance->list_of_vacant_states != NULL)))
  404057:	49 8b b4 24 b0 00 00 	mov    0xb0(%r12),%rsi
  40405e:	00 
        const fcs_card card = fcs_col_get_card(col, cards_num - 1);
  40405f:	83 e8 01             	sub    $0x1,%eax
  404062:	48 98                	cltq   
  404064:	0f b6 6c 02 01       	movzbl 0x1(%rdx,%rax,1),%ebp
  404069:	48 85 f6             	test   %rsi,%rsi
    if ((HT_FIELD(hard_thread, allocated_from_list) =
  40406c:	41 0f 95 84 24 18 05 	setne  0x518(%r12)
  404073:	00 00 
  404075:	0f 85 15 01 00 00    	jne    404190 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x340>
    if ((size_t)(allocator->max_ptr - allocator->ptr) < how_much)
  40407b:	49 8b b4 24 e8 00 00 	mov    0xe8(%r12),%rsi
  404082:	00 
  404083:	49 8b 84 24 e0 00 00 	mov    0xe0(%r12),%rax
  40408a:	00 
  40408b:	48 29 f0             	sub    %rsi,%rax
  40408e:	48 83 f8 5f          	cmp    $0x5f,%rax
  404092:	0f 86 98 01 00 00    	jbe    404230 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x3e0>
        allocator->rollback_ptr = allocator->ptr;
  404098:	49 89 b4 24 f0 00 00 	mov    %rsi,0xf0(%r12)
  40409f:	00 
    allocator->ptr += how_much;
  4040a0:	48 8d 46 60          	lea    0x60(%rsi),%rax
  4040a4:	49 89 84 24 e8 00 00 	mov    %rax,0xe8(%r12)
  4040ab:	00 
    return (const fcs_kv_state){.key = &(s->s), .val = &(s->info)};
  4040ac:	48 8d 46 48          	lea    0x48(%rsi),%rax
    *ret = FCS_STATE_keyval_pair_to_kv(s);
  4040b0:	c4 e1 f9 6e ce       	vmovq  %rsi,%xmm1
        copy_two_stacks(stack_idx, empty_stack_idx);
  4040b5:	4c 63 d9             	movslq %ecx,%r11
  4040b8:	c4 e3 f1 22 c0 01    	vpinsrq $0x1,%rax,%xmm1,%xmm0
  4040be:	c5 f8 29 44 24 30    	vmovaps %xmm0,0x30(%rsp)
    fcs_duplicate_kv_state(out_new_state_out, &raw_state_raw);
  4040c4:	c4 c1 7a 6f 06       	vmovdqu (%r14),%xmm0
  4040c9:	c5 f8 11 06          	vmovups %xmm0,(%rsi)
  4040cd:	c4 c1 7a 6f 46 10    	vmovdqu 0x10(%r14),%xmm0
  4040d3:	c5 f8 11 46 10       	vmovups %xmm0,0x10(%rsi)
  4040d8:	c4 c1 7a 6f 46 20    	vmovdqu 0x20(%r14),%xmm0
  4040de:	c5 f8 11 46 20       	vmovups %xmm0,0x20(%rsi)
  4040e3:	c4 c1 7a 6f 46 30    	vmovdqu 0x30(%r14),%xmm0
  4040e9:	c5 f8 11 46 30       	vmovups %xmm0,0x30(%rsi)
  4040ee:	49 8b 46 40          	mov    0x40(%r14),%rax
  4040f2:	c5 fa 6f 03          	vmovdqu (%rbx),%xmm0
  4040f6:	c5 f8 11 46 48       	vmovups %xmm0,0x48(%rsi)
  4040fb:	48 89 46 40          	mov    %rax,0x40(%rsi)
  4040ff:	48 8b 43 10          	mov    0x10(%rbx),%rax
    (FCS_S_DEPTH(raw_ptr_new_state))++;
  404103:	83 46 50 01          	addl   $0x1,0x50(%rsi)
    FCS_S_PARENT(raw_ptr_new_state) = INFO_STATE_PTR(&raw_state_raw);
  404107:	4c 89 76 48          	mov    %r14,0x48(%rsi)
    FCS_S_VISITED(raw_ptr_new_state) = 0;
  40410b:	c6 46 56 00          	movb   $0x0,0x56(%rsi)
    fcs_duplicate_kv_state(out_new_state_out, &raw_state_raw);
  40410f:	48 89 46 58          	mov    %rax,0x58(%rsi)
    FCS_S_NUM_ACTIVE_CHILDREN(raw_ptr_new_state) = 0;
  404113:	31 c0                	xor    %eax,%eax
  404115:	66 89 46 54          	mov    %ax,0x54(%rsi)
  404119:	b8 01 00 00 00       	mov    $0x1,%eax
  40411e:	d3 e0                	shl    %cl,%eax
    memset(&(FCS_S_SCAN_VISITED(raw_ptr_new_state)), '\0',
  404120:	c7 46 57 00 00 00 00 	movl   $0x0,0x57(%rsi)
  404127:	89 46 5c             	mov    %eax,0x5c(%rsi)
  40412a:	4a 8b 34 de          	mov    (%rsi,%r11,8),%rsi
  40412e:	4c 89 f8             	mov    %r15,%rax
  404131:	48 c1 e0 07          	shl    $0x7,%rax
  404135:	48 03 44 24 10       	add    0x10(%rsp),%rax
  40413a:	0f be 0e             	movsbl (%rsi),%ecx
  40413d:	83 c1 01             	add    $0x1,%ecx
  404140:	48 63 c9             	movslq %ecx,%rcx
  404143:	48 83 f9 08          	cmp    $0x8,%rcx
  404147:	0f 82 e3 fd ff ff    	jb     403f30 <fc_solve_sfs_atomic_move_card_to_empty_stack+0xe0>
  40414d:	48 8b 7c 0e f8       	mov    -0x8(%rsi,%rcx,1),%rdi
  404152:	48 89 7c 08 f8       	mov    %rdi,-0x8(%rax,%rcx,1)
  404157:	48 83 e9 01          	sub    $0x1,%rcx
  40415b:	48 89 c7             	mov    %rax,%rdi
  40415e:	48 c1 e9 03          	shr    $0x3,%rcx
  404162:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  404165:	e9 e3 fd ff ff       	jmpq   403f4d <fc_solve_sfs_atomic_move_card_to_empty_stack+0xfd>
  40416a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
  404170:	c3                   	retq   
  404171:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  404178:	00 00 00 00 
  40417c:	0f 1f 40 00          	nopl   0x0(%rax)
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  404180:	48 8b 54 24 30       	mov    0x30(%rsp),%rdx
  404185:	e9 5a fe ff ff       	jmpq   403fe4 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x194>
  40418a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
            FCS_S_NEXT(instance->list_of_vacant_states);
  404190:	48 8b 46 48          	mov    0x48(%rsi),%rax
        instance->list_of_vacant_states =
  404194:	49 89 84 24 b0 00 00 	mov    %rax,0xb0(%r12)
  40419b:	00 
  40419c:	e9 0b ff ff ff       	jmpq   4040ac <fc_solve_sfs_atomic_move_card_to_empty_stack+0x25c>
  4041a1:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4041a8:	00 00 00 00 
  4041ac:	0f 1f 40 00          	nopl   0x0(%rax)
  4041b0:	0b 4c 24 0c          	or     0xc(%rsp),%ecx
  4041b4:	48 8b 04 24          	mov    (%rsp),%rax
  4041b8:	89 4e 14             	mov    %ecx,0x14(%rsi)
  4041bb:	48 8b 34 c7          	mov    (%rdi,%rax,8),%rsi
  4041bf:	0f be 0e             	movsbl (%rsi),%ecx
  4041c2:	83 c1 01             	add    $0x1,%ecx
  4041c5:	48 63 c9             	movslq %ecx,%rcx
  4041c8:	48 83 f9 08          	cmp    $0x8,%rcx
  4041cc:	0f 83 ae 00 00 00    	jae    404280 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x430>
  4041d2:	f6 c1 04             	test   $0x4,%cl
  4041d5:	0f 85 95 01 00 00    	jne    404370 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x520>
  4041db:	48 85 c9             	test   %rcx,%rcx
  4041de:	0f 85 cc 00 00 00    	jne    4042b0 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x460>
  4041e4:	48 8b 04 24          	mov    (%rsp),%rax
  4041e8:	48 8b 54 24 20       	mov    0x20(%rsp),%rdx
  4041ed:	48 89 14 c7          	mov    %rdx,(%rdi,%rax,8)
  4041f1:	4a 8b 04 df          	mov    (%rdi,%r11,8),%rax
  4041f5:	e9 6e fd ff ff       	jmpq   403f68 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x118>
  4041fa:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
    allocator->ptr = allocator->rollback_ptr;
  404200:	48 8b 85 f0 00 00 00 	mov    0xf0(%rbp),%rax
  404207:	48 89 85 e8 00 00 00 	mov    %rax,0xe8(%rbp)
  40420e:	e9 cc fd ff ff       	jmpq   403fdf <fc_solve_sfs_atomic_move_card_to_empty_stack+0x18f>
  404213:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40421a:	00 00 00 00 
  40421e:	66 90                	xchg   %ax,%ax
}
  404220:	48 83 c4 58          	add    $0x58,%rsp
  404224:	5b                   	pop    %rbx
  404225:	5d                   	pop    %rbp
  404226:	41 5c                	pop    %r12
  404228:	41 5d                	pop    %r13
  40422a:	41 5e                	pop    %r14
  40422c:	41 5f                	pop    %r15
  40422e:	c3                   	retq   
  40422f:	90                   	nop
    char *const new_data = meta_request_new_buffer(allocator->meta);
  404230:	49 8b b4 24 f8 00 00 	mov    0xf8(%r12),%rsi
  404237:	00 
    char *const ret = meta_alloc->recycle_bin;
  404238:	48 8b 06             	mov    (%rsi),%rax
    if (ret)
  40423b:	48 85 c0             	test   %rax,%rax
  40423e:	0f 84 cc 00 00 00    	je     404310 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x4c0>
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  404244:	48 8b 38             	mov    (%rax),%rdi
  404247:	48 89 3e             	mov    %rdi,(%rsi)
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  40424a:	49 8b b4 24 d8 00 00 	mov    0xd8(%r12),%rsi
  404251:	00 
  404252:	48 89 30             	mov    %rsi,(%rax)
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  404255:	48 8d 70 08          	lea    0x8(%rax),%rsi
    allocator->old_list = new_data;
  404259:	49 89 84 24 d8 00 00 	mov    %rax,0xd8(%r12)
  404260:	00 
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  404261:	48 05 80 fe 00 00    	add    $0xfe80,%rax
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  404267:	49 89 b4 24 f0 00 00 	mov    %rsi,0xf0(%r12)
  40426e:	00 
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40426f:	49 89 84 24 e0 00 00 	mov    %rax,0xe0(%r12)
  404276:	00 
  404277:	e9 24 fe ff ff       	jmpq   4040a0 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x250>
  40427c:	0f 1f 40 00          	nopl   0x0(%rax)
        copy_two_stacks(stack_idx, empty_stack_idx);
  404280:	48 8b 44 0e f8       	mov    -0x8(%rsi,%rcx,1),%rax
  404285:	48 8b 7c 24 20       	mov    0x20(%rsp),%rdi
  40428a:	48 89 44 0f f8       	mov    %rax,-0x8(%rdi,%rcx,1)
  40428f:	48 83 e9 01          	sub    $0x1,%rcx
  404293:	48 c1 e9 03          	shr    $0x3,%rcx
  404297:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  40429a:	48 8b 7c 24 30       	mov    0x30(%rsp),%rdi
  40429f:	e9 40 ff ff ff       	jmpq   4041e4 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x394>
  4042a4:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4042ab:	00 00 00 00 
  4042af:	90                   	nop
  4042b0:	48 8b 7c 24 20       	mov    0x20(%rsp),%rdi
  4042b5:	0f b6 06             	movzbl (%rsi),%eax
  4042b8:	88 07                	mov    %al,(%rdi)
  4042ba:	48 8b 7c 24 30       	mov    0x30(%rsp),%rdi
  4042bf:	f6 c1 02             	test   $0x2,%cl
  4042c2:	0f 84 1c ff ff ff    	je     4041e4 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x394>
  4042c8:	48 8b 7c 24 20       	mov    0x20(%rsp),%rdi
  4042cd:	0f b7 44 0e fe       	movzwl -0x2(%rsi,%rcx,1),%eax
  4042d2:	66 89 44 0f fe       	mov    %ax,-0x2(%rdi,%rcx,1)
  4042d7:	48 8b 7c 24 30       	mov    0x30(%rsp),%rdi
  4042dc:	e9 03 ff ff ff       	jmpq   4041e4 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x394>
  4042e1:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4042e8:	00 00 00 00 
  4042ec:	0f 1f 40 00          	nopl   0x0(%rax)
  4042f0:	8b 3e                	mov    (%rsi),%edi
  4042f2:	89 38                	mov    %edi,(%rax)
  4042f4:	8b 74 0e fc          	mov    -0x4(%rsi,%rcx,1),%esi
  4042f8:	89 74 08 fc          	mov    %esi,-0x4(%rax,%rcx,1)
  4042fc:	e9 4c fc ff ff       	jmpq   403f4d <fc_solve_sfs_atomic_move_card_to_empty_stack+0xfd>
  404301:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  404308:	00 00 00 00 
  40430c:	0f 1f 40 00          	nopl   0x0(%rax)
        return malloc(ALLOCED_SIZE);
  404310:	bf 80 fe 00 00       	mov    $0xfe80,%edi
  404315:	44 89 7c 24 28       	mov    %r15d,0x28(%rsp)
  40431a:	e8 d1 cd ff ff       	callq  4010f0 <malloc@plt>
  40431f:	8b 4c 24 28          	mov    0x28(%rsp),%ecx
  404323:	e9 22 ff ff ff       	jmpq   40424a <fc_solve_sfs_atomic_move_card_to_empty_stack+0x3fa>
  404328:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40432f:	00 
  404330:	0f b7 74 0e fe       	movzwl -0x2(%rsi,%rcx,1),%esi
  404335:	66 89 74 08 fe       	mov    %si,-0x2(%rax,%rcx,1)
  40433a:	e9 0e fc ff ff       	jmpq   403f4d <fc_solve_sfs_atomic_move_card_to_empty_stack+0xfd>
    SET_empty_stack_idx(empty_stack_idx);
  40433f:	31 c9                	xor    %ecx,%ecx
  404341:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  404348:	00 00 00 00 
  40434c:	0f 1f 40 00          	nopl   0x0(%rax)
  404350:	89 c8                	mov    %ecx,%eax
  404352:	41 bd 01 00 00 00    	mov    $0x1,%r13d
  404358:	c1 e0 07             	shl    $0x7,%eax
  40435b:	41 d3 e5             	shl    %cl,%r13d
  40435e:	48 98                	cltq   
  404360:	44 89 6c 24 0c       	mov    %r13d,0xc(%rsp)
  404365:	e9 7e fb ff ff       	jmpq   403ee8 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x98>
  40436a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
        copy_two_stacks(stack_idx, empty_stack_idx);
  404370:	8b 06                	mov    (%rsi),%eax
  404372:	48 8b 7c 24 20       	mov    0x20(%rsp),%rdi
  404377:	89 07                	mov    %eax,(%rdi)
  404379:	8b 44 0e fc          	mov    -0x4(%rsi,%rcx,1),%eax
  40437d:	89 44 0f fc          	mov    %eax,-0x4(%rdi,%rcx,1)
  404381:	48 8b 7c 24 30       	mov    0x30(%rsp),%rdi
  404386:	e9 59 fe ff ff       	jmpq   4041e4 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x394>
    SET_empty_stack_idx(empty_stack_idx);
  40438b:	b9 01 00 00 00       	mov    $0x1,%ecx
  404390:	eb be                	jmp    404350 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x500>
  404392:	b9 02 00 00 00       	mov    $0x2,%ecx
  404397:	eb b7                	jmp    404350 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x500>
  404399:	b9 03 00 00 00       	mov    $0x3,%ecx
  40439e:	eb b0                	jmp    404350 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x500>
  4043a0:	b9 04 00 00 00       	mov    $0x4,%ecx
  4043a5:	eb a9                	jmp    404350 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x500>
  4043a7:	b9 05 00 00 00       	mov    $0x5,%ecx
  4043ac:	eb a2                	jmp    404350 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x500>
  4043ae:	b9 06 00 00 00       	mov    $0x6,%ecx
  4043b3:	eb 9b                	jmp    404350 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x500>
  4043b5:	b9 07 00 00 00       	mov    $0x7,%ecx
  4043ba:	eb 94                	jmp    404350 <fc_solve_sfs_atomic_move_card_to_empty_stack+0x500>
  4043bc:	0f 1f 40 00          	nopl   0x0(%rax)

00000000004043c0 <fc_solve_sfs_empty_stack_into_freecells>:
{
  4043c0:	41 57                	push   %r15
  4043c2:	41 56                	push   %r14
  4043c4:	41 55                	push   %r13
  4043c6:	41 54                	push   %r12
  4043c8:	55                   	push   %rbp
  4043c9:	53                   	push   %rbx
  4043ca:	48 83 ec 48          	sub    $0x48,%rsp
    const fcs_game_limit num_vacant_freecells =
  4043ce:	0f b6 af e4 01 00 00 	movzbl 0x1e4(%rdi),%ebp
    if ((!num_vacant_freecells) || soft_thread->num_vacant_stacks)
  4043d5:	40 84 ed             	test   %bpl,%bpl
  4043d8:	0f 84 92 01 00 00    	je     404570 <fc_solve_sfs_empty_stack_into_freecells+0x1b0>
  4043de:	80 bf e3 01 00 00 00 	cmpb   $0x0,0x1e3(%rdi)
  4043e5:	0f 85 85 01 00 00    	jne    404570 <fc_solve_sfs_empty_stack_into_freecells+0x1b0>
    tests_define_accessors();
  4043eb:	48 8b 07             	mov    (%rdi),%rax
  4043ee:	49 89 cd             	mov    %rcx,%r13
  4043f1:	48 89 54 24 18       	mov    %rdx,0x18(%rsp)
  4043f6:	49 89 f6             	mov    %rsi,%r14
  4043f9:	49 89 fc             	mov    %rdi,%r12
  4043fc:	31 db                	xor    %ebx,%ebx
  4043fe:	48 89 44 24 10       	mov    %rax,0x10(%rsp)
  404403:	eb 19                	jmp    40441e <fc_solve_sfs_empty_stack_into_freecells+0x5e>
  404405:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40440c:	00 00 00 00 
  404410:	48 83 c3 01          	add    $0x1,%rbx
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  404414:	48 83 fb 08          	cmp    $0x8,%rbx
  404418:	0f 84 52 01 00 00    	je     404570 <fc_solve_sfs_empty_stack_into_freecells+0x1b0>
        var_AUTO(col, fcs_state_get_col(state, stack_idx));
  40441e:	4c 63 cb             	movslq %ebx,%r9
        const int cards_num = fcs_col_len(col);
  404421:	4b 8b 04 ce          	mov    (%r14,%r9,8),%rax
  404425:	44 0f be 38          	movsbl (%rax),%r15d
        if ((!cards_num) || (cards_num > num_vacant_freecells))
  404429:	45 85 ff             	test   %r15d,%r15d
  40442c:	74 e2                	je     404410 <fc_solve_sfs_empty_stack_into_freecells+0x50>
  40442e:	44 39 fd             	cmp    %r15d,%ebp
  404431:	7c dd                	jl     404410 <fc_solve_sfs_empty_stack_into_freecells+0x50>
        sfs_check_state_begin();
  404433:	48 8b 4c 24 18       	mov    0x18(%rsp),%rcx
  404438:	48 8d 74 24 20       	lea    0x20(%rsp),%rsi
  40443d:	4c 89 f2             	mov    %r14,%rdx
  404440:	89 1c 24             	mov    %ebx,(%rsp)
  404443:	48 8b 7c 24 10       	mov    0x10(%rsp),%rdi
  404448:	4c 89 4c 24 08       	mov    %r9,0x8(%rsp)
  40444d:	e8 ae d4 ff ff       	callq  401900 <fc_solve_sfs_check_state_begin>
        my_copy_stack(stack_idx);
  404452:	48 8b 44 24 28       	mov    0x28(%rsp),%rax
  404457:	4c 63 1c 24          	movslq (%rsp),%r11
  40445b:	4c 8b 4c 24 08       	mov    0x8(%rsp),%r9
  404460:	8b 50 14             	mov    0x14(%rax),%edx
  404463:	44 0f a3 da          	bt     %r11d,%edx
  404467:	0f 83 c3 01 00 00    	jae    404630 <fc_solve_sfs_empty_stack_into_freecells+0x270>
  40446d:	48 8b 74 24 20       	mov    0x20(%rsp),%rsi
  404472:	4a 8b 14 ce          	mov    (%rsi,%r9,8),%rdx
        for (int c = 0; c < cards_num; ++c, ++b)
  404476:	31 ff                	xor    %edi,%edi
        int b = 0;
  404478:	31 c9                	xor    %ecx,%ecx
        for (int c = 0; c < cards_num; ++c, ++b)
  40447a:	45 85 ff             	test   %r15d,%r15d
  40447d:	0f 8e b0 00 00 00    	jle    404533 <fc_solve_sfs_empty_stack_into_freecells+0x173>
  404483:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40448a:	00 00 00 00 
  40448e:	66 90                	xchg   %ax,%ax
  404490:	8d 41 01             	lea    0x1(%rcx),%eax
            for (; b < LOCAL_FREECELLS_NUM; ++b)
  404493:	83 f9 03             	cmp    $0x3,%ecx
  404496:	0f 8f e4 00 00 00    	jg     404580 <fc_solve_sfs_empty_stack_into_freecells+0x1c0>
                if (fcs_freecell_is_empty(new_state_key, b))
  40449c:	4c 63 c9             	movslq %ecx,%r9
  40449f:	42 80 7c 0e 40 00    	cmpb   $0x0,0x40(%rsi,%r9,1)
  4044a5:	0f 84 d5 00 00 00    	je     404580 <fc_solve_sfs_empty_stack_into_freecells+0x1c0>
            for (; b < LOCAL_FREECELLS_NUM; ++b)
  4044ab:	83 f8 04             	cmp    $0x4,%eax
  4044ae:	0f 84 dc 00 00 00    	je     404590 <fc_solve_sfs_empty_stack_into_freecells+0x1d0>
                if (fcs_freecell_is_empty(new_state_key, b))
  4044b4:	48 98                	cltq   
  4044b6:	80 7c 06 40 00       	cmpb   $0x0,0x40(%rsi,%rax,1)
  4044bb:	0f 84 5f 01 00 00    	je     404620 <fc_solve_sfs_empty_stack_into_freecells+0x260>
            for (; b < LOCAL_FREECELLS_NUM; ++b)
  4044c1:	8d 41 02             	lea    0x2(%rcx),%eax
  4044c4:	83 f8 04             	cmp    $0x4,%eax
  4044c7:	0f 84 c3 00 00 00    	je     404590 <fc_solve_sfs_empty_stack_into_freecells+0x1d0>
                if (fcs_freecell_is_empty(new_state_key, b))
  4044cd:	48 98                	cltq   
  4044cf:	80 7c 06 40 00       	cmpb   $0x0,0x40(%rsi,%rax,1)
  4044d4:	0f 84 d6 01 00 00    	je     4046b0 <fc_solve_sfs_empty_stack_into_freecells+0x2f0>
            for (; b < LOCAL_FREECELLS_NUM; ++b)
  4044da:	8d 41 03             	lea    0x3(%rcx),%eax
  4044dd:	83 f8 03             	cmp    $0x3,%eax
  4044e0:	0f 85 da 01 00 00    	jne    4046c0 <fc_solve_sfs_empty_stack_into_freecells+0x300>
                if (fcs_freecell_is_empty(new_state_key, b))
  4044e6:	80 7e 43 01          	cmpb   $0x1,0x43(%rsi)
  4044ea:	19 c9                	sbb    %ecx,%ecx
  4044ec:	83 c1 05             	add    $0x5,%ecx
  4044ef:	80 7e 43 01          	cmpb   $0x1,0x43(%rsi)
  4044f3:	48 19 c0             	sbb    %rax,%rax
  4044f6:	48 83 c0 04          	add    $0x4,%rax
            fcs_col_pop_card(new_src_col, top_card);
  4044fa:	44 0f be 0a          	movsbl (%rdx),%r9d
        for (int c = 0; c < cards_num; ++c, ++b)
  4044fe:	83 c7 01             	add    $0x1,%edi
            fcs_col_pop_card(new_src_col, top_card);
  404501:	44 89 ce             	mov    %r9d,%esi
  404504:	41 83 e9 01          	sub    $0x1,%r9d
  404508:	83 ee 01             	sub    $0x1,%esi
  40450b:	4d 63 c9             	movslq %r9d,%r9
  40450e:	46 0f b6 4c 0a 01    	movzbl 0x1(%rdx,%r9,1),%r9d
  404514:	40 88 32             	mov    %sil,(%rdx)
  404517:	48 0f be f6          	movsbq %sil,%rsi
  40451b:	c6 44 32 01 00       	movb   $0x0,0x1(%rdx,%rsi,1)
            fcs_put_card_in_freecell(new_state_key, b, top_card);
  404520:	48 8b 74 24 20       	mov    0x20(%rsp),%rsi
  404525:	44 88 4c 06 40       	mov    %r9b,0x40(%rsi,%rax,1)
        for (int c = 0; c < cards_num; ++c, ++b)
  40452a:	41 39 ff             	cmp    %edi,%r15d
  40452d:	0f 85 5d ff ff ff    	jne    404490 <fc_solve_sfs_empty_stack_into_freecells+0xd0>
    const_SLOT(hard_thread, soft_thread);
  404533:	4d 8b 3c 24          	mov    (%r12),%r15
    if (!fc_solve_check_and_add_state(
  404537:	48 8d 54 24 30       	lea    0x30(%rsp),%rdx
  40453c:	48 8d 74 24 20       	lea    0x20(%rsp),%rsi
  404541:	4c 89 ff             	mov    %r15,%rdi
  404544:	e8 07 d5 ff ff       	callq  401a50 <fc_solve_check_and_add_state>
  404549:	84 c0                	test   %al,%al
  40454b:	75 53                	jne    4045a0 <fc_solve_sfs_empty_stack_into_freecells+0x1e0>
        if (HT_FIELD(hard_thread, allocated_from_list))
  40454d:	41 80 bf 18 05 00 00 	cmpb   $0x0,0x518(%r15)
  404554:	00 
  404555:	0f 85 a5 00 00 00    	jne    404600 <fc_solve_sfs_empty_stack_into_freecells+0x240>
  40455b:	49 8b 87 f0 00 00 00 	mov    0xf0(%r15),%rax
  404562:	49 89 87 e8 00 00 00 	mov    %rax,0xe8(%r15)
  404569:	48 8b 4c 24 30       	mov    0x30(%rsp),%rcx
  40456e:	eb 35                	jmp    4045a5 <fc_solve_sfs_empty_stack_into_freecells+0x1e5>
}
  404570:	48 83 c4 48          	add    $0x48,%rsp
  404574:	5b                   	pop    %rbx
  404575:	5d                   	pop    %rbp
  404576:	41 5c                	pop    %r12
  404578:	41 5d                	pop    %r13
  40457a:	41 5e                	pop    %r14
  40457c:	41 5f                	pop    %r15
  40457e:	c3                   	retq   
  40457f:	90                   	nop
                if (fcs_freecell_is_empty(new_state_key, b))
  404580:	89 c6                	mov    %eax,%esi
  404582:	48 63 c1             	movslq %ecx,%rax
  404585:	89 f1                	mov    %esi,%ecx
  404587:	e9 6e ff ff ff       	jmpq   4044fa <fc_solve_sfs_empty_stack_into_freecells+0x13a>
  40458c:	0f 1f 40 00          	nopl   0x0(%rax)
            for (; b < LOCAL_FREECELLS_NUM; ++b)
  404590:	b9 05 00 00 00       	mov    $0x5,%ecx
  404595:	b8 04 00 00 00       	mov    $0x4,%eax
  40459a:	e9 5b ff ff ff       	jmpq   4044fa <fc_solve_sfs_empty_stack_into_freecells+0x13a>
  40459f:	90                   	nop
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  4045a0:	48 8b 4c 24 20       	mov    0x20(%rsp),%rcx
    if ((!((list->num_states + (list->states != NULL)) &
  4045a5:	49 8b 45 08          	mov    0x8(%r13),%rax
  4045a9:	31 f6                	xor    %esi,%esi
  4045ab:	49 8b 55 00          	mov    0x0(%r13),%rdx
  4045af:	48 85 c0             	test   %rax,%rax
  4045b2:	40 0f 95 c6          	setne  %sil
  4045b6:	48 01 d6             	add    %rdx,%rsi
  4045b9:	40 f6 c6 0f          	test   $0xf,%sil
  4045bd:	75 20                	jne    4045df <fc_solve_sfs_empty_stack_into_freecells+0x21f>
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  4045bf:	48 83 c6 10          	add    $0x10,%rsi
  4045c3:	48 89 c7             	mov    %rax,%rdi
  4045c6:	48 89 0c 24          	mov    %rcx,(%rsp)
  4045ca:	48 c1 e6 04          	shl    $0x4,%rsi
  4045ce:	e8 9d cb ff ff       	callq  401170 <realloc@plt>
  4045d3:	49 8b 55 00          	mov    0x0(%r13),%rdx
  4045d7:	48 8b 0c 24          	mov    (%rsp),%rcx
        list->states =
  4045db:	49 89 45 08          	mov    %rax,0x8(%r13)
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  4045df:	48 8d 72 01          	lea    0x1(%rdx),%rsi
  4045e3:	48 c1 e2 04          	shl    $0x4,%rdx
  4045e7:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  4045eb:	48 01 d0             	add    %rdx,%rax
  4045ee:	49 89 75 00          	mov    %rsi,0x0(%r13)
  4045f2:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  4045f6:	48 89 08             	mov    %rcx,(%rax)
  4045f9:	e9 12 fe ff ff       	jmpq   404410 <fc_solve_sfs_empty_stack_into_freecells+0x50>
  4045fe:	66 90                	xchg   %ax,%ax
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  404600:	49 8b 97 b0 00 00 00 	mov    0xb0(%r15),%rdx
  404607:	48 8b 44 24 28       	mov    0x28(%rsp),%rax
  40460c:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  40460f:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  404614:	49 89 87 b0 00 00 00 	mov    %rax,0xb0(%r15)
  40461b:	e9 49 ff ff ff       	jmpq   404569 <fc_solve_sfs_empty_stack_into_freecells+0x1a9>
  404620:	83 c1 02             	add    $0x2,%ecx
  404623:	e9 d2 fe ff ff       	jmpq   4044fa <fc_solve_sfs_empty_stack_into_freecells+0x13a>
  404628:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40462f:	00 
        my_copy_stack(stack_idx);
  404630:	48 8b 74 24 20       	mov    0x20(%rsp),%rsi
  404635:	bf 01 00 00 00       	mov    $0x1,%edi
  40463a:	44 89 d9             	mov    %r11d,%ecx
  40463d:	d3 e7                	shl    %cl,%edi
  40463f:	09 fa                	or     %edi,%edx
  404641:	48 8b 7c 24 10       	mov    0x10(%rsp),%rdi
  404646:	89 50 14             	mov    %edx,0x14(%rax)
  404649:	48 89 d8             	mov    %rbx,%rax
  40464c:	4e 8b 0c ce          	mov    (%rsi,%r9,8),%r9
  404650:	48 c1 e0 07          	shl    $0x7,%rax
  404654:	48 8d 94 07 00 01 00 	lea    0x100(%rdi,%rax,1),%rdx
  40465b:	00 
  40465c:	41 0f be 01          	movsbl (%r9),%eax
  404660:	83 c0 01             	add    $0x1,%eax
  404663:	48 98                	cltq   
  404665:	48 83 f8 08          	cmp    $0x8,%rax
  404669:	73 65                	jae    4046d0 <fc_solve_sfs_empty_stack_into_freecells+0x310>
  40466b:	a8 04                	test   $0x4,%al
  40466d:	0f 85 7f 00 00 00    	jne    4046f2 <fc_solve_sfs_empty_stack_into_freecells+0x332>
  404673:	48 85 c0             	test   %rax,%rax
  404676:	74 28                	je     4046a0 <fc_solve_sfs_empty_stack_into_freecells+0x2e0>
  404678:	41 0f b6 09          	movzbl (%r9),%ecx
  40467c:	88 0a                	mov    %cl,(%rdx)
  40467e:	48 8b 74 24 20       	mov    0x20(%rsp),%rsi
  404683:	a8 02                	test   $0x2,%al
  404685:	74 19                	je     4046a0 <fc_solve_sfs_empty_stack_into_freecells+0x2e0>
  404687:	41 0f b7 4c 01 fe    	movzwl -0x2(%r9,%rax,1),%ecx
  40468d:	66 89 4c 02 fe       	mov    %cx,-0x2(%rdx,%rax,1)
  404692:	48 8b 74 24 20       	mov    0x20(%rsp),%rsi
  404697:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40469e:	00 00 
  4046a0:	4a 89 14 de          	mov    %rdx,(%rsi,%r11,8)
  4046a4:	e9 cd fd ff ff       	jmpq   404476 <fc_solve_sfs_empty_stack_into_freecells+0xb6>
  4046a9:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
  4046b0:	83 c1 03             	add    $0x3,%ecx
  4046b3:	e9 42 fe ff ff       	jmpq   4044fa <fc_solve_sfs_empty_stack_into_freecells+0x13a>
  4046b8:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  4046bf:	00 
  4046c0:	83 c1 04             	add    $0x4,%ecx
  4046c3:	48 98                	cltq   
  4046c5:	e9 30 fe ff ff       	jmpq   4044fa <fc_solve_sfs_empty_stack_into_freecells+0x13a>
  4046ca:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
  4046d0:	49 8b 4c 01 f8       	mov    -0x8(%r9,%rax,1),%rcx
  4046d5:	48 89 d7             	mov    %rdx,%rdi
  4046d8:	4c 89 ce             	mov    %r9,%rsi
  4046db:	48 89 4c 02 f8       	mov    %rcx,-0x8(%rdx,%rax,1)
  4046e0:	48 8d 48 ff          	lea    -0x1(%rax),%rcx
  4046e4:	48 c1 e9 03          	shr    $0x3,%rcx
  4046e8:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  4046eb:	48 8b 74 24 20       	mov    0x20(%rsp),%rsi
  4046f0:	eb ae                	jmp    4046a0 <fc_solve_sfs_empty_stack_into_freecells+0x2e0>
  4046f2:	41 8b 09             	mov    (%r9),%ecx
  4046f5:	89 0a                	mov    %ecx,(%rdx)
  4046f7:	41 8b 4c 01 fc       	mov    -0x4(%r9,%rax,1),%ecx
  4046fc:	89 4c 02 fc          	mov    %ecx,-0x4(%rdx,%rax,1)
  404700:	48 8b 74 24 20       	mov    0x20(%rsp),%rsi
  404705:	eb 99                	jmp    4046a0 <fc_solve_sfs_empty_stack_into_freecells+0x2e0>
  404707:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40470e:	00 00 

0000000000404710 <fc_solve_sfs_move_cards_to_a_different_parent>:
{
  404710:	41 57                	push   %r15
  404712:	49 89 f2             	mov    %rsi,%r10
  404715:	41 56                	push   %r14
  404717:	41 55                	push   %r13
  404719:	41 54                	push   %r12
  40471b:	55                   	push   %rbp
  40471c:	53                   	push   %rbx
  40471d:	48 81 ec c8 00 00 00 	sub    $0xc8,%rsp
    MOVE_FUNCS__define_common();
  404724:	4c 8b 1f             	mov    (%rdi),%r11
{
  404727:	48 89 54 24 68       	mov    %rdx,0x68(%rsp)
}

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)
  40472c:	8b 57 20             	mov    0x20(%rdi),%edx
  40472f:	48 89 7c 24 28       	mov    %rdi,0x28(%rsp)
  404734:	48 89 4c 24 18       	mov    %rcx,0x18(%rsp)
    MOVE_FUNCS__define_common();
  404739:	49 8d 9b 00 01 00 00 	lea    0x100(%r11),%rbx
  404740:	48 89 5c 24 78       	mov    %rbx,0x78(%rsp)
    const fcs_game_limit num_vacant_freecells =
  404745:	0f b6 9f e4 01 00 00 	movzbl 0x1e4(%rdi),%ebx
  40474c:	88 5c 24 16          	mov    %bl,0x16(%rsp)
    const fcs_game_limit num_vacant_stacks = soft_thread->num_vacant_stacks;
  404750:	0f b6 9f e3 01 00 00 	movzbl 0x1e3(%rdi),%ebx
  404757:	88 5c 24 17          	mov    %bl,0x17(%rsp)
    const int derived_start_idx = derived_states_list->num_states;
  40475b:	48 8b 19             	mov    (%rcx),%rbx
  40475e:	48 89 9c 24 80 00 00 	mov    %rbx,0x80(%rsp)
  404765:	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));
  404766:	48 8d 5f 60          	lea    0x60(%rdi),%rbx
  40476a:	48 89 5c 24 70       	mov    %rbx,0x70(%rsp)
    if (soft_thread->super_method_type == FCS_SUPER_METHOD_DFS)
  40476f:	85 d2                	test   %edx,%edx
  404771:	75 1d                	jne    404790 <fc_solve_sfs_move_cards_to_a_different_parent+0x80>
        return (DFS_VAR(soft_thread, soft_dfs_info)[DFS_VAR(soft_thread, depth)]
  404773:	48 8b 47 38          	mov    0x38(%rdi),%rax
  404777:	48 8d 14 80          	lea    (%rax,%rax,4),%rdx
  40477b:	48 8d 04 50          	lea    (%rax,%rdx,2),%rax
  40477f:	48 c1 e0 04          	shl    $0x4,%rax
  404783:	48 03 47 30          	add    0x30(%rdi),%rax
  404787:	48 83 c0 40          	add    $0x40,%rax
  40478b:	48 89 44 24 70       	mov    %rax,0x70(%rsp)
{
  404790:	48 c7 44 24 20 00 00 	movq   $0x0,0x20(%rsp)
  404797:	00 00 
                copy_two_stacks(stack_idx, ds);
  404799:	4d 89 dd             	mov    %r11,%r13
  40479c:	4d 89 d4             	mov    %r10,%r12
  40479f:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  4047a4:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4047ab:	00 00 00 00 
  4047af:	90                   	nop
        var_AUTO(col, fcs_state_get_col(state, stack_idx));
  4047b0:	49 8b 1c c4          	mov    (%r12,%rax,8),%rbx
  4047b4:	89 44 24 10          	mov    %eax,0x10(%rsp)
        const int cards_num = fcs_col_len(col);
  4047b8:	0f be 33             	movsbl (%rbx),%esi
        var_AUTO(col, fcs_state_get_col(state, stack_idx));
  4047bb:	48 89 5c 24 60       	mov    %rbx,0x60(%rsp)
        const int cards_num = fcs_col_len(col);
  4047c0:	89 74 24 58          	mov    %esi,0x58(%rsp)
        if (cards_num < 2)
  4047c4:	83 fe 01             	cmp    $0x1,%esi
  4047c7:	0f 8e 03 06 00 00    	jle    404dd0 <fc_solve_sfs_move_cards_to_a_different_parent+0x6c0>
        fcs_card upper_card = fcs_col_get_card(col, cards_num - 1);
  4047cd:	8d 46 ff             	lea    -0x1(%rsi),%eax
  4047d0:	49 89 d9             	mov    %rbx,%r9
        for (min_card_height = cards_num - 2; min_card_height >= 0;
  4047d3:	8d 4e fe             	lea    -0x2(%rsi),%ecx
        fcs_card upper_card = fcs_col_get_card(col, cards_num - 1);
  4047d6:	48 98                	cltq   
  4047d8:	0f b6 54 03 01       	movzbl 0x1(%rbx,%rax,1),%edx
  4047dd:	48 63 c1             	movslq %ecx,%rax
  4047e0:	89 c9                	mov    %ecx,%ecx
  4047e2:	4c 8d 40 ff          	lea    -0x1(%rax),%r8
  4047e6:	49 29 c8             	sub    %rcx,%r8
  4047e9:	48 0f be ca          	movsbq %dl,%rcx
  4047ed:	0f 1f 00             	nopl   (%rax)
            lower_card = fcs_col_get_card(col, min_card_height);
  4047f0:	49 0f be 54 01 01    	movsbq 0x1(%r9,%rax,1),%rdx
  4047f6:	89 c7                	mov    %eax,%edi
  4047f8:	48 89 d6             	mov    %rdx,%rsi
    return fc_solve_is_parent_buf[(size_t)parent][(size_t)child];
  4047fb:	48 c1 e2 06          	shl    $0x6,%rdx
            if (!fcs_is_parent_card(upper_card, lower_card))
  4047ff:	80 bc 11 c0 fe 40 00 	cmpb   $0x0,0x40fec0(%rcx,%rdx,1)
  404806:	00 
  404807:	0f 84 b5 08 00 00    	je     4050c2 <fc_solve_sfs_move_cards_to_a_different_parent+0x9b2>
  40480d:	48 83 e8 01          	sub    $0x1,%rax
             upper_card = lower_card, min_card_height--)
  404811:	48 0f be ce          	movsbq %sil,%rcx
        for (min_card_height = cards_num - 2; min_card_height >= 0;
  404815:	4c 39 c0             	cmp    %r8,%rax
  404818:	75 d6                	jne    4047f0 <fc_solve_sfs_move_cards_to_a_different_parent+0xe0>
        min_card_height += 2;
  40481a:	bf 01 00 00 00       	mov    $0x1,%edi
                copy_two_stacks(stack_idx, ds);
  40481f:	0f b6 4c 24 10       	movzbl 0x10(%rsp),%ecx
  404824:	b8 01 00 00 00       	mov    $0x1,%eax
  404829:	4d 89 eb             	mov    %r13,%r11
  40482c:	48 8b 5c 24 20       	mov    0x20(%rsp),%rbx
  404831:	44 8b 7c 24 58       	mov    0x58(%rsp),%r15d
  404836:	d3 e0                	shl    %cl,%eax
  404838:	89 44 24 5c          	mov    %eax,0x5c(%rsp)
  40483c:	48 89 d8             	mov    %rbx,%rax
  40483f:	48 c1 e0 07          	shl    $0x7,%rax
  404843:	48 03 44 24 78       	add    0x78(%rsp),%rax
  404848:	41 29 ff             	sub    %edi,%r15d
  40484b:	44 89 7c 24 04       	mov    %r15d,0x4(%rsp)
  404850:	48 89 44 24 48       	mov    %rax,0x48(%rsp)
  404855:	89 d8                	mov    %ebx,%eax
  404857:	c1 e0 08             	shl    $0x8,%eax
  40485a:	89 84 24 88 00 00 00 	mov    %eax,0x88(%rsp)
  404861:	48 63 c7             	movslq %edi,%rax
  404864:	48 89 44 24 08       	mov    %rax,0x8(%rsp)
  404869:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
            FCS_POS_IDX_TO_CHECK_START_LOOP(card)
  404870:	48 8b 44 24 60       	mov    0x60(%rsp),%rax
  404875:	48 8b 5c 24 08       	mov    0x8(%rsp),%rbx
  40487a:	4c 8b 7c 24 70       	mov    0x70(%rsp),%r15
  40487f:	48 0f be 44 18 01    	movsbq 0x1(%rax,%rbx,1),%rax
  404885:	48 c1 e0 04          	shl    $0x4,%rax
  404889:	4c 8b a8 40 fb 40 00 	mov    0x40fb40(%rax),%r13
  404890:	4d 01 fd             	add    %r15,%r13
  404893:	4c 03 b8 48 fb 40 00 	add    0x40fb48(%rax),%r15
  40489a:	4d 39 fd             	cmp    %r15,%r13
  40489d:	0f 83 10 05 00 00    	jae    404db3 <fc_solve_sfs_move_cards_to_a_different_parent+0x6a3>
                    ((((((stack_idx << 8) | c) << 8) | ds) << 8) | dc);
  4048a3:	8b 84 24 88 00 00 00 	mov    0x88(%rsp),%eax
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  4048aa:	4d 89 de             	mov    %r11,%r14
                    ((((((stack_idx << 8) | c) << 8) | ds) << 8) | dc);
  4048ad:	09 d8                	or     %ebx,%eax
  4048af:	c1 e0 08             	shl    $0x8,%eax
  4048b2:	48 98                	cltq   
  4048b4:	48 89 44 24 50       	mov    %rax,0x50(%rsp)
  4048b9:	e9 42 01 00 00       	jmpq   404a00 <fc_solve_sfs_move_cards_to_a_different_parent+0x2f0>
  4048be:	66 90                	xchg   %ax,%ax
  4048c0:	48 8b 84 24 a0 00 00 	mov    0xa0(%rsp),%rax
  4048c7:	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),
  4048c8:	48 8b 74 24 20       	mov    0x20(%rsp),%rsi
  4048cd:	4c 8b 04 d8          	mov    (%rax,%rbx,8),%r8
        &fcs_col_get_card(src_col, (fcs_col_len(src_col) -= cards_num));
  4048d1:	48 63 4c 24 04       	movslq 0x4(%rsp),%rcx
  4048d6:	48 8b 14 f0          	mov    (%rax,%rsi,8),%rdx
    memcpy(&fcs_col_get_card(dest_col, fcs_col_len(dest_col)), src_cards_ptr,
  4048da:	4c 89 44 24 40       	mov    %r8,0x40(%rsp)
  4048df:	48 89 4c 24 38       	mov    %rcx,0x38(%rsp)
        &fcs_col_get_card(src_col, (fcs_col_len(src_col) -= cards_num));
  4048e4:	0f b6 02             	movzbl (%rdx),%eax
  4048e7:	29 c8                	sub    %ecx,%eax
  4048e9:	88 02                	mov    %al,(%rdx)
  4048eb:	48 0f be c0          	movsbq %al,%rax
    fcs_card *const src_cards_ptr =
  4048ef:	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,
  4048f4:	49 0f be 00          	movsbq (%r8),%rax
  4048f8:	48 89 ca             	mov    %rcx,%rdx
  4048fb:	4c 89 ce             	mov    %r9,%rsi
  4048fe:	4c 89 4c 24 30       	mov    %r9,0x30(%rsp)
  404903:	49 8d 7c 00 01       	lea    0x1(%r8,%rax,1),%rdi
  404908:	e8 d3 c7 ff ff       	callq  4010e0 <memcpy@plt>
    fcs_col_len(dest_col) += cards_num;
  40490d:	4c 8b 44 24 40       	mov    0x40(%rsp),%r8
    memset(src_cards_ptr, 0, cards_size);
  404912:	31 f6                	xor    %esi,%esi
  404914:	48 8b 4c 24 38       	mov    0x38(%rsp),%rcx
  404919:	4c 8b 4c 24 30       	mov    0x30(%rsp),%r9
    fcs_col_len(dest_col) += cards_num;
  40491e:	0f b6 44 24 04       	movzbl 0x4(%rsp),%eax
  404923:	41 00 00             	add    %al,(%r8)
    memset(src_cards_ptr, 0, cards_size);
  404926:	48 89 ca             	mov    %rcx,%rdx
  404929:	4c 89 cf             	mov    %r9,%rdi
  40492c:	e8 6f c7 ff ff       	callq  4010a0 <memset@plt>
  404931:	48 0b 5c 24 50       	or     0x50(%rsp),%rbx
    if (!fc_solve_check_and_add_state(
  404936:	48 8d 94 24 b0 00 00 	lea    0xb0(%rsp),%rdx
  40493d:	00 
    const_SLOT(hard_thread, soft_thread);
  40493e:	48 8b 44 24 28       	mov    0x28(%rsp),%rax
    if (!fc_solve_check_and_add_state(
  404943:	48 8d b4 24 a0 00 00 	lea    0xa0(%rsp),%rsi
  40494a:	00 
  40494b:	48 c1 e3 08          	shl    $0x8,%rbx
                state_context_value =
  40494f:	09 dd                	or     %ebx,%ebp
    const_SLOT(hard_thread, soft_thread);
  404951:	48 8b 18             	mov    (%rax),%rbx
    if (!fc_solve_check_and_add_state(
  404954:	48 89 df             	mov    %rbx,%rdi
  404957:	e8 f4 d0 ff ff       	callq  401a50 <fc_solve_check_and_add_state>
  40495c:	84 c0                	test   %al,%al
  40495e:	0f 85 7c 05 00 00    	jne    404ee0 <fc_solve_sfs_move_cards_to_a_different_parent+0x7d0>
        if (HT_FIELD(hard_thread, allocated_from_list))
  404964:	80 bb 18 05 00 00 00 	cmpb   $0x0,0x518(%rbx)
  40496b:	0f 84 0f 06 00 00    	je     404f80 <fc_solve_sfs_move_cards_to_a_different_parent+0x870>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  404971:	48 8b 93 b0 00 00 00 	mov    0xb0(%rbx),%rdx
  404978:	48 8b 84 24 a8 00 00 	mov    0xa8(%rsp),%rax
  40497f:	00 
  404980:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  404983:	48 8b 84 24 a0 00 00 	mov    0xa0(%rsp),%rax
  40498a:	00 
  40498b:	48 89 83 b0 00 00 00 	mov    %rax,0xb0(%rbx)
  404992:	48 8b 9c 24 b0 00 00 	mov    0xb0(%rsp),%rbx
  404999:	00 
    if ((!((list->num_states + (list->states != NULL)) &
  40499a:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
  40499f:	31 d2                	xor    %edx,%edx
  4049a1:	48 8b 38             	mov    (%rax),%rdi
  4049a4:	48 8b 40 08          	mov    0x8(%rax),%rax
  4049a8:	48 85 c0             	test   %rax,%rax
  4049ab:	0f 95 c2             	setne  %dl
  4049ae:	48 01 fa             	add    %rdi,%rdx
  4049b1:	f6 c2 0f             	test   $0xf,%dl
  4049b4:	75 1c                	jne    4049d2 <fc_solve_sfs_move_cards_to_a_different_parent+0x2c2>
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  4049b6:	48 8d 72 10          	lea    0x10(%rdx),%rsi
  4049ba:	48 89 c7             	mov    %rax,%rdi
  4049bd:	48 c1 e6 04          	shl    $0x4,%rsi
  4049c1:	e8 aa c7 ff ff       	callq  401170 <realloc@plt>
        list->states =
  4049c6:	48 8b 74 24 18       	mov    0x18(%rsp),%rsi
  4049cb:	48 8b 3e             	mov    (%rsi),%rdi
  4049ce:	48 89 46 08          	mov    %rax,0x8(%rsi)
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  4049d2:	48 8b 74 24 18       	mov    0x18(%rsp),%rsi
  4049d7:	48 8d 57 01          	lea    0x1(%rdi),%rdx
  4049db:	48 c1 e7 04          	shl    $0x4,%rdi
  4049df:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  4049e3:	48 01 f8             	add    %rdi,%rax
  4049e6:	48 89 16             	mov    %rdx,(%rsi)
  4049e9:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  4049ed:	48 89 18             	mov    %rbx,(%rax)
  4049f0:	89 68 08             	mov    %ebp,0x8(%rax)
            FCS_POS_IDX_TO_CHECK_START_LOOP(card)
  4049f3:	49 83 c5 04          	add    $0x4,%r13
  4049f7:	4d 39 ef             	cmp    %r13,%r15
  4049fa:	0f 86 b0 03 00 00    	jbe    404db0 <fc_solve_sfs_move_cards_to_a_different_parent+0x6a0>
                const int_fast32_t ds = pos_idx_to_check[0];
  404a00:	49 0f be 5d 00       	movsbq 0x0(%r13),%rbx
  404a05:	49 89 db             	mov    %rbx,%r11
                if ((ds == -1) || (ds == stack_idx))
  404a08:	48 83 fb ff          	cmp    $0xffffffffffffffff,%rbx
  404a0c:	74 e5                	je     4049f3 <fc_solve_sfs_move_cards_to_a_different_parent+0x2e3>
  404a0e:	4c 0f be d3          	movsbq %bl,%r10
  404a12:	44 3b 54 24 10       	cmp    0x10(%rsp),%r10d
  404a17:	74 da                	je     4049f3 <fc_solve_sfs_move_cards_to_a_different_parent+0x2e3>
                const int dest_cards_num = fcs_col_len(dest_col);
  404a19:	49 8b 04 dc          	mov    (%r12,%rbx,8),%rax
                int num_cards_to_relocate = dest_cards_num - dc - 1;
  404a1d:	41 0f be 6d 01       	movsbl 0x1(%r13),%ebp
                    min(num_cards_to_relocate, num_virtual_vacant_stacks);
  404a22:	0f b6 4c 24 17       	movzbl 0x17(%rsp),%ecx
                int num_cards_to_relocate = dest_cards_num - dc - 1;
  404a27:	0f be 10             	movsbl (%rax),%edx
                    min(num_cards_to_relocate, num_vacant_freecells);
  404a2a:	0f b6 44 24 16       	movzbl 0x16(%rsp),%eax
                int num_cards_to_relocate = dest_cards_num - dc - 1;
  404a2f:	41 89 e8             	mov    %ebp,%r8d
  404a32:	41 f7 d0             	not    %r8d
  404a35:	44 01 c2             	add    %r8d,%edx
                const int freecells_to_fill =
  404a38:	39 d0                	cmp    %edx,%eax
  404a3a:	41 89 d0             	mov    %edx,%r8d
  404a3d:	44 0f 4e c0          	cmovle %eax,%r8d
                num_cards_to_relocate -= freecells_to_fill;
  404a41:	44 29 c2             	sub    %r8d,%edx
                if (!((num_cards_to_relocate == 0) &&
  404a44:	39 d1                	cmp    %edx,%ecx
  404a46:	7c ab                	jl     4049f3 <fc_solve_sfs_move_cards_to_a_different_parent+0x2e3>
                const int freestacks_to_fill =
  404a48:	0f 4e d1             	cmovle %ecx,%edx
                        (calc_max_sequence_move(
  404a4b:	44 29 c0             	sub    %r8d,%eax
  404a4e:	83 c0 01             	add    $0x1,%eax
  404a51:	29 d1                	sub    %edx,%ecx
  404a53:	d3 e0                	shl    %cl,%eax
                if (!((num_cards_to_relocate == 0) &&
  404a55:	3b 44 24 04          	cmp    0x4(%rsp),%eax
  404a59:	7c 98                	jl     4049f3 <fc_solve_sfs_move_cards_to_a_different_parent+0x2e3>
                (instance->list_of_vacant_states != NULL)))
  404a5b:	49 8b 8e b0 00 00 00 	mov    0xb0(%r14),%rcx
  404a62:	48 85 c9             	test   %rcx,%rcx
    if ((HT_FIELD(hard_thread, allocated_from_list) =
  404a65:	41 0f 95 86 18 05 00 	setne  0x518(%r14)
  404a6c:	00 
  404a6d:	0f 85 7d 04 00 00    	jne    404ef0 <fc_solve_sfs_move_cards_to_a_different_parent+0x7e0>
    if ((size_t)(allocator->max_ptr - allocator->ptr) < how_much)
  404a73:	49 8b 8e e8 00 00 00 	mov    0xe8(%r14),%rcx
  404a7a:	49 8b 86 e0 00 00 00 	mov    0xe0(%r14),%rax
  404a81:	48 29 c8             	sub    %rcx,%rax
  404a84:	48 83 f8 5f          	cmp    $0x5f,%rax
  404a88:	0f 86 a2 05 00 00    	jbe    405030 <fc_solve_sfs_move_cards_to_a_different_parent+0x920>
        allocator->rollback_ptr = allocator->ptr;
  404a8e:	49 89 8e f0 00 00 00 	mov    %rcx,0xf0(%r14)
    allocator->ptr += how_much;
  404a95:	48 8d 41 60          	lea    0x60(%rcx),%rax
  404a99:	49 89 86 e8 00 00 00 	mov    %rax,0xe8(%r14)
    return (const fcs_kv_state){.key = &(s->s), .val = &(s->info)};
  404aa0:	48 8d 41 48          	lea    0x48(%rcx),%rax
    *ret = FCS_STATE_keyval_pair_to_kv(s);
  404aa4:	c4 e1 f9 6e d1       	vmovq  %rcx,%xmm2
  404aa9:	c4 e3 e9 22 c0 01    	vpinsrq $0x1,%rax,%xmm2,%xmm0
  404aaf:	c5 f8 29 84 24 a0 00 	vmovaps %xmm0,0xa0(%rsp)
  404ab6:	00 00 
    fcs_duplicate_kv_state(out_new_state_out, &raw_state_raw);
  404ab8:	c4 c1 7a 6f 04 24    	vmovdqu (%r12),%xmm0
  404abe:	c5 f8 11 01          	vmovups %xmm0,(%rcx)
  404ac2:	c4 c1 7a 6f 44 24 10 	vmovdqu 0x10(%r12),%xmm0
  404ac9:	c5 f8 11 41 10       	vmovups %xmm0,0x10(%rcx)
  404ace:	c4 c1 7a 6f 44 24 20 	vmovdqu 0x20(%r12),%xmm0
  404ad5:	c5 f8 11 41 20       	vmovups %xmm0,0x20(%rcx)
  404ada:	c4 c1 7a 6f 44 24 30 	vmovdqu 0x30(%r12),%xmm0
  404ae1:	c5 f8 11 41 30       	vmovups %xmm0,0x30(%rcx)
  404ae6:	49 8b 44 24 40       	mov    0x40(%r12),%rax
  404aeb:	48 89 41 40          	mov    %rax,0x40(%rcx)
  404aef:	48 8b 44 24 68       	mov    0x68(%rsp),%rax
  404af4:	c5 fa 6f 00          	vmovdqu (%rax),%xmm0
  404af8:	c5 f8 11 41 48       	vmovups %xmm0,0x48(%rcx)
  404afd:	48 8b 40 10          	mov    0x10(%rax),%rax
    (FCS_S_DEPTH(raw_ptr_new_state))++;
  404b01:	83 41 50 01          	addl   $0x1,0x50(%rcx)
    FCS_S_PARENT(raw_ptr_new_state) = INFO_STATE_PTR(&raw_state_raw);
  404b05:	4c 89 61 48          	mov    %r12,0x48(%rcx)
    FCS_S_VISITED(raw_ptr_new_state) = 0;
  404b09:	c6 41 56 00          	movb   $0x0,0x56(%rcx)
    fcs_duplicate_kv_state(out_new_state_out, &raw_state_raw);
  404b0d:	48 89 41 58          	mov    %rax,0x58(%rcx)
    FCS_S_NUM_ACTIVE_CHILDREN(raw_ptr_new_state) = 0;
  404b11:	31 c0                	xor    %eax,%eax
  404b13:	66 89 41 54          	mov    %ax,0x54(%rcx)
                copy_two_stacks(stack_idx, ds);
  404b17:	8b 44 24 5c          	mov    0x5c(%rsp),%eax
    memset(&(FCS_S_SCAN_VISITED(raw_ptr_new_state)), '\0',
  404b1b:	c7 41 57 00 00 00 00 	movl   $0x0,0x57(%rcx)
  404b22:	89 41 5c             	mov    %eax,0x5c(%rcx)
  404b25:	48 63 44 24 10       	movslq 0x10(%rsp),%rax
  404b2a:	48 8b 34 c1          	mov    (%rcx,%rax,8),%rsi
  404b2e:	0f be 0e             	movsbl (%rsi),%ecx
  404b31:	83 c1 01             	add    $0x1,%ecx
  404b34:	48 63 c9             	movslq %ecx,%rcx
  404b37:	48 83 f9 08          	cmp    $0x8,%rcx
  404b3b:	0f 83 6f 03 00 00    	jae    404eb0 <fc_solve_sfs_move_cards_to_a_different_parent+0x7a0>
  404b41:	f6 c1 04             	test   $0x4,%cl
  404b44:	0f 85 8a 05 00 00    	jne    4050d4 <fc_solve_sfs_move_cards_to_a_different_parent+0x9c4>
  404b4a:	48 85 c9             	test   %rcx,%rcx
  404b4d:	74 14                	je     404b63 <fc_solve_sfs_move_cards_to_a_different_parent+0x453>
  404b4f:	0f b6 3e             	movzbl (%rsi),%edi
  404b52:	4c 8b 4c 24 48       	mov    0x48(%rsp),%r9
  404b57:	41 88 39             	mov    %dil,(%r9)
  404b5a:	f6 c1 02             	test   $0x2,%cl
  404b5d:	0f 85 ef 05 00 00    	jne    405152 <fc_solve_sfs_move_cards_to_a_different_parent+0xa42>
  404b63:	48 8b 74 24 48       	mov    0x48(%rsp),%rsi
  404b68:	4c 8b 8c 24 a0 00 00 	mov    0xa0(%rsp),%r9
  404b6f:	00 
  404b70:	49 89 34 c1          	mov    %rsi,(%r9,%rax,8)
  404b74:	48 8b 84 24 a8 00 00 	mov    0xa8(%rsp),%rax
  404b7b:	00 
  404b7c:	8b 70 14             	mov    0x14(%rax),%esi
  404b7f:	44 0f a3 de          	bt     %r11d,%esi
  404b83:	0f 83 77 03 00 00    	jae    404f00 <fc_solve_sfs_move_cards_to_a_different_parent+0x7f0>
  404b89:	48 8b 44 24 28       	mov    0x28(%rsp),%rax
                empty_two_cols_from_new_state(soft_thread,
  404b8e:	41 01 d0             	add    %edx,%r8d
        int dest_fc_idx = 0;
  404b91:	31 f6                	xor    %esi,%esi
                const int cols_indexes[3] = {ds, -1, -1};
  404b93:	44 89 94 24 94 00 00 	mov    %r10d,0x94(%rsp)
  404b9a:	00 
  404b9b:	48 c7 84 24 98 00 00 	movq   $0xffffffffffffffff,0x98(%rsp)
  404ba2:	00 ff ff ff ff 
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  404ba7:	44 89 84 24 b0 00 00 	mov    %r8d,0xb0(%rsp)
  404bae:	00 
  404baf:	4c 8b 18             	mov    (%rax),%r11
  404bb2:	48 b8 00 00 00 00 ff 	movabs $0xffffffff00000000,%rax
  404bb9:	ff ff ff 
  404bbc:	48 89 84 24 b4 00 00 	mov    %rax,0xb4(%rsp)
  404bc3:	00 
  404bc4:	31 c0                	xor    %eax,%eax
  404bc6:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  404bcd:	00 00 00 
            while ((*col_num_cards) == 0)
  404bd0:	45 85 c0             	test   %r8d,%r8d
  404bd3:	0f 84 e7 fc ff ff    	je     4048c0 <fc_solve_sfs_move_cards_to_a_different_parent+0x1b0>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  404bd9:	83 fe 03             	cmp    $0x3,%esi
  404bdc:	0f 8f 7e 02 00 00    	jg     404e60 <fc_solve_sfs_move_cards_to_a_different_parent+0x750>
  404be2:	8d 56 01             	lea    0x1(%rsi),%edx
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  404be5:	48 63 ce             	movslq %esi,%rcx
  404be8:	41 80 7c 09 40 00    	cmpb   $0x0,0x40(%r9,%rcx,1)
  404bee:	0f 84 6c 03 00 00    	je     404f60 <fc_solve_sfs_move_cards_to_a_different_parent+0x850>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  404bf4:	83 fa 04             	cmp    $0x4,%edx
  404bf7:	74 3d                	je     404c36 <fc_solve_sfs_move_cards_to_a_different_parent+0x526>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  404bf9:	48 63 d2             	movslq %edx,%rdx
  404bfc:	41 80 7c 11 40 00    	cmpb   $0x0,0x40(%r9,%rdx,1)
  404c02:	0f 84 68 03 00 00    	je     404f70 <fc_solve_sfs_move_cards_to_a_different_parent+0x860>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  404c08:	8d 56 02             	lea    0x2(%rsi),%edx
  404c0b:	83 fa 04             	cmp    $0x4,%edx
  404c0e:	74 26                	je     404c36 <fc_solve_sfs_move_cards_to_a_different_parent+0x526>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  404c10:	48 63 d2             	movslq %edx,%rdx
  404c13:	41 80 7c 11 40 00    	cmpb   $0x0,0x40(%r9,%rdx,1)
  404c19:	0f 84 81 03 00 00    	je     404fa0 <fc_solve_sfs_move_cards_to_a_different_parent+0x890>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  404c1f:	8d 56 03             	lea    0x3(%rsi),%edx
  404c22:	83 fa 03             	cmp    $0x3,%edx
  404c25:	0f 85 37 02 00 00    	jne    404e62 <fc_solve_sfs_move_cards_to_a_different_parent+0x752>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  404c2b:	41 80 79 43 00       	cmpb   $0x0,0x43(%r9)
  404c30:	0f 84 da 03 00 00    	je     405010 <fc_solve_sfs_move_cards_to_a_different_parent+0x900>
  404c36:	84 c0                	test   %al,%al
  404c38:	0f 85 88 05 00 00    	jne    4051c6 <fc_solve_sfs_move_cards_to_a_different_parent+0xab6>
  404c3e:	48 8b 84 24 a0 00 00 	mov    0xa0(%rsp),%rax
  404c45:	00 
    char *const indirect_stacks_buffer =
  404c46:	49 8d b3 00 01 00 00 	lea    0x100(%r11),%rsi
    int put_cards_in_col_idx = 0;
  404c4d:	31 d2                	xor    %edx,%edx
    char *const indirect_stacks_buffer =
  404c4f:	48 89 74 24 30       	mov    %rsi,0x30(%rsp)
  404c54:	48 63 ca             	movslq %edx,%rcx
  404c57:	48 8d 34 c8          	lea    (%rax,%rcx,8),%rsi
        if (fcs_state_col_is_empty(state, ret))
  404c5b:	48 8b 3e             	mov    (%rsi),%rdi
  404c5e:	8d 4a 01             	lea    0x1(%rdx),%ecx
  404c61:	80 3f 00             	cmpb   $0x0,(%rdi)
  404c64:	0f 84 82 04 00 00    	je     4050ec <fc_solve_sfs_move_cards_to_a_different_parent+0x9dc>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  404c6a:	83 f9 08             	cmp    $0x8,%ecx
  404c6d:	0f 84 ad 03 00 00    	je     405020 <fc_solve_sfs_move_cards_to_a_different_parent+0x910>
        if (fcs_state_col_is_empty(state, ret))
  404c73:	48 8b 7e 08          	mov    0x8(%rsi),%rdi
  404c77:	80 3f 00             	cmpb   $0x0,(%rdi)
  404c7a:	0f 84 b2 04 00 00    	je     405132 <fc_solve_sfs_move_cards_to_a_different_parent+0xa22>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  404c80:	8d 4a 02             	lea    0x2(%rdx),%ecx
  404c83:	83 f9 08             	cmp    $0x8,%ecx
  404c86:	0f 84 94 03 00 00    	je     405020 <fc_solve_sfs_move_cards_to_a_different_parent+0x910>
        if (fcs_state_col_is_empty(state, ret))
  404c8c:	48 8b 7e 10          	mov    0x10(%rsi),%rdi
  404c90:	80 3f 00             	cmpb   $0x0,(%rdi)
  404c93:	0f 84 a1 04 00 00    	je     40513a <fc_solve_sfs_move_cards_to_a_different_parent+0xa2a>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  404c99:	8d 4a 03             	lea    0x3(%rdx),%ecx
  404c9c:	83 f9 07             	cmp    $0x7,%ecx
  404c9f:	0f 8f 7b 03 00 00    	jg     405020 <fc_solve_sfs_move_cards_to_a_different_parent+0x910>
        if (fcs_state_col_is_empty(state, ret))
  404ca5:	48 8b 7e 18          	mov    0x18(%rsi),%rdi
  404ca9:	80 3f 00             	cmpb   $0x0,(%rdi)
  404cac:	0f 84 90 04 00 00    	je     405142 <fc_solve_sfs_move_cards_to_a_different_parent+0xa32>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  404cb2:	8d 4a 04             	lea    0x4(%rdx),%ecx
  404cb5:	83 f9 07             	cmp    $0x7,%ecx
  404cb8:	0f 8f 62 03 00 00    	jg     405020 <fc_solve_sfs_move_cards_to_a_different_parent+0x910>
        if (fcs_state_col_is_empty(state, ret))
  404cbe:	48 8b 7e 20          	mov    0x20(%rsi),%rdi
  404cc2:	80 3f 00             	cmpb   $0x0,(%rdi)
  404cc5:	0f 84 7f 04 00 00    	je     40514a <fc_solve_sfs_move_cards_to_a_different_parent+0xa3a>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  404ccb:	8d 4a 05             	lea    0x5(%rdx),%ecx
  404cce:	83 f9 07             	cmp    $0x7,%ecx
  404cd1:	0f 8f 49 03 00 00    	jg     405020 <fc_solve_sfs_move_cards_to_a_different_parent+0x910>
        if (fcs_state_col_is_empty(state, ret))
  404cd7:	48 8b 7e 28          	mov    0x28(%rsi),%rdi
  404cdb:	80 3f 00             	cmpb   $0x0,(%rdi)
  404cde:	0f 84 82 04 00 00    	je     405166 <fc_solve_sfs_move_cards_to_a_different_parent+0xa56>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  404ce4:	8d 4a 06             	lea    0x6(%rdx),%ecx
  404ce7:	83 f9 07             	cmp    $0x7,%ecx
  404cea:	0f 8f 30 03 00 00    	jg     405020 <fc_solve_sfs_move_cards_to_a_different_parent+0x910>
        if (fcs_state_col_is_empty(state, ret))
  404cf0:	48 8b 76 30          	mov    0x30(%rsi),%rsi
  404cf4:	80 3e 00             	cmpb   $0x0,(%rsi)
  404cf7:	0f 84 8a 04 00 00    	je     405187 <fc_solve_sfs_move_cards_to_a_different_parent+0xa77>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  404cfd:	85 d2                	test   %edx,%edx
  404cff:	0f 85 1b 03 00 00    	jne    405020 <fc_solve_sfs_move_cards_to_a_different_parent+0x910>
        if (fcs_state_col_is_empty(state, ret))
  404d05:	48 8b 40 38          	mov    0x38(%rax),%rax
  404d09:	be 08 00 00 00       	mov    $0x8,%esi
  404d0e:	80 38 00             	cmpb   $0x0,(%rax)
  404d11:	0f 44 d6             	cmove  %esi,%edx
  404d14:	80 38 01             	cmpb   $0x1,(%rax)
  404d17:	19 c9                	sbb    %ecx,%ecx
  404d19:	83 e1 08             	and    $0x8,%ecx
  404d1c:	83 e9 01             	sub    $0x1,%ecx
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  404d1f:	48 8b b4 24 a8 00 00 	mov    0xa8(%rsp),%rsi
  404d26:	00 
  404d27:	4c 63 d1             	movslq %ecx,%r10
  404d2a:	8b 46 14             	mov    0x14(%rsi),%eax
  404d2d:	0f a3 c8             	bt     %ecx,%eax
  404d30:	0f 83 7a 02 00 00    	jae    404fb0 <fc_solve_sfs_move_cards_to_a_different_parent+0x8a0>
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  404d36:	48 63 84 24 94 00 00 	movslq 0x94(%rsp),%rax
  404d3d:	00 
        --(*col_num_cards);
  404d3e:	41 83 e8 01          	sub    $0x1,%r8d
  404d42:	49 8b 34 c1          	mov    (%r9,%rax,8),%rsi
    fcs_col_pop_card(col, ret);
  404d46:	0f be 0e             	movsbl (%rsi),%ecx
  404d49:	89 c8                	mov    %ecx,%eax
  404d4b:	83 e9 01             	sub    $0x1,%ecx
  404d4e:	83 e8 01             	sub    $0x1,%eax
  404d51:	48 63 c9             	movslq %ecx,%rcx
  404d54:	0f b6 4c 0e 01       	movzbl 0x1(%rsi,%rcx,1),%ecx
  404d59:	88 06                	mov    %al,(%rsi)
  404d5b:	48 0f be c0          	movsbq %al,%rax
  404d5f:	c6 44 06 01 00       	movb   $0x0,0x1(%rsi,%rax,1)
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  404d64:	4b 8b 34 d1          	mov    (%r9,%r10,8),%rsi
    fcs_col_push_card(col, card);
  404d68:	48 0f be 06          	movsbq (%rsi),%rax
  404d6c:	8d 78 01             	lea    0x1(%rax),%edi
  404d6f:	40 88 3e             	mov    %dil,(%rsi)
  404d72:	88 4c 06 01          	mov    %cl,0x1(%rsi,%rax,1)
  404d76:	48 8b 84 24 a0 00 00 	mov    0xa0(%rsp),%rax
  404d7d:	00 
  404d7e:	44 89 84 24 b0 00 00 	mov    %r8d,0xb0(%rsp)
  404d85:	00 
        while ((*col_num_cards) == 0)
  404d86:	45 85 c0             	test   %r8d,%r8d
  404d89:	0f 84 39 fb ff ff    	je     4048c8 <fc_solve_sfs_move_cards_to_a_different_parent+0x1b8>
    return -1;
  404d8f:	b9 ff ff ff ff       	mov    $0xffffffff,%ecx
    for (int ret = start_from; ret < local_stacks_num; ret++)
  404d94:	83 fa 08             	cmp    $0x8,%edx
  404d97:	0f 85 b7 fe ff ff    	jne    404c54 <fc_solve_sfs_move_cards_to_a_different_parent+0x544>
  404d9d:	31 d2                	xor    %edx,%edx
  404d9f:	e9 7b ff ff ff       	jmpq   404d1f <fc_solve_sfs_move_cards_to_a_different_parent+0x60f>
  404da4:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  404dab:	00 00 00 00 
  404daf:	90                   	nop
  404db0:	4d 89 f3             	mov    %r14,%r11
  404db3:	48 83 44 24 08 01    	addq   $0x1,0x8(%rsp)
  404db9:	83 6c 24 04 01       	subl   $0x1,0x4(%rsp)
  404dbe:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
        for (int c = min_card_height; c < cards_num; c++)
  404dc3:	39 44 24 58          	cmp    %eax,0x58(%rsp)
  404dc7:	0f 8f a3 fa ff ff    	jg     404870 <fc_solve_sfs_move_cards_to_a_different_parent+0x160>
  404dcd:	4d 89 dd             	mov    %r11,%r13
  404dd0:	48 83 44 24 20 01    	addq   $0x1,0x20(%rsp)
  404dd6:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  404ddb:	48 83 f8 08          	cmp    $0x8,%rax
  404ddf:	0f 85 cb f9 ff ff    	jne    4047b0 <fc_solve_sfs_move_cards_to_a_different_parent+0xa0>
    var_AUTO(start, d->states + derived_start_idx);
  404de5:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
    sort_derived_states(derived_states_list, derived_start_idx);
  404dea:	48 63 94 24 80 00 00 	movslq 0x80(%rsp),%rdx
  404df1:	00 
    var_AUTO(start, d->states + derived_start_idx);
  404df2:	48 8b 70 08          	mov    0x8(%rax),%rsi
    const_AUTO(limit, d->states + d->num_states);
  404df6:	48 8b 00             	mov    (%rax),%rax
    var_AUTO(start, d->states + derived_start_idx);
  404df9:	48 c1 e2 04          	shl    $0x4,%rdx
  404dfd:	48 01 f2             	add    %rsi,%rdx
    for (var_AUTO(b, start + 1); b < limit; b++)
  404e00:	48 8d 4a 10          	lea    0x10(%rdx),%rcx
    const_AUTO(limit, d->states + d->num_states);
  404e04:	48 c1 e0 04          	shl    $0x4,%rax
  404e08:	48 01 c6             	add    %rax,%rsi
    for (var_AUTO(b, start + 1); b < limit; b++)
  404e0b:	48 39 ce             	cmp    %rcx,%rsi
  404e0e:	76 3d                	jbe    404e4d <fc_solve_sfs_move_cards_to_a_different_parent+0x73d>
        for (var_AUTO(c, b); (c > start) && (c[0].context.i < c[-1].context.i);
  404e10:	8b 41 08             	mov    0x8(%rcx),%eax
  404e13:	39 41 f8             	cmp    %eax,-0x8(%rcx)
  404e16:	7e 2c                	jle    404e44 <fc_solve_sfs_move_cards_to_a_different_parent+0x734>
  404e18:	48 89 c8             	mov    %rcx,%rax
  404e1b:	eb 0b                	jmp    404e28 <fc_solve_sfs_move_cards_to_a_different_parent+0x718>
  404e1d:	0f 1f 00             	nopl   (%rax)
  404e20:	8b 58 08             	mov    0x8(%rax),%ebx
  404e23:	39 58 f8             	cmp    %ebx,-0x8(%rax)
  404e26:	7e 1c                	jle    404e44 <fc_solve_sfs_move_cards_to_a_different_parent+0x734>
            const_AUTO(swap_temp, c[-1]);
  404e28:	c5 fa 6f 40 f0       	vmovdqu -0x10(%rax),%xmm0
             c--)
  404e2d:	48 83 e8 10          	sub    $0x10,%rax
            c[-1] = c[0];
  404e31:	c5 fa 6f 48 10       	vmovdqu 0x10(%rax),%xmm1
            c[0] = swap_temp;
  404e36:	c5 f8 11 40 10       	vmovups %xmm0,0x10(%rax)
            c[-1] = c[0];
  404e3b:	c5 f8 11 08          	vmovups %xmm1,(%rax)
        for (var_AUTO(c, b); (c > start) && (c[0].context.i < c[-1].context.i);
  404e3f:	48 39 c2             	cmp    %rax,%rdx
  404e42:	72 dc                	jb     404e20 <fc_solve_sfs_move_cards_to_a_different_parent+0x710>
    for (var_AUTO(b, start + 1); b < limit; b++)
  404e44:	48 83 c1 10          	add    $0x10,%rcx
  404e48:	48 39 ce             	cmp    %rcx,%rsi
  404e4b:	77 c3                	ja     404e10 <fc_solve_sfs_move_cards_to_a_different_parent+0x700>
}
  404e4d:	48 81 c4 c8 00 00 00 	add    $0xc8,%rsp
  404e54:	5b                   	pop    %rbx
  404e55:	5d                   	pop    %rbp
  404e56:	41 5c                	pop    %r12
  404e58:	41 5d                	pop    %r13
  404e5a:	41 5e                	pop    %r14
  404e5c:	41 5f                	pop    %r15
  404e5e:	c3                   	retq   
  404e5f:	90                   	nop
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  404e60:	89 f2                	mov    %esi,%edx
            if (dest_fc_idx == LOCAL_FREECELLS_NUM)
  404e62:	83 fa 04             	cmp    $0x4,%edx
  404e65:	0f 84 cb fd ff ff    	je     404c36 <fc_solve_sfs_move_cards_to_a_different_parent+0x526>
  404e6b:	8d 72 01             	lea    0x1(%rdx),%esi
  404e6e:	48 63 d2             	movslq %edx,%rdx
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  404e71:	4b 8b 0c d1          	mov    (%r9,%r10,8),%rcx
            --(*col_num_cards);
  404e75:	41 83 e8 01          	sub    $0x1,%r8d
    fcs_col_pop_card(col, ret);
  404e79:	0f be 39             	movsbl (%rcx),%edi
  404e7c:	89 f8                	mov    %edi,%eax
  404e7e:	83 ef 01             	sub    $0x1,%edi
  404e81:	48 63 ff             	movslq %edi,%rdi
  404e84:	83 e8 01             	sub    $0x1,%eax
  404e87:	0f b6 7c 39 01       	movzbl 0x1(%rcx,%rdi,1),%edi
  404e8c:	88 01                	mov    %al,(%rcx)
  404e8e:	48 0f be c0          	movsbq %al,%rax
  404e92:	c6 44 01 01 00       	movb   $0x0,0x1(%rcx,%rax,1)
  404e97:	b8 01 00 00 00       	mov    $0x1,%eax
            fcs_put_card_in_freecell(*new_key, dest_fc_idx, top_card);
  404e9c:	41 88 7c 11 40       	mov    %dil,0x40(%r9,%rdx,1)
  404ea1:	e9 2a fd ff ff       	jmpq   404bd0 <fc_solve_sfs_move_cards_to_a_different_parent+0x4c0>
  404ea6:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  404ead:	00 00 00 
                copy_two_stacks(stack_idx, ds);
  404eb0:	48 8b 7c 0e f8       	mov    -0x8(%rsi,%rcx,1),%rdi
  404eb5:	4c 8b 4c 24 48       	mov    0x48(%rsp),%r9
  404eba:	49 89 7c 09 f8       	mov    %rdi,-0x8(%r9,%rcx,1)
  404ebf:	48 83 e9 01          	sub    $0x1,%rcx
  404ec3:	4c 89 cf             	mov    %r9,%rdi
  404ec6:	48 c1 e9 03          	shr    $0x3,%rcx
  404eca:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  404ecd:	e9 91 fc ff ff       	jmpq   404b63 <fc_solve_sfs_move_cards_to_a_different_parent+0x453>
  404ed2:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  404ed9:	00 00 00 00 
  404edd:	0f 1f 00             	nopl   (%rax)
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  404ee0:	48 8b 9c 24 a0 00 00 	mov    0xa0(%rsp),%rbx
  404ee7:	00 
  404ee8:	e9 ad fa ff ff       	jmpq   40499a <fc_solve_sfs_move_cards_to_a_different_parent+0x28a>
  404eed:	0f 1f 00             	nopl   (%rax)
            FCS_S_NEXT(instance->list_of_vacant_states);
  404ef0:	48 8b 41 48          	mov    0x48(%rcx),%rax
        instance->list_of_vacant_states =
  404ef4:	49 89 86 b0 00 00 00 	mov    %rax,0xb0(%r14)
  404efb:	e9 a0 fb ff ff       	jmpq   404aa0 <fc_solve_sfs_move_cards_to_a_different_parent+0x390>
  404f00:	44 89 d9             	mov    %r11d,%ecx
  404f03:	bf 01 00 00 00       	mov    $0x1,%edi
  404f08:	d3 e7                	shl    %cl,%edi
  404f0a:	09 fe                	or     %edi,%esi
  404f0c:	89 70 14             	mov    %esi,0x14(%rax)
  404f0f:	49 8b 34 d9          	mov    (%r9,%rbx,8),%rsi
  404f13:	48 89 d8             	mov    %rbx,%rax
  404f16:	48 c1 e0 07          	shl    $0x7,%rax
  404f1a:	48 03 44 24 78       	add    0x78(%rsp),%rax
  404f1f:	0f be 0e             	movsbl (%rsi),%ecx
  404f22:	83 c1 01             	add    $0x1,%ecx
  404f25:	48 63 c9             	movslq %ecx,%rcx
  404f28:	48 83 f9 08          	cmp    $0x8,%rcx
  404f2c:	0f 83 4e 01 00 00    	jae    405080 <fc_solve_sfs_move_cards_to_a_different_parent+0x970>
  404f32:	f6 c1 04             	test   $0x4,%cl
  404f35:	0f 85 33 02 00 00    	jne    40516e <fc_solve_sfs_move_cards_to_a_different_parent+0xa5e>
  404f3b:	48 85 c9             	test   %rcx,%rcx
  404f3e:	74 17                	je     404f57 <fc_solve_sfs_move_cards_to_a_different_parent+0x847>
  404f40:	0f b6 3e             	movzbl (%rsi),%edi
  404f43:	40 88 38             	mov    %dil,(%rax)
  404f46:	4c 8b 8c 24 a0 00 00 	mov    0xa0(%rsp),%r9
  404f4d:	00 
  404f4e:	f6 c1 02             	test   $0x2,%cl
  404f51:	0f 85 49 02 00 00    	jne    4051a0 <fc_solve_sfs_move_cards_to_a_different_parent+0xa90>
  404f57:	49 89 04 d9          	mov    %rax,(%r9,%rbx,8)
  404f5b:	e9 29 fc ff ff       	jmpq   404b89 <fc_solve_sfs_move_cards_to_a_different_parent+0x479>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  404f60:	89 d0                	mov    %edx,%eax
  404f62:	48 63 d6             	movslq %esi,%rdx
  404f65:	89 c6                	mov    %eax,%esi
  404f67:	e9 05 ff ff ff       	jmpq   404e71 <fc_solve_sfs_move_cards_to_a_different_parent+0x761>
  404f6c:	0f 1f 40 00          	nopl   0x0(%rax)
  404f70:	83 c6 02             	add    $0x2,%esi
  404f73:	e9 f9 fe ff ff       	jmpq   404e71 <fc_solve_sfs_move_cards_to_a_different_parent+0x761>
  404f78:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  404f7f:	00 
    allocator->ptr = allocator->rollback_ptr;
  404f80:	48 8b 83 f0 00 00 00 	mov    0xf0(%rbx),%rax
  404f87:	48 89 83 e8 00 00 00 	mov    %rax,0xe8(%rbx)
  404f8e:	e9 ff f9 ff ff       	jmpq   404992 <fc_solve_sfs_move_cards_to_a_different_parent+0x282>
  404f93:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  404f9a:	00 00 00 00 
  404f9e:	66 90                	xchg   %ax,%ax
  404fa0:	83 c6 03             	add    $0x3,%esi
  404fa3:	e9 c9 fe ff ff       	jmpq   404e71 <fc_solve_sfs_move_cards_to_a_different_parent+0x761>
  404fa8:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  404faf:	00 
  404fb0:	4f 8d 1c d1          	lea    (%r9,%r10,8),%r11
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  404fb4:	bf 01 00 00 00       	mov    $0x1,%edi
  404fb9:	d3 e7                	shl    %cl,%edi
  404fbb:	c1 e1 07             	shl    $0x7,%ecx
  404fbe:	09 f8                	or     %edi,%eax
  404fc0:	89 46 14             	mov    %eax,0x14(%rsi)
  404fc3:	49 8b 33             	mov    (%r11),%rsi
  404fc6:	48 63 c1             	movslq %ecx,%rax
  404fc9:	48 03 44 24 30       	add    0x30(%rsp),%rax
  404fce:	0f be 0e             	movsbl (%rsi),%ecx
  404fd1:	83 c1 01             	add    $0x1,%ecx
  404fd4:	48 63 c9             	movslq %ecx,%rcx
  404fd7:	48 83 f9 08          	cmp    $0x8,%rcx
  404fdb:	0f 83 c4 00 00 00    	jae    4050a5 <fc_solve_sfs_move_cards_to_a_different_parent+0x995>
  404fe1:	f6 c1 04             	test   $0x4,%cl
  404fe4:	0f 85 a5 01 00 00    	jne    40518f <fc_solve_sfs_move_cards_to_a_different_parent+0xa7f>
  404fea:	48 85 c9             	test   %rcx,%rcx
  404fed:	74 0f                	je     404ffe <fc_solve_sfs_move_cards_to_a_different_parent+0x8ee>
  404fef:	0f b6 3e             	movzbl (%rsi),%edi
  404ff2:	40 88 38             	mov    %dil,(%rax)
  404ff5:	f6 c1 02             	test   $0x2,%cl
  404ff8:	0f 85 b9 01 00 00    	jne    4051b7 <fc_solve_sfs_move_cards_to_a_different_parent+0xaa7>
  404ffe:	49 89 03             	mov    %rax,(%r11)
  405001:	e9 30 fd ff ff       	jmpq   404d36 <fc_solve_sfs_move_cards_to_a_different_parent+0x626>
  405006:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  40500d:	00 00 00 
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  405010:	be 04 00 00 00       	mov    $0x4,%esi
  405015:	ba 03 00 00 00       	mov    $0x3,%edx
  40501a:	e9 52 fe ff ff       	jmpq   404e71 <fc_solve_sfs_move_cards_to_a_different_parent+0x761>
  40501f:	90                   	nop
    for (int ret = start_from; ret < local_stacks_num; ret++)
  405020:	31 d2                	xor    %edx,%edx
    return -1;
  405022:	b9 ff ff ff ff       	mov    $0xffffffff,%ecx
  405027:	e9 f3 fc ff ff       	jmpq   404d1f <fc_solve_sfs_move_cards_to_a_different_parent+0x60f>
  40502c:	0f 1f 40 00          	nopl   0x0(%rax)
    char *const new_data = meta_request_new_buffer(allocator->meta);
  405030:	49 8b 8e f8 00 00 00 	mov    0xf8(%r14),%rcx
    char *const ret = meta_alloc->recycle_bin;
  405037:	48 8b 01             	mov    (%rcx),%rax
    if (ret)
  40503a:	48 85 c0             	test   %rax,%rax
  40503d:	0f 84 b4 00 00 00    	je     4050f7 <fc_solve_sfs_move_cards_to_a_different_parent+0x9e7>
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  405043:	48 8b 30             	mov    (%rax),%rsi
  405046:	48 89 31             	mov    %rsi,(%rcx)
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  405049:	49 8b 8e d8 00 00 00 	mov    0xd8(%r14),%rcx
  405050:	48 89 08             	mov    %rcx,(%rax)
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  405053:	48 8d 48 08          	lea    0x8(%rax),%rcx
    allocator->old_list = new_data;
  405057:	49 89 86 d8 00 00 00 	mov    %rax,0xd8(%r14)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40505e:	48 05 80 fe 00 00    	add    $0xfe80,%rax
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  405064:	49 89 8e f0 00 00 00 	mov    %rcx,0xf0(%r14)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40506b:	49 89 86 e0 00 00 00 	mov    %rax,0xe0(%r14)
  405072:	e9 1e fa ff ff       	jmpq   404a95 <fc_solve_sfs_move_cards_to_a_different_parent+0x385>
  405077:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40507e:	00 00 
                copy_two_stacks(stack_idx, ds);
  405080:	48 8b 7c 0e f8       	mov    -0x8(%rsi,%rcx,1),%rdi
  405085:	48 89 7c 08 f8       	mov    %rdi,-0x8(%rax,%rcx,1)
  40508a:	48 83 e9 01          	sub    $0x1,%rcx
  40508e:	48 89 c7             	mov    %rax,%rdi
  405091:	48 c1 e9 03          	shr    $0x3,%rcx
  405095:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  405098:	4c 8b 8c 24 a0 00 00 	mov    0xa0(%rsp),%r9
  40509f:	00 
  4050a0:	e9 b2 fe ff ff       	jmpq   404f57 <fc_solve_sfs_move_cards_to_a_different_parent+0x847>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  4050a5:	48 8b 7c 0e f8       	mov    -0x8(%rsi,%rcx,1),%rdi
  4050aa:	48 89 7c 08 f8       	mov    %rdi,-0x8(%rax,%rcx,1)
  4050af:	48 83 e9 01          	sub    $0x1,%rcx
  4050b3:	48 89 c7             	mov    %rax,%rdi
  4050b6:	48 c1 e9 03          	shr    $0x3,%rcx
  4050ba:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  4050bd:	e9 3c ff ff ff       	jmpq   404ffe <fc_solve_sfs_move_cards_to_a_different_parent+0x8ee>
        min_card_height += 2;
  4050c2:	83 c7 02             	add    $0x2,%edi
        for (int c = min_card_height; c < cards_num; c++)
  4050c5:	39 7c 24 58          	cmp    %edi,0x58(%rsp)
  4050c9:	0f 8f 50 f7 ff ff    	jg     40481f <fc_solve_sfs_move_cards_to_a_different_parent+0x10f>
  4050cf:	e9 fc fc ff ff       	jmpq   404dd0 <fc_solve_sfs_move_cards_to_a_different_parent+0x6c0>
                copy_two_stacks(stack_idx, ds);
  4050d4:	8b 3e                	mov    (%rsi),%edi
  4050d6:	4c 8b 4c 24 48       	mov    0x48(%rsp),%r9
  4050db:	41 89 39             	mov    %edi,(%r9)
  4050de:	8b 74 0e fc          	mov    -0x4(%rsi,%rcx,1),%esi
  4050e2:	41 89 74 09 fc       	mov    %esi,-0x4(%r9,%rcx,1)
  4050e7:	e9 77 fa ff ff       	jmpq   404b63 <fc_solve_sfs_move_cards_to_a_different_parent+0x453>
        if (fcs_state_col_is_empty(state, ret))
  4050ec:	89 c8                	mov    %ecx,%eax
  4050ee:	89 d1                	mov    %edx,%ecx
  4050f0:	89 c2                	mov    %eax,%edx
  4050f2:	e9 28 fc ff ff       	jmpq   404d1f <fc_solve_sfs_move_cards_to_a_different_parent+0x60f>
        return malloc(ALLOCED_SIZE);
  4050f7:	bf 80 fe 00 00       	mov    $0xfe80,%edi
  4050fc:	89 94 24 8c 00 00 00 	mov    %edx,0x8c(%rsp)
  405103:	44 89 44 24 40       	mov    %r8d,0x40(%rsp)
  405108:	44 89 54 24 38       	mov    %r10d,0x38(%rsp)
  40510d:	88 5c 24 30          	mov    %bl,0x30(%rsp)
  405111:	e8 da bf ff ff       	callq  4010f0 <malloc@plt>
  405116:	8b 94 24 8c 00 00 00 	mov    0x8c(%rsp),%edx
  40511d:	44 8b 44 24 40       	mov    0x40(%rsp),%r8d
  405122:	4c 63 54 24 38       	movslq 0x38(%rsp),%r10
  405127:	44 0f b6 5c 24 30    	movzbl 0x30(%rsp),%r11d
  40512d:	e9 17 ff ff ff       	jmpq   405049 <fc_solve_sfs_move_cards_to_a_different_parent+0x939>
  405132:	83 c2 02             	add    $0x2,%edx
  405135:	e9 e5 fb ff ff       	jmpq   404d1f <fc_solve_sfs_move_cards_to_a_different_parent+0x60f>
  40513a:	83 c2 03             	add    $0x3,%edx
  40513d:	e9 dd fb ff ff       	jmpq   404d1f <fc_solve_sfs_move_cards_to_a_different_parent+0x60f>
  405142:	83 c2 04             	add    $0x4,%edx
  405145:	e9 d5 fb ff ff       	jmpq   404d1f <fc_solve_sfs_move_cards_to_a_different_parent+0x60f>
  40514a:	83 c2 05             	add    $0x5,%edx
  40514d:	e9 cd fb ff ff       	jmpq   404d1f <fc_solve_sfs_move_cards_to_a_different_parent+0x60f>
                copy_two_stacks(stack_idx, ds);
  405152:	0f b7 74 0e fe       	movzwl -0x2(%rsi,%rcx,1),%esi
  405157:	48 8b 7c 24 48       	mov    0x48(%rsp),%rdi
  40515c:	66 89 74 0f fe       	mov    %si,-0x2(%rdi,%rcx,1)
  405161:	e9 fd f9 ff ff       	jmpq   404b63 <fc_solve_sfs_move_cards_to_a_different_parent+0x453>
  405166:	83 c2 06             	add    $0x6,%edx
  405169:	e9 b1 fb ff ff       	jmpq   404d1f <fc_solve_sfs_move_cards_to_a_different_parent+0x60f>
  40516e:	8b 3e                	mov    (%rsi),%edi
  405170:	89 38                	mov    %edi,(%rax)
  405172:	8b 74 0e fc          	mov    -0x4(%rsi,%rcx,1),%esi
  405176:	89 74 08 fc          	mov    %esi,-0x4(%rax,%rcx,1)
  40517a:	4c 8b 8c 24 a0 00 00 	mov    0xa0(%rsp),%r9
  405181:	00 
  405182:	e9 d0 fd ff ff       	jmpq   404f57 <fc_solve_sfs_move_cards_to_a_different_parent+0x847>
  405187:	83 c2 07             	add    $0x7,%edx
  40518a:	e9 90 fb ff ff       	jmpq   404d1f <fc_solve_sfs_move_cards_to_a_different_parent+0x60f>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  40518f:	8b 3e                	mov    (%rsi),%edi
  405191:	89 38                	mov    %edi,(%rax)
  405193:	8b 74 0e fc          	mov    -0x4(%rsi,%rcx,1),%esi
  405197:	89 74 08 fc          	mov    %esi,-0x4(%rax,%rcx,1)
  40519b:	e9 5e fe ff ff       	jmpq   404ffe <fc_solve_sfs_move_cards_to_a_different_parent+0x8ee>
                copy_two_stacks(stack_idx, ds);
  4051a0:	0f b7 74 0e fe       	movzwl -0x2(%rsi,%rcx,1),%esi
  4051a5:	66 89 74 08 fe       	mov    %si,-0x2(%rax,%rcx,1)
  4051aa:	4c 8b 8c 24 a0 00 00 	mov    0xa0(%rsp),%r9
  4051b1:	00 
  4051b2:	e9 a0 fd ff ff       	jmpq   404f57 <fc_solve_sfs_move_cards_to_a_different_parent+0x847>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  4051b7:	0f b7 74 0e fe       	movzwl -0x2(%rsi,%rcx,1),%esi
  4051bc:	66 89 74 08 fe       	mov    %si,-0x2(%rax,%rcx,1)
  4051c1:	e9 38 fe ff ff       	jmpq   404ffe <fc_solve_sfs_move_cards_to_a_different_parent+0x8ee>
  4051c6:	44 89 84 24 b0 00 00 	mov    %r8d,0xb0(%rsp)
  4051cd:	00 
  4051ce:	e9 6b fa ff ff       	jmpq   404c3e <fc_solve_sfs_move_cards_to_a_different_parent+0x52e>
  4051d3:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4051da:	00 00 00 00 
  4051de:	66 90                	xchg   %ax,%ax

00000000004051e0 <fc_solve_sfs_move_fc_to_empty_and_put_on_top>:
    const fcs_game_limit num_vacant_stacks = soft_thread->num_vacant_stacks;
  4051e0:	0f b6 87 e3 01 00 00 	movzbl 0x1e3(%rdi),%eax
    if (!num_vacant_stacks)
  4051e7:	84 c0                	test   %al,%al
  4051e9:	0f 84 a5 02 00 00    	je     405494 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x2b4>
{
  4051ef:	41 57                	push   %r15
  4051f1:	49 89 c9             	mov    %rcx,%r9
  4051f4:	41 56                	push   %r14
  4051f6:	41 55                	push   %r13
  4051f8:	41 54                	push   %r12
  4051fa:	55                   	push   %rbp
  4051fb:	53                   	push   %rbx
  4051fc:	48 81 ec b8 00 00 00 	sub    $0xb8,%rsp
    SET_empty_stack_idx(empty_stack_idx);
  405203:	48 8b 0e             	mov    (%rsi),%rcx
  405206:	80 39 00             	cmpb   $0x0,(%rcx)
  405209:	0f 84 6c 0b 00 00    	je     405d7b <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb9b>
  40520f:	48 8b 4e 08          	mov    0x8(%rsi),%rcx
  405213:	80 39 00             	cmpb   $0x0,(%rcx)
  405216:	0f 84 25 09 00 00    	je     405b41 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x961>
  40521c:	48 8b 4e 10          	mov    0x10(%rsi),%rcx
  405220:	80 39 00             	cmpb   $0x0,(%rcx)
  405223:	0f 84 45 0b 00 00    	je     405d6e <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb8e>
  405229:	48 8b 4e 18          	mov    0x18(%rsi),%rcx
  40522d:	80 39 00             	cmpb   $0x0,(%rcx)
  405230:	0f 84 a3 0b 00 00    	je     405dd9 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xbf9>
  405236:	48 8b 4e 20          	mov    0x20(%rsi),%rcx
  40523a:	80 39 00             	cmpb   $0x0,(%rcx)
  40523d:	0f 84 89 0b 00 00    	je     405dcc <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xbec>
  405243:	48 8b 4e 28          	mov    0x28(%rsi),%rcx
  405247:	80 39 00             	cmpb   $0x0,(%rcx)
  40524a:	0f 84 6f 0b 00 00    	je     405dbf <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xbdf>
  405250:	48 8b 4e 30          	mov    0x30(%rsi),%rcx
  405254:	80 39 00             	cmpb   $0x0,(%rcx)
  405257:	0f 84 55 0b 00 00    	je     405db2 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xbd2>
  40525d:	48 8b 4e 38          	mov    0x38(%rsi),%rcx
  405261:	c7 44 24 3c 00 01 00 	movl   $0x100,0x3c(%rsp)
  405268:	00 
  405269:	41 b8 00 04 00 00    	mov    $0x400,%r8d
  40526f:	c7 44 24 1c 08 00 00 	movl   $0x8,0x1c(%rsp)
  405276:	00 
  405277:	80 39 00             	cmpb   $0x0,(%rcx)
  40527a:	0f 84 e1 0a 00 00    	je     405d61 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb81>
  405280:	48 89 34 24          	mov    %rsi,(%rsp)
  405284:	48 89 fe             	mov    %rdi,%rsi
    const fcs_game_limit num_virtual_vacant_stacks = num_vacant_stacks - 1;
  405287:	83 e8 01             	sub    $0x1,%eax
  40528a:	48 89 7c 24 68       	mov    %rdi,0x68(%rsp)
    MOVE_FUNCS__define_common();
  40528f:	48 8b 3f             	mov    (%rdi),%rdi
    const fcs_game_limit num_virtual_vacant_freecells =
  405292:	0f b6 b6 e4 01 00 00 	movzbl 0x1e4(%rsi),%esi
    const fcs_game_limit num_virtual_vacant_stacks = num_vacant_stacks - 1;
  405299:	88 44 24 1b          	mov    %al,0x1b(%rsp)
            my_copy_stack(empty_stack_idx);
  40529d:	48 c7 44 24 10 03 00 	movq   $0x3,0x10(%rsp)
  4052a4:	00 00 
  4052a6:	48 8b 44 24 10       	mov    0x10(%rsp),%rax
  4052ab:	4c 89 4c 24 30       	mov    %r9,0x30(%rsp)
    MOVE_FUNCS__define_common();
  4052b0:	48 89 7c 24 50       	mov    %rdi,0x50(%rsp)
  4052b5:	48 81 c7 00 01 00 00 	add    $0x100,%rdi
    const fcs_game_limit num_virtual_vacant_freecells =
  4052bc:	40 88 74 24 08       	mov    %sil,0x8(%rsp)
            my_copy_stack(empty_stack_idx);
  4052c1:	49 01 f8             	add    %rdi,%r8
    const fcs_game_limit num_virtual_vacant_freecells =
  4052c4:	83 c6 01             	add    $0x1,%esi
  4052c7:	48 89 54 24 58       	mov    %rdx,0x58(%rsp)
    MOVE_FUNCS__define_common();
  4052cc:	48 89 7c 24 60       	mov    %rdi,0x60(%rsp)
    const fcs_game_limit num_virtual_vacant_freecells =
  4052d1:	40 88 74 24 1a       	mov    %sil,0x1a(%rsp)
            my_copy_stack(empty_stack_idx);
  4052d6:	4c 89 44 24 20       	mov    %r8,0x20(%rsp)
        const fcs_card src_card = fcs_freecell_card(state, fc);
  4052db:	4c 8b 34 24          	mov    (%rsp),%r14
  4052df:	41 89 c4             	mov    %eax,%r12d
  4052e2:	89 44 24 38          	mov    %eax,0x38(%rsp)
  4052e6:	41 0f b6 44 06 40    	movzbl 0x40(%r14,%rax,1),%eax
  4052ec:	88 44 24 19          	mov    %al,0x19(%rsp)
        if (SHOULD_SKIP_FC_CARD(src_card))
  4052f0:	84 c0                	test   %al,%al
  4052f2:	0f 84 75 01 00 00    	je     40546d <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x28d>
    return fc_solve_is_parent_buf[(size_t)parent][(size_t)child];
  4052f8:	4c 0f be e8          	movsbq %al,%r13
  4052fc:	31 db                	xor    %ebx,%ebx
  4052fe:	49 c1 e5 06          	shl    $0x6,%r13
  405302:	49 81 c5 c0 fe 40 00 	add    $0x40fec0,%r13
  405309:	41 89 df             	mov    %ebx,%r15d
            if (dest_fc == fc)
  40530c:	41 39 dc             	cmp    %ebx,%r12d
  40530f:	74 1b                	je     40532c <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x14c>
            const fcs_card dest_card = fcs_freecell_card(state, dest_fc);
  405311:	41 0f b6 6c 1e 40    	movzbl 0x40(%r14,%rbx,1),%ebp
            if (fcs_card_is_empty(dest_card))
  405317:	40 84 ed             	test   %bpl,%bpl
  40531a:	74 10                	je     40532c <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x14c>
  40531c:	48 0f be c5          	movsbq %bpl,%rax
            if (!unlikely(fcs_is_parent_card(dest_card, src_card)))
  405320:	41 80 7c 05 00 00    	cmpb   $0x0,0x0(%r13,%rax,1)
  405326:	0f 85 81 05 00 00    	jne    4058ad <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x6cd>
  40532c:	48 83 c3 01          	add    $0x1,%rbx
        for (int dest_fc = 0; dest_fc < LOCAL_FREECELLS_NUM; ++dest_fc)
  405330:	48 83 fb 04          	cmp    $0x4,%rbx
  405334:	75 d3                	jne    405309 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x129>
  405336:	4c 8b 44 24 60       	mov    0x60(%rsp),%r8
  40533b:	45 31 db             	xor    %r11d,%r11d
  40533e:	4d 89 c2             	mov    %r8,%r10
  405341:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  405348:	00 00 00 00 
  40534c:	0f 1f 40 00          	nopl   0x0(%rax)
    ret.col = fcs_state_get_col(*s, stack_idx);
  405350:	48 8b 04 24          	mov    (%rsp),%rax
  405354:	44 89 5c 24 08       	mov    %r11d,0x8(%rsp)
  405359:	4a 8b 1c d8          	mov    (%rax,%r11,8),%rbx
    ret.col_len_minus_1 = (ret.col_len = fcs_col_len(ret.col)) - 1;
  40535d:	4c 0f be 33          	movsbq (%rbx),%r14
  405361:	4d 8d 7e ff          	lea    -0x1(%r14),%r15
    for ((*iter).seq_end = (*iter).c; (*iter).seq_end < (*iter).col_len_minus_1;
  405365:	4d 85 ff             	test   %r15,%r15
  405368:	0f 8e 38 05 00 00    	jle    4058a6 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x6c6>
  40536e:	48 0f be 43 01       	movsbq 0x1(%rbx),%rax
  405373:	48 0f be 53 02       	movsbq 0x2(%rbx),%rdx
  405378:	48 c1 e0 06          	shl    $0x6,%rax
        if (!fcs_is_parent_card(fcs_col_get_card(col, (*iter).seq_end + 1),
  40537c:	80 bc 02 c0 fe 40 00 	cmpb   $0x0,0x40fec0(%rdx,%rax,1)
  405383:	00 
  405384:	0f 84 1c 05 00 00    	je     4058a6 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x6c6>
  40538a:	b8 01 00 00 00       	mov    $0x1,%eax
  40538f:	eb 2d                	jmp    4053be <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x1de>
  405391:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  405398:	00 00 00 00 
  40539c:	0f 1f 40 00          	nopl   0x0(%rax)
  4053a0:	48 0f be 54 03 01    	movsbq 0x1(%rbx,%rax,1),%rdx
  4053a6:	48 0f be 4c 03 02    	movsbq 0x2(%rbx,%rax,1),%rcx
  4053ac:	48 83 c0 01          	add    $0x1,%rax
  4053b0:	48 c1 e2 06          	shl    $0x6,%rdx
  4053b4:	80 bc 11 c0 fe 40 00 	cmpb   $0x0,0x40fec0(%rcx,%rdx,1)
  4053bb:	00 
  4053bc:	74 08                	je     4053c6 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x1e6>
         ++((*iter).seq_end))
  4053be:	48 89 c5             	mov    %rax,%rbp
    for ((*iter).seq_end = (*iter).c; (*iter).seq_end < (*iter).col_len_minus_1;
  4053c1:	49 39 c7             	cmp    %rax,%r15
  4053c4:	75 da                	jne    4053a0 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x1c0>
  4053c6:	0f b6 4c 24 08       	movzbl 0x8(%rsp),%ecx
  4053cb:	b8 01 00 00 00       	mov    $0x1,%eax
    return ret;
  4053d0:	31 ff                	xor    %edi,%edi
  4053d2:	d3 e0                	shl    %cl,%eax
  4053d4:	89 44 24 0c          	mov    %eax,0xc(%rsp)
  4053d8:	48 0f be 44 24 19    	movsbq 0x19(%rsp),%rax
  4053de:	48 c1 e0 06          	shl    $0x6,%rax
  4053e2:	4c 8d a8 c0 fe 40 00 	lea    0x40fec0(%rax),%r13
            for (; iter.c < iter.col_len; col_seqs_iter__advance(&iter))
  4053e9:	49 39 fe             	cmp    %rdi,%r14
  4053ec:	7e 6d                	jle    40545b <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x27b>
  4053ee:	48 0f be 44 3b 01    	movsbq 0x1(%rbx,%rdi,1),%rax
                if (!unlikely(fcs_is_parent_card(card, src_card)))
  4053f4:	41 80 7c 05 00 00    	cmpb   $0x0,0x0(%r13,%rax,1)
  4053fa:	0f 85 b0 00 00 00    	jne    4054b0 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x2d0>
    iter->c = iter->seq_end + 1;
  405400:	48 8d 7d 01          	lea    0x1(%rbp),%rdi
    for ((*iter).seq_end = (*iter).c; (*iter).seq_end < (*iter).col_len_minus_1;
  405404:	49 39 ff             	cmp    %rdi,%r15
  405407:	0f 8e 93 00 00 00    	jle    4054a0 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x2c0>
  40540d:	48 0f be 44 3b 01    	movsbq 0x1(%rbx,%rdi,1),%rax
  405413:	48 0f be 54 3b 02    	movsbq 0x2(%rbx,%rdi,1),%rdx
  405419:	48 c1 e0 06          	shl    $0x6,%rax
        if (!fcs_is_parent_card(fcs_col_get_card(col, (*iter).seq_end + 1),
  40541d:	80 bc 02 c0 fe 40 00 	cmpb   $0x0,0x40fec0(%rdx,%rax,1)
  405424:	00 
  405425:	74 79                	je     4054a0 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x2c0>
  405427:	48 8d 45 02          	lea    0x2(%rbp),%rax
  40542b:	49 8d 76 ff          	lea    -0x1(%r14),%rsi
  40542f:	90                   	nop
         ++((*iter).seq_end))
  405430:	48 89 c5             	mov    %rax,%rbp
    for ((*iter).seq_end = (*iter).c; (*iter).seq_end < (*iter).col_len_minus_1;
  405433:	48 39 f0             	cmp    %rsi,%rax
  405436:	74 b1                	je     4053e9 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x209>
  405438:	48 0f be 54 03 01    	movsbq 0x1(%rbx,%rax,1),%rdx
  40543e:	48 0f be 4c 03 02    	movsbq 0x2(%rbx,%rax,1),%rcx
  405444:	48 83 c0 01          	add    $0x1,%rax
  405448:	48 c1 e2 06          	shl    $0x6,%rdx
        if (!fcs_is_parent_card(fcs_col_get_card(col, (*iter).seq_end + 1),
  40544c:	80 bc 11 c0 fe 40 00 	cmpb   $0x0,0x40fec0(%rcx,%rdx,1)
  405453:	00 
  405454:	75 da                	jne    405430 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x250>
            for (; iter.c < iter.col_len; col_seqs_iter__advance(&iter))
  405456:	49 39 fe             	cmp    %rdi,%r14
  405459:	7f 93                	jg     4053ee <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x20e>
  40545b:	49 83 c3 01          	add    $0x1,%r11
  40545f:	49 83 ea 80          	sub    $0xffffffffffffff80,%r10
        for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; ++stack_idx)
  405463:	49 83 fb 08          	cmp    $0x8,%r11
  405467:	0f 85 e3 fe ff ff    	jne    405350 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x170>
  40546d:	48 83 6c 24 10 01    	subq   $0x1,0x10(%rsp)
  405473:	48 8b 44 24 10       	mov    0x10(%rsp),%rax
    for (int fc = LOCAL_FREECELLS_NUM - 1; fc >= 0; --fc)
  405478:	48 83 f8 ff          	cmp    $0xffffffffffffffff,%rax
  40547c:	0f 85 59 fe ff ff    	jne    4052db <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xfb>
}
  405482:	48 81 c4 b8 00 00 00 	add    $0xb8,%rsp
  405489:	5b                   	pop    %rbx
  40548a:	5d                   	pop    %rbp
  40548b:	41 5c                	pop    %r12
  40548d:	41 5d                	pop    %r13
  40548f:	41 5e                	pop    %r14
  405491:	41 5f                	pop    %r15
  405493:	c3                   	retq   
  405494:	c3                   	retq   
  405495:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40549c:	00 00 00 00 
        if (!fcs_is_parent_card(fcs_col_get_card(col, (*iter).seq_end + 1),
  4054a0:	48 89 fd             	mov    %rdi,%rbp
  4054a3:	e9 41 ff ff ff       	jmpq   4053e9 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x209>
  4054a8:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  4054af:	00 
    const fcs_game_limit freecells_to_fill =
  4054b0:	0f b6 44 24 1a       	movzbl 0x1a(%rsp),%eax
                const int col_num_cards = iter.col_len_minus_1 - iter.seq_end;
  4054b5:	45 89 fc             	mov    %r15d,%r12d
  4054b8:	41 29 ec             	sub    %ebp,%r12d
    return ((num_cards_to_relocate == 0) &&
  4054bb:	0f b6 74 24 1b       	movzbl 0x1b(%rsp),%esi
    num_cards_to_relocate -= freecells_to_fill;
  4054c0:	44 89 e2             	mov    %r12d,%edx
    const fcs_game_limit freecells_to_fill =
  4054c3:	41 38 c4             	cmp    %al,%r12b
  4054c6:	89 c1                	mov    %eax,%ecx
  4054c8:	41 0f 46 cc          	cmovbe %r12d,%ecx
    num_cards_to_relocate -= freecells_to_fill;
  4054cc:	29 ca                	sub    %ecx,%edx
    return ((num_cards_to_relocate == 0) &&
  4054ce:	40 38 d6             	cmp    %dl,%sil
  4054d1:	0f 82 29 ff ff ff    	jb     405400 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x220>
            (calc_max_sequence_move(
  4054d7:	0f b6 c9             	movzbl %cl,%ecx
                iter->seq_end - iter->c + 1));
  4054da:	49 89 e8             	mov    %rbp,%r8
            (calc_max_sequence_move(
  4054dd:	29 c8                	sub    %ecx,%eax
                iter->seq_end - iter->c + 1));
  4054df:	49 29 f8             	sub    %rdi,%r8
            (calc_max_sequence_move(
  4054e2:	83 c0 01             	add    $0x1,%eax
    const fcs_game_limit freestacks_to_fill =
  4054e5:	40 38 d6             	cmp    %dl,%sil
                iter->seq_end - iter->c + 1));
  4054e8:	4c 89 44 24 28       	mov    %r8,0x28(%rsp)
    const fcs_game_limit freestacks_to_fill =
  4054ed:	0f 46 d6             	cmovbe %esi,%edx
            (calc_max_sequence_move(
  4054f0:	29 d6                	sub    %edx,%esi
  4054f2:	89 f1                	mov    %esi,%ecx
  4054f4:	d3 e0                	shl    %cl,%eax
  4054f6:	48 98                	cltq   
    return ((num_cards_to_relocate == 0) &&
  4054f8:	49 39 c0             	cmp    %rax,%r8
  4054fb:	0f 8d ff fe ff ff    	jge    405400 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x220>
                sfs_check_state_begin();
  405501:	48 8b 4c 24 58       	mov    0x58(%rsp),%rcx
  405506:	48 8d b4 24 90 00 00 	lea    0x90(%rsp),%rsi
  40550d:	00 
  40550e:	4c 89 5c 24 48       	mov    %r11,0x48(%rsp)
  405513:	48 8b 14 24          	mov    (%rsp),%rdx
  405517:	4c 89 54 24 40       	mov    %r10,0x40(%rsp)
  40551c:	48 8b 7c 24 50       	mov    0x50(%rsp),%rdi
  405521:	e8 da c3 ff ff       	callq  401900 <fc_solve_sfs_check_state_begin>
                copy_two_stacks(stack_idx, empty_stack_idx);
  405526:	48 8b 84 24 98 00 00 	mov    0x98(%rsp),%rax
  40552d:	00 
  40552e:	4c 8b 54 24 40       	mov    0x40(%rsp),%r10
  405533:	4c 8b 5c 24 48       	mov    0x48(%rsp),%r11
  405538:	8b 48 14             	mov    0x14(%rax),%ecx
  40553b:	85 4c 24 0c          	test   %ecx,0xc(%rsp)
  40553f:	0f 84 9f 06 00 00    	je     405be4 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xa04>
  405545:	48 8b 94 24 90 00 00 	mov    0x90(%rsp),%rdx
  40554c:	00 
  40554d:	48 63 74 24 1c       	movslq 0x1c(%rsp),%rsi
  405552:	48 89 74 24 40       	mov    %rsi,0x40(%rsp)
  405557:	48 8b 34 f2          	mov    (%rdx,%rsi,8),%rsi
  40555b:	85 4c 24 3c          	test   %ecx,0x3c(%rsp)
  40555f:	0f 84 29 06 00 00    	je     405b8e <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x9ae>
    fcs_col_push_card(col, card);
  405565:	48 0f be 16          	movsbq (%rsi),%rdx
                const int col_num_cards = iter.col_len_minus_1 - iter.seq_end;
  405569:	44 89 e0             	mov    %r12d,%eax
                const int cols_indexes[3] = {stack_idx, -1, -1};
  40556c:	48 c7 84 24 88 00 00 	movq   $0xffffffffffffffff,0x88(%rsp)
  405573:	00 ff ff ff ff 
        int dest_fc_idx = 0;
  405578:	45 31 c0             	xor    %r8d,%r8d
  40557b:	0f b6 7c 24 19       	movzbl 0x19(%rsp),%edi
                const int cols_indexes[3] = {stack_idx, -1, -1};
  405580:	4c 63 64 24 08       	movslq 0x8(%rsp),%r12
  405585:	8d 4a 01             	lea    0x1(%rdx),%ecx
  405588:	88 0e                	mov    %cl,(%rsi)
                fcs_empty_freecell(new_state_key, fc);
  40558a:	48 63 4c 24 38       	movslq 0x38(%rsp),%rcx
  40558f:	40 88 7c 16 01       	mov    %dil,0x1(%rsi,%rdx,1)
  405594:	48 8b 7c 24 68       	mov    0x68(%rsp),%rdi
  405599:	48 8b 94 24 90 00 00 	mov    0x90(%rsp),%rdx
  4055a0:	00 
                const int cols_indexes[3] = {stack_idx, -1, -1};
  4055a1:	44 89 a4 24 84 00 00 	mov    %r12d,0x84(%rsp)
  4055a8:	00 
                fcs_empty_freecell(new_state_key, fc);
  4055a9:	c6 44 0a 40 00       	movb   $0x0,0x40(%rdx,%rcx,1)
  4055ae:	48 8b 3f             	mov    (%rdi),%rdi
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  4055b1:	89 c1                	mov    %eax,%ecx
  4055b3:	89 84 24 a0 00 00 00 	mov    %eax,0xa0(%rsp)
  4055ba:	48 89 7c 24 48       	mov    %rdi,0x48(%rsp)
  4055bf:	48 bf 00 00 00 00 ff 	movabs $0xffffffff00000000,%rdi
  4055c6:	ff ff ff 
  4055c9:	48 89 bc 24 a4 00 00 	mov    %rdi,0xa4(%rsp)
  4055d0:	00 
  4055d1:	31 ff                	xor    %edi,%edi
  4055d3:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4055da:	00 00 00 00 
  4055de:	66 90                	xchg   %ax,%ax
            while ((*col_num_cards) == 0)
  4055e0:	85 c0                	test   %eax,%eax
  4055e2:	0f 85 dc 00 00 00    	jne    4056c4 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x4e4>
  4055e8:	48 8b b4 24 90 00 00 	mov    0x90(%rsp),%rsi
  4055ef:	00 
  4055f0:	4a 8b 14 de          	mov    (%rsi,%r11,8),%rdx
  4055f4:	4c 89 54 24 78       	mov    %r10,0x78(%rsp)
  4055f9:	48 8b 44 24 40       	mov    0x40(%rsp),%rax
  4055fe:	4c 89 5c 24 70       	mov    %r11,0x70(%rsp)
                fcs_move_sequence(
  405603:	4c 8b 64 24 28       	mov    0x28(%rsp),%r12
  405608:	48 8b 0c c6          	mov    (%rsi,%rax,8),%rcx
        &fcs_col_get_card(src_col, (fcs_col_len(src_col) -= cards_num));
  40560c:	0f b6 02             	movzbl (%rdx),%eax
  40560f:	49 83 c4 01          	add    $0x1,%r12
    const size_t cards_size = (((size_t)cards_num) * sizeof(fcs_card));
  405613:	4d 63 cc             	movslq %r12d,%r9
    memcpy(&fcs_col_get_card(dest_col, fcs_col_len(dest_col)), src_cards_ptr,
  405616:	4c 89 4c 24 40       	mov    %r9,0x40(%rsp)
  40561b:	48 89 4c 24 48       	mov    %rcx,0x48(%rsp)
        &fcs_col_get_card(src_col, (fcs_col_len(src_col) -= cards_num));
  405620:	44 29 e0             	sub    %r12d,%eax
  405623:	88 02                	mov    %al,(%rdx)
  405625:	48 0f be c0          	movsbq %al,%rax
    fcs_card *const src_cards_ptr =
  405629:	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,
  40562e:	48 0f be 01          	movsbq (%rcx),%rax
  405632:	4c 89 ca             	mov    %r9,%rdx
  405635:	4c 89 c6             	mov    %r8,%rsi
  405638:	4c 89 44 24 28       	mov    %r8,0x28(%rsp)
  40563d:	48 8d 7c 01 01       	lea    0x1(%rcx,%rax,1),%rdi
  405642:	e8 99 ba ff ff       	callq  4010e0 <memcpy@plt>
    fcs_col_len(dest_col) += cards_num;
  405647:	48 8b 4c 24 48       	mov    0x48(%rsp),%rcx
    memset(src_cards_ptr, 0, cards_size);
  40564c:	31 f6                	xor    %esi,%esi
  40564e:	4c 8b 4c 24 40       	mov    0x40(%rsp),%r9
  405653:	4c 8b 44 24 28       	mov    0x28(%rsp),%r8
    fcs_col_len(dest_col) += cards_num;
  405658:	44 00 21             	add    %r12b,(%rcx)
    memset(src_cards_ptr, 0, cards_size);
  40565b:	4c 89 ca             	mov    %r9,%rdx
  40565e:	4c 89 c7             	mov    %r8,%rdi
  405661:	e8 3a ba ff ff       	callq  4010a0 <memset@plt>
    const_SLOT(hard_thread, soft_thread);
  405666:	48 8b 44 24 68       	mov    0x68(%rsp),%rax
    if (!fc_solve_check_and_add_state(
  40566b:	48 8d 94 24 a0 00 00 	lea    0xa0(%rsp),%rdx
  405672:	00 
  405673:	48 8d b4 24 90 00 00 	lea    0x90(%rsp),%rsi
  40567a:	00 
    const_SLOT(hard_thread, soft_thread);
  40567b:	4c 8b 20             	mov    (%rax),%r12
    if (!fc_solve_check_and_add_state(
  40567e:	4c 89 e7             	mov    %r12,%rdi
  405681:	e8 ca c3 ff ff       	callq  401a50 <fc_solve_check_and_add_state>
  405686:	4c 8b 5c 24 70       	mov    0x70(%rsp),%r11
  40568b:	84 c0                	test   %al,%al
  40568d:	4c 8b 54 24 78       	mov    0x78(%rsp),%r10
  405692:	0f 85 58 03 00 00    	jne    4059f0 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x810>
        if (HT_FIELD(hard_thread, allocated_from_list))
  405698:	41 80 bc 24 18 05 00 	cmpb   $0x0,0x518(%r12)
  40569f:	00 00 
  4056a1:	0f 85 10 04 00 00    	jne    405ab7 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x8d7>
  4056a7:	49 8b 84 24 f0 00 00 	mov    0xf0(%r12),%rax
  4056ae:	00 
  4056af:	49 89 84 24 e8 00 00 	mov    %rax,0xe8(%r12)
  4056b6:	00 
  4056b7:	4c 8b a4 24 a0 00 00 	mov    0xa0(%rsp),%r12
  4056be:	00 
  4056bf:	e9 34 03 00 00       	jmpq   4059f8 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x818>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  4056c4:	41 83 f8 03          	cmp    $0x3,%r8d
  4056c8:	0f 8f 9c 03 00 00    	jg     405a6a <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x88a>
  4056ce:	41 8d 70 01          	lea    0x1(%r8),%esi
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  4056d2:	4d 63 c8             	movslq %r8d,%r9
  4056d5:	42 80 7c 0a 40 00    	cmpb   $0x0,0x40(%rdx,%r9,1)
  4056db:	0f 84 a0 04 00 00    	je     405b81 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x9a1>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  4056e1:	83 fe 04             	cmp    $0x4,%esi
  4056e4:	74 3c                	je     405722 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x542>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  4056e6:	48 63 f6             	movslq %esi,%rsi
  4056e9:	80 7c 32 40 00       	cmpb   $0x0,0x40(%rdx,%rsi,1)
  4056ee:	0f 84 54 05 00 00    	je     405c48 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xa68>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  4056f4:	41 8d 70 02          	lea    0x2(%r8),%esi
  4056f8:	83 fe 04             	cmp    $0x4,%esi
  4056fb:	74 25                	je     405722 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x542>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  4056fd:	48 63 f6             	movslq %esi,%rsi
  405700:	80 7c 32 40 00       	cmpb   $0x0,0x40(%rdx,%rsi,1)
  405705:	0f 84 46 05 00 00    	je     405c51 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xa71>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  40570b:	41 8d 70 03          	lea    0x3(%r8),%esi
  40570f:	83 fe 03             	cmp    $0x3,%esi
  405712:	0f 85 55 03 00 00    	jne    405a6d <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x88d>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  405718:	80 7a 43 00          	cmpb   $0x0,0x43(%rdx)
  40571c:	0f 84 38 05 00 00    	je     405c5a <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xa7a>
  405722:	40 84 ff             	test   %dil,%dil
  405725:	0f 85 c4 06 00 00    	jne    405def <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xc0f>
    char *const indirect_stacks_buffer =
  40572b:	48 8b 7c 24 48       	mov    0x48(%rsp),%rdi
    int put_cards_in_col_idx = 0;
  405730:	45 31 e4             	xor    %r12d,%r12d
  405733:	48 89 5c 24 70       	mov    %rbx,0x70(%rsp)
  405738:	48 8b b4 24 90 00 00 	mov    0x90(%rsp),%rsi
  40573f:	00 
    char *const indirect_stacks_buffer =
  405740:	48 81 c7 00 01 00 00 	add    $0x100,%rdi
  405747:	48 89 7c 24 48       	mov    %rdi,0x48(%rsp)
  40574c:	49 63 cc             	movslq %r12d,%rcx
  40574f:	48 8d 3c ce          	lea    (%rsi,%rcx,8),%rdi
        if (fcs_state_col_is_empty(state, ret))
  405753:	4c 8b 07             	mov    (%rdi),%r8
  405756:	41 8d 4c 24 01       	lea    0x1(%r12),%ecx
  40575b:	41 80 38 00          	cmpb   $0x0,(%r8)
  40575f:	0f 84 e6 05 00 00    	je     405d4b <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb6b>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  405765:	83 f9 08             	cmp    $0x8,%ecx
  405768:	0f 84 d0 05 00 00    	je     405d3e <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb5e>
        if (fcs_state_col_is_empty(state, ret))
  40576e:	4c 8b 47 08          	mov    0x8(%rdi),%r8
  405772:	41 80 38 00          	cmpb   $0x0,(%r8)
  405776:	0f 84 dc 05 00 00    	je     405d58 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb78>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  40577c:	41 8d 4c 24 02       	lea    0x2(%r12),%ecx
  405781:	83 f9 08             	cmp    $0x8,%ecx
  405784:	0f 84 b4 05 00 00    	je     405d3e <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb5e>
        if (fcs_state_col_is_empty(state, ret))
  40578a:	4c 8b 47 10          	mov    0x10(%rdi),%r8
  40578e:	41 80 38 00          	cmpb   $0x0,(%r8)
  405792:	0f 84 4e 06 00 00    	je     405de6 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xc06>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  405798:	41 8d 4c 24 03       	lea    0x3(%r12),%ecx
  40579d:	83 f9 07             	cmp    $0x7,%ecx
  4057a0:	0f 8f 98 05 00 00    	jg     405d3e <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb5e>
        if (fcs_state_col_is_empty(state, ret))
  4057a6:	4c 8b 47 18          	mov    0x18(%rdi),%r8
  4057aa:	41 80 38 00          	cmpb   $0x0,(%r8)
  4057ae:	0f 84 3c 07 00 00    	je     405ef0 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xd10>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4057b4:	41 8d 4c 24 04       	lea    0x4(%r12),%ecx
  4057b9:	83 f9 07             	cmp    $0x7,%ecx
  4057bc:	0f 8f 7c 05 00 00    	jg     405d3e <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb5e>
        if (fcs_state_col_is_empty(state, ret))
  4057c2:	4c 8b 47 20          	mov    0x20(%rdi),%r8
  4057c6:	41 80 38 00          	cmpb   $0x0,(%r8)
  4057ca:	0f 84 17 07 00 00    	je     405ee7 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xd07>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4057d0:	41 8d 4c 24 05       	lea    0x5(%r12),%ecx
  4057d5:	83 f9 07             	cmp    $0x7,%ecx
  4057d8:	0f 8f 60 05 00 00    	jg     405d3e <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb5e>
        if (fcs_state_col_is_empty(state, ret))
  4057de:	4c 8b 47 28          	mov    0x28(%rdi),%r8
  4057e2:	41 80 38 00          	cmpb   $0x0,(%r8)
  4057e6:	0f 84 f2 06 00 00    	je     405ede <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xcfe>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4057ec:	41 8d 4c 24 06       	lea    0x6(%r12),%ecx
  4057f1:	83 f9 07             	cmp    $0x7,%ecx
  4057f4:	0f 8f 44 05 00 00    	jg     405d3e <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb5e>
        if (fcs_state_col_is_empty(state, ret))
  4057fa:	48 8b 7f 30          	mov    0x30(%rdi),%rdi
  4057fe:	80 3f 00             	cmpb   $0x0,(%rdi)
  405801:	0f 84 ce 06 00 00    	je     405ed5 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xcf5>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  405807:	45 85 e4             	test   %r12d,%r12d
  40580a:	0f 85 2e 05 00 00    	jne    405d3e <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb5e>
        if (fcs_state_col_is_empty(state, ret))
  405810:	48 8b 4e 38          	mov    0x38(%rsi),%rcx
  405814:	be 08 00 00 00       	mov    $0x8,%esi
  405819:	80 39 00             	cmpb   $0x0,(%rcx)
  40581c:	44 0f 44 e6          	cmove  %esi,%r12d
  405820:	80 39 01             	cmpb   $0x1,(%rcx)
  405823:	19 c9                	sbb    %ecx,%ecx
  405825:	83 e1 08             	and    $0x8,%ecx
  405828:	83 e9 01             	sub    $0x1,%ecx
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  40582b:	48 8b bc 24 98 00 00 	mov    0x98(%rsp),%rdi
  405832:	00 
  405833:	4c 63 c9             	movslq %ecx,%r9
  405836:	44 8b 47 14          	mov    0x14(%rdi),%r8d
  40583a:	41 0f a3 c8          	bt     %ecx,%r8d
  40583e:	0f 83 7a 04 00 00    	jae    405cbe <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xade>
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  405844:	48 63 8c 24 84 00 00 	movslq 0x84(%rsp),%rcx
  40584b:	00 
        --(*col_num_cards);
  40584c:	83 e8 01             	sub    $0x1,%eax
  40584f:	48 8b 3c ca          	mov    (%rdx,%rcx,8),%rdi
    fcs_col_pop_card(col, ret);
  405853:	0f be 37             	movsbl (%rdi),%esi
  405856:	89 f1                	mov    %esi,%ecx
  405858:	83 ee 01             	sub    $0x1,%esi
  40585b:	83 e9 01             	sub    $0x1,%ecx
  40585e:	48 63 f6             	movslq %esi,%rsi
  405861:	0f b6 74 37 01       	movzbl 0x1(%rdi,%rsi,1),%esi
  405866:	88 0f                	mov    %cl,(%rdi)
  405868:	48 0f be c9          	movsbq %cl,%rcx
  40586c:	c6 44 0f 01 00       	movb   $0x0,0x1(%rdi,%rcx,1)
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  405871:	4a 8b 3c ca          	mov    (%rdx,%r9,8),%rdi
    fcs_col_push_card(col, card);
  405875:	48 0f be 0f          	movsbq (%rdi),%rcx
  405879:	44 8d 41 01          	lea    0x1(%rcx),%r8d
  40587d:	44 88 07             	mov    %r8b,(%rdi)
  405880:	40 88 74 0f 01       	mov    %sil,0x1(%rdi,%rcx,1)
  405885:	48 8b b4 24 90 00 00 	mov    0x90(%rsp),%rsi
  40588c:	00 
  40588d:	89 84 24 a0 00 00 00 	mov    %eax,0xa0(%rsp)
        while ((*col_num_cards) == 0)
  405894:	85 c0                	test   %eax,%eax
  405896:	0f 85 ce 02 00 00    	jne    405b6a <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x98a>
  40589c:	48 8b 5c 24 70       	mov    0x70(%rsp),%rbx
  4058a1:	e9 4a fd ff ff       	jmpq   4055f0 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x410>
    for ((*iter).seq_end = (*iter).c; (*iter).seq_end < (*iter).col_len_minus_1;
  4058a6:	31 ed                	xor    %ebp,%ebp
  4058a8:	e9 19 fb ff ff       	jmpq   4053c6 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x1e6>
            sfs_check_state_begin();
  4058ad:	48 8b 4c 24 58       	mov    0x58(%rsp),%rcx
  4058b2:	4c 89 f2             	mov    %r14,%rdx
  4058b5:	48 8b 7c 24 50       	mov    0x50(%rsp),%rdi
  4058ba:	48 8d b4 24 90 00 00 	lea    0x90(%rsp),%rsi
  4058c1:	00 
  4058c2:	e8 39 c0 ff ff       	callq  401900 <fc_solve_sfs_check_state_begin>
            my_copy_stack(empty_stack_idx);
  4058c7:	48 8b 94 24 98 00 00 	mov    0x98(%rsp),%rdx
  4058ce:	00 
  4058cf:	8b 42 14             	mov    0x14(%rdx),%eax
  4058d2:	85 44 24 3c          	test   %eax,0x3c(%rsp)
  4058d6:	0f 84 03 02 00 00    	je     405adf <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x8ff>
  4058dc:	48 63 54 24 1c       	movslq 0x1c(%rsp),%rdx
  4058e1:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  4058e8:	00 
  4058e9:	48 8b 0c d0          	mov    (%rax,%rdx,8),%rcx
  4058ed:	48 0f be 01          	movsbq (%rcx),%rax
            fcs_empty_freecell(new_state_key, dest_fc);
  4058f1:	4d 63 c7             	movslq %r15d,%r8
  4058f4:	8d 70 01             	lea    0x1(%rax),%esi
  4058f7:	40 88 31             	mov    %sil,(%rcx)
  4058fa:	0f b6 74 24 19       	movzbl 0x19(%rsp),%esi
  4058ff:	40 88 74 01 01       	mov    %sil,0x1(%rcx,%rax,1)
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  405904:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  40590b:	00 
    if (!fc_solve_check_and_add_state(
  40590c:	48 8d b4 24 90 00 00 	lea    0x90(%rsp),%rsi
  405913:	00 
  405914:	48 8b 14 d0          	mov    (%rax,%rdx,8),%rdx
    fcs_col_push_card(col, card);
  405918:	48 0f be 02          	movsbq (%rdx),%rax
  40591c:	8d 48 01             	lea    0x1(%rax),%ecx
  40591f:	88 0a                	mov    %cl,(%rdx)
  405921:	40 88 6c 02 01       	mov    %bpl,0x1(%rdx,%rax,1)
            fcs_empty_freecell(new_state_key, fc);
  405926:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  40592d:	00 
  40592e:	49 63 d4             	movslq %r12d,%rdx
  405931:	c6 44 10 40 00       	movb   $0x0,0x40(%rax,%rdx,1)
  405936:	48 8d 94 24 a0 00 00 	lea    0xa0(%rsp),%rdx
  40593d:	00 
            fcs_empty_freecell(new_state_key, dest_fc);
  40593e:	42 c6 44 00 40 00    	movb   $0x0,0x40(%rax,%r8,1)
    const_SLOT(hard_thread, soft_thread);
  405944:	48 8b 44 24 68       	mov    0x68(%rsp),%rax
  405949:	48 8b 28             	mov    (%rax),%rbp
    if (!fc_solve_check_and_add_state(
  40594c:	48 89 ef             	mov    %rbp,%rdi
  40594f:	e8 fc c0 ff ff       	callq  401a50 <fc_solve_check_and_add_state>
  405954:	84 c0                	test   %al,%al
  405956:	0f 85 55 03 00 00    	jne    405cb1 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xad1>
        if (HT_FIELD(hard_thread, allocated_from_list))
  40595c:	80 bd 18 05 00 00 00 	cmpb   $0x0,0x518(%rbp)
  405963:	0f 84 c2 03 00 00    	je     405d2b <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb4b>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  405969:	48 8b 95 b0 00 00 00 	mov    0xb0(%rbp),%rdx
  405970:	48 8b 84 24 98 00 00 	mov    0x98(%rsp),%rax
  405977:	00 
  405978:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  40597b:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  405982:	00 
  405983:	48 89 85 b0 00 00 00 	mov    %rax,0xb0(%rbp)
  40598a:	48 8b ac 24 a0 00 00 	mov    0xa0(%rsp),%rbp
  405991:	00 
    if ((!((list->num_states + (list->states != NULL)) &
  405992:	48 8b 44 24 30       	mov    0x30(%rsp),%rax
  405997:	31 d2                	xor    %edx,%edx
  405999:	48 8b 08             	mov    (%rax),%rcx
  40599c:	48 8b 40 08          	mov    0x8(%rax),%rax
  4059a0:	48 85 c0             	test   %rax,%rax
  4059a3:	0f 95 c2             	setne  %dl
  4059a6:	48 01 ca             	add    %rcx,%rdx
  4059a9:	f6 c2 0f             	test   $0xf,%dl
  4059ac:	75 1f                	jne    4059cd <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x7ed>
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  4059ae:	48 83 c2 10          	add    $0x10,%rdx
  4059b2:	48 89 c7             	mov    %rax,%rdi
  4059b5:	48 89 d6             	mov    %rdx,%rsi
  4059b8:	48 c1 e6 04          	shl    $0x4,%rsi
  4059bc:	e8 af b7 ff ff       	callq  401170 <realloc@plt>
        list->states =
  4059c1:	48 8b 74 24 30       	mov    0x30(%rsp),%rsi
  4059c6:	48 8b 0e             	mov    (%rsi),%rcx
  4059c9:	48 89 46 08          	mov    %rax,0x8(%rsi)
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  4059cd:	48 8b 74 24 30       	mov    0x30(%rsp),%rsi
  4059d2:	48 8d 51 01          	lea    0x1(%rcx),%rdx
  4059d6:	48 c1 e1 04          	shl    $0x4,%rcx
  4059da:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  4059de:	48 01 c8             	add    %rcx,%rax
  4059e1:	48 89 16             	mov    %rdx,(%rsi)
  4059e4:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  4059e8:	48 89 28             	mov    %rbp,(%rax)
  4059eb:	e9 3c f9 ff ff       	jmpq   40532c <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x14c>
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  4059f0:	4c 8b a4 24 90 00 00 	mov    0x90(%rsp),%r12
  4059f7:	00 
    if ((!((list->num_states + (list->states != NULL)) &
  4059f8:	48 8b 44 24 30       	mov    0x30(%rsp),%rax
  4059fd:	31 d2                	xor    %edx,%edx
  4059ff:	48 8b 08             	mov    (%rax),%rcx
  405a02:	48 8b 40 08          	mov    0x8(%rax),%rax
  405a06:	48 85 c0             	test   %rax,%rax
  405a09:	0f 95 c2             	setne  %dl
  405a0c:	48 01 ca             	add    %rcx,%rdx
  405a0f:	f6 c2 0f             	test   $0xf,%dl
  405a12:	75 33                	jne    405a47 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x867>
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  405a14:	48 83 c2 10          	add    $0x10,%rdx
  405a18:	48 89 c7             	mov    %rax,%rdi
  405a1b:	4c 89 5c 24 40       	mov    %r11,0x40(%rsp)
  405a20:	48 89 d6             	mov    %rdx,%rsi
  405a23:	4c 89 54 24 28       	mov    %r10,0x28(%rsp)
  405a28:	48 c1 e6 04          	shl    $0x4,%rsi
  405a2c:	e8 3f b7 ff ff       	callq  401170 <realloc@plt>
        list->states =
  405a31:	48 8b 74 24 30       	mov    0x30(%rsp),%rsi
  405a36:	4c 8b 5c 24 40       	mov    0x40(%rsp),%r11
  405a3b:	4c 8b 54 24 28       	mov    0x28(%rsp),%r10
  405a40:	48 8b 0e             	mov    (%rsi),%rcx
  405a43:	48 89 46 08          	mov    %rax,0x8(%rsi)
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  405a47:	48 8b 74 24 30       	mov    0x30(%rsp),%rsi
  405a4c:	48 8d 51 01          	lea    0x1(%rcx),%rdx
  405a50:	48 c1 e1 04          	shl    $0x4,%rcx
  405a54:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  405a58:	48 01 c8             	add    %rcx,%rax
  405a5b:	48 89 16             	mov    %rdx,(%rsi)
  405a5e:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  405a62:	4c 89 20             	mov    %r12,(%rax)
  405a65:	e9 96 f9 ff ff       	jmpq   405400 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x220>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  405a6a:	44 89 c6             	mov    %r8d,%esi
            if (dest_fc_idx == LOCAL_FREECELLS_NUM)
  405a6d:	83 fe 04             	cmp    $0x4,%esi
  405a70:	0f 84 ac fc ff ff    	je     405722 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x542>
  405a76:	44 8d 46 01          	lea    0x1(%rsi),%r8d
  405a7a:	48 63 f6             	movslq %esi,%rsi
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  405a7d:	4a 8b 3c e2          	mov    (%rdx,%r12,8),%rdi
            --(*col_num_cards);
  405a81:	83 e8 01             	sub    $0x1,%eax
    fcs_col_pop_card(col, ret);
  405a84:	44 0f be 0f          	movsbl (%rdi),%r9d
  405a88:	44 89 c9             	mov    %r9d,%ecx
  405a8b:	41 83 e9 01          	sub    $0x1,%r9d
  405a8f:	4d 63 c9             	movslq %r9d,%r9
  405a92:	83 e9 01             	sub    $0x1,%ecx
  405a95:	46 0f b6 4c 0f 01    	movzbl 0x1(%rdi,%r9,1),%r9d
  405a9b:	88 0f                	mov    %cl,(%rdi)
  405a9d:	48 0f be c9          	movsbq %cl,%rcx
  405aa1:	c6 44 0f 01 00       	movb   $0x0,0x1(%rdi,%rcx,1)
  405aa6:	bf 01 00 00 00       	mov    $0x1,%edi
  405aab:	89 c1                	mov    %eax,%ecx
            fcs_put_card_in_freecell(*new_key, dest_fc_idx, top_card);
  405aad:	44 88 4c 32 40       	mov    %r9b,0x40(%rdx,%rsi,1)
  405ab2:	e9 29 fb ff ff       	jmpq   4055e0 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x400>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  405ab7:	49 8b 94 24 b0 00 00 	mov    0xb0(%r12),%rdx
  405abe:	00 
  405abf:	48 8b 84 24 98 00 00 	mov    0x98(%rsp),%rax
  405ac6:	00 
  405ac7:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  405aca:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  405ad1:	00 
  405ad2:	49 89 84 24 b0 00 00 	mov    %rax,0xb0(%r12)
  405ad9:	00 
  405ada:	e9 d8 fb ff ff       	jmpq   4056b7 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x4d7>
            my_copy_stack(empty_stack_idx);
  405adf:	0b 44 24 3c          	or     0x3c(%rsp),%eax
  405ae3:	48 8b 8c 24 90 00 00 	mov    0x90(%rsp),%rcx
  405aea:	00 
  405aeb:	89 42 14             	mov    %eax,0x14(%rdx)
  405aee:	48 63 54 24 1c       	movslq 0x1c(%rsp),%rdx
  405af3:	48 8b 34 d1          	mov    (%rcx,%rdx,8),%rsi
  405af7:	0f be 06             	movsbl (%rsi),%eax
  405afa:	83 c0 01             	add    $0x1,%eax
  405afd:	48 98                	cltq   
  405aff:	48 83 f8 08          	cmp    $0x8,%rax
  405b03:	0f 83 7f 02 00 00    	jae    405d88 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xba8>
  405b09:	a8 04                	test   $0x4,%al
  405b0b:	0f 85 a6 03 00 00    	jne    405eb7 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xcd7>
  405b11:	48 85 c0             	test   %rax,%rax
  405b14:	74 1a                	je     405b30 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x950>
  405b16:	0f b6 0e             	movzbl (%rsi),%ecx
  405b19:	48 8b 7c 24 20       	mov    0x20(%rsp),%rdi
  405b1e:	88 0f                	mov    %cl,(%rdi)
  405b20:	48 8b 8c 24 90 00 00 	mov    0x90(%rsp),%rcx
  405b27:	00 
  405b28:	a8 02                	test   $0x2,%al
  405b2a:	0f 85 6b 03 00 00    	jne    405e9b <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xcbb>
  405b30:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  405b35:	48 89 04 d1          	mov    %rax,(%rcx,%rdx,8)
  405b39:	48 89 c1             	mov    %rax,%rcx
  405b3c:	e9 ac fd ff ff       	jmpq   4058ed <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x70d>
    SET_empty_stack_idx(empty_stack_idx);
  405b41:	c7 44 24 1c 01 00 00 	movl   $0x1,0x1c(%rsp)
  405b48:	00 
  405b49:	8b 4c 24 1c          	mov    0x1c(%rsp),%ecx
  405b4d:	41 ba 01 00 00 00    	mov    $0x1,%r10d
  405b53:	41 89 c8             	mov    %ecx,%r8d
  405b56:	41 d3 e2             	shl    %cl,%r10d
  405b59:	41 c1 e0 07          	shl    $0x7,%r8d
  405b5d:	44 89 54 24 3c       	mov    %r10d,0x3c(%rsp)
  405b62:	4d 63 c0             	movslq %r8d,%r8
  405b65:	e9 16 f7 ff ff       	jmpq   405280 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xa0>
    return -1;
  405b6a:	b9 ff ff ff ff       	mov    $0xffffffff,%ecx
    for (int ret = start_from; ret < local_stacks_num; ret++)
  405b6f:	41 83 fc 08          	cmp    $0x8,%r12d
  405b73:	0f 85 d3 fb ff ff    	jne    40574c <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x56c>
  405b79:	45 31 e4             	xor    %r12d,%r12d
  405b7c:	e9 aa fc ff ff       	jmpq   40582b <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x64b>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  405b81:	89 f1                	mov    %esi,%ecx
  405b83:	49 63 f0             	movslq %r8d,%rsi
  405b86:	41 89 c8             	mov    %ecx,%r8d
  405b89:	e9 ef fe ff ff       	jmpq   405a7d <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x89d>
                copy_two_stacks(stack_idx, empty_stack_idx);
  405b8e:	0b 4c 24 3c          	or     0x3c(%rsp),%ecx
  405b92:	89 48 14             	mov    %ecx,0x14(%rax)
  405b95:	0f be 06             	movsbl (%rsi),%eax
  405b98:	83 c0 01             	add    $0x1,%eax
  405b9b:	48 98                	cltq   
  405b9d:	48 83 f8 08          	cmp    $0x8,%rax
  405ba1:	0f 83 c3 00 00 00    	jae    405c6a <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xa8a>
  405ba7:	a8 04                	test   $0x4,%al
  405ba9:	0f 85 ce 02 00 00    	jne    405e7d <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xc9d>
  405baf:	48 85 c0             	test   %rax,%rax
  405bb2:	74 1a                	je     405bce <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x9ee>
  405bb4:	0f b6 16             	movzbl (%rsi),%edx
  405bb7:	48 8b 7c 24 20       	mov    0x20(%rsp),%rdi
  405bbc:	88 17                	mov    %dl,(%rdi)
  405bbe:	48 8b 94 24 90 00 00 	mov    0x90(%rsp),%rdx
  405bc5:	00 
  405bc6:	a8 02                	test   $0x2,%al
  405bc8:	0f 85 93 02 00 00    	jne    405e61 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xc81>
  405bce:	48 8b 74 24 40       	mov    0x40(%rsp),%rsi
  405bd3:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  405bd8:	48 89 04 f2          	mov    %rax,(%rdx,%rsi,8)
  405bdc:	48 89 c6             	mov    %rax,%rsi
  405bdf:	e9 81 f9 ff ff       	jmpq   405565 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x385>
  405be4:	48 8b 94 24 90 00 00 	mov    0x90(%rsp),%rdx
  405beb:	00 
  405bec:	4c 63 44 24 08       	movslq 0x8(%rsp),%r8
  405bf1:	0b 4c 24 0c          	or     0xc(%rsp),%ecx
  405bf5:	4a 8b 34 c2          	mov    (%rdx,%r8,8),%rsi
  405bf9:	89 48 14             	mov    %ecx,0x14(%rax)
  405bfc:	0f be 0e             	movsbl (%rsi),%ecx
  405bff:	83 c1 01             	add    $0x1,%ecx
  405c02:	48 63 c9             	movslq %ecx,%rcx
  405c05:	48 83 f9 08          	cmp    $0x8,%rcx
  405c09:	0f 83 85 00 00 00    	jae    405c94 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xab4>
  405c0f:	f6 c1 04             	test   $0x4,%cl
  405c12:	0f 85 26 02 00 00    	jne    405e3e <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xc5e>
  405c18:	48 85 c9             	test   %rcx,%rcx
  405c1b:	74 1f                	je     405c3c <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xa5c>
  405c1d:	0f b6 06             	movzbl (%rsi),%eax
  405c20:	41 88 02             	mov    %al,(%r10)
  405c23:	f6 c1 02             	test   $0x2,%cl
  405c26:	0f 85 f2 01 00 00    	jne    405e1e <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xc3e>
  405c2c:	48 8b 84 24 98 00 00 	mov    0x98(%rsp),%rax
  405c33:	00 
  405c34:	48 8b 94 24 90 00 00 	mov    0x90(%rsp),%rdx
  405c3b:	00 
  405c3c:	4e 89 14 c2          	mov    %r10,(%rdx,%r8,8)
  405c40:	8b 48 14             	mov    0x14(%rax),%ecx
  405c43:	e9 05 f9 ff ff       	jmpq   40554d <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x36d>
  405c48:	41 83 c0 02          	add    $0x2,%r8d
  405c4c:	e9 2c fe ff ff       	jmpq   405a7d <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x89d>
  405c51:	41 83 c0 03          	add    $0x3,%r8d
  405c55:	e9 23 fe ff ff       	jmpq   405a7d <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x89d>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  405c5a:	41 b8 04 00 00 00    	mov    $0x4,%r8d
  405c60:	be 03 00 00 00       	mov    $0x3,%esi
  405c65:	e9 13 fe ff ff       	jmpq   405a7d <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x89d>
                copy_two_stacks(stack_idx, empty_stack_idx);
  405c6a:	48 8b 54 06 f8       	mov    -0x8(%rsi,%rax,1),%rdx
  405c6f:	48 8b 7c 24 20       	mov    0x20(%rsp),%rdi
  405c74:	48 89 54 07 f8       	mov    %rdx,-0x8(%rdi,%rax,1)
  405c79:	48 83 e8 01          	sub    $0x1,%rax
  405c7d:	48 c1 e8 03          	shr    $0x3,%rax
  405c81:	48 89 c1             	mov    %rax,%rcx
  405c84:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  405c87:	48 8b 94 24 90 00 00 	mov    0x90(%rsp),%rdx
  405c8e:	00 
  405c8f:	e9 3a ff ff ff       	jmpq   405bce <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x9ee>
  405c94:	48 8b 44 0e f8       	mov    -0x8(%rsi,%rcx,1),%rax
  405c99:	4c 89 d7             	mov    %r10,%rdi
  405c9c:	49 89 44 0a f8       	mov    %rax,-0x8(%r10,%rcx,1)
  405ca1:	48 83 e9 01          	sub    $0x1,%rcx
  405ca5:	48 c1 e9 03          	shr    $0x3,%rcx
  405ca9:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  405cac:	e9 7b ff ff ff       	jmpq   405c2c <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xa4c>
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  405cb1:	48 8b ac 24 90 00 00 	mov    0x90(%rsp),%rbp
  405cb8:	00 
  405cb9:	e9 d4 fc ff ff       	jmpq   405992 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x7b2>
  405cbe:	4a 8d 1c ca          	lea    (%rdx,%r9,8),%rbx
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  405cc2:	be 01 00 00 00       	mov    $0x1,%esi
  405cc7:	d3 e6                	shl    %cl,%esi
  405cc9:	c1 e1 07             	shl    $0x7,%ecx
  405ccc:	44 09 c6             	or     %r8d,%esi
  405ccf:	4c 63 c1             	movslq %ecx,%r8
  405cd2:	4c 03 44 24 48       	add    0x48(%rsp),%r8
  405cd7:	89 77 14             	mov    %esi,0x14(%rdi)
  405cda:	48 8b 33             	mov    (%rbx),%rsi
  405cdd:	0f be 0e             	movsbl (%rsi),%ecx
  405ce0:	83 c1 01             	add    $0x1,%ecx
  405ce3:	48 63 c9             	movslq %ecx,%rcx
  405ce6:	48 83 f9 08          	cmp    $0x8,%rcx
  405cea:	73 25                	jae    405d11 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb31>
  405cec:	f6 c1 04             	test   $0x4,%cl
  405cef:	0f 85 16 01 00 00    	jne    405e0b <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xc2b>
  405cf5:	48 85 c9             	test   %rcx,%rcx
  405cf8:	74 0f                	je     405d09 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb29>
  405cfa:	0f b6 3e             	movzbl (%rsi),%edi
  405cfd:	41 88 38             	mov    %dil,(%r8)
  405d00:	f6 c1 02             	test   $0x2,%cl
  405d03:	0f 85 f2 00 00 00    	jne    405dfb <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xc1b>
  405d09:	4c 89 03             	mov    %r8,(%rbx)
  405d0c:	e9 33 fb ff ff       	jmpq   405844 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x664>
  405d11:	48 8b 7c 0e f8       	mov    -0x8(%rsi,%rcx,1),%rdi
  405d16:	49 89 7c 08 f8       	mov    %rdi,-0x8(%r8,%rcx,1)
  405d1b:	48 83 e9 01          	sub    $0x1,%rcx
  405d1f:	4c 89 c7             	mov    %r8,%rdi
  405d22:	48 c1 e9 03          	shr    $0x3,%rcx
  405d26:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  405d29:	eb de                	jmp    405d09 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb29>
  405d2b:	48 8b 85 f0 00 00 00 	mov    0xf0(%rbp),%rax
  405d32:	48 89 85 e8 00 00 00 	mov    %rax,0xe8(%rbp)
  405d39:	e9 4c fc ff ff       	jmpq   40598a <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x7aa>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  405d3e:	45 31 e4             	xor    %r12d,%r12d
    return -1;
  405d41:	b9 ff ff ff ff       	mov    $0xffffffff,%ecx
  405d46:	e9 e0 fa ff ff       	jmpq   40582b <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x64b>
        if (fcs_state_col_is_empty(state, ret))
  405d4b:	89 ce                	mov    %ecx,%esi
  405d4d:	44 89 e1             	mov    %r12d,%ecx
  405d50:	41 89 f4             	mov    %esi,%r12d
  405d53:	e9 d3 fa ff ff       	jmpq   40582b <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x64b>
  405d58:	41 83 c4 02          	add    $0x2,%r12d
  405d5c:	e9 ca fa ff ff       	jmpq   40582b <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x64b>
    SET_empty_stack_idx(empty_stack_idx);
  405d61:	c7 44 24 1c 07 00 00 	movl   $0x7,0x1c(%rsp)
  405d68:	00 
  405d69:	e9 db fd ff ff       	jmpq   405b49 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x969>
  405d6e:	c7 44 24 1c 02 00 00 	movl   $0x2,0x1c(%rsp)
  405d75:	00 
  405d76:	e9 ce fd ff ff       	jmpq   405b49 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x969>
  405d7b:	c7 44 24 1c 00 00 00 	movl   $0x0,0x1c(%rsp)
  405d82:	00 
  405d83:	e9 c1 fd ff ff       	jmpq   405b49 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x969>
            my_copy_stack(empty_stack_idx);
  405d88:	48 8b 4c 06 f8       	mov    -0x8(%rsi,%rax,1),%rcx
  405d8d:	48 8b 7c 24 20       	mov    0x20(%rsp),%rdi
  405d92:	48 89 4c 07 f8       	mov    %rcx,-0x8(%rdi,%rax,1)
  405d97:	48 83 e8 01          	sub    $0x1,%rax
  405d9b:	48 c1 e8 03          	shr    $0x3,%rax
  405d9f:	48 89 c1             	mov    %rax,%rcx
  405da2:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  405da5:	48 8b 8c 24 90 00 00 	mov    0x90(%rsp),%rcx
  405dac:	00 
  405dad:	e9 7e fd ff ff       	jmpq   405b30 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x950>
    SET_empty_stack_idx(empty_stack_idx);
  405db2:	c7 44 24 1c 06 00 00 	movl   $0x6,0x1c(%rsp)
  405db9:	00 
  405dba:	e9 8a fd ff ff       	jmpq   405b49 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x969>
  405dbf:	c7 44 24 1c 05 00 00 	movl   $0x5,0x1c(%rsp)
  405dc6:	00 
  405dc7:	e9 7d fd ff ff       	jmpq   405b49 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x969>
  405dcc:	c7 44 24 1c 04 00 00 	movl   $0x4,0x1c(%rsp)
  405dd3:	00 
  405dd4:	e9 70 fd ff ff       	jmpq   405b49 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x969>
  405dd9:	c7 44 24 1c 03 00 00 	movl   $0x3,0x1c(%rsp)
  405de0:	00 
  405de1:	e9 63 fd ff ff       	jmpq   405b49 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x969>
  405de6:	41 83 c4 03          	add    $0x3,%r12d
  405dea:	e9 3c fa ff ff       	jmpq   40582b <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x64b>
  405def:	89 8c 24 a0 00 00 00 	mov    %ecx,0xa0(%rsp)
  405df6:	e9 30 f9 ff ff       	jmpq   40572b <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x54b>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  405dfb:	0f b7 74 0e fe       	movzwl -0x2(%rsi,%rcx,1),%esi
  405e00:	66 41 89 74 08 fe    	mov    %si,-0x2(%r8,%rcx,1)
  405e06:	e9 fe fe ff ff       	jmpq   405d09 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb29>
  405e0b:	8b 3e                	mov    (%rsi),%edi
  405e0d:	41 89 38             	mov    %edi,(%r8)
  405e10:	8b 74 0e fc          	mov    -0x4(%rsi,%rcx,1),%esi
  405e14:	41 89 74 08 fc       	mov    %esi,-0x4(%r8,%rcx,1)
  405e19:	e9 eb fe ff ff       	jmpq   405d09 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xb29>
                copy_two_stacks(stack_idx, empty_stack_idx);
  405e1e:	0f b7 44 0e fe       	movzwl -0x2(%rsi,%rcx,1),%eax
  405e23:	66 41 89 44 0a fe    	mov    %ax,-0x2(%r10,%rcx,1)
  405e29:	48 8b 84 24 98 00 00 	mov    0x98(%rsp),%rax
  405e30:	00 
  405e31:	48 8b 94 24 90 00 00 	mov    0x90(%rsp),%rdx
  405e38:	00 
  405e39:	e9 fe fd ff ff       	jmpq   405c3c <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xa5c>
  405e3e:	8b 06                	mov    (%rsi),%eax
  405e40:	41 89 02             	mov    %eax,(%r10)
  405e43:	8b 44 0e fc          	mov    -0x4(%rsi,%rcx,1),%eax
  405e47:	41 89 44 0a fc       	mov    %eax,-0x4(%r10,%rcx,1)
  405e4c:	48 8b 84 24 98 00 00 	mov    0x98(%rsp),%rax
  405e53:	00 
  405e54:	48 8b 94 24 90 00 00 	mov    0x90(%rsp),%rdx
  405e5b:	00 
  405e5c:	e9 db fd ff ff       	jmpq   405c3c <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0xa5c>
  405e61:	0f b7 54 06 fe       	movzwl -0x2(%rsi,%rax,1),%edx
  405e66:	48 8b 74 24 20       	mov    0x20(%rsp),%rsi
  405e6b:	66 89 54 06 fe       	mov    %dx,-0x2(%rsi,%rax,1)
  405e70:	48 8b 94 24 90 00 00 	mov    0x90(%rsp),%rdx
  405e77:	00 
  405e78:	e9 51 fd ff ff       	jmpq   405bce <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x9ee>
  405e7d:	8b 16                	mov    (%rsi),%edx
  405e7f:	48 8b 7c 24 20       	mov    0x20(%rsp),%rdi
  405e84:	89 17                	mov    %edx,(%rdi)
  405e86:	8b 54 06 fc          	mov    -0x4(%rsi,%rax,1),%edx
  405e8a:	89 54 07 fc          	mov    %edx,-0x4(%rdi,%rax,1)
  405e8e:	48 8b 94 24 90 00 00 	mov    0x90(%rsp),%rdx
  405e95:	00 
  405e96:	e9 33 fd ff ff       	jmpq   405bce <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x9ee>
            my_copy_stack(empty_stack_idx);
  405e9b:	0f b7 4c 06 fe       	movzwl -0x2(%rsi,%rax,1),%ecx
  405ea0:	48 8b 74 24 20       	mov    0x20(%rsp),%rsi
  405ea5:	66 89 4c 06 fe       	mov    %cx,-0x2(%rsi,%rax,1)
  405eaa:	48 8b 8c 24 90 00 00 	mov    0x90(%rsp),%rcx
  405eb1:	00 
  405eb2:	e9 79 fc ff ff       	jmpq   405b30 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x950>
  405eb7:	8b 0e                	mov    (%rsi),%ecx
  405eb9:	48 8b 7c 24 20       	mov    0x20(%rsp),%rdi
  405ebe:	89 0f                	mov    %ecx,(%rdi)
  405ec0:	8b 4c 06 fc          	mov    -0x4(%rsi,%rax,1),%ecx
  405ec4:	89 4c 07 fc          	mov    %ecx,-0x4(%rdi,%rax,1)
  405ec8:	48 8b 8c 24 90 00 00 	mov    0x90(%rsp),%rcx
  405ecf:	00 
  405ed0:	e9 5b fc ff ff       	jmpq   405b30 <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x950>
  405ed5:	41 83 c4 07          	add    $0x7,%r12d
  405ed9:	e9 4d f9 ff ff       	jmpq   40582b <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x64b>
  405ede:	41 83 c4 06          	add    $0x6,%r12d
  405ee2:	e9 44 f9 ff ff       	jmpq   40582b <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x64b>
  405ee7:	41 83 c4 05          	add    $0x5,%r12d
  405eeb:	e9 3b f9 ff ff       	jmpq   40582b <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x64b>
  405ef0:	41 83 c4 04          	add    $0x4,%r12d
  405ef4:	e9 32 f9 ff ff       	jmpq   40582b <fc_solve_sfs_move_fc_to_empty_and_put_on_top+0x64b>
  405ef9:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)

0000000000405f00 <fc_solve_sfs_move_freecell_cards_to_empty_stack>:
    if (!soft_thread->num_vacant_stacks)
  405f00:	80 bf e3 01 00 00 00 	cmpb   $0x0,0x1e3(%rdi)
  405f07:	0f 84 a3 02 00 00    	je     4061b0 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x2b0>
{
  405f0d:	41 57                	push   %r15
  405f0f:	41 56                	push   %r14
  405f11:	49 89 ce             	mov    %rcx,%r14
  405f14:	41 55                	push   %r13
  405f16:	41 54                	push   %r12
  405f18:	55                   	push   %rbp
  405f19:	53                   	push   %rbx
  405f1a:	48 83 ec 48          	sub    $0x48,%rsp
    SET_empty_stack_idx(empty_stack_idx);
  405f1e:	48 8b 06             	mov    (%rsi),%rax
  405f21:	80 38 00             	cmpb   $0x0,(%rax)
  405f24:	0f 84 66 03 00 00    	je     406290 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x390>
  405f2a:	48 8b 46 08          	mov    0x8(%rsi),%rax
  405f2e:	80 38 00             	cmpb   $0x0,(%rax)
  405f31:	0f 84 b9 03 00 00    	je     4062f0 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x3f0>
  405f37:	48 8b 46 10          	mov    0x10(%rsi),%rax
  405f3b:	80 38 00             	cmpb   $0x0,(%rax)
  405f3e:	0f 84 bc 03 00 00    	je     406300 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x400>
  405f44:	48 8b 46 18          	mov    0x18(%rsi),%rax
  405f48:	80 38 00             	cmpb   $0x0,(%rax)
  405f4b:	0f 84 bf 03 00 00    	je     406310 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x410>
  405f51:	48 8b 46 20          	mov    0x20(%rsi),%rax
  405f55:	80 38 00             	cmpb   $0x0,(%rax)
  405f58:	0f 84 c2 03 00 00    	je     406320 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x420>
  405f5e:	48 8b 46 28          	mov    0x28(%rsi),%rax
  405f62:	80 38 00             	cmpb   $0x0,(%rax)
  405f65:	0f 84 c5 03 00 00    	je     406330 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x430>
  405f6b:	48 8b 46 30          	mov    0x30(%rsi),%rax
  405f6f:	80 38 00             	cmpb   $0x0,(%rax)
  405f72:	0f 84 c8 03 00 00    	je     406340 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x440>
  405f78:	4c 8b 46 38          	mov    0x38(%rsi),%r8
  405f7c:	b8 00 04 00 00       	mov    $0x400,%eax
  405f81:	b9 08 00 00 00       	mov    $0x8,%ecx
  405f86:	c7 44 24 18 00 01 00 	movl   $0x100,0x18(%rsp)
  405f8d:	00 
  405f8e:	41 80 38 00          	cmpb   $0x0,(%r8)
  405f92:	0f 84 c8 03 00 00    	je     406360 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x460>
    tests_define_accessors();
  405f98:	4c 8b 3f             	mov    (%rdi),%r15
  405f9b:	49 89 d5             	mov    %rdx,%r13
  405f9e:	48 89 f3             	mov    %rsi,%rbx
  405fa1:	48 89 7c 24 08       	mov    %rdi,0x8(%rsp)
        my_copy_stack(empty_stack_idx);
  405fa6:	31 ed                	xor    %ebp,%ebp
  405fa8:	4d 8d a4 07 00 01 00 	lea    0x100(%r15,%rax,1),%r12
  405faf:	00 
  405fb0:	48 63 c1             	movslq %ecx,%rax
  405fb3:	48 89 04 24          	mov    %rax,(%rsp)
        const fcs_card card = fcs_freecell_card(state, fc);
  405fb7:	44 0f b6 54 2b 40    	movzbl 0x40(%rbx,%rbp,1),%r10d
  405fbd:	48 63 d5             	movslq %ebp,%rdx
        if (SHOULD_SKIP_FC_CARD(card))
  405fc0:	45 84 d2             	test   %r10b,%r10b
  405fc3:	0f 84 c8 01 00 00    	je     406191 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x291>
                (instance->list_of_vacant_states != NULL)))
  405fc9:	49 8b 8f b0 00 00 00 	mov    0xb0(%r15),%rcx
  405fd0:	48 85 c9             	test   %rcx,%rcx
    if ((HT_FIELD(hard_thread, allocated_from_list) =
  405fd3:	41 0f 95 87 18 05 00 	setne  0x518(%r15)
  405fda:	00 
  405fdb:	0f 85 0f 02 00 00    	jne    4061f0 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x2f0>
    if ((size_t)(allocator->max_ptr - allocator->ptr) < how_much)
  405fe1:	49 8b 8f e8 00 00 00 	mov    0xe8(%r15),%rcx
  405fe8:	49 8b 87 e0 00 00 00 	mov    0xe0(%r15),%rax
  405fef:	48 29 c8             	sub    %rcx,%rax
  405ff2:	48 83 f8 5f          	cmp    $0x5f,%rax
  405ff6:	0f 86 24 02 00 00    	jbe    406220 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x320>
        allocator->rollback_ptr = allocator->ptr;
  405ffc:	49 89 8f f0 00 00 00 	mov    %rcx,0xf0(%r15)
    allocator->ptr += how_much;
  406003:	48 8d 41 60          	lea    0x60(%rcx),%rax
  406007:	49 89 87 e8 00 00 00 	mov    %rax,0xe8(%r15)
    return (const fcs_kv_state){.key = &(s->s), .val = &(s->info)};
  40600e:	48 8d 41 48          	lea    0x48(%rcx),%rax
    *ret = FCS_STATE_keyval_pair_to_kv(s);
  406012:	c4 e1 f9 6e c9       	vmovq  %rcx,%xmm1
  406017:	c4 e3 f1 22 c0 01    	vpinsrq $0x1,%rax,%xmm1,%xmm0
  40601d:	c5 f8 29 44 24 20    	vmovaps %xmm0,0x20(%rsp)
    fcs_duplicate_kv_state(out_new_state_out, &raw_state_raw);
  406023:	c5 fa 6f 03          	vmovdqu (%rbx),%xmm0
  406027:	c5 f8 11 01          	vmovups %xmm0,(%rcx)
  40602b:	c5 fa 6f 43 10       	vmovdqu 0x10(%rbx),%xmm0
  406030:	c5 f8 11 41 10       	vmovups %xmm0,0x10(%rcx)
  406035:	c5 fa 6f 43 20       	vmovdqu 0x20(%rbx),%xmm0
  40603a:	c5 f8 11 41 20       	vmovups %xmm0,0x20(%rcx)
  40603f:	c5 fa 6f 43 30       	vmovdqu 0x30(%rbx),%xmm0
  406044:	c5 f8 11 41 30       	vmovups %xmm0,0x30(%rcx)
  406049:	48 8b 43 40          	mov    0x40(%rbx),%rax
  40604d:	c4 c1 7a 6f 45 00    	vmovdqu 0x0(%r13),%xmm0
  406053:	c5 f8 11 41 48       	vmovups %xmm0,0x48(%rcx)
  406058:	48 89 41 40          	mov    %rax,0x40(%rcx)
  40605c:	49 8b 45 10          	mov    0x10(%r13),%rax
    (FCS_S_DEPTH(raw_ptr_new_state))++;
  406060:	83 41 50 01          	addl   $0x1,0x50(%rcx)
    FCS_S_PARENT(raw_ptr_new_state) = INFO_STATE_PTR(&raw_state_raw);
  406064:	48 89 59 48          	mov    %rbx,0x48(%rcx)
    FCS_S_VISITED(raw_ptr_new_state) = 0;
  406068:	c6 41 56 00          	movb   $0x0,0x56(%rcx)
    fcs_duplicate_kv_state(out_new_state_out, &raw_state_raw);
  40606c:	48 89 41 58          	mov    %rax,0x58(%rcx)
    FCS_S_NUM_ACTIVE_CHILDREN(raw_ptr_new_state) = 0;
  406070:	31 c0                	xor    %eax,%eax
  406072:	66 89 41 54          	mov    %ax,0x54(%rcx)
        my_copy_stack(empty_stack_idx);
  406076:	8b 44 24 18          	mov    0x18(%rsp),%eax
    memset(&(FCS_S_SCAN_VISITED(raw_ptr_new_state)), '\0',
  40607a:	c7 41 57 00 00 00 00 	movl   $0x0,0x57(%rcx)
  406081:	89 41 5c             	mov    %eax,0x5c(%rcx)
  406084:	48 8b 04 24          	mov    (%rsp),%rax
  406088:	48 8b 34 c1          	mov    (%rcx,%rax,8),%rsi
  40608c:	0f be 0e             	movsbl (%rsi),%ecx
  40608f:	83 c1 01             	add    $0x1,%ecx
  406092:	48 63 c9             	movslq %ecx,%rcx
  406095:	48 83 f9 08          	cmp    $0x8,%rcx
  406099:	0f 83 31 01 00 00    	jae    4061d0 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x2d0>
  40609f:	f6 c1 04             	test   $0x4,%cl
  4060a2:	0f 85 c8 01 00 00    	jne    406270 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x370>
  4060a8:	48 85 c9             	test   %rcx,%rcx
  4060ab:	74 10                	je     4060bd <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x1bd>
  4060ad:	0f b6 06             	movzbl (%rsi),%eax
  4060b0:	41 88 04 24          	mov    %al,(%r12)
  4060b4:	f6 c1 02             	test   $0x2,%cl
  4060b7:	0f 85 93 02 00 00    	jne    406350 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x450>
  4060bd:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
    if (!fc_solve_check_and_add_state(
  4060c2:	48 8d 74 24 20       	lea    0x20(%rsp),%rsi
  4060c7:	48 8b 3c 24          	mov    (%rsp),%rdi
  4060cb:	4c 89 24 f8          	mov    %r12,(%rax,%rdi,8)
    fcs_col_push_card(col, card);
  4060cf:	49 0f be 04 24       	movsbq (%r12),%rax
  4060d4:	8d 48 01             	lea    0x1(%rax),%ecx
  4060d7:	41 88 0c 24          	mov    %cl,(%r12)
  4060db:	45 88 54 04 01       	mov    %r10b,0x1(%r12,%rax,1)
        fcs_empty_freecell(new_state_key, fc);
  4060e0:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  4060e5:	c6 44 10 40 00       	movb   $0x0,0x40(%rax,%rdx,1)
    const_SLOT(hard_thread, soft_thread);
  4060ea:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
    if (!fc_solve_check_and_add_state(
  4060ef:	48 8d 54 24 30       	lea    0x30(%rsp),%rdx
    const_SLOT(hard_thread, soft_thread);
  4060f4:	48 8b 08             	mov    (%rax),%rcx
    if (!fc_solve_check_and_add_state(
  4060f7:	48 89 cf             	mov    %rcx,%rdi
  4060fa:	48 89 4c 24 10       	mov    %rcx,0x10(%rsp)
  4060ff:	e8 4c b9 ff ff       	callq  401a50 <fc_solve_check_and_add_state>
  406104:	84 c0                	test   %al,%al
  406106:	0f 85 b4 00 00 00    	jne    4061c0 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x2c0>
        if (HT_FIELD(hard_thread, allocated_from_list))
  40610c:	48 8b 4c 24 10       	mov    0x10(%rsp),%rcx
  406111:	80 b9 18 05 00 00 00 	cmpb   $0x0,0x518(%rcx)
  406118:	0f 84 e2 00 00 00    	je     406200 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x300>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  40611e:	48 8b 91 b0 00 00 00 	mov    0xb0(%rcx),%rdx
  406125:	48 8b 44 24 28       	mov    0x28(%rsp),%rax
  40612a:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  40612d:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  406132:	48 89 81 b0 00 00 00 	mov    %rax,0xb0(%rcx)
  406139:	48 8b 54 24 30       	mov    0x30(%rsp),%rdx
    if ((!((list->num_states + (list->states != NULL)) &
  40613e:	49 8b 46 08          	mov    0x8(%r14),%rax
  406142:	31 f6                	xor    %esi,%esi
  406144:	49 8b 3e             	mov    (%r14),%rdi
  406147:	48 85 c0             	test   %rax,%rax
  40614a:	40 0f 95 c6          	setne  %sil
  40614e:	48 01 fe             	add    %rdi,%rsi
  406151:	40 f6 c6 0f          	test   $0xf,%sil
  406155:	75 21                	jne    406178 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x278>
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  406157:	48 83 c6 10          	add    $0x10,%rsi
  40615b:	48 89 c7             	mov    %rax,%rdi
  40615e:	48 89 54 24 10       	mov    %rdx,0x10(%rsp)
  406163:	48 c1 e6 04          	shl    $0x4,%rsi
  406167:	e8 04 b0 ff ff       	callq  401170 <realloc@plt>
  40616c:	49 8b 3e             	mov    (%r14),%rdi
  40616f:	48 8b 54 24 10       	mov    0x10(%rsp),%rdx
        list->states =
  406174:	49 89 46 08          	mov    %rax,0x8(%r14)
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  406178:	48 8d 4f 01          	lea    0x1(%rdi),%rcx
  40617c:	48 c1 e7 04          	shl    $0x4,%rdi
  406180:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  406184:	48 01 f8             	add    %rdi,%rax
  406187:	49 89 0e             	mov    %rcx,(%r14)
  40618a:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  40618e:	48 89 10             	mov    %rdx,(%rax)
  406191:	48 83 c5 01          	add    $0x1,%rbp
    for (int fc = 0; fc < LOCAL_FREECELLS_NUM; fc++)
  406195:	48 83 fd 04          	cmp    $0x4,%rbp
  406199:	0f 85 18 fe ff ff    	jne    405fb7 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0xb7>
}
  40619f:	48 83 c4 48          	add    $0x48,%rsp
  4061a3:	5b                   	pop    %rbx
  4061a4:	5d                   	pop    %rbp
  4061a5:	41 5c                	pop    %r12
  4061a7:	41 5d                	pop    %r13
  4061a9:	41 5e                	pop    %r14
  4061ab:	41 5f                	pop    %r15
  4061ad:	c3                   	retq   
  4061ae:	66 90                	xchg   %ax,%ax
  4061b0:	c3                   	retq   
  4061b1:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4061b8:	00 00 00 00 
  4061bc:	0f 1f 40 00          	nopl   0x0(%rax)
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  4061c0:	48 8b 54 24 20       	mov    0x20(%rsp),%rdx
  4061c5:	e9 74 ff ff ff       	jmpq   40613e <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x23e>
  4061ca:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
        my_copy_stack(empty_stack_idx);
  4061d0:	48 8b 44 0e f8       	mov    -0x8(%rsi,%rcx,1),%rax
  4061d5:	4c 89 e7             	mov    %r12,%rdi
  4061d8:	49 89 44 0c f8       	mov    %rax,-0x8(%r12,%rcx,1)
  4061dd:	48 83 e9 01          	sub    $0x1,%rcx
  4061e1:	48 c1 e9 03          	shr    $0x3,%rcx
  4061e5:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  4061e8:	e9 d0 fe ff ff       	jmpq   4060bd <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x1bd>
  4061ed:	0f 1f 00             	nopl   (%rax)
            FCS_S_NEXT(instance->list_of_vacant_states);
  4061f0:	48 8b 41 48          	mov    0x48(%rcx),%rax
        instance->list_of_vacant_states =
  4061f4:	49 89 87 b0 00 00 00 	mov    %rax,0xb0(%r15)
  4061fb:	e9 0e fe ff ff       	jmpq   40600e <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x10e>
    allocator->ptr = allocator->rollback_ptr;
  406200:	48 8b 81 f0 00 00 00 	mov    0xf0(%rcx),%rax
  406207:	48 89 81 e8 00 00 00 	mov    %rax,0xe8(%rcx)
  40620e:	e9 26 ff ff ff       	jmpq   406139 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x239>
  406213:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40621a:	00 00 00 00 
  40621e:	66 90                	xchg   %ax,%ax
    char *const new_data = meta_request_new_buffer(allocator->meta);
  406220:	49 8b 8f f8 00 00 00 	mov    0xf8(%r15),%rcx
    char *const ret = meta_alloc->recycle_bin;
  406227:	48 8b 01             	mov    (%rcx),%rax
    if (ret)
  40622a:	48 85 c0             	test   %rax,%rax
  40622d:	0f 84 8d 00 00 00    	je     4062c0 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x3c0>
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  406233:	48 8b 30             	mov    (%rax),%rsi
  406236:	48 89 31             	mov    %rsi,(%rcx)
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  406239:	49 8b 8f d8 00 00 00 	mov    0xd8(%r15),%rcx
  406240:	48 89 08             	mov    %rcx,(%rax)
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  406243:	48 8d 48 08          	lea    0x8(%rax),%rcx
    allocator->old_list = new_data;
  406247:	49 89 87 d8 00 00 00 	mov    %rax,0xd8(%r15)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40624e:	48 05 80 fe 00 00    	add    $0xfe80,%rax
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  406254:	49 89 8f f0 00 00 00 	mov    %rcx,0xf0(%r15)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40625b:	49 89 87 e0 00 00 00 	mov    %rax,0xe0(%r15)
  406262:	e9 9c fd ff ff       	jmpq   406003 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x103>
  406267:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40626e:	00 00 
  406270:	8b 06                	mov    (%rsi),%eax
  406272:	41 89 04 24          	mov    %eax,(%r12)
  406276:	8b 44 0e fc          	mov    -0x4(%rsi,%rcx,1),%eax
  40627a:	41 89 44 0c fc       	mov    %eax,-0x4(%r12,%rcx,1)
  40627f:	e9 39 fe ff ff       	jmpq   4060bd <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x1bd>
  406284:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40628b:	00 00 00 00 
  40628f:	90                   	nop
    SET_empty_stack_idx(empty_stack_idx);
  406290:	31 c9                	xor    %ecx,%ecx
  406292:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  406299:	00 00 00 00 
  40629d:	0f 1f 00             	nopl   (%rax)
  4062a0:	41 bf 01 00 00 00    	mov    $0x1,%r15d
  4062a6:	89 c8                	mov    %ecx,%eax
  4062a8:	41 d3 e7             	shl    %cl,%r15d
  4062ab:	c1 e0 07             	shl    $0x7,%eax
  4062ae:	44 89 7c 24 18       	mov    %r15d,0x18(%rsp)
  4062b3:	48 98                	cltq   
  4062b5:	e9 de fc ff ff       	jmpq   405f98 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x98>
  4062ba:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
        return malloc(ALLOCED_SIZE);
  4062c0:	bf 80 fe 00 00       	mov    $0xfe80,%edi
  4062c5:	89 54 24 1c          	mov    %edx,0x1c(%rsp)
  4062c9:	44 88 54 24 10       	mov    %r10b,0x10(%rsp)
  4062ce:	e8 1d ae ff ff       	callq  4010f0 <malloc@plt>
  4062d3:	48 63 54 24 1c       	movslq 0x1c(%rsp),%rdx
  4062d8:	44 0f b6 54 24 10    	movzbl 0x10(%rsp),%r10d
  4062de:	e9 56 ff ff ff       	jmpq   406239 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x339>
  4062e3:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4062ea:	00 00 00 00 
  4062ee:	66 90                	xchg   %ax,%ax
  4062f0:	b9 01 00 00 00       	mov    $0x1,%ecx
  4062f5:	eb a9                	jmp    4062a0 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x3a0>
  4062f7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  4062fe:	00 00 
  406300:	b9 02 00 00 00       	mov    $0x2,%ecx
  406305:	eb 99                	jmp    4062a0 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x3a0>
  406307:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40630e:	00 00 
  406310:	b9 03 00 00 00       	mov    $0x3,%ecx
  406315:	eb 89                	jmp    4062a0 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x3a0>
  406317:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40631e:	00 00 
  406320:	b9 04 00 00 00       	mov    $0x4,%ecx
  406325:	e9 76 ff ff ff       	jmpq   4062a0 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x3a0>
  40632a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
  406330:	b9 05 00 00 00       	mov    $0x5,%ecx
  406335:	e9 66 ff ff ff       	jmpq   4062a0 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x3a0>
  40633a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
  406340:	b9 06 00 00 00       	mov    $0x6,%ecx
  406345:	e9 56 ff ff ff       	jmpq   4062a0 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x3a0>
  40634a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
        my_copy_stack(empty_stack_idx);
  406350:	0f b7 44 0e fe       	movzwl -0x2(%rsi,%rcx,1),%eax
  406355:	66 41 89 44 0c fe    	mov    %ax,-0x2(%r12,%rcx,1)
  40635b:	e9 5d fd ff ff       	jmpq   4060bd <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x1bd>
    SET_empty_stack_idx(empty_stack_idx);
  406360:	b9 07 00 00 00       	mov    $0x7,%ecx
  406365:	e9 36 ff ff ff       	jmpq   4062a0 <fc_solve_sfs_move_freecell_cards_to_empty_stack+0x3a0>
  40636a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)

0000000000406370 <fc_solve_sfs_move_sequences_to_free_stacks>:
    const fcs_game_limit num_vacant_stacks = soft_thread->num_vacant_stacks;
  406370:	0f b6 87 e3 01 00 00 	movzbl 0x1e3(%rdi),%eax
    if (num_vacant_stacks == 0)
  406377:	84 c0                	test   %al,%al
  406379:	0f 84 8e 02 00 00    	je     40660d <fc_solve_sfs_move_sequences_to_free_stacks+0x29d>
{
  40637f:	41 57                	push   %r15
  406381:	49 89 c8             	mov    %rcx,%r8
  406384:	41 56                	push   %r14
  406386:	41 55                	push   %r13
  406388:	41 54                	push   %r12
  40638a:	55                   	push   %rbp
  40638b:	53                   	push   %rbx
        calc_max_sequence_move(num_vacant_freecells, num_vacant_stacks - 1);
  40638c:	89 c3                	mov    %eax,%ebx
  40638e:	8d 4b ff             	lea    -0x1(%rbx),%ecx
{
  406391:	48 81 ec b8 00 00 00 	sub    $0xb8,%rsp
        calc_max_sequence_move(num_vacant_freecells, num_vacant_stacks - 1);
  406398:	44 0f b6 b7 e4 01 00 	movzbl 0x1e4(%rdi),%r14d
  40639f:	00 
  4063a0:	89 44 24 14          	mov    %eax,0x14(%rsp)
  4063a4:	41 8d 46 01          	lea    0x1(%r14),%eax
    const int max_sequence_len =
  4063a8:	d3 e0                	shl    %cl,%eax
  4063aa:	89 44 24 6c          	mov    %eax,0x6c(%rsp)
        if (fcs_state_col_is_empty(state, ret))
  4063ae:	48 8b 06             	mov    (%rsi),%rax
  4063b1:	80 38 00             	cmpb   $0x0,(%rax)
  4063b4:	0f 84 96 0c 00 00    	je     407050 <fc_solve_sfs_move_sequences_to_free_stacks+0xce0>
  4063ba:	48 8b 46 08          	mov    0x8(%rsi),%rax
  4063be:	80 38 00             	cmpb   $0x0,(%rax)
  4063c1:	0f 84 b1 0c 00 00    	je     407078 <fc_solve_sfs_move_sequences_to_free_stacks+0xd08>
  4063c7:	48 8b 46 10          	mov    0x10(%rsi),%rax
  4063cb:	80 38 00             	cmpb   $0x0,(%rax)
  4063ce:	0f 84 ae 0c 00 00    	je     407082 <fc_solve_sfs_move_sequences_to_free_stacks+0xd12>
  4063d4:	48 8b 46 18          	mov    0x18(%rsi),%rax
  4063d8:	80 38 00             	cmpb   $0x0,(%rax)
  4063db:	0f 84 ab 0c 00 00    	je     40708c <fc_solve_sfs_move_sequences_to_free_stacks+0xd1c>
  4063e1:	48 8b 46 20          	mov    0x20(%rsi),%rax
  4063e5:	80 38 00             	cmpb   $0x0,(%rax)
  4063e8:	0f 84 a8 0c 00 00    	je     407096 <fc_solve_sfs_move_sequences_to_free_stacks+0xd26>
  4063ee:	48 8b 46 28          	mov    0x28(%rsi),%rax
  4063f2:	80 38 00             	cmpb   $0x0,(%rax)
  4063f5:	0f 84 a5 0c 00 00    	je     4070a0 <fc_solve_sfs_move_sequences_to_free_stacks+0xd30>
  4063fb:	48 8b 46 30          	mov    0x30(%rsi),%rax
  4063ff:	80 38 00             	cmpb   $0x0,(%rax)
  406402:	0f 84 a2 0c 00 00    	je     4070aa <fc_solve_sfs_move_sequences_to_free_stacks+0xd3a>
  406408:	48 8b 4e 38          	mov    0x38(%rsi),%rcx
  40640c:	c7 44 24 74 00 00 00 	movl   $0x0,0x74(%rsp)
  406413:	00 
  406414:	48 c7 c0 80 ff ff ff 	mov    $0xffffffffffffff80,%rax
    return -1;
  40641b:	c7 44 24 70 ff ff ff 	movl   $0xffffffff,0x70(%rsp)
  406422:	ff 
        if (fcs_state_col_is_empty(state, ret))
  406423:	80 39 00             	cmpb   $0x0,(%rcx)
  406426:	0f 84 0f 0d 00 00    	je     40713b <fc_solve_sfs_move_sequences_to_free_stacks+0xdcb>
    MOVE_FUNCS__define_common();
  40642c:	48 8b 1f             	mov    (%rdi),%rbx
  40642f:	4c 89 44 24 20       	mov    %r8,0x20(%rsp)
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  406434:	45 89 f7             	mov    %r14d,%r15d
                copy_two_stacks(stack_idx, ds);
  406437:	48 c7 44 24 08 00 00 	movq   $0x0,0x8(%rsp)
  40643e:	00 00 
  406440:	48 89 54 24 48       	mov    %rdx,0x48(%rsp)
  406445:	48 89 74 24 18       	mov    %rsi,0x18(%rsp)
    MOVE_FUNCS__define_common();
  40644a:	48 89 5c 24 40       	mov    %rbx,0x40(%rsp)
  40644f:	48 81 c3 00 01 00 00 	add    $0x100,%rbx
                copy_two_stacks(stack_idx, ds);
  406456:	48 01 d8             	add    %rbx,%rax
  406459:	48 89 7c 24 30       	mov    %rdi,0x30(%rsp)
  40645e:	48 89 44 24 78       	mov    %rax,0x78(%rsp)
  406463:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
    MOVE_FUNCS__define_common();
  406468:	48 89 5c 24 60       	mov    %rbx,0x60(%rsp)
  40646d:	0f 1f 00             	nopl   (%rax)
    ret.col = fcs_state_get_col(*s, stack_idx);
  406470:	48 8b 7c 24 18       	mov    0x18(%rsp),%rdi
  406475:	89 44 24 28          	mov    %eax,0x28(%rsp)
  406479:	48 8b 1c c7          	mov    (%rdi,%rax,8),%rbx
    ret.col_len_minus_1 = (ret.col_len = fcs_col_len(ret.col)) - 1;
  40647d:	4c 0f be 13          	movsbq (%rbx),%r10
  406481:	4d 8d 72 ff          	lea    -0x1(%r10),%r14
    for ((*iter).seq_end = (*iter).c; (*iter).seq_end < (*iter).col_len_minus_1;
  406485:	4d 85 f6             	test   %r14,%r14
  406488:	0f 8e c4 09 00 00    	jle    406e52 <fc_solve_sfs_move_sequences_to_free_stacks+0xae2>
    return fc_solve_is_parent_buf[(size_t)parent][(size_t)child];
  40648e:	48 0f be 43 01       	movsbq 0x1(%rbx),%rax
  406493:	48 0f be 53 02       	movsbq 0x2(%rbx),%rdx
  406498:	48 c1 e0 06          	shl    $0x6,%rax
        if (!fcs_is_parent_card(fcs_col_get_card(col, (*iter).seq_end + 1),
  40649c:	80 bc 02 c0 fe 40 00 	cmpb   $0x0,0x40fec0(%rdx,%rax,1)
  4064a3:	00 
  4064a4:	0f 84 a8 09 00 00    	je     406e52 <fc_solve_sfs_move_sequences_to_free_stacks+0xae2>
  4064aa:	b8 01 00 00 00       	mov    $0x1,%eax
  4064af:	eb 2d                	jmp    4064de <fc_solve_sfs_move_sequences_to_free_stacks+0x16e>
  4064b1:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4064b8:	00 00 00 00 
  4064bc:	0f 1f 40 00          	nopl   0x0(%rax)
  4064c0:	48 0f be 54 03 01    	movsbq 0x1(%rbx,%rax,1),%rdx
  4064c6:	48 0f be 4c 03 02    	movsbq 0x2(%rbx,%rax,1),%rcx
  4064cc:	48 83 c0 01          	add    $0x1,%rax
  4064d0:	48 c1 e2 06          	shl    $0x6,%rdx
  4064d4:	80 bc 11 c0 fe 40 00 	cmpb   $0x0,0x40fec0(%rcx,%rdx,1)
  4064db:	00 
  4064dc:	74 08                	je     4064e6 <fc_solve_sfs_move_sequences_to_free_stacks+0x176>
         ++((*iter).seq_end))
  4064de:	49 89 c5             	mov    %rax,%r13
    for ((*iter).seq_end = (*iter).c; (*iter).seq_end < (*iter).col_len_minus_1;
  4064e1:	4c 39 f0             	cmp    %r14,%rax
  4064e4:	75 da                	jne    4064c0 <fc_solve_sfs_move_sequences_to_free_stacks+0x150>
  4064e6:	0f b6 4c 24 28       	movzbl 0x28(%rsp),%ecx
  4064eb:	b8 01 00 00 00       	mov    $0x1,%eax
  4064f0:	45 89 f8             	mov    %r15d,%r8d
    return ret;
  4064f3:	31 f6                	xor    %esi,%esi
  4064f5:	4d 89 d7             	mov    %r10,%r15
  4064f8:	d3 e0                	shl    %cl,%eax
  4064fa:	89 44 24 2c          	mov    %eax,0x2c(%rsp)
  4064fe:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
  406503:	48 c1 e0 07          	shl    $0x7,%rax
  406507:	48 03 44 24 60       	add    0x60(%rsp),%rax
  40650c:	48 89 44 24 38       	mov    %rax,0x38(%rsp)
        for (; iter.c < iter.col_len; col_seqs_iter__advance(&iter))
  406511:	49 39 f7             	cmp    %rsi,%r15
  406514:	0f 8e c9 00 00 00    	jle    4065e3 <fc_solve_sfs_move_sequences_to_free_stacks+0x273>
            if (iter.seq_end == iter.col_len_minus_1)
  40651a:	4d 39 f5             	cmp    %r14,%r13
  40651d:	0f 84 ed 00 00 00    	je     406610 <fc_solve_sfs_move_sequences_to_free_stacks+0x2a0>
                int num_cards_to_relocate = iter.col_len_minus_1 - iter.seq_end;
  406523:	44 89 f5             	mov    %r14d,%ebp
                if (!((num_cards_to_relocate == 0) &&
  406526:	8b 4c 24 14          	mov    0x14(%rsp),%ecx
                int num_cards_to_relocate = iter.col_len_minus_1 - iter.seq_end;
  40652a:	44 29 ed             	sub    %r13d,%ebp
                const int freecells_to_fill =
  40652d:	41 39 e8             	cmp    %ebp,%r8d
  406530:	89 ef                	mov    %ebp,%edi
                num_cards_to_relocate -= freecells_to_fill;
  406532:	89 ea                	mov    %ebp,%edx
                const int freecells_to_fill =
  406534:	41 0f 4e f8          	cmovle %r8d,%edi
                num_cards_to_relocate -= freecells_to_fill;
  406538:	29 fa                	sub    %edi,%edx
                if (!((num_cards_to_relocate == 0) &&
  40653a:	39 d1                	cmp    %edx,%ecx
  40653c:	7c 30                	jl     40656e <fc_solve_sfs_move_sequences_to_free_stacks+0x1fe>
                        (num_vacant_stacks - freestacks_to_fill > 0)))
  40653e:	29 d1                	sub    %edx,%ecx
                if (!((num_cards_to_relocate == 0) &&
  406540:	85 c9                	test   %ecx,%ecx
  406542:	7e 2a                	jle    40656e <fc_solve_sfs_move_sequences_to_free_stacks+0x1fe>
                    const int m = iter.seq_end + 1 - max_seq_move;
  406544:	45 8d 65 01          	lea    0x1(%r13),%r12d
                    const int max_seq_move = calc_max_sequence_move(
  406548:	44 89 c0             	mov    %r8d,%eax
  40654b:	83 e9 01             	sub    $0x1,%ecx
  40654e:	29 f8                	sub    %edi,%eax
  406550:	83 c0 01             	add    $0x1,%eax
  406553:	d3 e0                	shl    %cl,%eax
                    const int m = iter.seq_end + 1 - max_seq_move;
  406555:	41 29 c4             	sub    %eax,%r12d
                    max(m, iter.c);
  406558:	4d 63 e4             	movslq %r12d,%r12
  40655b:	49 39 f4             	cmp    %rsi,%r12
  40655e:	4c 0f 4c e6          	cmovl  %rsi,%r12
                if (!((seq_start <= iter.seq_end) &&
  406562:	4d 63 e4             	movslq %r12d,%r12
  406565:	4d 39 ec             	cmp    %r13,%r12
  406568:	0f 8e 82 02 00 00    	jle    4067f0 <fc_solve_sfs_move_sequences_to_free_stacks+0x480>
    iter->c = iter->seq_end + 1;
  40656e:	49 8d 75 01          	lea    0x1(%r13),%rsi
    for ((*iter).seq_end = (*iter).c; (*iter).seq_end < (*iter).col_len_minus_1;
  406572:	49 39 f6             	cmp    %rsi,%r14
  406575:	0f 8e 65 02 00 00    	jle    4067e0 <fc_solve_sfs_move_sequences_to_free_stacks+0x470>
  40657b:	48 0f be 44 33 01    	movsbq 0x1(%rbx,%rsi,1),%rax
  406581:	48 0f be 54 33 02    	movsbq 0x2(%rbx,%rsi,1),%rdx
  406587:	48 c1 e0 06          	shl    $0x6,%rax
        if (!fcs_is_parent_card(fcs_col_get_card(col, (*iter).seq_end + 1),
  40658b:	80 bc 02 c0 fe 40 00 	cmpb   $0x0,0x40fec0(%rdx,%rax,1)
  406592:	00 
  406593:	0f 84 47 02 00 00    	je     4067e0 <fc_solve_sfs_move_sequences_to_free_stacks+0x470>
  406599:	49 8d 45 02          	lea    0x2(%r13),%rax
  40659d:	49 8d 7f ff          	lea    -0x1(%r15),%rdi
  4065a1:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4065a8:	00 00 00 00 
  4065ac:	0f 1f 40 00          	nopl   0x0(%rax)
         ++((*iter).seq_end))
  4065b0:	49 89 c5             	mov    %rax,%r13
    for ((*iter).seq_end = (*iter).c; (*iter).seq_end < (*iter).col_len_minus_1;
  4065b3:	48 39 f8             	cmp    %rdi,%rax
  4065b6:	0f 84 55 ff ff ff    	je     406511 <fc_solve_sfs_move_sequences_to_free_stacks+0x1a1>
  4065bc:	48 0f be 54 03 01    	movsbq 0x1(%rbx,%rax,1),%rdx
  4065c2:	48 0f be 4c 03 02    	movsbq 0x2(%rbx,%rax,1),%rcx
  4065c8:	48 83 c0 01          	add    $0x1,%rax
  4065cc:	48 c1 e2 06          	shl    $0x6,%rdx
        if (!fcs_is_parent_card(fcs_col_get_card(col, (*iter).seq_end + 1),
  4065d0:	80 bc 11 c0 fe 40 00 	cmpb   $0x0,0x40fec0(%rcx,%rdx,1)
  4065d7:	00 
  4065d8:	75 d6                	jne    4065b0 <fc_solve_sfs_move_sequences_to_free_stacks+0x240>
        for (; iter.c < iter.col_len; col_seqs_iter__advance(&iter))
  4065da:	49 39 f7             	cmp    %rsi,%r15
  4065dd:	0f 8f 37 ff ff ff    	jg     40651a <fc_solve_sfs_move_sequences_to_free_stacks+0x1aa>
  4065e3:	48 83 44 24 08 01    	addq   $0x1,0x8(%rsp)
  4065e9:	45 89 c7             	mov    %r8d,%r15d
  4065ec:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  4065f1:	48 83 f8 08          	cmp    $0x8,%rax
  4065f5:	0f 85 75 fe ff ff    	jne    406470 <fc_solve_sfs_move_sequences_to_free_stacks+0x100>
}
  4065fb:	48 81 c4 b8 00 00 00 	add    $0xb8,%rsp
  406602:	5b                   	pop    %rbx
  406603:	5d                   	pop    %rbp
  406604:	41 5c                	pop    %r12
  406606:	41 5d                	pop    %r13
  406608:	41 5e                	pop    %r14
  40660a:	41 5f                	pop    %r15
  40660c:	c3                   	retq   
  40660d:	c3                   	retq   
  40660e:	66 90                	xchg   %ax,%ax
                while ((max_sequence_len < iter.col_len - c) && (c > 0))
  406610:	48 63 4c 24 6c       	movslq 0x6c(%rsp),%rcx
  406615:	48 63 c6             	movslq %esi,%rax
  406618:	4c 89 fd             	mov    %r15,%rbp
                int c = iter.c;
  40661b:	89 f2                	mov    %esi,%edx
                while ((max_sequence_len < iter.col_len - c) && (c > 0))
  40661d:	48 29 c5             	sub    %rax,%rbp
  406620:	48 39 cd             	cmp    %rcx,%rbp
  406623:	7e 32                	jle    406657 <fc_solve_sfs_move_sequences_to_free_stacks+0x2e7>
  406625:	85 f6                	test   %esi,%esi
  406627:	0f 8e 41 ff ff ff    	jle    40656e <fc_solve_sfs_move_sequences_to_free_stacks+0x1fe>
  40662d:	48 83 e8 01          	sub    $0x1,%rax
  406631:	4c 89 ff             	mov    %r15,%rdi
  406634:	48 29 c7             	sub    %rax,%rdi
  406637:	48 89 f8             	mov    %rdi,%rax
  40663a:	eb 10                	jmp    40664c <fc_solve_sfs_move_sequences_to_free_stacks+0x2dc>
  40663c:	0f 1f 40 00          	nopl   0x0(%rax)
  406640:	48 83 c0 01          	add    $0x1,%rax
  406644:	85 d2                	test   %edx,%edx
  406646:	0f 84 22 ff ff ff    	je     40656e <fc_solve_sfs_move_sequences_to_free_stacks+0x1fe>
                    c--;
  40664c:	83 ea 01             	sub    $0x1,%edx
                while ((max_sequence_len < iter.col_len - c) && (c > 0))
  40664f:	48 89 c5             	mov    %rax,%rbp
  406652:	48 39 c8             	cmp    %rcx,%rax
  406655:	7f e9                	jg     406640 <fc_solve_sfs_move_sequences_to_free_stacks+0x2d0>
                if (!((c > 0) && ((IS_FILLED_BY_KINGS_ONLY())
  406657:	85 d2                	test   %edx,%edx
  406659:	0f 8e 0f ff ff ff    	jle    40656e <fc_solve_sfs_move_sequences_to_free_stacks+0x1fe>
                sfs_check_state_begin();
  40665f:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
  406664:	48 8d b4 24 90 00 00 	lea    0x90(%rsp),%rsi
  40666b:	00 
  40666c:	44 89 44 24 50       	mov    %r8d,0x50(%rsp)
  406671:	48 8b 7c 24 40       	mov    0x40(%rsp),%rdi
  406676:	48 8b 4c 24 48       	mov    0x48(%rsp),%rcx
  40667b:	e8 80 b2 ff ff       	callq  401900 <fc_solve_sfs_check_state_begin>
                copy_two_stacks(stack_idx, ds);
  406680:	48 8b bc 24 98 00 00 	mov    0x98(%rsp),%rdi
  406687:	00 
  406688:	44 8b 44 24 50       	mov    0x50(%rsp),%r8d
  40668d:	8b 57 14             	mov    0x14(%rdi),%edx
  406690:	85 54 24 2c          	test   %edx,0x2c(%rsp)
  406694:	0f 84 b1 06 00 00    	je     406d4b <fc_solve_sfs_move_sequences_to_free_stacks+0x9db>
  40669a:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  4066a1:	00 
  4066a2:	4c 63 4c 24 70       	movslq 0x70(%rsp),%r9
  4066a7:	85 54 24 74          	test   %edx,0x74(%rsp)
  4066ab:	0f 84 45 06 00 00    	je     406cf6 <fc_solve_sfs_move_sequences_to_free_stacks+0x986>
  4066b1:	44 89 44 24 68       	mov    %r8d,0x68(%rsp)
  4066b6:	48 8b 7c 24 08       	mov    0x8(%rsp),%rdi
  4066bb:	4e 8b 24 c8          	mov    (%rax,%r9,8),%r12
    const size_t cards_size = (((size_t)cards_num) * sizeof(fcs_card));
  4066bf:	4c 63 cd             	movslq %ebp,%r9
  4066c2:	48 8b 14 f8          	mov    (%rax,%rdi,8),%rdx
        &fcs_col_get_card(src_col, (fcs_col_len(src_col) -= cards_num));
  4066c6:	0f b6 02             	movzbl (%rdx),%eax
  4066c9:	29 e8                	sub    %ebp,%eax
  4066cb:	88 02                	mov    %al,(%rdx)
  4066cd:	48 0f be c0          	movsbq %al,%rax
    fcs_card *const src_cards_ptr =
  4066d1:	48 8d 4c 02 01       	lea    0x1(%rdx,%rax,1),%rcx
    memcpy(&fcs_col_get_card(dest_col, fcs_col_len(dest_col)), src_cards_ptr,
  4066d6:	49 0f be 04 24       	movsbq (%r12),%rax
  4066db:	4c 89 ca             	mov    %r9,%rdx
  4066de:	4c 89 4c 24 58       	mov    %r9,0x58(%rsp)
  4066e3:	48 89 ce             	mov    %rcx,%rsi
  4066e6:	48 89 4c 24 50       	mov    %rcx,0x50(%rsp)
  4066eb:	49 8d 7c 04 01       	lea    0x1(%r12,%rax,1),%rdi
  4066f0:	e8 eb a9 ff ff       	callq  4010e0 <memcpy@plt>
    memset(src_cards_ptr, 0, cards_size);
  4066f5:	31 f6                	xor    %esi,%esi
    fcs_col_len(dest_col) += cards_num;
  4066f7:	41 00 2c 24          	add    %bpl,(%r12)
    memset(src_cards_ptr, 0, cards_size);
  4066fb:	4c 8b 4c 24 58       	mov    0x58(%rsp),%r9
  406700:	48 8b 4c 24 50       	mov    0x50(%rsp),%rcx
  406705:	4c 89 ca             	mov    %r9,%rdx
  406708:	48 89 cf             	mov    %rcx,%rdi
  40670b:	e8 90 a9 ff ff       	callq  4010a0 <memset@plt>
    const_SLOT(hard_thread, soft_thread);
  406710:	48 8b 44 24 30       	mov    0x30(%rsp),%rax
    if (!fc_solve_check_and_add_state(
  406715:	48 8d 94 24 a0 00 00 	lea    0xa0(%rsp),%rdx
  40671c:	00 
  40671d:	48 8d b4 24 90 00 00 	lea    0x90(%rsp),%rsi
  406724:	00 
    const_SLOT(hard_thread, soft_thread);
  406725:	48 8b 28             	mov    (%rax),%rbp
    if (!fc_solve_check_and_add_state(
  406728:	48 89 ef             	mov    %rbp,%rdi
  40672b:	e8 20 b3 ff ff       	callq  401a50 <fc_solve_check_and_add_state>
  406730:	44 8b 44 24 68       	mov    0x68(%rsp),%r8d
  406735:	84 c0                	test   %al,%al
  406737:	0f 85 83 04 00 00    	jne    406bc0 <fc_solve_sfs_move_sequences_to_free_stacks+0x850>
        if (HT_FIELD(hard_thread, allocated_from_list))
  40673d:	80 bd 18 05 00 00 00 	cmpb   $0x0,0x518(%rbp)
  406744:	0f 84 d6 04 00 00    	je     406c20 <fc_solve_sfs_move_sequences_to_free_stacks+0x8b0>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  40674a:	48 8b 84 24 98 00 00 	mov    0x98(%rsp),%rax
  406751:	00 
  406752:	48 8b 95 b0 00 00 00 	mov    0xb0(%rbp),%rdx
  406759:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  40675c:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  406763:	00 
  406764:	48 89 85 b0 00 00 00 	mov    %rax,0xb0(%rbp)
  40676b:	48 8b ac 24 a0 00 00 	mov    0xa0(%rsp),%rbp
  406772:	00 
    if ((!((list->num_states + (list->states != NULL)) &
  406773:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
  406778:	31 c9                	xor    %ecx,%ecx
  40677a:	48 8b 10             	mov    (%rax),%rdx
  40677d:	48 8b 40 08          	mov    0x8(%rax),%rax
  406781:	48 85 c0             	test   %rax,%rax
  406784:	0f 95 c1             	setne  %cl
  406787:	48 01 d1             	add    %rdx,%rcx
  40678a:	f6 c1 0f             	test   $0xf,%cl
  40678d:	75 26                	jne    4067b5 <fc_solve_sfs_move_sequences_to_free_stacks+0x445>
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  40678f:	48 8d 71 10          	lea    0x10(%rcx),%rsi
  406793:	48 89 c7             	mov    %rax,%rdi
  406796:	44 89 44 24 50       	mov    %r8d,0x50(%rsp)
  40679b:	48 c1 e6 04          	shl    $0x4,%rsi
  40679f:	e8 cc a9 ff ff       	callq  401170 <realloc@plt>
        list->states =
  4067a4:	48 8b 7c 24 20       	mov    0x20(%rsp),%rdi
  4067a9:	44 8b 44 24 50       	mov    0x50(%rsp),%r8d
  4067ae:	48 8b 17             	mov    (%rdi),%rdx
  4067b1:	48 89 47 08          	mov    %rax,0x8(%rdi)
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  4067b5:	48 8b 7c 24 20       	mov    0x20(%rsp),%rdi
  4067ba:	48 8d 4a 01          	lea    0x1(%rdx),%rcx
  4067be:	48 c1 e2 04          	shl    $0x4,%rdx
  4067c2:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
    iter->c = iter->seq_end + 1;
  4067c6:	49 8d 75 01          	lea    0x1(%r13),%rsi
  4067ca:	48 01 d0             	add    %rdx,%rax
  4067cd:	48 89 0f             	mov    %rcx,(%rdi)
  4067d0:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  4067d4:	48 89 28             	mov    %rbp,(%rax)
    for ((*iter).seq_end = (*iter).c; (*iter).seq_end < (*iter).col_len_minus_1;
  4067d7:	49 39 f6             	cmp    %rsi,%r14
  4067da:	0f 8f 9b fd ff ff    	jg     40657b <fc_solve_sfs_move_sequences_to_free_stacks+0x20b>
        if (!fcs_is_parent_card(fcs_col_get_card(col, (*iter).seq_end + 1),
  4067e0:	49 89 f5             	mov    %rsi,%r13
  4067e3:	e9 29 fd ff ff       	jmpq   406511 <fc_solve_sfs_move_sequences_to_free_stacks+0x1a1>
  4067e8:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  4067ef:	00 
                sfs_check_state_begin();
  4067f0:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
  4067f5:	48 8d b4 24 90 00 00 	lea    0x90(%rsp),%rsi
  4067fc:	00 
  4067fd:	44 89 44 24 50       	mov    %r8d,0x50(%rsp)
  406802:	48 8b 4c 24 48       	mov    0x48(%rsp),%rcx
  406807:	48 8b 7c 24 40       	mov    0x40(%rsp),%rdi
  40680c:	e8 ef b0 ff ff       	callq  401900 <fc_solve_sfs_check_state_begin>
                my_copy_stack(stack_idx);
  406811:	48 8b 94 24 98 00 00 	mov    0x98(%rsp),%rdx
  406818:	00 
  406819:	44 8b 44 24 50       	mov    0x50(%rsp),%r8d
  40681e:	8b 42 14             	mov    0x14(%rdx),%eax
  406821:	85 44 24 2c          	test   %eax,0x2c(%rsp)
  406825:	0f 84 08 04 00 00    	je     406c33 <fc_solve_sfs_move_sequences_to_free_stacks+0x8c3>
  40682b:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  406832:	00 
  406833:	48 8b 7c 24 30       	mov    0x30(%rsp),%rdi
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  406838:	31 d2                	xor    %edx,%edx
  40683a:	48 b9 00 00 00 00 ff 	movabs $0xffffffff00000000,%rcx
  406841:	ff ff ff 
                const int cols_indexes[3] = {stack_idx, -1, -1};
  406844:	48 c7 84 24 88 00 00 	movq   $0xffffffffffffffff,0x88(%rsp)
  40684b:	00 ff ff ff ff 
  406850:	4c 63 5c 24 28       	movslq 0x28(%rsp),%r11
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  406855:	89 ac 24 a0 00 00 00 	mov    %ebp,0xa0(%rsp)
        int dest_fc_idx = 0;
  40685c:	45 31 c9             	xor    %r9d,%r9d
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  40685f:	48 89 8c 24 a4 00 00 	mov    %rcx,0xa4(%rsp)
  406866:	00 
  406867:	48 8b 3f             	mov    (%rdi),%rdi
                const int cols_indexes[3] = {stack_idx, -1, -1};
  40686a:	44 89 9c 24 84 00 00 	mov    %r11d,0x84(%rsp)
  406871:	00 
  406872:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  406879:	00 00 00 00 
  40687d:	0f 1f 00             	nopl   (%rax)
            while ((*col_num_cards) == 0)
  406880:	85 ed                	test   %ebp,%ebp
  406882:	0f 85 d8 00 00 00    	jne    406960 <fc_solve_sfs_move_sequences_to_free_stacks+0x5f0>
        if (fcs_state_col_is_empty(state, ret))
  406888:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
  40688d:	48 8b 00             	mov    (%rax),%rax
  406890:	80 38 00             	cmpb   $0x0,(%rax)
  406893:	0f 84 85 06 00 00    	je     406f1e <fc_solve_sfs_move_sequences_to_free_stacks+0xbae>
  406899:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
  40689e:	48 8b 40 08          	mov    0x8(%rax),%rax
  4068a2:	80 38 00             	cmpb   $0x0,(%rax)
  4068a5:	0f 84 be 06 00 00    	je     406f69 <fc_solve_sfs_move_sequences_to_free_stacks+0xbf9>
  4068ab:	48 8b 4c 24 18       	mov    0x18(%rsp),%rcx
  4068b0:	48 8b 41 10          	mov    0x10(%rcx),%rax
  4068b4:	80 38 00             	cmpb   $0x0,(%rax)
  4068b7:	0f 84 9f 06 00 00    	je     406f5c <fc_solve_sfs_move_sequences_to_free_stacks+0xbec>
  4068bd:	48 8b 41 18          	mov    0x18(%rcx),%rax
  4068c1:	80 38 00             	cmpb   $0x0,(%rax)
  4068c4:	0f 84 22 06 00 00    	je     406eec <fc_solve_sfs_move_sequences_to_free_stacks+0xb7c>
  4068ca:	48 8b 41 20          	mov    0x20(%rcx),%rax
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4068ce:	ba 04 00 00 00       	mov    $0x4,%edx
        if (fcs_state_col_is_empty(state, ret))
  4068d3:	80 38 00             	cmpb   $0x0,(%rax)
  4068d6:	0f 84 d9 02 00 00    	je     406bb5 <fc_solve_sfs_move_sequences_to_free_stacks+0x845>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4068dc:	8d 45 05             	lea    0x5(%rbp),%eax
  4068df:	83 f8 07             	cmp    $0x7,%eax
  4068e2:	7f 33                	jg     406917 <fc_solve_sfs_move_sequences_to_free_stacks+0x5a7>
        if (fcs_state_col_is_empty(state, ret))
  4068e4:	48 8b 51 28          	mov    0x28(%rcx),%rdx
  4068e8:	80 3a 00             	cmpb   $0x0,(%rdx)
  4068eb:	0f 84 35 06 00 00    	je     406f26 <fc_solve_sfs_move_sequences_to_free_stacks+0xbb6>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4068f1:	8d 45 06             	lea    0x6(%rbp),%eax
  4068f4:	83 f8 07             	cmp    $0x7,%eax
  4068f7:	7f 1e                	jg     406917 <fc_solve_sfs_move_sequences_to_free_stacks+0x5a7>
        if (fcs_state_col_is_empty(state, ret))
  4068f9:	48 8b 51 30          	mov    0x30(%rcx),%rdx
  4068fd:	80 3a 00             	cmpb   $0x0,(%rdx)
  406900:	0f 84 20 06 00 00    	je     406f26 <fc_solve_sfs_move_sequences_to_free_stacks+0xbb6>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  406906:	85 ed                	test   %ebp,%ebp
  406908:	75 0d                	jne    406917 <fc_solve_sfs_move_sequences_to_free_stacks+0x5a7>
        if (fcs_state_col_is_empty(state, ret))
  40690a:	48 8b 41 38          	mov    0x38(%rcx),%rax
  40690e:	80 38 00             	cmpb   $0x0,(%rax)
  406911:	0f 84 9a 06 00 00    	je     406fb1 <fc_solve_sfs_move_sequences_to_free_stacks+0xc41>
  406917:	49 c7 c1 ff ff ff ff 	mov    $0xffffffffffffffff,%r9
    return -1;
  40691e:	bd ff ff ff ff       	mov    $0xffffffff,%ebp
                my_copy_stack(b);
  406923:	48 8b 94 24 98 00 00 	mov    0x98(%rsp),%rdx
  40692a:	00 
  40692b:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  406932:	00 
  406933:	8b 72 14             	mov    0x14(%rdx),%esi
  406936:	0f a3 ee             	bt     %ebp,%esi
  406939:	0f 83 56 03 00 00    	jae    406c95 <fc_solve_sfs_move_sequences_to_free_stacks+0x925>
                fcs_move_sequence(b, stack_idx, iter.seq_end - seq_start + 1);
  40693f:	4c 89 ed             	mov    %r13,%rbp
  406942:	44 89 44 24 68       	mov    %r8d,0x68(%rsp)
  406947:	4c 29 e5             	sub    %r12,%rbp
  40694a:	48 83 c5 01          	add    $0x1,%rbp
  40694e:	e9 63 fd ff ff       	jmpq   4066b6 <fc_solve_sfs_move_sequences_to_free_stacks+0x346>
  406953:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40695a:	00 00 00 00 
  40695e:	66 90                	xchg   %ax,%ax
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  406960:	41 83 f9 03          	cmp    $0x3,%r9d
  406964:	0f 8f 63 02 00 00    	jg     406bcd <fc_solve_sfs_move_sequences_to_free_stacks+0x85d>
  40696a:	41 8d 49 01          	lea    0x1(%r9),%ecx
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  40696e:	49 63 f1             	movslq %r9d,%rsi
  406971:	80 7c 30 40 00       	cmpb   $0x0,0x40(%rax,%rsi,1)
  406976:	0f 84 3c 04 00 00    	je     406db8 <fc_solve_sfs_move_sequences_to_free_stacks+0xa48>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  40697c:	83 f9 04             	cmp    $0x4,%ecx
  40697f:	74 3c                	je     4069bd <fc_solve_sfs_move_sequences_to_free_stacks+0x64d>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  406981:	48 63 c9             	movslq %ecx,%rcx
  406984:	80 7c 08 40 00       	cmpb   $0x0,0x40(%rax,%rcx,1)
  406989:	0f 84 36 04 00 00    	je     406dc5 <fc_solve_sfs_move_sequences_to_free_stacks+0xa55>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  40698f:	41 8d 49 02          	lea    0x2(%r9),%ecx
  406993:	83 f9 04             	cmp    $0x4,%ecx
  406996:	74 25                	je     4069bd <fc_solve_sfs_move_sequences_to_free_stacks+0x64d>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  406998:	48 63 c9             	movslq %ecx,%rcx
  40699b:	80 7c 08 40 00       	cmpb   $0x0,0x40(%rax,%rcx,1)
  4069a0:	0f 84 28 04 00 00    	je     406dce <fc_solve_sfs_move_sequences_to_free_stacks+0xa5e>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  4069a6:	41 8d 49 03          	lea    0x3(%r9),%ecx
  4069aa:	83 f9 03             	cmp    $0x3,%ecx
  4069ad:	0f 85 1d 02 00 00    	jne    406bd0 <fc_solve_sfs_move_sequences_to_free_stacks+0x860>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  4069b3:	80 78 43 00          	cmpb   $0x0,0x43(%rax)
  4069b7:	0f 84 85 04 00 00    	je     406e42 <fc_solve_sfs_move_sequences_to_free_stacks+0xad2>
  4069bd:	84 d2                	test   %dl,%dl
  4069bf:	0f 85 83 07 00 00    	jne    407148 <fc_solve_sfs_move_sequences_to_free_stacks+0xdd8>
    char *const indirect_stacks_buffer =
  4069c5:	48 81 c7 00 01 00 00 	add    $0x100,%rdi
    int put_cards_in_col_idx = 0;
  4069cc:	45 31 db             	xor    %r11d,%r11d
    char *const indirect_stacks_buffer =
  4069cf:	48 89 7c 24 50       	mov    %rdi,0x50(%rsp)
  4069d4:	48 8b bc 24 90 00 00 	mov    0x90(%rsp),%rdi
  4069db:	00 
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4069dc:	41 83 fb 08          	cmp    $0x8,%r11d
  4069e0:	0f 84 f1 03 00 00    	je     406dd7 <fc_solve_sfs_move_sequences_to_free_stacks+0xa67>
  4069e6:	49 63 d3             	movslq %r11d,%rdx
  4069e9:	48 8d 0c d7          	lea    (%rdi,%rdx,8),%rcx
        if (fcs_state_col_is_empty(state, ret))
  4069ed:	48 8b 31             	mov    (%rcx),%rsi
  4069f0:	41 8d 53 01          	lea    0x1(%r11),%edx
  4069f4:	80 3e 00             	cmpb   $0x0,(%rsi)
  4069f7:	0f 84 52 05 00 00    	je     406f4f <fc_solve_sfs_move_sequences_to_free_stacks+0xbdf>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4069fd:	83 fa 08             	cmp    $0x8,%edx
  406a00:	0f 84 d1 03 00 00    	je     406dd7 <fc_solve_sfs_move_sequences_to_free_stacks+0xa67>
        if (fcs_state_col_is_empty(state, ret))
  406a06:	48 8b 71 08          	mov    0x8(%rcx),%rsi
  406a0a:	80 3e 00             	cmpb   $0x0,(%rsi)
  406a0d:	0f 84 66 05 00 00    	je     406f79 <fc_solve_sfs_move_sequences_to_free_stacks+0xc09>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  406a13:	41 8d 53 02          	lea    0x2(%r11),%edx
  406a17:	83 fa 08             	cmp    $0x8,%edx
  406a1a:	0f 84 b7 03 00 00    	je     406dd7 <fc_solve_sfs_move_sequences_to_free_stacks+0xa67>
        if (fcs_state_col_is_empty(state, ret))
  406a20:	48 8b 71 10          	mov    0x10(%rcx),%rsi
  406a24:	80 3e 00             	cmpb   $0x0,(%rsi)
  406a27:	0f 84 5f 05 00 00    	je     406f8c <fc_solve_sfs_move_sequences_to_free_stacks+0xc1c>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  406a2d:	41 8d 53 03          	lea    0x3(%r11),%edx
  406a31:	83 fa 07             	cmp    $0x7,%edx
  406a34:	0f 8f 9d 03 00 00    	jg     406dd7 <fc_solve_sfs_move_sequences_to_free_stacks+0xa67>
        if (fcs_state_col_is_empty(state, ret))
  406a3a:	48 8b 71 18          	mov    0x18(%rcx),%rsi
  406a3e:	80 3e 00             	cmpb   $0x0,(%rsi)
  406a41:	0f 84 4e 05 00 00    	je     406f95 <fc_solve_sfs_move_sequences_to_free_stacks+0xc25>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  406a47:	41 8d 53 04          	lea    0x4(%r11),%edx
  406a4b:	83 fa 07             	cmp    $0x7,%edx
  406a4e:	0f 8f 83 03 00 00    	jg     406dd7 <fc_solve_sfs_move_sequences_to_free_stacks+0xa67>
        if (fcs_state_col_is_empty(state, ret))
  406a54:	48 8b 71 20          	mov    0x20(%rcx),%rsi
  406a58:	80 3e 00             	cmpb   $0x0,(%rsi)
  406a5b:	0f 84 3d 05 00 00    	je     406f9e <fc_solve_sfs_move_sequences_to_free_stacks+0xc2e>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  406a61:	41 8d 53 05          	lea    0x5(%r11),%edx
  406a65:	83 fa 07             	cmp    $0x7,%edx
  406a68:	0f 8f 69 03 00 00    	jg     406dd7 <fc_solve_sfs_move_sequences_to_free_stacks+0xa67>
        if (fcs_state_col_is_empty(state, ret))
  406a6e:	48 8b 71 28          	mov    0x28(%rcx),%rsi
  406a72:	80 3e 00             	cmpb   $0x0,(%rsi)
  406a75:	0f 84 46 05 00 00    	je     406fc1 <fc_solve_sfs_move_sequences_to_free_stacks+0xc51>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  406a7b:	41 8d 53 06          	lea    0x6(%r11),%edx
  406a7f:	83 fa 07             	cmp    $0x7,%edx
  406a82:	0f 8f 4f 03 00 00    	jg     406dd7 <fc_solve_sfs_move_sequences_to_free_stacks+0xa67>
        if (fcs_state_col_is_empty(state, ret))
  406a88:	48 8b 49 30          	mov    0x30(%rcx),%rcx
  406a8c:	80 39 00             	cmpb   $0x0,(%rcx)
  406a8f:	0f 84 53 05 00 00    	je     406fe8 <fc_solve_sfs_move_sequences_to_free_stacks+0xc78>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  406a95:	45 85 db             	test   %r11d,%r11d
  406a98:	0f 85 39 03 00 00    	jne    406dd7 <fc_solve_sfs_move_sequences_to_free_stacks+0xa67>
        if (fcs_state_col_is_empty(state, ret))
  406a9e:	48 8b 57 38          	mov    0x38(%rdi),%rdx
  406aa2:	bf 08 00 00 00       	mov    $0x8,%edi
  406aa7:	80 3a 00             	cmpb   $0x0,(%rdx)
  406aaa:	44 0f 44 df          	cmove  %edi,%r11d
  406aae:	80 3a 01             	cmpb   $0x1,(%rdx)
  406ab1:	19 d2                	sbb    %edx,%edx
  406ab3:	83 e2 08             	and    $0x8,%edx
  406ab6:	83 ea 01             	sub    $0x1,%edx
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  406ab9:	48 8b bc 24 98 00 00 	mov    0x98(%rsp),%rdi
  406ac0:	00 
  406ac1:	4c 63 ca             	movslq %edx,%r9
  406ac4:	8b 77 14             	mov    0x14(%rdi),%esi
  406ac7:	0f a3 d6             	bt     %edx,%esi
  406aca:	0f 83 14 03 00 00    	jae    406de4 <fc_solve_sfs_move_sequences_to_free_stacks+0xa74>
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  406ad0:	48 63 8c 24 84 00 00 	movslq 0x84(%rsp),%rcx
  406ad7:	00 
        --(*col_num_cards);
  406ad8:	83 ed 01             	sub    $0x1,%ebp
  406adb:	48 8b 34 c8          	mov    (%rax,%rcx,8),%rsi
    fcs_col_pop_card(col, ret);
  406adf:	0f be 3e             	movsbl (%rsi),%edi
  406ae2:	89 f9                	mov    %edi,%ecx
  406ae4:	83 ef 01             	sub    $0x1,%edi
  406ae7:	83 e9 01             	sub    $0x1,%ecx
  406aea:	48 63 ff             	movslq %edi,%rdi
  406aed:	0f b6 7c 3e 01       	movzbl 0x1(%rsi,%rdi,1),%edi
  406af2:	88 0e                	mov    %cl,(%rsi)
  406af4:	48 0f be c9          	movsbq %cl,%rcx
  406af8:	c6 44 0e 01 00       	movb   $0x0,0x1(%rsi,%rcx,1)
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  406afd:	4a 8b 34 c8          	mov    (%rax,%r9,8),%rsi
    fcs_col_push_card(col, card);
  406b01:	48 0f be 0e          	movsbq (%rsi),%rcx
  406b05:	44 8d 51 01          	lea    0x1(%rcx),%r10d
  406b09:	44 88 16             	mov    %r10b,(%rsi)
  406b0c:	40 88 7c 0e 01       	mov    %dil,0x1(%rsi,%rcx,1)
  406b11:	89 ac 24 a0 00 00 00 	mov    %ebp,0xa0(%rsp)
        while ((*col_num_cards) == 0)
  406b18:	85 ed                	test   %ebp,%ebp
  406b1a:	0f 85 b4 fe ff ff    	jne    4069d4 <fc_solve_sfs_move_sequences_to_free_stacks+0x664>
                const int b = find_empty_stack(raw_state_raw,
  406b20:	8d 6a 01             	lea    0x1(%rdx),%ebp
    for (int ret = start_from; ret < local_stacks_num; ret++)
  406b23:	83 fd 08             	cmp    $0x8,%ebp
  406b26:	0f 84 eb fd ff ff    	je     406917 <fc_solve_sfs_move_sequences_to_free_stacks+0x5a7>
  406b2c:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
  406b31:	4a 8d 04 c8          	lea    (%rax,%r9,8),%rax
        if (fcs_state_col_is_empty(state, ret))
  406b35:	48 8b 48 08          	mov    0x8(%rax),%rcx
  406b39:	80 39 00             	cmpb   $0x0,(%rcx)
  406b3c:	0f 84 af 03 00 00    	je     406ef1 <fc_solve_sfs_move_sequences_to_free_stacks+0xb81>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  406b42:	8d 4a 02             	lea    0x2(%rdx),%ecx
  406b45:	83 f9 08             	cmp    $0x8,%ecx
  406b48:	0f 84 c9 fd ff ff    	je     406917 <fc_solve_sfs_move_sequences_to_free_stacks+0x5a7>
        if (fcs_state_col_is_empty(state, ret))
  406b4e:	48 8b 40 10          	mov    0x10(%rax),%rax
  406b52:	80 38 00             	cmpb   $0x0,(%rax)
  406b55:	0f 84 4c 04 00 00    	je     406fa7 <fc_solve_sfs_move_sequences_to_free_stacks+0xc37>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  406b5b:	8d 42 03             	lea    0x3(%rdx),%eax
  406b5e:	83 f8 07             	cmp    $0x7,%eax
  406b61:	0f 8f b0 fd ff ff    	jg     406917 <fc_solve_sfs_move_sequences_to_free_stacks+0x5a7>
        if (fcs_state_col_is_empty(state, ret))
  406b67:	48 8b 7c 24 18       	mov    0x18(%rsp),%rdi
  406b6c:	48 63 c8             	movslq %eax,%rcx
  406b6f:	48 8b 0c cf          	mov    (%rdi,%rcx,8),%rcx
  406b73:	80 39 00             	cmpb   $0x0,(%rcx)
  406b76:	0f 84 06 04 00 00    	je     406f82 <fc_solve_sfs_move_sequences_to_free_stacks+0xc12>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  406b7c:	8d 42 04             	lea    0x4(%rdx),%eax
  406b7f:	83 f8 07             	cmp    $0x7,%eax
  406b82:	0f 8f 8f fd ff ff    	jg     406917 <fc_solve_sfs_move_sequences_to_free_stacks+0x5a7>
  406b88:	48 63 cd             	movslq %ebp,%rcx
  406b8b:	48 8d 0c cf          	lea    (%rdi,%rcx,8),%rcx
        if (fcs_state_col_is_empty(state, ret))
  406b8f:	48 8b 71 18          	mov    0x18(%rcx),%rsi
  406b93:	80 3e 00             	cmpb   $0x0,(%rsi)
  406b96:	0f 84 e6 03 00 00    	je     406f82 <fc_solve_sfs_move_sequences_to_free_stacks+0xc12>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  406b9c:	83 c2 05             	add    $0x5,%edx
  406b9f:	83 fa 07             	cmp    $0x7,%edx
  406ba2:	0f 8f 6f fd ff ff    	jg     406917 <fc_solve_sfs_move_sequences_to_free_stacks+0x5a7>
        if (fcs_state_col_is_empty(state, ret))
  406ba8:	48 8b 41 20          	mov    0x20(%rcx),%rax
  406bac:	80 38 00             	cmpb   $0x0,(%rax)
  406baf:	0f 85 27 fd ff ff    	jne    4068dc <fc_solve_sfs_move_sequences_to_free_stacks+0x56c>
  406bb5:	4c 63 ca             	movslq %edx,%r9
  406bb8:	89 d5                	mov    %edx,%ebp
  406bba:	e9 64 fd ff ff       	jmpq   406923 <fc_solve_sfs_move_sequences_to_free_stacks+0x5b3>
  406bbf:	90                   	nop
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  406bc0:	48 8b ac 24 90 00 00 	mov    0x90(%rsp),%rbp
  406bc7:	00 
  406bc8:	e9 a6 fb ff ff       	jmpq   406773 <fc_solve_sfs_move_sequences_to_free_stacks+0x403>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  406bcd:	44 89 c9             	mov    %r9d,%ecx
            if (dest_fc_idx == LOCAL_FREECELLS_NUM)
  406bd0:	83 f9 04             	cmp    $0x4,%ecx
  406bd3:	0f 84 e4 fd ff ff    	je     4069bd <fc_solve_sfs_move_sequences_to_free_stacks+0x64d>
  406bd9:	44 8d 49 01          	lea    0x1(%rcx),%r9d
  406bdd:	48 63 c9             	movslq %ecx,%rcx
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  406be0:	4a 8b 34 d8          	mov    (%rax,%r11,8),%rsi
            --(*col_num_cards);
  406be4:	83 ed 01             	sub    $0x1,%ebp
    fcs_col_pop_card(col, ret);
  406be7:	44 0f be 16          	movsbl (%rsi),%r10d
  406beb:	44 89 d2             	mov    %r10d,%edx
  406bee:	41 83 ea 01          	sub    $0x1,%r10d
  406bf2:	4d 63 d2             	movslq %r10d,%r10
  406bf5:	83 ea 01             	sub    $0x1,%edx
  406bf8:	46 0f b6 54 16 01    	movzbl 0x1(%rsi,%r10,1),%r10d
  406bfe:	88 16                	mov    %dl,(%rsi)
  406c00:	48 0f be d2          	movsbq %dl,%rdx
  406c04:	c6 44 16 01 00       	movb   $0x0,0x1(%rsi,%rdx,1)
  406c09:	ba 01 00 00 00       	mov    $0x1,%edx
            fcs_put_card_in_freecell(*new_key, dest_fc_idx, top_card);
  406c0e:	44 88 54 08 40       	mov    %r10b,0x40(%rax,%rcx,1)
  406c13:	e9 68 fc ff ff       	jmpq   406880 <fc_solve_sfs_move_sequences_to_free_stacks+0x510>
  406c18:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  406c1f:	00 
  406c20:	48 8b 85 f0 00 00 00 	mov    0xf0(%rbp),%rax
  406c27:	48 89 85 e8 00 00 00 	mov    %rax,0xe8(%rbp)
  406c2e:	e9 38 fb ff ff       	jmpq   40676b <fc_solve_sfs_move_sequences_to_free_stacks+0x3fb>
                my_copy_stack(stack_idx);
  406c33:	0b 44 24 2c          	or     0x2c(%rsp),%eax
  406c37:	89 42 14             	mov    %eax,0x14(%rdx)
  406c3a:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  406c41:	00 
  406c42:	48 63 54 24 28       	movslq 0x28(%rsp),%rdx
  406c47:	48 8b 34 d0          	mov    (%rax,%rdx,8),%rsi
  406c4b:	0f be 0e             	movsbl (%rsi),%ecx
  406c4e:	83 c1 01             	add    $0x1,%ecx
  406c51:	48 63 c9             	movslq %ecx,%rcx
  406c54:	48 83 f9 08          	cmp    $0x8,%rcx
  406c58:	0f 83 21 02 00 00    	jae    406e7f <fc_solve_sfs_move_sequences_to_free_stacks+0xb0f>
  406c5e:	f6 c1 04             	test   $0x4,%cl
  406c61:	0f 85 63 03 00 00    	jne    406fca <fc_solve_sfs_move_sequences_to_free_stacks+0xc5a>
  406c67:	48 85 c9             	test   %rcx,%rcx
  406c6a:	74 1b                	je     406c87 <fc_solve_sfs_move_sequences_to_free_stacks+0x917>
  406c6c:	0f b6 06             	movzbl (%rsi),%eax
  406c6f:	48 8b 7c 24 38       	mov    0x38(%rsp),%rdi
  406c74:	88 07                	mov    %al,(%rdi)
  406c76:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  406c7d:	00 
  406c7e:	f6 c1 02             	test   $0x2,%cl
  406c81:	0f 85 98 04 00 00    	jne    40711f <fc_solve_sfs_move_sequences_to_free_stacks+0xdaf>
  406c87:	48 8b 7c 24 38       	mov    0x38(%rsp),%rdi
  406c8c:	48 89 3c d0          	mov    %rdi,(%rax,%rdx,8)
  406c90:	e9 9e fb ff ff       	jmpq   406833 <fc_solve_sfs_move_sequences_to_free_stacks+0x4c3>
                my_copy_stack(b);
  406c95:	89 e9                	mov    %ebp,%ecx
  406c97:	bf 01 00 00 00       	mov    $0x1,%edi
  406c9c:	4c 63 dd             	movslq %ebp,%r11
  406c9f:	d3 e7                	shl    %cl,%edi
  406ca1:	c1 e5 07             	shl    $0x7,%ebp
  406ca4:	09 fe                	or     %edi,%esi
  406ca6:	4c 63 d5             	movslq %ebp,%r10
  406ca9:	4c 03 54 24 60       	add    0x60(%rsp),%r10
  406cae:	89 72 14             	mov    %esi,0x14(%rdx)
  406cb1:	4a 8b 34 d8          	mov    (%rax,%r11,8),%rsi
  406cb5:	0f be 16             	movsbl (%rsi),%edx
  406cb8:	83 c2 01             	add    $0x1,%edx
  406cbb:	48 63 d2             	movslq %edx,%rdx
  406cbe:	48 83 fa 08          	cmp    $0x8,%rdx
  406cc2:	0f 83 92 01 00 00    	jae    406e5a <fc_solve_sfs_move_sequences_to_free_stacks+0xaea>
  406cc8:	f6 c2 04             	test   $0x4,%dl
  406ccb:	0f 85 64 03 00 00    	jne    407035 <fc_solve_sfs_move_sequences_to_free_stacks+0xcc5>
  406cd1:	48 85 d2             	test   %rdx,%rdx
  406cd4:	74 17                	je     406ced <fc_solve_sfs_move_sequences_to_free_stacks+0x97d>
  406cd6:	0f b6 06             	movzbl (%rsi),%eax
  406cd9:	41 88 02             	mov    %al,(%r10)
  406cdc:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  406ce3:	00 
  406ce4:	f6 c2 02             	test   $0x2,%dl
  406ce7:	0f 85 c7 03 00 00    	jne    4070b4 <fc_solve_sfs_move_sequences_to_free_stacks+0xd44>
  406ced:	4e 89 14 d8          	mov    %r10,(%rax,%r11,8)
  406cf1:	e9 49 fc ff ff       	jmpq   40693f <fc_solve_sfs_move_sequences_to_free_stacks+0x5cf>
                copy_two_stacks(stack_idx, ds);
  406cf6:	0b 54 24 74          	or     0x74(%rsp),%edx
  406cfa:	4a 8b 34 c8          	mov    (%rax,%r9,8),%rsi
  406cfe:	89 57 14             	mov    %edx,0x14(%rdi)
  406d01:	0f be 16             	movsbl (%rsi),%edx
  406d04:	83 c2 01             	add    $0x1,%edx
  406d07:	48 63 d2             	movslq %edx,%rdx
  406d0a:	48 83 fa 08          	cmp    $0x8,%rdx
  406d0e:	0f 83 b1 01 00 00    	jae    406ec5 <fc_solve_sfs_move_sequences_to_free_stacks+0xb55>
  406d14:	f6 c2 04             	test   $0x4,%dl
  406d17:	0f 85 fa 02 00 00    	jne    407017 <fc_solve_sfs_move_sequences_to_free_stacks+0xca7>
  406d1d:	48 85 d2             	test   %rdx,%rdx
  406d20:	74 1b                	je     406d3d <fc_solve_sfs_move_sequences_to_free_stacks+0x9cd>
  406d22:	0f b6 06             	movzbl (%rsi),%eax
  406d25:	48 8b 7c 24 78       	mov    0x78(%rsp),%rdi
  406d2a:	88 07                	mov    %al,(%rdi)
  406d2c:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  406d33:	00 
  406d34:	f6 c2 02             	test   $0x2,%dl
  406d37:	0f 85 8f 03 00 00    	jne    4070cc <fc_solve_sfs_move_sequences_to_free_stacks+0xd5c>
  406d3d:	48 8b 7c 24 78       	mov    0x78(%rsp),%rdi
  406d42:	4a 89 3c c8          	mov    %rdi,(%rax,%r9,8)
  406d46:	e9 66 f9 ff ff       	jmpq   4066b1 <fc_solve_sfs_move_sequences_to_free_stacks+0x341>
  406d4b:	0b 54 24 2c          	or     0x2c(%rsp),%edx
  406d4f:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  406d56:	00 
  406d57:	89 57 14             	mov    %edx,0x14(%rdi)
  406d5a:	48 63 54 24 28       	movslq 0x28(%rsp),%rdx
  406d5f:	48 8b 34 d0          	mov    (%rax,%rdx,8),%rsi
  406d63:	0f be 0e             	movsbl (%rsi),%ecx
  406d66:	83 c1 01             	add    $0x1,%ecx
  406d69:	48 63 c9             	movslq %ecx,%rcx
  406d6c:	48 83 f9 08          	cmp    $0x8,%rcx
  406d70:	0f 83 30 01 00 00    	jae    406ea6 <fc_solve_sfs_move_sequences_to_free_stacks+0xb36>
  406d76:	f6 c1 04             	test   $0x4,%cl
  406d79:	0f 85 72 02 00 00    	jne    406ff1 <fc_solve_sfs_move_sequences_to_free_stacks+0xc81>
  406d7f:	48 85 c9             	test   %rcx,%rcx
  406d82:	74 23                	je     406da7 <fc_solve_sfs_move_sequences_to_free_stacks+0xa37>
  406d84:	0f b6 06             	movzbl (%rsi),%eax
  406d87:	48 8b 7c 24 38       	mov    0x38(%rsp),%rdi
  406d8c:	88 07                	mov    %al,(%rdi)
  406d8e:	f6 c1 02             	test   $0x2,%cl
  406d91:	0f 85 51 03 00 00    	jne    4070e8 <fc_solve_sfs_move_sequences_to_free_stacks+0xd78>
  406d97:	48 8b bc 24 98 00 00 	mov    0x98(%rsp),%rdi
  406d9e:	00 
  406d9f:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  406da6:	00 
  406da7:	48 8b 74 24 38       	mov    0x38(%rsp),%rsi
  406dac:	48 89 34 d0          	mov    %rsi,(%rax,%rdx,8)
  406db0:	8b 57 14             	mov    0x14(%rdi),%edx
  406db3:	e9 ea f8 ff ff       	jmpq   4066a2 <fc_solve_sfs_move_sequences_to_free_stacks+0x332>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  406db8:	89 ca                	mov    %ecx,%edx
  406dba:	49 63 c9             	movslq %r9d,%rcx
  406dbd:	41 89 d1             	mov    %edx,%r9d
  406dc0:	e9 1b fe ff ff       	jmpq   406be0 <fc_solve_sfs_move_sequences_to_free_stacks+0x870>
  406dc5:	41 83 c1 02          	add    $0x2,%r9d
  406dc9:	e9 12 fe ff ff       	jmpq   406be0 <fc_solve_sfs_move_sequences_to_free_stacks+0x870>
  406dce:	41 83 c1 03          	add    $0x3,%r9d
  406dd2:	e9 09 fe ff ff       	jmpq   406be0 <fc_solve_sfs_move_sequences_to_free_stacks+0x870>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  406dd7:	45 31 db             	xor    %r11d,%r11d
    return -1;
  406dda:	ba ff ff ff ff       	mov    $0xffffffff,%edx
  406ddf:	e9 d5 fc ff ff       	jmpq   406ab9 <fc_solve_sfs_move_sequences_to_free_stacks+0x749>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  406de4:	89 d1                	mov    %edx,%ecx
  406de6:	41 ba 01 00 00 00    	mov    $0x1,%r10d
  406dec:	41 d3 e2             	shl    %cl,%r10d
  406def:	44 09 d6             	or     %r10d,%esi
  406df2:	41 89 d2             	mov    %edx,%r10d
  406df5:	89 77 14             	mov    %esi,0x14(%rdi)
  406df8:	4a 8d 3c c8          	lea    (%rax,%r9,8),%rdi
  406dfc:	41 c1 e2 07          	shl    $0x7,%r10d
  406e00:	48 8b 37             	mov    (%rdi),%rsi
  406e03:	4d 63 d2             	movslq %r10d,%r10
  406e06:	48 89 7c 24 58       	mov    %rdi,0x58(%rsp)
  406e0b:	4c 03 54 24 50       	add    0x50(%rsp),%r10
  406e10:	0f be 0e             	movsbl (%rsi),%ecx
  406e13:	83 c1 01             	add    $0x1,%ecx
  406e16:	48 63 c9             	movslq %ecx,%rcx
  406e19:	48 83 f9 08          	cmp    $0x8,%rcx
  406e1d:	0f 83 d6 00 00 00    	jae    406ef9 <fc_solve_sfs_move_sequences_to_free_stacks+0xb89>
  406e23:	f6 c1 04             	test   $0x4,%cl
  406e26:	0f 85 e0 02 00 00    	jne    40710c <fc_solve_sfs_move_sequences_to_free_stacks+0xd9c>
  406e2c:	48 85 c9             	test   %rcx,%rcx
  406e2f:	0f 85 fb 00 00 00    	jne    406f30 <fc_solve_sfs_move_sequences_to_free_stacks+0xbc0>
  406e35:	48 8b 7c 24 58       	mov    0x58(%rsp),%rdi
  406e3a:	4c 89 17             	mov    %r10,(%rdi)
  406e3d:	e9 8e fc ff ff       	jmpq   406ad0 <fc_solve_sfs_move_sequences_to_free_stacks+0x760>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  406e42:	41 b9 04 00 00 00    	mov    $0x4,%r9d
  406e48:	b9 03 00 00 00       	mov    $0x3,%ecx
  406e4d:	e9 8e fd ff ff       	jmpq   406be0 <fc_solve_sfs_move_sequences_to_free_stacks+0x870>
    for ((*iter).seq_end = (*iter).c; (*iter).seq_end < (*iter).col_len_minus_1;
  406e52:	45 31 ed             	xor    %r13d,%r13d
  406e55:	e9 8c f6 ff ff       	jmpq   4064e6 <fc_solve_sfs_move_sequences_to_free_stacks+0x176>
                my_copy_stack(b);
  406e5a:	48 8b 44 16 f8       	mov    -0x8(%rsi,%rdx,1),%rax
  406e5f:	48 8d 4a ff          	lea    -0x1(%rdx),%rcx
  406e63:	4c 89 d7             	mov    %r10,%rdi
  406e66:	48 c1 e9 03          	shr    $0x3,%rcx
  406e6a:	49 89 44 12 f8       	mov    %rax,-0x8(%r10,%rdx,1)
  406e6f:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  406e72:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  406e79:	00 
  406e7a:	e9 6e fe ff ff       	jmpq   406ced <fc_solve_sfs_move_sequences_to_free_stacks+0x97d>
                my_copy_stack(stack_idx);
  406e7f:	48 8b 44 0e f8       	mov    -0x8(%rsi,%rcx,1),%rax
  406e84:	48 8b 7c 24 38       	mov    0x38(%rsp),%rdi
  406e89:	48 89 44 0f f8       	mov    %rax,-0x8(%rdi,%rcx,1)
  406e8e:	48 83 e9 01          	sub    $0x1,%rcx
  406e92:	48 c1 e9 03          	shr    $0x3,%rcx
  406e96:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  406e99:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  406ea0:	00 
  406ea1:	e9 e1 fd ff ff       	jmpq   406c87 <fc_solve_sfs_move_sequences_to_free_stacks+0x917>
                copy_two_stacks(stack_idx, ds);
  406ea6:	48 8b 44 0e f8       	mov    -0x8(%rsi,%rcx,1),%rax
  406eab:	48 8b 7c 24 38       	mov    0x38(%rsp),%rdi
  406eb0:	48 89 44 0f f8       	mov    %rax,-0x8(%rdi,%rcx,1)
  406eb5:	48 83 e9 01          	sub    $0x1,%rcx
  406eb9:	48 c1 e9 03          	shr    $0x3,%rcx
  406ebd:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  406ec0:	e9 d2 fe ff ff       	jmpq   406d97 <fc_solve_sfs_move_sequences_to_free_stacks+0xa27>
  406ec5:	48 8b 44 16 f8       	mov    -0x8(%rsi,%rdx,1),%rax
  406eca:	48 8d 4a ff          	lea    -0x1(%rdx),%rcx
  406ece:	48 8b 7c 24 78       	mov    0x78(%rsp),%rdi
  406ed3:	48 c1 e9 03          	shr    $0x3,%rcx
  406ed7:	48 89 44 17 f8       	mov    %rax,-0x8(%rdi,%rdx,1)
  406edc:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  406edf:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  406ee6:	00 
  406ee7:	e9 51 fe ff ff       	jmpq   406d3d <fc_solve_sfs_move_sequences_to_free_stacks+0x9cd>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  406eec:	bd 03 00 00 00       	mov    $0x3,%ebp
  406ef1:	4c 63 cd             	movslq %ebp,%r9
  406ef4:	e9 2a fa ff ff       	jmpq   406923 <fc_solve_sfs_move_sequences_to_free_stacks+0x5b3>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  406ef9:	48 8b 7c 0e f8       	mov    -0x8(%rsi,%rcx,1),%rdi
  406efe:	49 89 7c 0a f8       	mov    %rdi,-0x8(%r10,%rcx,1)
  406f03:	48 83 e9 01          	sub    $0x1,%rcx
  406f07:	4c 89 d7             	mov    %r10,%rdi
  406f0a:	48 c1 e9 03          	shr    $0x3,%rcx
  406f0e:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  406f11:	48 8b 7c 24 58       	mov    0x58(%rsp),%rdi
  406f16:	4c 89 17             	mov    %r10,(%rdi)
  406f19:	e9 b2 fb ff ff       	jmpq   406ad0 <fc_solve_sfs_move_sequences_to_free_stacks+0x760>
        if (fcs_state_col_is_empty(state, ret))
  406f1e:	45 31 c9             	xor    %r9d,%r9d
  406f21:	e9 fd f9 ff ff       	jmpq   406923 <fc_solve_sfs_move_sequences_to_free_stacks+0x5b3>
  406f26:	4c 63 c8             	movslq %eax,%r9
  406f29:	89 c5                	mov    %eax,%ebp
  406f2b:	e9 f3 f9 ff ff       	jmpq   406923 <fc_solve_sfs_move_sequences_to_free_stacks+0x5b3>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  406f30:	0f b6 3e             	movzbl (%rsi),%edi
  406f33:	41 88 3a             	mov    %dil,(%r10)
  406f36:	f6 c1 02             	test   $0x2,%cl
  406f39:	0f 84 f6 fe ff ff    	je     406e35 <fc_solve_sfs_move_sequences_to_free_stacks+0xac5>
  406f3f:	0f b7 74 0e fe       	movzwl -0x2(%rsi,%rcx,1),%esi
  406f44:	66 41 89 74 0a fe    	mov    %si,-0x2(%r10,%rcx,1)
  406f4a:	e9 e6 fe ff ff       	jmpq   406e35 <fc_solve_sfs_move_sequences_to_free_stacks+0xac5>
        if (fcs_state_col_is_empty(state, ret))
  406f4f:	89 d1                	mov    %edx,%ecx
  406f51:	44 89 da             	mov    %r11d,%edx
  406f54:	41 89 cb             	mov    %ecx,%r11d
  406f57:	e9 5d fb ff ff       	jmpq   406ab9 <fc_solve_sfs_move_sequences_to_free_stacks+0x749>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  406f5c:	bd 02 00 00 00       	mov    $0x2,%ebp
  406f61:	4c 63 cd             	movslq %ebp,%r9
  406f64:	e9 ba f9 ff ff       	jmpq   406923 <fc_solve_sfs_move_sequences_to_free_stacks+0x5b3>
        if (fcs_state_col_is_empty(state, ret))
  406f69:	41 b9 01 00 00 00    	mov    $0x1,%r9d
    for (int ret = start_from; ret < local_stacks_num; ret++)
  406f6f:	bd 01 00 00 00       	mov    $0x1,%ebp
  406f74:	e9 aa f9 ff ff       	jmpq   406923 <fc_solve_sfs_move_sequences_to_free_stacks+0x5b3>
  406f79:	41 83 c3 02          	add    $0x2,%r11d
  406f7d:	e9 37 fb ff ff       	jmpq   406ab9 <fc_solve_sfs_move_sequences_to_free_stacks+0x749>
        if (fcs_state_col_is_empty(state, ret))
  406f82:	89 c5                	mov    %eax,%ebp
  406f84:	4c 63 cd             	movslq %ebp,%r9
  406f87:	e9 97 f9 ff ff       	jmpq   406923 <fc_solve_sfs_move_sequences_to_free_stacks+0x5b3>
  406f8c:	41 83 c3 03          	add    $0x3,%r11d
  406f90:	e9 24 fb ff ff       	jmpq   406ab9 <fc_solve_sfs_move_sequences_to_free_stacks+0x749>
  406f95:	41 83 c3 04          	add    $0x4,%r11d
  406f99:	e9 1b fb ff ff       	jmpq   406ab9 <fc_solve_sfs_move_sequences_to_free_stacks+0x749>
  406f9e:	41 83 c3 05          	add    $0x5,%r11d
  406fa2:	e9 12 fb ff ff       	jmpq   406ab9 <fc_solve_sfs_move_sequences_to_free_stacks+0x749>
  406fa7:	4c 63 c9             	movslq %ecx,%r9
  406faa:	89 cd                	mov    %ecx,%ebp
  406fac:	e9 72 f9 ff ff       	jmpq   406923 <fc_solve_sfs_move_sequences_to_free_stacks+0x5b3>
  406fb1:	41 b9 07 00 00 00    	mov    $0x7,%r9d
  406fb7:	bd 07 00 00 00       	mov    $0x7,%ebp
  406fbc:	e9 62 f9 ff ff       	jmpq   406923 <fc_solve_sfs_move_sequences_to_free_stacks+0x5b3>
  406fc1:	41 83 c3 06          	add    $0x6,%r11d
  406fc5:	e9 ef fa ff ff       	jmpq   406ab9 <fc_solve_sfs_move_sequences_to_free_stacks+0x749>
                my_copy_stack(stack_idx);
  406fca:	8b 06                	mov    (%rsi),%eax
  406fcc:	48 8b 7c 24 38       	mov    0x38(%rsp),%rdi
  406fd1:	89 07                	mov    %eax,(%rdi)
  406fd3:	8b 44 0e fc          	mov    -0x4(%rsi,%rcx,1),%eax
  406fd7:	89 44 0f fc          	mov    %eax,-0x4(%rdi,%rcx,1)
  406fdb:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  406fe2:	00 
  406fe3:	e9 9f fc ff ff       	jmpq   406c87 <fc_solve_sfs_move_sequences_to_free_stacks+0x917>
  406fe8:	41 83 c3 07          	add    $0x7,%r11d
  406fec:	e9 c8 fa ff ff       	jmpq   406ab9 <fc_solve_sfs_move_sequences_to_free_stacks+0x749>
                copy_two_stacks(stack_idx, ds);
  406ff1:	8b 06                	mov    (%rsi),%eax
  406ff3:	48 8b 7c 24 38       	mov    0x38(%rsp),%rdi
  406ff8:	89 07                	mov    %eax,(%rdi)
  406ffa:	8b 44 0e fc          	mov    -0x4(%rsi,%rcx,1),%eax
  406ffe:	89 44 0f fc          	mov    %eax,-0x4(%rdi,%rcx,1)
  407002:	48 8b bc 24 98 00 00 	mov    0x98(%rsp),%rdi
  407009:	00 
  40700a:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  407011:	00 
  407012:	e9 90 fd ff ff       	jmpq   406da7 <fc_solve_sfs_move_sequences_to_free_stacks+0xa37>
  407017:	8b 06                	mov    (%rsi),%eax
  407019:	48 8b 7c 24 78       	mov    0x78(%rsp),%rdi
  40701e:	89 07                	mov    %eax,(%rdi)
  407020:	8b 44 16 fc          	mov    -0x4(%rsi,%rdx,1),%eax
  407024:	89 44 17 fc          	mov    %eax,-0x4(%rdi,%rdx,1)
  407028:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  40702f:	00 
  407030:	e9 08 fd ff ff       	jmpq   406d3d <fc_solve_sfs_move_sequences_to_free_stacks+0x9cd>
                my_copy_stack(b);
  407035:	8b 06                	mov    (%rsi),%eax
  407037:	41 89 02             	mov    %eax,(%r10)
  40703a:	8b 44 16 fc          	mov    -0x4(%rsi,%rdx,1),%eax
  40703e:	41 89 44 12 fc       	mov    %eax,-0x4(%r10,%rdx,1)
  407043:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  40704a:	00 
  40704b:	e9 9d fc ff ff       	jmpq   406ced <fc_solve_sfs_move_sequences_to_free_stacks+0x97d>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  407050:	c7 44 24 70 00 00 00 	movl   $0x0,0x70(%rsp)
  407057:	00 
  407058:	8b 5c 24 70          	mov    0x70(%rsp),%ebx
  40705c:	41 b9 01 00 00 00    	mov    $0x1,%r9d
  407062:	89 d8                	mov    %ebx,%eax
  407064:	89 d9                	mov    %ebx,%ecx
  407066:	c1 e0 07             	shl    $0x7,%eax
  407069:	41 d3 e1             	shl    %cl,%r9d
  40706c:	48 98                	cltq   
  40706e:	44 89 4c 24 74       	mov    %r9d,0x74(%rsp)
  407073:	e9 b4 f3 ff ff       	jmpq   40642c <fc_solve_sfs_move_sequences_to_free_stacks+0xbc>
  407078:	c7 44 24 70 01 00 00 	movl   $0x1,0x70(%rsp)
  40707f:	00 
  407080:	eb d6                	jmp    407058 <fc_solve_sfs_move_sequences_to_free_stacks+0xce8>
  407082:	c7 44 24 70 02 00 00 	movl   $0x2,0x70(%rsp)
  407089:	00 
  40708a:	eb cc                	jmp    407058 <fc_solve_sfs_move_sequences_to_free_stacks+0xce8>
  40708c:	c7 44 24 70 03 00 00 	movl   $0x3,0x70(%rsp)
  407093:	00 
  407094:	eb c2                	jmp    407058 <fc_solve_sfs_move_sequences_to_free_stacks+0xce8>
  407096:	c7 44 24 70 04 00 00 	movl   $0x4,0x70(%rsp)
  40709d:	00 
  40709e:	eb b8                	jmp    407058 <fc_solve_sfs_move_sequences_to_free_stacks+0xce8>
  4070a0:	c7 44 24 70 05 00 00 	movl   $0x5,0x70(%rsp)
  4070a7:	00 
  4070a8:	eb ae                	jmp    407058 <fc_solve_sfs_move_sequences_to_free_stacks+0xce8>
  4070aa:	c7 44 24 70 06 00 00 	movl   $0x6,0x70(%rsp)
  4070b1:	00 
  4070b2:	eb a4                	jmp    407058 <fc_solve_sfs_move_sequences_to_free_stacks+0xce8>
                my_copy_stack(b);
  4070b4:	0f b7 44 16 fe       	movzwl -0x2(%rsi,%rdx,1),%eax
  4070b9:	66 41 89 44 12 fe    	mov    %ax,-0x2(%r10,%rdx,1)
  4070bf:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  4070c6:	00 
  4070c7:	e9 21 fc ff ff       	jmpq   406ced <fc_solve_sfs_move_sequences_to_free_stacks+0x97d>
                copy_two_stacks(stack_idx, ds);
  4070cc:	0f b7 44 16 fe       	movzwl -0x2(%rsi,%rdx,1),%eax
  4070d1:	48 8b 7c 24 78       	mov    0x78(%rsp),%rdi
  4070d6:	66 89 44 17 fe       	mov    %ax,-0x2(%rdi,%rdx,1)
  4070db:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  4070e2:	00 
  4070e3:	e9 55 fc ff ff       	jmpq   406d3d <fc_solve_sfs_move_sequences_to_free_stacks+0x9cd>
  4070e8:	0f b7 44 0e fe       	movzwl -0x2(%rsi,%rcx,1),%eax
  4070ed:	48 8b 7c 24 38       	mov    0x38(%rsp),%rdi
  4070f2:	66 89 44 0f fe       	mov    %ax,-0x2(%rdi,%rcx,1)
  4070f7:	48 8b bc 24 98 00 00 	mov    0x98(%rsp),%rdi
  4070fe:	00 
  4070ff:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  407106:	00 
  407107:	e9 9b fc ff ff       	jmpq   406da7 <fc_solve_sfs_move_sequences_to_free_stacks+0xa37>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  40710c:	8b 3e                	mov    (%rsi),%edi
  40710e:	41 89 3a             	mov    %edi,(%r10)
  407111:	8b 74 0e fc          	mov    -0x4(%rsi,%rcx,1),%esi
  407115:	41 89 74 0a fc       	mov    %esi,-0x4(%r10,%rcx,1)
  40711a:	e9 16 fd ff ff       	jmpq   406e35 <fc_solve_sfs_move_sequences_to_free_stacks+0xac5>
                my_copy_stack(stack_idx);
  40711f:	0f b7 44 0e fe       	movzwl -0x2(%rsi,%rcx,1),%eax
  407124:	48 8b 7c 24 38       	mov    0x38(%rsp),%rdi
  407129:	66 89 44 0f fe       	mov    %ax,-0x2(%rdi,%rcx,1)
  40712e:	48 8b 84 24 90 00 00 	mov    0x90(%rsp),%rax
  407135:	00 
  407136:	e9 4c fb ff ff       	jmpq   406c87 <fc_solve_sfs_move_sequences_to_free_stacks+0x917>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  40713b:	c7 44 24 70 07 00 00 	movl   $0x7,0x70(%rsp)
  407142:	00 
  407143:	e9 10 ff ff ff       	jmpq   407058 <fc_solve_sfs_move_sequences_to_free_stacks+0xce8>
  407148:	89 ac 24 a0 00 00 00 	mov    %ebp,0xa0(%rsp)
  40714f:	e9 71 f8 ff ff       	jmpq   4069c5 <fc_solve_sfs_move_sequences_to_free_stacks+0x655>
  407154:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40715b:	00 00 00 00 
  40715f:	90                   	nop

0000000000407160 <fc_solve_sfs_move_stack_cards_to_different_stacks>:
{
  407160:	41 57                	push   %r15
  407162:	41 56                	push   %r14
  407164:	49 89 f6             	mov    %rsi,%r14
  407167:	41 55                	push   %r13
  407169:	41 54                	push   %r12
  40716b:	55                   	push   %rbp
  40716c:	53                   	push   %rbx
  40716d:	48 81 ec e8 00 00 00 	sub    $0xe8,%rsp
    MOVE_FUNCS__define_common();
  407174:	48 8b 1f             	mov    (%rdi),%rbx
{
  407177:	48 89 94 24 98 00 00 	mov    %rdx,0x98(%rsp)
  40717e:	00 
    if (soft_thread->super_method_type == FCS_SUPER_METHOD_DFS)
  40717f:	8b 57 20             	mov    0x20(%rdi),%edx
  407182:	48 89 bc 24 80 00 00 	mov    %rdi,0x80(%rsp)
  407189:	00 
    const_SLOT(num_vacant_freecells, soft_thread);
  40718a:	44 0f b6 bf e4 01 00 	movzbl 0x1e4(%rdi),%r15d
  407191:	00 
{
  407192:	48 89 4c 24 70       	mov    %rcx,0x70(%rsp)
    MOVE_FUNCS__define_common();
  407197:	48 89 5c 24 40       	mov    %rbx,0x40(%rsp)
  40719c:	48 81 c3 00 01 00 00 	add    $0x100,%rbx
  4071a3:	48 89 9c 24 a0 00 00 	mov    %rbx,0xa0(%rsp)
  4071aa:	00 
    const_SLOT(num_vacant_stacks, soft_thread);
  4071ab:	0f b6 9f e3 01 00 00 	movzbl 0x1e3(%rdi),%ebx
  4071b2:	88 9c 24 8a 00 00 00 	mov    %bl,0x8a(%rsp)
        return (BEFS_M_VAR(soft_thread, befs_positions_by_rank));
  4071b9:	48 8d 5f 60          	lea    0x60(%rdi),%rbx
  4071bd:	48 89 5c 24 68       	mov    %rbx,0x68(%rsp)
    if (soft_thread->super_method_type == FCS_SUPER_METHOD_DFS)
  4071c2:	85 d2                	test   %edx,%edx
  4071c4:	75 1d                	jne    4071e3 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x83>
        return (DFS_VAR(soft_thread, soft_dfs_info)[DFS_VAR(soft_thread, depth)]
  4071c6:	48 8b 47 38          	mov    0x38(%rdi),%rax
  4071ca:	48 8d 14 80          	lea    (%rax,%rax,4),%rdx
  4071ce:	48 8d 04 50          	lea    (%rax,%rdx,2),%rax
  4071d2:	48 c1 e0 04          	shl    $0x4,%rax
  4071d6:	48 03 47 30          	add    0x30(%rdi),%rax
  4071da:	48 83 c0 40          	add    $0x40,%rax
  4071de:	48 89 44 24 68       	mov    %rax,0x68(%rsp)
{
  4071e3:	48 c7 44 24 50 00 00 	movq   $0x0,0x50(%rsp)
  4071ea:	00 00 
  4071ec:	48 8b 44 24 50       	mov    0x50(%rsp),%rax
    const int *col_idx = cols_indexes;
  4071f1:	4d 89 f4             	mov    %r14,%r12
  4071f4:	44 88 bc 24 8b 00 00 	mov    %r15b,0x8b(%rsp)
  4071fb:	00 
  4071fc:	0f 1f 40 00          	nopl   0x0(%rax)
    ret.col = fcs_state_get_col(*s, stack_idx);
  407200:	4d 8b 1c c4          	mov    (%r12,%rax,8),%r11
  407204:	89 44 24 10          	mov    %eax,0x10(%rsp)
    ret.col_len_minus_1 = (ret.col_len = fcs_col_len(ret.col)) - 1;
  407208:	49 0f be 03          	movsbq (%r11),%rax
  40720c:	48 8d 70 ff          	lea    -0x1(%rax),%rsi
  407210:	48 89 44 24 38       	mov    %rax,0x38(%rsp)
  407215:	48 89 74 24 20       	mov    %rsi,0x20(%rsp)
    for ((*iter).seq_end = (*iter).c; (*iter).seq_end < (*iter).col_len_minus_1;
  40721a:	48 85 f6             	test   %rsi,%rsi
  40721d:	0f 8e aa 09 00 00    	jle    407bcd <fc_solve_sfs_move_stack_cards_to_different_stacks+0xa6d>
    return fc_solve_is_parent_buf[(size_t)parent][(size_t)child];
  407223:	49 0f be 43 01       	movsbq 0x1(%r11),%rax
  407228:	49 0f be 53 02       	movsbq 0x2(%r11),%rdx
  40722d:	48 c1 e0 06          	shl    $0x6,%rax
        if (!fcs_is_parent_card(fcs_col_get_card(col, (*iter).seq_end + 1),
  407231:	80 bc 02 c0 fe 40 00 	cmpb   $0x0,0x40fec0(%rdx,%rax,1)
  407238:	00 
  407239:	0f 84 8e 09 00 00    	je     407bcd <fc_solve_sfs_move_stack_cards_to_different_stacks+0xa6d>
  40723f:	b8 01 00 00 00       	mov    $0x1,%eax
  407244:	eb 28                	jmp    40726e <fc_solve_sfs_move_stack_cards_to_different_stacks+0x10e>
  407246:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  40724d:	00 00 00 
  407250:	49 0f be 54 03 01    	movsbq 0x1(%r11,%rax,1),%rdx
  407256:	49 0f be 4c 03 02    	movsbq 0x2(%r11,%rax,1),%rcx
  40725c:	48 83 c0 01          	add    $0x1,%rax
  407260:	48 c1 e2 06          	shl    $0x6,%rdx
  407264:	80 bc 11 c0 fe 40 00 	cmpb   $0x0,0x40fec0(%rcx,%rdx,1)
  40726b:	00 
  40726c:	74 08                	je     407276 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x116>
         ++((*iter).seq_end))
  40726e:	49 89 c5             	mov    %rax,%r13
    for ((*iter).seq_end = (*iter).c; (*iter).seq_end < (*iter).col_len_minus_1;
  407271:	48 39 c6             	cmp    %rax,%rsi
  407274:	75 da                	jne    407250 <fc_solve_sfs_move_stack_cards_to_different_stacks+0xf0>
                copy_two_stacks(stack_idx, ds);
  407276:	0f b6 4c 24 10       	movzbl 0x10(%rsp),%ecx
  40727b:	b8 01 00 00 00       	mov    $0x1,%eax
    return ret;
  407280:	31 f6                	xor    %esi,%esi
  407282:	4d 89 ee             	mov    %r13,%r14
  407285:	4d 89 da             	mov    %r11,%r10
  407288:	4d 89 e7             	mov    %r12,%r15
                copy_two_stacks(stack_idx, ds);
  40728b:	d3 e0                	shl    %cl,%eax
  40728d:	89 84 24 8c 00 00 00 	mov    %eax,0x8c(%rsp)
  407294:	48 8b 44 24 50       	mov    0x50(%rsp),%rax
  407299:	48 c1 e0 07          	shl    $0x7,%rax
  40729d:	48 03 84 24 a0 00 00 	add    0xa0(%rsp),%rax
  4072a4:	00 
  4072a5:	48 89 44 24 78       	mov    %rax,0x78(%rsp)
  4072aa:	48 8b 44 24 38       	mov    0x38(%rsp),%rax
  4072af:	48 83 e8 01          	sub    $0x1,%rax
  4072b3:	48 89 44 24 60       	mov    %rax,0x60(%rsp)
        for (; iter.c < iter.col_len; col_seqs_iter__advance(&iter))
  4072b8:	48 39 74 24 38       	cmp    %rsi,0x38(%rsp)
  4072bd:	0f 8e 42 06 00 00    	jle    407905 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x7a5>
            const int col_num_cards = iter.col_len_minus_1 - iter.seq_end;
  4072c3:	8b 44 24 20          	mov    0x20(%rsp),%eax
  4072c7:	44 29 f0             	sub    %r14d,%eax
  4072ca:	89 44 24 14          	mov    %eax,0x14(%rsp)
    return fc_solve_is_king_buf[(size_t)card];
  4072ce:	49 0f be 44 32 01    	movsbq 0x1(%r10,%rsi,1),%rax
            if (unlikely(fcs_card_is_king(card)))
  4072d4:	80 b8 00 fb 40 00 00 	cmpb   $0x0,0x40fb00(%rax)
  4072db:	0f 85 a8 05 00 00    	jne    407889 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x729>
            FCS_POS_IDX_TO_CHECK_START_LOOP(card)
  4072e1:	48 c1 e0 04          	shl    $0x4,%rax
  4072e5:	48 8b 5c 24 68       	mov    0x68(%rsp),%rbx
  4072ea:	4c 8b 98 40 fb 40 00 	mov    0x40fb40(%rax),%r11
  4072f1:	49 01 db             	add    %rbx,%r11
  4072f4:	48 03 98 48 fb 40 00 	add    0x40fb48(%rax),%rbx
  4072fb:	48 89 5c 24 08       	mov    %rbx,0x8(%rsp)
  407300:	49 39 db             	cmp    %rbx,%r11
  407303:	0f 83 80 05 00 00    	jae    407889 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x729>
                iter->seq_end - iter->c + 1));
  407309:	4c 89 f0             	mov    %r14,%rax
    const size_t cards_size = (((size_t)cards_num) * sizeof(fcs_card));
  40730c:	4c 89 74 24 28       	mov    %r14,0x28(%rsp)
  407311:	4c 89 db             	mov    %r11,%rbx
  407314:	44 0f b6 a4 24 8b 00 	movzbl 0x8b(%rsp),%r12d
  40731b:	00 00 
  40731d:	48 29 f0             	sub    %rsi,%rax
  407320:	4c 89 54 24 30       	mov    %r10,0x30(%rsp)
  407325:	48 89 44 24 18       	mov    %rax,0x18(%rsp)
                fcs_move_sequence(ds, stack_idx, iter.seq_end - iter.c + 1);
  40732a:	48 83 c0 01          	add    $0x1,%rax
  40732e:	48 89 44 24 48       	mov    %rax,0x48(%rsp)
  407333:	48 98                	cltq   
  407335:	48 89 44 24 58       	mov    %rax,0x58(%rsp)
  40733a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
                const int_fast32_t ds = pos_idx_to_check[0];
  407340:	48 0f be 2b          	movsbq (%rbx),%rbp
  407344:	49 89 ed             	mov    %rbp,%r13
                if ((ds < 0) || (ds == stack_idx))
  407347:	48 85 ed             	test   %rbp,%rbp
  40734a:	0f 88 20 05 00 00    	js     407870 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x710>
  407350:	44 0f be f5          	movsbl %bpl,%r14d
  407354:	44 3b 74 24 10       	cmp    0x10(%rsp),%r14d
  407359:	0f 84 11 05 00 00    	je     407870 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x710>
                    fcs_state_col_len(state, ds) - dc - 1;
  40735f:	49 8b 04 ef          	mov    (%r15,%rbp,8),%rax
    const fcs_game_limit freecells_to_fill =
  407363:	44 89 e6             	mov    %r12d,%esi
    return ((num_cards_to_relocate == 0) &&
  407366:	0f b6 bc 24 8a 00 00 	movzbl 0x8a(%rsp),%edi
  40736d:	00 
                    fcs_state_col_len(state, ds) - dc - 1;
  40736e:	0f be 10             	movsbl (%rax),%edx
  407371:	0f be 43 01          	movsbl 0x1(%rbx),%eax
  407375:	f7 d0                	not    %eax
  407377:	01 c2                	add    %eax,%edx
                if (!unlikely(
  407379:	0f b6 44 24 14       	movzbl 0x14(%rsp),%eax
  40737e:	8d 0c 02             	lea    (%rdx,%rax,1),%ecx
    const fcs_game_limit freecells_to_fill =
  407381:	44 38 e1             	cmp    %r12b,%cl
  407384:	0f 46 f1             	cmovbe %ecx,%esi
    num_cards_to_relocate -= freecells_to_fill;
  407387:	29 f1                	sub    %esi,%ecx
    return ((num_cards_to_relocate == 0) &&
  407389:	40 38 cf             	cmp    %cl,%dil
  40738c:	0f 82 de 04 00 00    	jb     407870 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x710>
                if (!unlikely(
  407392:	41 0f b6 c4          	movzbl %r12b,%eax
            (calc_max_sequence_move(
  407396:	40 0f b6 f6          	movzbl %sil,%esi
  40739a:	29 f0                	sub    %esi,%eax
  40739c:	83 c0 01             	add    $0x1,%eax
    const fcs_game_limit freestacks_to_fill =
  40739f:	40 38 cf             	cmp    %cl,%dil
  4073a2:	0f 46 cf             	cmovbe %edi,%ecx
            (calc_max_sequence_move(
  4073a5:	29 cf                	sub    %ecx,%edi
  4073a7:	89 f9                	mov    %edi,%ecx
  4073a9:	d3 e0                	shl    %cl,%eax
  4073ab:	48 98                	cltq   
    return ((num_cards_to_relocate == 0) &&
  4073ad:	48 39 44 24 18       	cmp    %rax,0x18(%rsp)
  4073b2:	0f 8d b8 04 00 00    	jge    407870 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x710>
                (instance->list_of_vacant_states != NULL)))
  4073b8:	48 8b 44 24 40       	mov    0x40(%rsp),%rax
  4073bd:	48 8b 88 b0 00 00 00 	mov    0xb0(%rax),%rcx
  4073c4:	48 85 c9             	test   %rcx,%rcx
    if ((HT_FIELD(hard_thread, allocated_from_list) =
  4073c7:	0f 95 80 18 05 00 00 	setne  0x518(%rax)
  4073ce:	0f 85 ec 05 00 00    	jne    4079c0 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x860>
    if ((size_t)(allocator->max_ptr - allocator->ptr) < how_much)
  4073d4:	48 8b 88 e8 00 00 00 	mov    0xe8(%rax),%rcx
  4073db:	48 8b 80 e0 00 00 00 	mov    0xe0(%rax),%rax
  4073e2:	48 89 84 24 90 00 00 	mov    %rax,0x90(%rsp)
  4073e9:	00 
  4073ea:	48 29 c8             	sub    %rcx,%rax
  4073ed:	48 83 f8 5f          	cmp    $0x5f,%rax
    char *const new_data = meta_request_new_buffer(allocator->meta);
  4073f1:	48 8b 44 24 40       	mov    0x40(%rsp),%rax
  4073f6:	0f 86 43 07 00 00    	jbe    407b3f <fc_solve_sfs_move_stack_cards_to_different_stacks+0x9df>
        allocator->rollback_ptr = allocator->ptr;
  4073fc:	48 89 88 f0 00 00 00 	mov    %rcx,0xf0(%rax)
  407403:	48 89 c7             	mov    %rax,%rdi
    allocator->ptr += how_much;
  407406:	48 8d 41 60          	lea    0x60(%rcx),%rax
  40740a:	48 89 87 e8 00 00 00 	mov    %rax,0xe8(%rdi)
    return (const fcs_kv_state){.key = &(s->s), .val = &(s->info)};
  407411:	48 8d 41 48          	lea    0x48(%rcx),%rax
    *ret = FCS_STATE_keyval_pair_to_kv(s);
  407415:	c4 e1 f9 6e c9       	vmovq  %rcx,%xmm1
  40741a:	c4 e3 f1 22 c0 01    	vpinsrq $0x1,%rax,%xmm1,%xmm0
  407420:	c5 f8 29 84 24 c0 00 	vmovaps %xmm0,0xc0(%rsp)
  407427:	00 00 
    fcs_duplicate_kv_state(out_new_state_out, &raw_state_raw);
  407429:	c4 c1 7a 6f 07       	vmovdqu (%r15),%xmm0
  40742e:	c5 f8 11 01          	vmovups %xmm0,(%rcx)
  407432:	c4 c1 7a 6f 47 10    	vmovdqu 0x10(%r15),%xmm0
  407438:	c5 f8 11 41 10       	vmovups %xmm0,0x10(%rcx)
  40743d:	c4 c1 7a 6f 47 20    	vmovdqu 0x20(%r15),%xmm0
  407443:	c5 f8 11 41 20       	vmovups %xmm0,0x20(%rcx)
  407448:	c4 c1 7a 6f 47 30    	vmovdqu 0x30(%r15),%xmm0
  40744e:	c5 f8 11 41 30       	vmovups %xmm0,0x30(%rcx)
  407453:	49 8b 47 40          	mov    0x40(%r15),%rax
  407457:	48 89 41 40          	mov    %rax,0x40(%rcx)
  40745b:	48 8b 84 24 98 00 00 	mov    0x98(%rsp),%rax
  407462:	00 
  407463:	c5 fa 6f 00          	vmovdqu (%rax),%xmm0
  407467:	c5 f8 11 41 48       	vmovups %xmm0,0x48(%rcx)
  40746c:	48 8b 40 10          	mov    0x10(%rax),%rax
    (FCS_S_DEPTH(raw_ptr_new_state))++;
  407470:	83 41 50 01          	addl   $0x1,0x50(%rcx)
    FCS_S_PARENT(raw_ptr_new_state) = INFO_STATE_PTR(&raw_state_raw);
  407474:	4c 89 79 48          	mov    %r15,0x48(%rcx)
    FCS_S_VISITED(raw_ptr_new_state) = 0;
  407478:	c6 41 56 00          	movb   $0x0,0x56(%rcx)
    fcs_duplicate_kv_state(out_new_state_out, &raw_state_raw);
  40747c:	48 89 41 58          	mov    %rax,0x58(%rcx)
    FCS_S_NUM_ACTIVE_CHILDREN(raw_ptr_new_state) = 0;
  407480:	31 c0                	xor    %eax,%eax
  407482:	66 89 41 54          	mov    %ax,0x54(%rcx)
                copy_two_stacks(stack_idx, ds);
  407486:	8b 84 24 8c 00 00 00 	mov    0x8c(%rsp),%eax
    memset(&(FCS_S_SCAN_VISITED(raw_ptr_new_state)), '\0',
  40748d:	c7 41 57 00 00 00 00 	movl   $0x0,0x57(%rcx)
  407494:	89 41 5c             	mov    %eax,0x5c(%rcx)
  407497:	48 63 44 24 10       	movslq 0x10(%rsp),%rax
  40749c:	48 8b 34 c1          	mov    (%rcx,%rax,8),%rsi
  4074a0:	0f be 0e             	movsbl (%rsi),%ecx
  4074a3:	83 c1 01             	add    $0x1,%ecx
  4074a6:	48 63 c9             	movslq %ecx,%rcx
  4074a9:	48 83 f9 08          	cmp    $0x8,%rcx
  4074ad:	0f 83 dd 04 00 00    	jae    407990 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x830>
  4074b3:	f6 c1 04             	test   $0x4,%cl
  4074b6:	0f 85 19 07 00 00    	jne    407bd5 <fc_solve_sfs_move_stack_cards_to_different_stacks+0xa75>
  4074bc:	48 85 c9             	test   %rcx,%rcx
  4074bf:	74 14                	je     4074d5 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x375>
  4074c1:	0f b6 3e             	movzbl (%rsi),%edi
  4074c4:	4c 8b 4c 24 78       	mov    0x78(%rsp),%r9
  4074c9:	41 88 39             	mov    %dil,(%r9)
  4074cc:	f6 c1 02             	test   $0x2,%cl
  4074cf:	0f 85 5d 07 00 00    	jne    407c32 <fc_solve_sfs_move_stack_cards_to_different_stacks+0xad2>
  4074d5:	4c 8b 8c 24 c0 00 00 	mov    0xc0(%rsp),%r9
  4074dc:	00 
  4074dd:	48 8b 7c 24 78       	mov    0x78(%rsp),%rdi
  4074e2:	49 89 3c c1          	mov    %rdi,(%r9,%rax,8)
  4074e6:	48 8b 84 24 c8 00 00 	mov    0xc8(%rsp),%rax
  4074ed:	00 
  4074ee:	8b 70 14             	mov    0x14(%rax),%esi
  4074f1:	44 0f a3 ee          	bt     %r13d,%esi
  4074f5:	0f 83 f5 04 00 00    	jae    4079f0 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x890>
                const int dest_cards_num =
  4074fb:	89 d0                	mov    %edx,%eax
                const int cols_indexes[3] = {ds, stack_idx, -1};
  4074fd:	44 8b 54 24 10       	mov    0x10(%rsp),%r10d
        int dest_fc_idx = 0;
  407502:	31 ff                	xor    %edi,%edi
                const int cols_indexes[3] = {ds, stack_idx, -1};
  407504:	44 89 b4 24 b4 00 00 	mov    %r14d,0xb4(%rsp)
  40750b:	00 
  40750c:	48 8b 94 24 80 00 00 	mov    0x80(%rsp),%rdx
  407513:	00 
  407514:	c7 84 24 bc 00 00 00 	movl   $0xffffffff,0xbc(%rsp)
  40751b:	ff ff ff ff 
    const int *col_idx = cols_indexes;
  40751f:	4c 8d 84 24 b4 00 00 	lea    0xb4(%rsp),%r8
  407526:	00 
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  407527:	89 84 24 d0 00 00 00 	mov    %eax,0xd0(%rsp)
  40752e:	c7 84 24 d8 00 00 00 	movl   $0xffffffff,0xd8(%rsp)
  407535:	ff ff ff ff 
                const int cols_indexes[3] = {ds, stack_idx, -1};
  407539:	44 89 94 24 b8 00 00 	mov    %r10d,0xb8(%rsp)
  407540:	00 
  407541:	4c 8b 32             	mov    (%rdx),%r14
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  407544:	8b 54 24 14          	mov    0x14(%rsp),%edx
  407548:	89 94 24 d4 00 00 00 	mov    %edx,0xd4(%rsp)
    int *col_num_cards = num_cards_to_move_from_columns;
  40754f:	48 8d 94 24 d0 00 00 	lea    0xd0(%rsp),%rdx
  407556:	00 
  407557:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40755e:	00 00 
            while ((*col_num_cards) == 0)
  407560:	85 c0                	test   %eax,%eax
  407562:	75 1d                	jne    407581 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x421>
                if (*(++col_idx) == -1)
  407564:	41 83 fa ff          	cmp    $0xffffffff,%r10d
  407568:	0f 84 f2 01 00 00    	je     407760 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x600>
  40756e:	8b 42 04             	mov    0x4(%rdx),%eax
  407571:	49 83 c0 04          	add    $0x4,%r8
                ++col_num_cards;
  407575:	48 83 c2 04          	add    $0x4,%rdx
  407579:	45 8b 50 04          	mov    0x4(%r8),%r10d
            while ((*col_num_cards) == 0)
  40757d:	85 c0                	test   %eax,%eax
  40757f:	74 e3                	je     407564 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x404>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  407581:	83 ff 03             	cmp    $0x3,%edi
  407584:	0f 8f a6 03 00 00    	jg     407930 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x7d0>
  40758a:	8d 4f 01             	lea    0x1(%rdi),%ecx
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  40758d:	48 63 f7             	movslq %edi,%rsi
  407590:	41 80 7c 31 40 00    	cmpb   $0x0,0x40(%r9,%rsi,1)
  407596:	0f 84 c4 04 00 00    	je     407a60 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x900>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  40759c:	83 f9 04             	cmp    $0x4,%ecx
  40759f:	74 3d                	je     4075de <fc_solve_sfs_move_stack_cards_to_different_stacks+0x47e>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  4075a1:	48 63 c9             	movslq %ecx,%rcx
  4075a4:	41 80 7c 09 40 00    	cmpb   $0x0,0x40(%r9,%rcx,1)
  4075aa:	0f 84 c0 04 00 00    	je     407a70 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x910>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  4075b0:	8d 4f 02             	lea    0x2(%rdi),%ecx
  4075b3:	83 f9 04             	cmp    $0x4,%ecx
  4075b6:	74 26                	je     4075de <fc_solve_sfs_move_stack_cards_to_different_stacks+0x47e>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  4075b8:	48 63 c9             	movslq %ecx,%rcx
  4075bb:	41 80 7c 09 40 00    	cmpb   $0x0,0x40(%r9,%rcx,1)
  4075c1:	0f 84 d9 04 00 00    	je     407aa0 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x940>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  4075c7:	8d 4f 03             	lea    0x3(%rdi),%ecx
  4075ca:	83 f9 03             	cmp    $0x3,%ecx
  4075cd:	0f 85 5f 03 00 00    	jne    407932 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x7d2>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  4075d3:	41 80 79 43 00       	cmpb   $0x0,0x43(%r9)
  4075d8:	0f 84 52 05 00 00    	je     407b30 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x9d0>
  4075de:	48 8b b4 24 c0 00 00 	mov    0xc0(%rsp),%rsi
  4075e5:	00 
    char *const indirect_stacks_buffer =
  4075e6:	49 8d be 00 01 00 00 	lea    0x100(%r14),%rdi
    int put_cards_in_col_idx = 0;
  4075ed:	45 31 ed             	xor    %r13d,%r13d
    char *const indirect_stacks_buffer =
  4075f0:	48 89 bc 24 90 00 00 	mov    %rdi,0x90(%rsp)
  4075f7:	00 
        while ((*col_num_cards) == 0)
  4075f8:	85 c0                	test   %eax,%eax
  4075fa:	75 1d                	jne    407619 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x4b9>
            if (*(++col_idx) == -1)
  4075fc:	41 83 fa ff          	cmp    $0xffffffff,%r10d
  407600:	0f 84 62 01 00 00    	je     407768 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x608>
  407606:	8b 42 04             	mov    0x4(%rdx),%eax
  407609:	49 83 c0 04          	add    $0x4,%r8
            ++col_num_cards;
  40760d:	48 83 c2 04          	add    $0x4,%rdx
  407611:	45 8b 50 04          	mov    0x4(%r8),%r10d
        while ((*col_num_cards) == 0)
  407615:	85 c0                	test   %eax,%eax
  407617:	74 e3                	je     4075fc <fc_solve_sfs_move_stack_cards_to_different_stacks+0x49c>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  407619:	41 83 fd 08          	cmp    $0x8,%r13d
  40761d:	0f 84 8d 04 00 00    	je     407ab0 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x950>
  407623:	49 63 cd             	movslq %r13d,%rcx
  407626:	48 8d 3c ce          	lea    (%rsi,%rcx,8),%rdi
        if (fcs_state_col_is_empty(state, ret))
  40762a:	4c 8b 1f             	mov    (%rdi),%r11
  40762d:	41 8d 4d 01          	lea    0x1(%r13),%ecx
  407631:	41 80 3b 00          	cmpb   $0x0,(%r11)
  407635:	0f 84 b2 05 00 00    	je     407bed <fc_solve_sfs_move_stack_cards_to_different_stacks+0xa8d>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  40763b:	83 f9 08             	cmp    $0x8,%ecx
  40763e:	0f 84 6c 04 00 00    	je     407ab0 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x950>
        if (fcs_state_col_is_empty(state, ret))
  407644:	4c 8b 5f 08          	mov    0x8(%rdi),%r11
  407648:	41 80 3b 00          	cmpb   $0x0,(%r11)
  40764c:	0f 84 a8 05 00 00    	je     407bfa <fc_solve_sfs_move_stack_cards_to_different_stacks+0xa9a>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  407652:	41 8d 4d 02          	lea    0x2(%r13),%ecx
  407656:	83 f9 08             	cmp    $0x8,%ecx
  407659:	0f 84 51 04 00 00    	je     407ab0 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x950>
        if (fcs_state_col_is_empty(state, ret))
  40765f:	4c 8b 5f 10          	mov    0x10(%rdi),%r11
  407663:	41 80 3b 00          	cmpb   $0x0,(%r11)
  407667:	0f 84 b3 05 00 00    	je     407c20 <fc_solve_sfs_move_stack_cards_to_different_stacks+0xac0>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  40766d:	41 8d 4d 03          	lea    0x3(%r13),%ecx
  407671:	83 f9 07             	cmp    $0x7,%ecx
  407674:	0f 8f 36 04 00 00    	jg     407ab0 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x950>
        if (fcs_state_col_is_empty(state, ret))
  40767a:	4c 8b 5f 18          	mov    0x18(%rdi),%r11
  40767e:	41 80 3b 00          	cmpb   $0x0,(%r11)
  407682:	0f 84 a1 05 00 00    	je     407c29 <fc_solve_sfs_move_stack_cards_to_different_stacks+0xac9>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  407688:	41 8d 4d 04          	lea    0x4(%r13),%ecx
  40768c:	83 f9 07             	cmp    $0x7,%ecx
  40768f:	0f 8f 1b 04 00 00    	jg     407ab0 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x950>
        if (fcs_state_col_is_empty(state, ret))
  407695:	4c 8b 5f 20          	mov    0x20(%rdi),%r11
  407699:	41 80 3b 00          	cmpb   $0x0,(%r11)
  40769d:	0f 84 a3 05 00 00    	je     407c46 <fc_solve_sfs_move_stack_cards_to_different_stacks+0xae6>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4076a3:	41 8d 4d 05          	lea    0x5(%r13),%ecx
  4076a7:	83 f9 07             	cmp    $0x7,%ecx
  4076aa:	0f 8f 00 04 00 00    	jg     407ab0 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x950>
        if (fcs_state_col_is_empty(state, ret))
  4076b0:	4c 8b 5f 28          	mov    0x28(%rdi),%r11
  4076b4:	41 80 3b 00          	cmpb   $0x0,(%r11)
  4076b8:	0f 84 91 05 00 00    	je     407c4f <fc_solve_sfs_move_stack_cards_to_different_stacks+0xaef>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4076be:	41 8d 4d 06          	lea    0x6(%r13),%ecx
  4076c2:	83 f9 07             	cmp    $0x7,%ecx
  4076c5:	0f 8f e5 03 00 00    	jg     407ab0 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x950>
        if (fcs_state_col_is_empty(state, ret))
  4076cb:	48 8b 7f 30          	mov    0x30(%rdi),%rdi
  4076cf:	80 3f 00             	cmpb   $0x0,(%rdi)
  4076d2:	0f 84 80 05 00 00    	je     407c58 <fc_solve_sfs_move_stack_cards_to_different_stacks+0xaf8>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4076d8:	45 85 ed             	test   %r13d,%r13d
  4076db:	0f 85 cf 03 00 00    	jne    407ab0 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x950>
        if (fcs_state_col_is_empty(state, ret))
  4076e1:	48 8b 4e 38          	mov    0x38(%rsi),%rcx
  4076e5:	bf 08 00 00 00       	mov    $0x8,%edi
  4076ea:	80 39 00             	cmpb   $0x0,(%rcx)
  4076ed:	44 0f 44 ef          	cmove  %edi,%r13d
  4076f1:	80 39 01             	cmpb   $0x1,(%rcx)
  4076f4:	19 c9                	sbb    %ecx,%ecx
  4076f6:	83 e1 08             	and    $0x8,%ecx
  4076f9:	83 e9 01             	sub    $0x1,%ecx
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  4076fc:	48 8b b4 24 c8 00 00 	mov    0xc8(%rsp),%rsi
  407703:	00 
  407704:	4c 63 f1             	movslq %ecx,%r14
  407707:	8b 7e 14             	mov    0x14(%rsi),%edi
  40770a:	0f a3 cf             	bt     %ecx,%edi
  40770d:	0f 83 ad 03 00 00    	jae    407ac0 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x960>
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  407713:	49 63 08             	movslq (%r8),%rcx
        --(*col_num_cards);
  407716:	83 e8 01             	sub    $0x1,%eax
  407719:	89 02                	mov    %eax,(%rdx)
  40771b:	49 8b 34 c9          	mov    (%r9,%rcx,8),%rsi
    fcs_col_pop_card(col, ret);
  40771f:	0f be 3e             	movsbl (%rsi),%edi
  407722:	89 f9                	mov    %edi,%ecx
  407724:	83 ef 01             	sub    $0x1,%edi
  407727:	83 e9 01             	sub    $0x1,%ecx
  40772a:	48 63 ff             	movslq %edi,%rdi
  40772d:	0f b6 7c 3e 01       	movzbl 0x1(%rsi,%rdi,1),%edi
  407732:	88 0e                	mov    %cl,(%rsi)
  407734:	48 0f be c9          	movsbq %cl,%rcx
  407738:	c6 44 0e 01 00       	movb   $0x0,0x1(%rsi,%rcx,1)
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  40773d:	4b 8b 34 f1          	mov    (%r9,%r14,8),%rsi
    fcs_col_push_card(col, card);
  407741:	48 0f be 0e          	movsbq (%rsi),%rcx
  407745:	44 8d 59 01          	lea    0x1(%rcx),%r11d
  407749:	44 88 1e             	mov    %r11b,(%rsi)
  40774c:	40 88 7c 0e 01       	mov    %dil,0x1(%rsi,%rcx,1)
  407751:	48 8b b4 24 c0 00 00 	mov    0xc0(%rsp),%rsi
  407758:	00 
  407759:	e9 9a fe ff ff       	jmpq   4075f8 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x498>
  40775e:	66 90                	xchg   %ax,%ax
  407760:	48 8b b4 24 c0 00 00 	mov    0xc0(%rsp),%rsi
  407767:	00 
  407768:	48 8b 44 24 50       	mov    0x50(%rsp),%rax
  40776d:	48 8b 2c ee          	mov    (%rsi,%rbp,8),%rbp
    memcpy(&fcs_col_get_card(dest_col, fcs_col_len(dest_col)), src_cards_ptr,
  407771:	4c 8b 74 24 58       	mov    0x58(%rsp),%r14
  407776:	48 8b 14 c6          	mov    (%rsi,%rax,8),%rdx
        &fcs_col_get_card(src_col, (fcs_col_len(src_col) -= cards_num));
  40777a:	0f b6 02             	movzbl (%rdx),%eax
  40777d:	2a 44 24 48          	sub    0x48(%rsp),%al
  407781:	88 02                	mov    %al,(%rdx)
  407783:	48 0f be c0          	movsbq %al,%rax
    fcs_card *const src_cards_ptr =
  407787:	4c 8d 6c 02 01       	lea    0x1(%rdx,%rax,1),%r13
    memcpy(&fcs_col_get_card(dest_col, fcs_col_len(dest_col)), src_cards_ptr,
  40778c:	48 0f be 45 00       	movsbq 0x0(%rbp),%rax
  407791:	4c 89 f2             	mov    %r14,%rdx
  407794:	4c 89 ee             	mov    %r13,%rsi
  407797:	48 8d 7c 05 01       	lea    0x1(%rbp,%rax,1),%rdi
  40779c:	e8 3f 99 ff ff       	callq  4010e0 <memcpy@plt>
    fcs_col_len(dest_col) += cards_num;
  4077a1:	0f b6 44 24 48       	movzbl 0x48(%rsp),%eax
    memset(src_cards_ptr, 0, cards_size);
  4077a6:	31 f6                	xor    %esi,%esi
  4077a8:	4c 89 f2             	mov    %r14,%rdx
    fcs_col_len(dest_col) += cards_num;
  4077ab:	00 45 00             	add    %al,0x0(%rbp)
    memset(src_cards_ptr, 0, cards_size);
  4077ae:	4c 89 ef             	mov    %r13,%rdi
  4077b1:	e8 ea 98 ff ff       	callq  4010a0 <memset@plt>
    const_SLOT(hard_thread, soft_thread);
  4077b6:	48 8b 84 24 80 00 00 	mov    0x80(%rsp),%rax
  4077bd:	00 
    if (!fc_solve_check_and_add_state(
  4077be:	48 8d 94 24 d0 00 00 	lea    0xd0(%rsp),%rdx
  4077c5:	00 
  4077c6:	48 8d b4 24 c0 00 00 	lea    0xc0(%rsp),%rsi
  4077cd:	00 
    const_SLOT(hard_thread, soft_thread);
  4077ce:	48 8b 28             	mov    (%rax),%rbp
    if (!fc_solve_check_and_add_state(
  4077d1:	48 89 ef             	mov    %rbp,%rdi
  4077d4:	e8 77 a2 ff ff       	callq  401a50 <fc_solve_check_and_add_state>
  4077d9:	84 c0                	test   %al,%al
  4077db:	0f 85 9f 01 00 00    	jne    407980 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x820>
        if (HT_FIELD(hard_thread, allocated_from_list))
  4077e1:	80 bd 18 05 00 00 00 	cmpb   $0x0,0x518(%rbp)
  4077e8:	0f 84 92 02 00 00    	je     407a80 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x920>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  4077ee:	48 8b 95 b0 00 00 00 	mov    0xb0(%rbp),%rdx
  4077f5:	48 8b 84 24 c8 00 00 	mov    0xc8(%rsp),%rax
  4077fc:	00 
  4077fd:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  407800:	48 8b 84 24 c0 00 00 	mov    0xc0(%rsp),%rax
  407807:	00 
  407808:	48 89 85 b0 00 00 00 	mov    %rax,0xb0(%rbp)
  40780f:	48 8b ac 24 d0 00 00 	mov    0xd0(%rsp),%rbp
  407816:	00 
    if ((!((list->num_states + (list->states != NULL)) &
  407817:	48 8b 44 24 70       	mov    0x70(%rsp),%rax
  40781c:	31 d2                	xor    %edx,%edx
  40781e:	48 8b 38             	mov    (%rax),%rdi
  407821:	48 8b 40 08          	mov    0x8(%rax),%rax
  407825:	48 85 c0             	test   %rax,%rax
  407828:	0f 95 c2             	setne  %dl
  40782b:	48 01 fa             	add    %rdi,%rdx
  40782e:	f6 c2 0f             	test   $0xf,%dl
  407831:	75 1c                	jne    40784f <fc_solve_sfs_move_stack_cards_to_different_stacks+0x6ef>
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  407833:	48 8d 72 10          	lea    0x10(%rdx),%rsi
  407837:	48 89 c7             	mov    %rax,%rdi
  40783a:	48 c1 e6 04          	shl    $0x4,%rsi
  40783e:	e8 2d 99 ff ff       	callq  401170 <realloc@plt>
        list->states =
  407843:	48 8b 54 24 70       	mov    0x70(%rsp),%rdx
  407848:	48 8b 3a             	mov    (%rdx),%rdi
  40784b:	48 89 42 08          	mov    %rax,0x8(%rdx)
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  40784f:	48 8b 74 24 70       	mov    0x70(%rsp),%rsi
  407854:	48 8d 57 01          	lea    0x1(%rdi),%rdx
  407858:	48 c1 e7 04          	shl    $0x4,%rdi
  40785c:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  407860:	48 01 f8             	add    %rdi,%rax
  407863:	48 89 16             	mov    %rdx,(%rsi)
  407866:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  40786a:	48 89 28             	mov    %rbp,(%rax)
  40786d:	0f 1f 00             	nopl   (%rax)
            FCS_POS_IDX_TO_CHECK_START_LOOP(card)
  407870:	48 83 c3 04          	add    $0x4,%rbx
  407874:	48 39 5c 24 08       	cmp    %rbx,0x8(%rsp)
  407879:	0f 87 c1 fa ff ff    	ja     407340 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x1e0>
  40787f:	4c 8b 74 24 28       	mov    0x28(%rsp),%r14
  407884:	4c 8b 54 24 30       	mov    0x30(%rsp),%r10
    iter->c = iter->seq_end + 1;
  407889:	49 8d 76 01          	lea    0x1(%r14),%rsi
    for ((*iter).seq_end = (*iter).c; (*iter).seq_end < (*iter).col_len_minus_1;
  40788d:	48 39 74 24 20       	cmp    %rsi,0x20(%rsp)
  407892:	0f 8e 48 01 00 00    	jle    4079e0 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x880>
    return fc_solve_is_parent_buf[(size_t)parent][(size_t)child];
  407898:	49 0f be 44 32 01    	movsbq 0x1(%r10,%rsi,1),%rax
  40789e:	49 0f be 54 32 02    	movsbq 0x2(%r10,%rsi,1),%rdx
  4078a4:	48 c1 e0 06          	shl    $0x6,%rax
        if (!fcs_is_parent_card(fcs_col_get_card(col, (*iter).seq_end + 1),
  4078a8:	80 bc 02 c0 fe 40 00 	cmpb   $0x0,0x40fec0(%rdx,%rax,1)
  4078af:	00 
  4078b0:	0f 84 2a 01 00 00    	je     4079e0 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x880>
  4078b6:	49 8d 46 02          	lea    0x2(%r14),%rax
  4078ba:	48 8b 7c 24 60       	mov    0x60(%rsp),%rdi
  4078bf:	eb 31                	jmp    4078f2 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x792>
  4078c1:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4078c8:	00 00 00 00 
  4078cc:	0f 1f 40 00          	nopl   0x0(%rax)
  4078d0:	49 0f be 54 02 01    	movsbq 0x1(%r10,%rax,1),%rdx
  4078d6:	49 0f be 4c 02 02    	movsbq 0x2(%r10,%rax,1),%rcx
  4078dc:	48 83 c0 01          	add    $0x1,%rax
  4078e0:	48 c1 e2 06          	shl    $0x6,%rdx
  4078e4:	80 bc 11 c0 fe 40 00 	cmpb   $0x0,0x40fec0(%rcx,%rdx,1)
  4078eb:	00 
  4078ec:	0f 84 c6 f9 ff ff    	je     4072b8 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x158>
         ++((*iter).seq_end))
  4078f2:	49 89 c6             	mov    %rax,%r14
    for ((*iter).seq_end = (*iter).c; (*iter).seq_end < (*iter).col_len_minus_1;
  4078f5:	48 39 f8             	cmp    %rdi,%rax
  4078f8:	75 d6                	jne    4078d0 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x770>
        for (; iter.c < iter.col_len; col_seqs_iter__advance(&iter))
  4078fa:	48 39 74 24 38       	cmp    %rsi,0x38(%rsp)
  4078ff:	0f 8f be f9 ff ff    	jg     4072c3 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x163>
  407905:	48 83 44 24 50 01    	addq   $0x1,0x50(%rsp)
  40790b:	4d 89 fc             	mov    %r15,%r12
  40790e:	48 8b 44 24 50       	mov    0x50(%rsp),%rax
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  407913:	48 83 f8 08          	cmp    $0x8,%rax
  407917:	0f 85 e3 f8 ff ff    	jne    407200 <fc_solve_sfs_move_stack_cards_to_different_stacks+0xa0>
}
  40791d:	48 81 c4 e8 00 00 00 	add    $0xe8,%rsp
  407924:	5b                   	pop    %rbx
  407925:	5d                   	pop    %rbp
  407926:	41 5c                	pop    %r12
  407928:	41 5d                	pop    %r13
  40792a:	41 5e                	pop    %r14
  40792c:	41 5f                	pop    %r15
  40792e:	c3                   	retq   
  40792f:	90                   	nop
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  407930:	89 f9                	mov    %edi,%ecx
            if (dest_fc_idx == LOCAL_FREECELLS_NUM)
  407932:	83 f9 04             	cmp    $0x4,%ecx
  407935:	0f 84 a3 fc ff ff    	je     4075de <fc_solve_sfs_move_stack_cards_to_different_stacks+0x47e>
  40793b:	8d 79 01             	lea    0x1(%rcx),%edi
  40793e:	48 63 c9             	movslq %ecx,%rcx
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  407941:	49 63 30             	movslq (%r8),%rsi
            --(*col_num_cards);
  407944:	83 e8 01             	sub    $0x1,%eax
  407947:	89 02                	mov    %eax,(%rdx)
  407949:	4d 8b 1c f1          	mov    (%r9,%rsi,8),%r11
    fcs_col_pop_card(col, ret);
  40794d:	45 0f be 2b          	movsbl (%r11),%r13d
  407951:	44 89 ee             	mov    %r13d,%esi
  407954:	41 83 ed 01          	sub    $0x1,%r13d
  407958:	4d 63 ed             	movslq %r13d,%r13
  40795b:	83 ee 01             	sub    $0x1,%esi
  40795e:	47 0f b6 6c 2b 01    	movzbl 0x1(%r11,%r13,1),%r13d
  407964:	41 88 33             	mov    %sil,(%r11)
  407967:	48 0f be f6          	movsbq %sil,%rsi
  40796b:	41 c6 44 33 01 00    	movb   $0x0,0x1(%r11,%rsi,1)
            fcs_put_card_in_freecell(*new_key, dest_fc_idx, top_card);
  407971:	45 88 6c 09 40       	mov    %r13b,0x40(%r9,%rcx,1)
  407976:	e9 e5 fb ff ff       	jmpq   407560 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x400>
  40797b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  407980:	48 8b ac 24 c0 00 00 	mov    0xc0(%rsp),%rbp
  407987:	00 
  407988:	e9 8a fe ff ff       	jmpq   407817 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x6b7>
  40798d:	0f 1f 00             	nopl   (%rax)
                copy_two_stacks(stack_idx, ds);
  407990:	48 8b 7c 0e f8       	mov    -0x8(%rsi,%rcx,1),%rdi
  407995:	4c 8b 44 24 78       	mov    0x78(%rsp),%r8
  40799a:	49 89 7c 08 f8       	mov    %rdi,-0x8(%r8,%rcx,1)
  40799f:	48 83 e9 01          	sub    $0x1,%rcx
  4079a3:	4c 89 c7             	mov    %r8,%rdi
  4079a6:	48 c1 e9 03          	shr    $0x3,%rcx
  4079aa:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  4079ad:	e9 23 fb ff ff       	jmpq   4074d5 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x375>
  4079b2:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4079b9:	00 00 00 00 
  4079bd:	0f 1f 00             	nopl   (%rax)
  4079c0:	48 89 c7             	mov    %rax,%rdi
            FCS_S_NEXT(instance->list_of_vacant_states);
  4079c3:	48 8b 41 48          	mov    0x48(%rcx),%rax
        instance->list_of_vacant_states =
  4079c7:	48 89 87 b0 00 00 00 	mov    %rax,0xb0(%rdi)
  4079ce:	e9 3e fa ff ff       	jmpq   407411 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x2b1>
  4079d3:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4079da:	00 00 00 00 
  4079de:	66 90                	xchg   %ax,%ax
        if (!fcs_is_parent_card(fcs_col_get_card(col, (*iter).seq_end + 1),
  4079e0:	49 89 f6             	mov    %rsi,%r14
  4079e3:	e9 d0 f8 ff ff       	jmpq   4072b8 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x158>
  4079e8:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  4079ef:	00 
                copy_two_stacks(stack_idx, ds);
  4079f0:	44 89 e9             	mov    %r13d,%ecx
  4079f3:	bf 01 00 00 00       	mov    $0x1,%edi
  4079f8:	d3 e7                	shl    %cl,%edi
  4079fa:	09 fe                	or     %edi,%esi
  4079fc:	89 70 14             	mov    %esi,0x14(%rax)
  4079ff:	49 8b 34 e9          	mov    (%r9,%rbp,8),%rsi
  407a03:	48 89 e8             	mov    %rbp,%rax
  407a06:	48 c1 e0 07          	shl    $0x7,%rax
  407a0a:	48 03 84 24 a0 00 00 	add    0xa0(%rsp),%rax
  407a11:	00 
  407a12:	0f be 0e             	movsbl (%rsi),%ecx
  407a15:	83 c1 01             	add    $0x1,%ecx
  407a18:	48 63 c9             	movslq %ecx,%rcx
  407a1b:	48 83 f9 08          	cmp    $0x8,%rcx
  407a1f:	0f 83 66 01 00 00    	jae    407b8b <fc_solve_sfs_move_stack_cards_to_different_stacks+0xa2b>
  407a25:	f6 c1 04             	test   $0x4,%cl
  407a28:	0f 85 33 02 00 00    	jne    407c61 <fc_solve_sfs_move_stack_cards_to_different_stacks+0xb01>
  407a2e:	48 85 c9             	test   %rcx,%rcx
  407a31:	74 17                	je     407a4a <fc_solve_sfs_move_stack_cards_to_different_stacks+0x8ea>
  407a33:	0f b6 3e             	movzbl (%rsi),%edi
  407a36:	40 88 38             	mov    %dil,(%rax)
  407a39:	4c 8b 8c 24 c0 00 00 	mov    0xc0(%rsp),%r9
  407a40:	00 
  407a41:	f6 c1 02             	test   $0x2,%cl
  407a44:	0f 85 53 02 00 00    	jne    407c9d <fc_solve_sfs_move_stack_cards_to_different_stacks+0xb3d>
  407a4a:	49 89 04 e9          	mov    %rax,(%r9,%rbp,8)
  407a4e:	e9 a8 fa ff ff       	jmpq   4074fb <fc_solve_sfs_move_stack_cards_to_different_stacks+0x39b>
  407a53:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  407a5a:	00 00 00 00 
  407a5e:	66 90                	xchg   %ax,%ax
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  407a60:	89 ce                	mov    %ecx,%esi
  407a62:	48 63 cf             	movslq %edi,%rcx
  407a65:	89 f7                	mov    %esi,%edi
  407a67:	e9 d5 fe ff ff       	jmpq   407941 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x7e1>
  407a6c:	0f 1f 40 00          	nopl   0x0(%rax)
  407a70:	83 c7 02             	add    $0x2,%edi
  407a73:	e9 c9 fe ff ff       	jmpq   407941 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x7e1>
  407a78:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  407a7f:	00 
    allocator->ptr = allocator->rollback_ptr;
  407a80:	48 8b 85 f0 00 00 00 	mov    0xf0(%rbp),%rax
  407a87:	48 89 85 e8 00 00 00 	mov    %rax,0xe8(%rbp)
  407a8e:	e9 7c fd ff ff       	jmpq   40780f <fc_solve_sfs_move_stack_cards_to_different_stacks+0x6af>
  407a93:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  407a9a:	00 00 00 00 
  407a9e:	66 90                	xchg   %ax,%ax
  407aa0:	83 c7 03             	add    $0x3,%edi
  407aa3:	e9 99 fe ff ff       	jmpq   407941 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x7e1>
  407aa8:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  407aaf:	00 
    for (int ret = start_from; ret < local_stacks_num; ret++)
  407ab0:	45 31 ed             	xor    %r13d,%r13d
    return -1;
  407ab3:	b9 ff ff ff ff       	mov    $0xffffffff,%ecx
  407ab8:	e9 3f fc ff ff       	jmpq   4076fc <fc_solve_sfs_move_stack_cards_to_different_stacks+0x59c>
  407abd:	0f 1f 00             	nopl   (%rax)
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  407ac0:	41 bb 01 00 00 00    	mov    $0x1,%r11d
  407ac6:	41 d3 e3             	shl    %cl,%r11d
  407ac9:	c1 e1 07             	shl    $0x7,%ecx
  407acc:	44 09 df             	or     %r11d,%edi
  407acf:	4c 63 d9             	movslq %ecx,%r11
  407ad2:	4c 03 9c 24 90 00 00 	add    0x90(%rsp),%r11
  407ad9:	00 
  407ada:	89 7e 14             	mov    %edi,0x14(%rsi)
  407add:	4b 8d 3c f1          	lea    (%r9,%r14,8),%rdi
  407ae1:	48 8b 37             	mov    (%rdi),%rsi
  407ae4:	48 89 bc 24 a8 00 00 	mov    %rdi,0xa8(%rsp)
  407aeb:	00 
  407aec:	0f be 0e             	movsbl (%rsi),%ecx
  407aef:	83 c1 01             	add    $0x1,%ecx
  407af2:	48 63 c9             	movslq %ecx,%rcx
  407af5:	48 83 f9 08          	cmp    $0x8,%rcx
  407af9:	0f 83 b1 00 00 00    	jae    407bb0 <fc_solve_sfs_move_stack_cards_to_different_stacks+0xa50>
  407aff:	f6 c1 04             	test   $0x4,%cl
  407b02:	0f 85 72 01 00 00    	jne    407c7a <fc_solve_sfs_move_stack_cards_to_different_stacks+0xb1a>
  407b08:	48 85 c9             	test   %rcx,%rcx
  407b0b:	74 0f                	je     407b1c <fc_solve_sfs_move_stack_cards_to_different_stacks+0x9bc>
  407b0d:	0f b6 3e             	movzbl (%rsi),%edi
  407b10:	41 88 3b             	mov    %dil,(%r11)
  407b13:	f6 c1 02             	test   $0x2,%cl
  407b16:	0f 85 71 01 00 00    	jne    407c8d <fc_solve_sfs_move_stack_cards_to_different_stacks+0xb2d>
  407b1c:	48 8b bc 24 a8 00 00 	mov    0xa8(%rsp),%rdi
  407b23:	00 
  407b24:	4c 89 1f             	mov    %r11,(%rdi)
  407b27:	e9 e7 fb ff ff       	jmpq   407713 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x5b3>
  407b2c:	0f 1f 40 00          	nopl   0x0(%rax)
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  407b30:	bf 04 00 00 00       	mov    $0x4,%edi
  407b35:	b9 03 00 00 00       	mov    $0x3,%ecx
  407b3a:	e9 02 fe ff ff       	jmpq   407941 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x7e1>
  407b3f:	48 8b 88 f8 00 00 00 	mov    0xf8(%rax),%rcx
    char *const ret = meta_alloc->recycle_bin;
  407b46:	48 8b 01             	mov    (%rcx),%rax
    if (ret)
  407b49:	48 85 c0             	test   %rax,%rax
  407b4c:	0f 84 b1 00 00 00    	je     407c03 <fc_solve_sfs_move_stack_cards_to_different_stacks+0xaa3>
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  407b52:	48 8b 30             	mov    (%rax),%rsi
  407b55:	48 89 31             	mov    %rsi,(%rcx)
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  407b58:	48 8b 7c 24 40       	mov    0x40(%rsp),%rdi
  407b5d:	48 8b 8f d8 00 00 00 	mov    0xd8(%rdi),%rcx
  407b64:	48 89 08             	mov    %rcx,(%rax)
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  407b67:	48 8d 48 08          	lea    0x8(%rax),%rcx
    allocator->old_list = new_data;
  407b6b:	48 89 87 d8 00 00 00 	mov    %rax,0xd8(%rdi)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  407b72:	48 05 80 fe 00 00    	add    $0xfe80,%rax
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  407b78:	48 89 8f f0 00 00 00 	mov    %rcx,0xf0(%rdi)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  407b7f:	48 89 87 e0 00 00 00 	mov    %rax,0xe0(%rdi)
  407b86:	e9 7b f8 ff ff       	jmpq   407406 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x2a6>
                copy_two_stacks(stack_idx, ds);
  407b8b:	48 8b 7c 0e f8       	mov    -0x8(%rsi,%rcx,1),%rdi
  407b90:	48 89 7c 08 f8       	mov    %rdi,-0x8(%rax,%rcx,1)
  407b95:	48 83 e9 01          	sub    $0x1,%rcx
  407b99:	48 89 c7             	mov    %rax,%rdi
  407b9c:	48 c1 e9 03          	shr    $0x3,%rcx
  407ba0:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  407ba3:	4c 8b 8c 24 c0 00 00 	mov    0xc0(%rsp),%r9
  407baa:	00 
  407bab:	e9 9a fe ff ff       	jmpq   407a4a <fc_solve_sfs_move_stack_cards_to_different_stacks+0x8ea>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  407bb0:	48 8b 7c 0e f8       	mov    -0x8(%rsi,%rcx,1),%rdi
  407bb5:	49 89 7c 0b f8       	mov    %rdi,-0x8(%r11,%rcx,1)
  407bba:	48 83 e9 01          	sub    $0x1,%rcx
  407bbe:	4c 89 df             	mov    %r11,%rdi
  407bc1:	48 c1 e9 03          	shr    $0x3,%rcx
  407bc5:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  407bc8:	e9 4f ff ff ff       	jmpq   407b1c <fc_solve_sfs_move_stack_cards_to_different_stacks+0x9bc>
    for ((*iter).seq_end = (*iter).c; (*iter).seq_end < (*iter).col_len_minus_1;
  407bcd:	45 31 ed             	xor    %r13d,%r13d
  407bd0:	e9 a1 f6 ff ff       	jmpq   407276 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x116>
                copy_two_stacks(stack_idx, ds);
  407bd5:	8b 3e                	mov    (%rsi),%edi
  407bd7:	4c 8b 4c 24 78       	mov    0x78(%rsp),%r9
  407bdc:	41 89 39             	mov    %edi,(%r9)
  407bdf:	8b 74 0e fc          	mov    -0x4(%rsi,%rcx,1),%esi
  407be3:	41 89 74 09 fc       	mov    %esi,-0x4(%r9,%rcx,1)
  407be8:	e9 e8 f8 ff ff       	jmpq   4074d5 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x375>
        if (fcs_state_col_is_empty(state, ret))
  407bed:	89 ce                	mov    %ecx,%esi
  407bef:	44 89 e9             	mov    %r13d,%ecx
  407bf2:	41 89 f5             	mov    %esi,%r13d
  407bf5:	e9 02 fb ff ff       	jmpq   4076fc <fc_solve_sfs_move_stack_cards_to_different_stacks+0x59c>
  407bfa:	41 83 c5 02          	add    $0x2,%r13d
  407bfe:	e9 f9 fa ff ff       	jmpq   4076fc <fc_solve_sfs_move_stack_cards_to_different_stacks+0x59c>
        return malloc(ALLOCED_SIZE);
  407c03:	bf 80 fe 00 00       	mov    $0xfe80,%edi
  407c08:	89 94 24 90 00 00 00 	mov    %edx,0x90(%rsp)
  407c0f:	e8 dc 94 ff ff       	callq  4010f0 <malloc@plt>
  407c14:	8b 94 24 90 00 00 00 	mov    0x90(%rsp),%edx
  407c1b:	e9 38 ff ff ff       	jmpq   407b58 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x9f8>
  407c20:	41 83 c5 03          	add    $0x3,%r13d
  407c24:	e9 d3 fa ff ff       	jmpq   4076fc <fc_solve_sfs_move_stack_cards_to_different_stacks+0x59c>
  407c29:	41 83 c5 04          	add    $0x4,%r13d
  407c2d:	e9 ca fa ff ff       	jmpq   4076fc <fc_solve_sfs_move_stack_cards_to_different_stacks+0x59c>
                copy_two_stacks(stack_idx, ds);
  407c32:	0f b7 74 0e fe       	movzwl -0x2(%rsi,%rcx,1),%esi
  407c37:	48 8b 7c 24 78       	mov    0x78(%rsp),%rdi
  407c3c:	66 89 74 0f fe       	mov    %si,-0x2(%rdi,%rcx,1)
  407c41:	e9 8f f8 ff ff       	jmpq   4074d5 <fc_solve_sfs_move_stack_cards_to_different_stacks+0x375>
  407c46:	41 83 c5 05          	add    $0x5,%r13d
  407c4a:	e9 ad fa ff ff       	jmpq   4076fc <fc_solve_sfs_move_stack_cards_to_different_stacks+0x59c>
  407c4f:	41 83 c5 06          	add    $0x6,%r13d
  407c53:	e9 a4 fa ff ff       	jmpq   4076fc <fc_solve_sfs_move_stack_cards_to_different_stacks+0x59c>
  407c58:	41 83 c5 07          	add    $0x7,%r13d
  407c5c:	e9 9b fa ff ff       	jmpq   4076fc <fc_solve_sfs_move_stack_cards_to_different_stacks+0x59c>
  407c61:	8b 3e                	mov    (%rsi),%edi
  407c63:	89 38                	mov    %edi,(%rax)
  407c65:	8b 74 0e fc          	mov    -0x4(%rsi,%rcx,1),%esi
  407c69:	89 74 08 fc          	mov    %esi,-0x4(%rax,%rcx,1)
  407c6d:	4c 8b 8c 24 c0 00 00 	mov    0xc0(%rsp),%r9
  407c74:	00 
  407c75:	e9 d0 fd ff ff       	jmpq   407a4a <fc_solve_sfs_move_stack_cards_to_different_stacks+0x8ea>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  407c7a:	8b 3e                	mov    (%rsi),%edi
  407c7c:	41 89 3b             	mov    %edi,(%r11)
  407c7f:	8b 74 0e fc          	mov    -0x4(%rsi,%rcx,1),%esi
  407c83:	41 89 74 0b fc       	mov    %esi,-0x4(%r11,%rcx,1)
  407c88:	e9 8f fe ff ff       	jmpq   407b1c <fc_solve_sfs_move_stack_cards_to_different_stacks+0x9bc>
  407c8d:	0f b7 74 0e fe       	movzwl -0x2(%rsi,%rcx,1),%esi
  407c92:	66 41 89 74 0b fe    	mov    %si,-0x2(%r11,%rcx,1)
  407c98:	e9 7f fe ff ff       	jmpq   407b1c <fc_solve_sfs_move_stack_cards_to_different_stacks+0x9bc>
                copy_two_stacks(stack_idx, ds);
  407c9d:	0f b7 74 0e fe       	movzwl -0x2(%rsi,%rcx,1),%esi
  407ca2:	66 89 74 08 fe       	mov    %si,-0x2(%rax,%rcx,1)
  407ca7:	4c 8b 8c 24 c0 00 00 	mov    0xc0(%rsp),%r9
  407cae:	00 
  407caf:	e9 96 fd ff ff       	jmpq   407a4a <fc_solve_sfs_move_stack_cards_to_different_stacks+0x8ea>
  407cb4:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  407cbb:	00 00 00 00 
  407cbf:	90                   	nop

0000000000407cc0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack>:
{
  407cc0:	41 57                	push   %r15
  407cc2:	41 56                	push   %r14
  407cc4:	41 55                	push   %r13
  407cc6:	41 54                	push   %r12
  407cc8:	49 89 f4             	mov    %rsi,%r12
  407ccb:	55                   	push   %rbp
  407ccc:	53                   	push   %rbx
  407ccd:	48 89 fb             	mov    %rdi,%rbx
  407cd0:	48 81 ec a8 00 00 00 	sub    $0xa8,%rsp
    return (soft_thread->num_vacant_freecells +
  407cd7:	0f b6 83 e4 01 00 00 	movzbl 0x1e4(%rbx),%eax
  407cde:	02 83 e3 01 00 00    	add    0x1e3(%rbx),%al
{
  407ce4:	48 89 7c 24 08       	mov    %rdi,0x8(%rsp)
    MOVE_FUNCS__define_common();
  407ce9:	48 8b 3f             	mov    (%rdi),%rdi
{
  407cec:	48 89 54 24 58       	mov    %rdx,0x58(%rsp)
  407cf1:	48 89 4c 24 18       	mov    %rcx,0x18(%rsp)
    const fcs_game_limit num_vacant_slots_plus_1 =
  407cf6:	48 c7 44 24 60 00 00 	movq   $0x0,0x60(%rsp)
  407cfd:	00 00 
  407cff:	83 c0 01             	add    $0x1,%eax
  407d02:	0f b6 c0             	movzbl %al,%eax
    MOVE_FUNCS__define_common();
  407d05:	48 89 7c 24 10       	mov    %rdi,0x10(%rsp)
  407d0a:	89 44 24 6c          	mov    %eax,0x6c(%rsp)
  407d0e:	48 8d 87 00 01 00 00 	lea    0x100(%rdi),%rax
  407d15:	48 89 44 24 28       	mov    %rax,0x28(%rsp)
  407d1a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
  407d20:	48 8b 74 24 60       	mov    0x60(%rsp),%rsi
        var_AUTO(col, fcs_state_get_col(state, stack_idx));
  407d25:	49 8b 04 f4          	mov    (%r12,%rsi,8),%rax
  407d29:	89 74 24 30          	mov    %esi,0x30(%rsp)
        const int cards_num = fcs_col_len(col);
  407d2d:	0f be 18             	movsbl (%rax),%ebx
        var_AUTO(col, fcs_state_get_col(state, stack_idx));
  407d30:	48 89 44 24 40       	mov    %rax,0x40(%rsp)
static inline int max0(const int e) { return max(e, 0); }
  407d35:	b8 00 00 00 00       	mov    $0x0,%eax
  407d3a:	89 df                	mov    %ebx,%edi
  407d3c:	2b 7c 24 6c          	sub    0x6c(%rsp),%edi
        const int cards_num = fcs_col_len(col);
  407d40:	89 5c 24 50          	mov    %ebx,0x50(%rsp)
  407d44:	0f 49 c7             	cmovns %edi,%eax
        for (int c = start_dc + 2; c < cards_num; c++)
  407d47:	8d 50 02             	lea    0x2(%rax),%edx
  407d4a:	89 c7                	mov    %eax,%edi
  407d4c:	89 44 24 68          	mov    %eax,0x68(%rsp)
  407d50:	39 d3                	cmp    %edx,%ebx
  407d52:	0f 8e e8 09 00 00    	jle    408740 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xa80>
                my_copy_stack(ds);
  407d58:	b8 01 00 00 00       	mov    $0x1,%eax
  407d5d:	89 f1                	mov    %esi,%ecx
  407d5f:	48 63 d2             	movslq %edx,%rdx
  407d62:	d3 e0                	shl    %cl,%eax
  407d64:	89 44 24 54          	mov    %eax,0x54(%rsp)
  407d68:	8d 43 fd             	lea    -0x3(%rbx),%eax
  407d6b:	48 8d 5a 01          	lea    0x1(%rdx),%rbx
  407d6f:	29 f8                	sub    %edi,%eax
  407d71:	48 01 d8             	add    %rbx,%rax
  407d74:	48 89 5c 24 20       	mov    %rbx,0x20(%rsp)
  407d79:	48 89 44 24 48       	mov    %rax,0x48(%rsp)
  407d7e:	66 90                	xchg   %ax,%ax
    return fc_solve_is_parent_buf[(size_t)parent][(size_t)child];
  407d80:	48 8b 5c 24 40       	mov    0x40(%rsp),%rbx
  407d85:	48 0f be 04 13       	movsbq (%rbx,%rdx,1),%rax
  407d8a:	48 0f be 7c 13 01    	movsbq 0x1(%rbx,%rdx,1),%rdi
  407d90:	48 c1 e0 06          	shl    $0x6,%rax
            if (fcs_is_parent_card(card, fcs_col_get_card(col, below_c)))
  407d94:	80 bc 07 c0 fe 40 00 	cmpb   $0x0,0x40fec0(%rdi,%rax,1)
  407d9b:	00 
  407d9c:	48 89 3c 24          	mov    %rdi,(%rsp)
  407da0:	0f 85 0a 07 00 00    	jne    4084b0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x7f0>
            for (int dc = start_dc; dc < below_c; dc++)
  407da6:	8b 7c 24 68          	mov    0x68(%rsp),%edi
  407daa:	8d 42 ff             	lea    -0x1(%rdx),%eax
  407dad:	89 54 24 34          	mov    %edx,0x34(%rsp)
  407db1:	39 c7                	cmp    %eax,%edi
  407db3:	0f 8d f7 06 00 00    	jge    4084b0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x7f0>
  407db9:	89 f8                	mov    %edi,%eax
  407dbb:	f7 d0                	not    %eax
  407dbd:	44 8d 3c 10          	lea    (%rax,%rdx,1),%r15d
  407dc1:	48 63 c7             	movslq %edi,%rax
  407dc4:	4c 8d 6c 03 02       	lea    0x2(%rbx,%rax,1),%r13
  407dc9:	e9 68 01 00 00       	jmpq   407f36 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x276>
  407dce:	66 90                	xchg   %ax,%ax
  407dd0:	48 8b 94 24 80 00 00 	mov    0x80(%rsp),%rdx
  407dd7:	00 
            while ((*col_num_cards) == 0)
  407dd8:	31 db                	xor    %ebx,%ebx
  407dda:	4d 63 c0             	movslq %r8d,%r8
  407ddd:	8b 7c 24 74          	mov    0x74(%rsp),%edi
  407de1:	48 8b 74 24 08       	mov    0x8(%rsp),%rsi
                empty_two_cols_from_new_state(soft_thread,
  407de6:	44 89 f8             	mov    %r15d,%eax
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  407de9:	45 89 fa             	mov    %r15d,%r10d
  407dec:	31 c9                	xor    %ecx,%ecx
  407dee:	44 89 bc 24 90 00 00 	mov    %r15d,0x90(%rsp)
  407df5:	00 
        int dest_fc_idx = 0;
  407df6:	45 31 db             	xor    %r11d,%r11d
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  407df9:	4c 63 f7             	movslq %edi,%r14
  407dfc:	48 8b 36             	mov    (%rsi),%rsi
  407dff:	48 89 74 24 38       	mov    %rsi,0x38(%rsp)
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  407e04:	48 be 00 00 00 00 ff 	movabs $0xffffffff00000000,%rsi
  407e0b:	ff ff ff 
  407e0e:	48 89 b4 24 94 00 00 	mov    %rsi,0x94(%rsp)
  407e15:	00 
  407e16:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  407e1d:	00 00 00 
            while ((*col_num_cards) == 0)
  407e20:	85 c0                	test   %eax,%eax
  407e22:	0f 85 98 04 00 00    	jne    4082c0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x600>
  407e28:	48 8b b4 24 80 00 00 	mov    0x80(%rsp),%rsi
  407e2f:	00 
                if (last_dest.is_col)
  407e30:	84 db                	test   %bl,%bl
  407e32:	0f 84 78 07 00 00    	je     4085b0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x8f0>
                    var_AUTO(new_source_col,
  407e38:	4a 8b 0c c6          	mov    (%rsi,%r8,8),%rcx
                    fcs_col_pop_card(new_source_col, moved_card);
  407e3c:	0f be 11             	movsbl (%rcx),%edx
  407e3f:	89 d0                	mov    %edx,%eax
  407e41:	83 ea 01             	sub    $0x1,%edx
  407e44:	83 e8 01             	sub    $0x1,%eax
  407e47:	48 63 d2             	movslq %edx,%rdx
  407e4a:	0f b6 54 11 01       	movzbl 0x1(%rcx,%rdx,1),%edx
  407e4f:	88 01                	mov    %al,(%rcx)
  407e51:	48 0f be c0          	movsbq %al,%rax
  407e55:	c6 44 01 01 00       	movb   $0x0,0x1(%rcx,%rax,1)
  407e5a:	48 8b b4 24 80 00 00 	mov    0x80(%rsp),%rsi
  407e61:	00 
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  407e62:	4a 8b 0c ce          	mov    (%rsi,%r9,8),%rcx
    fcs_col_push_card(col, card);
  407e66:	48 0f be 01          	movsbq (%rcx),%rax
  407e6a:	8d 70 01             	lea    0x1(%rax),%esi
  407e6d:	40 88 31             	mov    %sil,(%rcx)
    if (!fc_solve_check_and_add_state(
  407e70:	48 8d b4 24 80 00 00 	lea    0x80(%rsp),%rsi
  407e77:	00 
  407e78:	88 54 01 01          	mov    %dl,0x1(%rcx,%rax,1)
    const_SLOT(hard_thread, soft_thread);
  407e7c:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
    if (!fc_solve_check_and_add_state(
  407e81:	48 8d 94 24 90 00 00 	lea    0x90(%rsp),%rdx
  407e88:	00 
    const_SLOT(hard_thread, soft_thread);
  407e89:	48 8b 18             	mov    (%rax),%rbx
    if (!fc_solve_check_and_add_state(
  407e8c:	48 89 df             	mov    %rbx,%rdi
  407e8f:	e8 bc 9b ff ff       	callq  401a50 <fc_solve_check_and_add_state>
  407e94:	84 c0                	test   %al,%al
  407e96:	0f 85 04 07 00 00    	jne    4085a0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x8e0>
        if (HT_FIELD(hard_thread, allocated_from_list))
  407e9c:	80 bb 18 05 00 00 00 	cmpb   $0x0,0x518(%rbx)
  407ea3:	0f 84 77 07 00 00    	je     408620 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x960>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  407ea9:	48 8b 93 b0 00 00 00 	mov    0xb0(%rbx),%rdx
  407eb0:	48 8b 84 24 88 00 00 	mov    0x88(%rsp),%rax
  407eb7:	00 
  407eb8:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  407ebb:	48 8b 84 24 80 00 00 	mov    0x80(%rsp),%rax
  407ec2:	00 
  407ec3:	48 89 83 b0 00 00 00 	mov    %rax,0xb0(%rbx)
  407eca:	48 8b 9c 24 90 00 00 	mov    0x90(%rsp),%rbx
  407ed1:	00 
    if ((!((list->num_states + (list->states != NULL)) &
  407ed2:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
  407ed7:	31 d2                	xor    %edx,%edx
  407ed9:	48 8b 38             	mov    (%rax),%rdi
  407edc:	48 8b 40 08          	mov    0x8(%rax),%rax
  407ee0:	48 85 c0             	test   %rax,%rax
  407ee3:	0f 95 c2             	setne  %dl
  407ee6:	48 01 fa             	add    %rdi,%rdx
  407ee9:	f6 c2 0f             	test   $0xf,%dl
  407eec:	75 1c                	jne    407f0a <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x24a>
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  407eee:	48 8d 72 10          	lea    0x10(%rdx),%rsi
  407ef2:	48 89 c7             	mov    %rax,%rdi
  407ef5:	48 c1 e6 04          	shl    $0x4,%rsi
  407ef9:	e8 72 92 ff ff       	callq  401170 <realloc@plt>
        list->states =
  407efe:	48 8b 7c 24 18       	mov    0x18(%rsp),%rdi
  407f03:	48 89 47 08          	mov    %rax,0x8(%rdi)
  407f07:	48 8b 3f             	mov    (%rdi),%rdi
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  407f0a:	48 8b 74 24 18       	mov    0x18(%rsp),%rsi
  407f0f:	48 8d 57 01          	lea    0x1(%rdi),%rdx
  407f13:	48 c1 e7 04          	shl    $0x4,%rdi
  407f17:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  407f1b:	48 01 f8             	add    %rdi,%rax
  407f1e:	48 89 16             	mov    %rdx,(%rsi)
  407f21:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  407f25:	48 89 18             	mov    %rbx,(%rax)
  407f28:	49 83 c5 01          	add    $0x1,%r13
            for (int dc = start_dc; dc < below_c; dc++)
  407f2c:	41 83 ef 01          	sub    $0x1,%r15d
  407f30:	0f 84 7a 05 00 00    	je     4084b0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x7f0>
    return fc_solve_is_parent_buf[(size_t)parent][(size_t)child];
  407f36:	49 0f be 45 ff       	movsbq -0x1(%r13),%rax
  407f3b:	48 8b 1c 24          	mov    (%rsp),%rbx
  407f3f:	48 c1 e0 06          	shl    $0x6,%rax
  407f43:	0f b6 9c 18 c0 fe 40 	movzbl 0x40fec0(%rax,%rbx,1),%ebx
  407f4a:	00 
  407f4b:	48 05 c0 fe 40 00    	add    $0x40fec0,%rax
                if ((!fcs_is_parent_card(card, dest_card)) ||
  407f51:	84 db                	test   %bl,%bl
  407f53:	74 d3                	je     407f28 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x268>
  407f55:	49 0f be 55 00       	movsbq 0x0(%r13),%rdx
  407f5a:	80 3c 10 00          	cmpb   $0x0,(%rax,%rdx,1)
  407f5e:	75 c8                	jne    407f28 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x268>
                (instance->list_of_vacant_states != NULL)))
  407f60:	48 8b 7c 24 10       	mov    0x10(%rsp),%rdi
  407f65:	48 8b 97 b0 00 00 00 	mov    0xb0(%rdi),%rdx
  407f6c:	48 85 d2             	test   %rdx,%rdx
    if ((HT_FIELD(hard_thread, allocated_from_list) =
  407f6f:	0f 95 87 18 05 00 00 	setne  0x518(%rdi)
  407f76:	0f 85 54 06 00 00    	jne    4085d0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x910>
    if ((size_t)(allocator->max_ptr - allocator->ptr) < how_much)
  407f7c:	48 8b 87 e0 00 00 00 	mov    0xe0(%rdi),%rax
  407f83:	48 8b 97 e8 00 00 00 	mov    0xe8(%rdi),%rdx
  407f8a:	48 89 44 24 38       	mov    %rax,0x38(%rsp)
  407f8f:	48 29 d0             	sub    %rdx,%rax
  407f92:	48 83 f8 5f          	cmp    $0x5f,%rax
    char *const new_data = meta_request_new_buffer(allocator->meta);
  407f96:	48 8b 44 24 10       	mov    0x10(%rsp),%rax
  407f9b:	0f 86 ef 07 00 00    	jbe    408790 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xad0>
        allocator->rollback_ptr = allocator->ptr;
  407fa1:	48 89 90 f0 00 00 00 	mov    %rdx,0xf0(%rax)
  407fa8:	48 89 c7             	mov    %rax,%rdi
    allocator->ptr += how_much;
  407fab:	48 8d 42 60          	lea    0x60(%rdx),%rax
  407faf:	48 89 87 e8 00 00 00 	mov    %rax,0xe8(%rdi)
    return (const fcs_kv_state){.key = &(s->s), .val = &(s->info)};
  407fb6:	48 8d 42 48          	lea    0x48(%rdx),%rax
    *ret = FCS_STATE_keyval_pair_to_kv(s);
  407fba:	c4 e1 f9 6e ca       	vmovq  %rdx,%xmm1
                my_copy_stack(ds);
  407fbf:	4c 63 4c 24 30       	movslq 0x30(%rsp),%r9
  407fc4:	c4 e3 f1 22 c0 01    	vpinsrq $0x1,%rax,%xmm1,%xmm0
  407fca:	c5 f8 29 84 24 80 00 	vmovaps %xmm0,0x80(%rsp)
  407fd1:	00 00 
    fcs_duplicate_kv_state(out_new_state_out, &raw_state_raw);
  407fd3:	c4 c1 7a 6f 04 24    	vmovdqu (%r12),%xmm0
  407fd9:	c5 f8 11 02          	vmovups %xmm0,(%rdx)
  407fdd:	c4 c1 7a 6f 44 24 10 	vmovdqu 0x10(%r12),%xmm0
  407fe4:	c5 f8 11 42 10       	vmovups %xmm0,0x10(%rdx)
  407fe9:	c4 c1 7a 6f 44 24 20 	vmovdqu 0x20(%r12),%xmm0
  407ff0:	c5 f8 11 42 20       	vmovups %xmm0,0x20(%rdx)
  407ff5:	c4 c1 7a 6f 44 24 30 	vmovdqu 0x30(%r12),%xmm0
  407ffc:	c5 f8 11 42 30       	vmovups %xmm0,0x30(%rdx)
  408001:	49 8b 44 24 40       	mov    0x40(%r12),%rax
  408006:	48 89 42 40          	mov    %rax,0x40(%rdx)
  40800a:	48 8b 44 24 58       	mov    0x58(%rsp),%rax
  40800f:	c5 fa 6f 00          	vmovdqu (%rax),%xmm0
  408013:	c5 f8 11 42 48       	vmovups %xmm0,0x48(%rdx)
  408018:	48 8b 40 10          	mov    0x10(%rax),%rax
    (FCS_S_DEPTH(raw_ptr_new_state))++;
  40801c:	83 42 50 01          	addl   $0x1,0x50(%rdx)
    FCS_S_PARENT(raw_ptr_new_state) = INFO_STATE_PTR(&raw_state_raw);
  408020:	4c 89 62 48          	mov    %r12,0x48(%rdx)
    FCS_S_VISITED(raw_ptr_new_state) = 0;
  408024:	c6 42 56 00          	movb   $0x0,0x56(%rdx)
    fcs_duplicate_kv_state(out_new_state_out, &raw_state_raw);
  408028:	48 89 42 58          	mov    %rax,0x58(%rdx)
    FCS_S_NUM_ACTIVE_CHILDREN(raw_ptr_new_state) = 0;
  40802c:	31 c0                	xor    %eax,%eax
  40802e:	66 89 42 54          	mov    %ax,0x54(%rdx)
  408032:	8b 44 24 54          	mov    0x54(%rsp),%eax
    memset(&(FCS_S_SCAN_VISITED(raw_ptr_new_state)), '\0',
  408036:	c7 42 57 00 00 00 00 	movl   $0x0,0x57(%rdx)
  40803d:	4a 8b 34 ca          	mov    (%rdx,%r9,8),%rsi
  408041:	89 42 5c             	mov    %eax,0x5c(%rdx)
  408044:	0f be 06             	movsbl (%rsi),%eax
  408047:	83 c0 01             	add    $0x1,%eax
  40804a:	48 98                	cltq   
  40804c:	48 83 f8 08          	cmp    $0x8,%rax
  408050:	0f 83 2a 05 00 00    	jae    408580 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x8c0>
  408056:	a8 04                	test   $0x4,%al
  408058:	0f 85 bc 07 00 00    	jne    40881a <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xb5a>
  40805e:	48 85 c0             	test   %rax,%rax
  408061:	74 12                	je     408075 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x3b5>
  408063:	0f b6 16             	movzbl (%rsi),%edx
  408066:	48 8b 7c 24 28       	mov    0x28(%rsp),%rdi
  40806b:	88 17                	mov    %dl,(%rdi)
  40806d:	a8 02                	test   $0x2,%al
  40806f:	0f 85 23 08 00 00    	jne    408898 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xbd8>
  408075:	48 8b 44 24 28       	mov    0x28(%rsp),%rax
                const int cols_indexes[3] = {ds, -1, -1};
  40807a:	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};
  408081:	31 d2                	xor    %edx,%edx
                my_copy_stack(ds);
  408083:	4c 8b 94 24 80 00 00 	mov    0x80(%rsp),%r10
  40808a:	00 
                const int cols_indexes[3] = {ds, -1, -1};
  40808b:	4c 89 44 24 78       	mov    %r8,0x78(%rsp)
  408090:	48 8b 7c 24 08       	mov    0x8(%rsp),%rdi
                my_copy_stack(ds);
  408095:	4b 89 04 ca          	mov    %rax,(%r10,%r9,8)
                const int cols_indexes[3] = {ds, -1, -1};
  408099:	8b 44 24 30          	mov    0x30(%rsp),%eax
  40809d:	48 8b 2f             	mov    (%rdi),%rbp
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  4080a0:	48 bf 00 00 00 00 ff 	movabs $0xffffffff00000000,%rdi
  4080a7:	ff ff ff 
  4080aa:	48 89 bc 24 94 00 00 	mov    %rdi,0x94(%rsp)
  4080b1:	00 
        int dest_fc_idx = 0;
  4080b2:	31 ff                	xor    %edi,%edi
                const int cols_indexes[3] = {ds, -1, -1};
  4080b4:	89 44 24 74          	mov    %eax,0x74(%rsp)
  4080b8:	8b 44 24 50          	mov    0x50(%rsp),%eax
  4080bc:	2b 44 24 34          	sub    0x34(%rsp),%eax
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  4080c0:	89 84 24 90 00 00 00 	mov    %eax,0x90(%rsp)
  4080c7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  4080ce:	00 00 
            while ((*col_num_cards) == 0)
  4080d0:	85 c0                	test   %eax,%eax
  4080d2:	0f 84 f8 fc ff ff    	je     407dd0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x110>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  4080d8:	83 ff 03             	cmp    $0x3,%edi
  4080db:	0f 8f ff 03 00 00    	jg     4084e0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x820>
  4080e1:	44 8d 47 01          	lea    0x1(%rdi),%r8d
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  4080e5:	48 63 cf             	movslq %edi,%rcx
  4080e8:	41 80 7c 0a 40 00    	cmpb   $0x0,0x40(%r10,%rcx,1)
  4080ee:	0f 84 fc 04 00 00    	je     4085f0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x930>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  4080f4:	41 83 f8 04          	cmp    $0x4,%r8d
  4080f8:	74 41                	je     40813b <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x47b>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  4080fa:	49 63 f0             	movslq %r8d,%rsi
  4080fd:	41 80 7c 32 40 00    	cmpb   $0x0,0x40(%r10,%rsi,1)
  408103:	0f 84 07 05 00 00    	je     408610 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x950>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  408109:	44 8d 47 02          	lea    0x2(%rdi),%r8d
  40810d:	41 83 f8 04          	cmp    $0x4,%r8d
  408111:	74 28                	je     40813b <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x47b>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  408113:	49 63 f0             	movslq %r8d,%rsi
  408116:	41 80 7c 32 40 00    	cmpb   $0x0,0x40(%r10,%rsi,1)
  40811c:	0f 84 1e 05 00 00    	je     408640 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x980>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  408122:	44 8d 47 03          	lea    0x3(%rdi),%r8d
  408126:	41 83 f8 03          	cmp    $0x3,%r8d
  40812a:	0f 85 b3 03 00 00    	jne    4084e3 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x823>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  408130:	41 80 7a 43 00       	cmpb   $0x0,0x43(%r10)
  408135:	0f 84 f5 05 00 00    	je     408730 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xa70>
  40813b:	84 d2                	test   %dl,%dl
  40813d:	0f 85 ee 07 00 00    	jne    408931 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xc71>
    char *const indirect_stacks_buffer =
  408143:	48 8d bd 00 01 00 00 	lea    0x100(%rbp),%rdi
    int put_cards_in_col_idx = 0;
  40814a:	45 31 db             	xor    %r11d,%r11d
  40814d:	48 8b 94 24 80 00 00 	mov    0x80(%rsp),%rdx
  408154:	00 
        if (fcs_state_col_is_empty(state, ret))
  408155:	41 be 08 00 00 00    	mov    $0x8,%r14d
    char *const indirect_stacks_buffer =
  40815b:	48 89 7c 24 38       	mov    %rdi,0x38(%rsp)
  408160:	49 63 cb             	movslq %r11d,%rcx
  408163:	48 8d 34 ca          	lea    (%rdx,%rcx,8),%rsi
        if (fcs_state_col_is_empty(state, ret))
  408167:	48 8b 3e             	mov    (%rsi),%rdi
  40816a:	41 8d 4b 01          	lea    0x1(%r11),%ecx
  40816e:	80 3f 00             	cmpb   $0x0,(%rdi)
  408171:	0f 84 c6 06 00 00    	je     40883d <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xb7d>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  408177:	83 f9 08             	cmp    $0x8,%ecx
  40817a:	0f 84 00 06 00 00    	je     408780 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xac0>
        if (fcs_state_col_is_empty(state, ret))
  408180:	48 8b 7e 08          	mov    0x8(%rsi),%rdi
  408184:	80 3f 00             	cmpb   $0x0,(%rdi)
  408187:	0f 84 cc 06 00 00    	je     408859 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xb99>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  40818d:	41 8d 4b 02          	lea    0x2(%r11),%ecx
  408191:	83 f9 08             	cmp    $0x8,%ecx
  408194:	0f 84 e6 05 00 00    	je     408780 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xac0>
        if (fcs_state_col_is_empty(state, ret))
  40819a:	48 8b 7e 10          	mov    0x10(%rsi),%rdi
  40819e:	80 3f 00             	cmpb   $0x0,(%rdi)
  4081a1:	0f 84 c4 06 00 00    	je     40886b <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xbab>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4081a7:	41 8d 4b 03          	lea    0x3(%r11),%ecx
  4081ab:	83 f9 07             	cmp    $0x7,%ecx
  4081ae:	0f 8f cc 05 00 00    	jg     408780 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xac0>
        if (fcs_state_col_is_empty(state, ret))
  4081b4:	48 8b 7e 18          	mov    0x18(%rsi),%rdi
  4081b8:	80 3f 00             	cmpb   $0x0,(%rdi)
  4081bb:	0f 84 c5 06 00 00    	je     408886 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xbc6>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4081c1:	41 8d 4b 04          	lea    0x4(%r11),%ecx
  4081c5:	83 f9 07             	cmp    $0x7,%ecx
  4081c8:	0f 8f b2 05 00 00    	jg     408780 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xac0>
        if (fcs_state_col_is_empty(state, ret))
  4081ce:	48 8b 7e 20          	mov    0x20(%rsi),%rdi
  4081d2:	80 3f 00             	cmpb   $0x0,(%rdi)
  4081d5:	0f 84 b4 06 00 00    	je     40888f <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xbcf>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4081db:	41 8d 4b 05          	lea    0x5(%r11),%ecx
  4081df:	83 f9 07             	cmp    $0x7,%ecx
  4081e2:	0f 8f 98 05 00 00    	jg     408780 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xac0>
        if (fcs_state_col_is_empty(state, ret))
  4081e8:	48 8b 7e 28          	mov    0x28(%rsi),%rdi
  4081ec:	80 3f 00             	cmpb   $0x0,(%rdi)
  4081ef:	0f 84 c0 06 00 00    	je     4088b5 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xbf5>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4081f5:	41 8d 4b 06          	lea    0x6(%r11),%ecx
  4081f9:	83 f9 07             	cmp    $0x7,%ecx
  4081fc:	0f 8f 7e 05 00 00    	jg     408780 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xac0>
        if (fcs_state_col_is_empty(state, ret))
  408202:	48 8b 76 30          	mov    0x30(%rsi),%rsi
  408206:	80 3e 00             	cmpb   $0x0,(%rsi)
  408209:	0f 84 b8 06 00 00    	je     4088c7 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xc07>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  40820f:	45 85 db             	test   %r11d,%r11d
  408212:	0f 85 68 05 00 00    	jne    408780 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xac0>
        if (fcs_state_col_is_empty(state, ret))
  408218:	48 8b 52 38          	mov    0x38(%rdx),%rdx
  40821c:	80 3a 00             	cmpb   $0x0,(%rdx)
  40821f:	45 0f 44 de          	cmove  %r14d,%r11d
  408223:	80 3a 01             	cmpb   $0x1,(%rdx)
  408226:	19 c9                	sbb    %ecx,%ecx
  408228:	83 e1 08             	and    $0x8,%ecx
  40822b:	83 e9 01             	sub    $0x1,%ecx
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  40822e:	48 8b b4 24 88 00 00 	mov    0x88(%rsp),%rsi
  408235:	00 
  408236:	4c 63 c1             	movslq %ecx,%r8
  408239:	8b 56 14             	mov    0x14(%rsi),%edx
  40823c:	0f a3 ca             	bt     %ecx,%edx
  40823f:	0f 83 1b 04 00 00    	jae    408660 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x9a0>
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  408245:	48 63 54 24 74       	movslq 0x74(%rsp),%rdx
        --(*col_num_cards);
  40824a:	83 e8 01             	sub    $0x1,%eax
  40824d:	49 8b 0c d2          	mov    (%r10,%rdx,8),%rcx
  408251:	48 89 d7             	mov    %rdx,%rdi
    fcs_col_pop_card(col, ret);
  408254:	0f be 31             	movsbl (%rcx),%esi
  408257:	89 f2                	mov    %esi,%edx
  408259:	83 ee 01             	sub    $0x1,%esi
  40825c:	83 ea 01             	sub    $0x1,%edx
  40825f:	48 63 f6             	movslq %esi,%rsi
  408262:	0f b6 74 31 01       	movzbl 0x1(%rcx,%rsi,1),%esi
  408267:	88 11                	mov    %dl,(%rcx)
  408269:	48 0f be d2          	movsbq %dl,%rdx
  40826d:	c6 44 11 01 00       	movb   $0x0,0x1(%rcx,%rdx,1)
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  408272:	4b 8b 0c c2          	mov    (%r10,%r8,8),%rcx
    fcs_col_push_card(col, card);
  408276:	48 0f be 11          	movsbq (%rcx),%rdx
  40827a:	8d 6a 01             	lea    0x1(%rdx),%ebp
  40827d:	40 88 29             	mov    %bpl,(%rcx)
  408280:	40 88 74 11 01       	mov    %sil,0x1(%rcx,%rdx,1)
  408285:	48 8b 94 24 80 00 00 	mov    0x80(%rsp),%rdx
  40828c:	00 
  40828d:	89 84 24 90 00 00 00 	mov    %eax,0x90(%rsp)
        while ((*col_num_cards) == 0)
  408294:	85 c0                	test   %eax,%eax
  408296:	0f 84 45 fb ff ff    	je     407de1 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x121>
    return -1;
  40829c:	b9 ff ff ff ff       	mov    $0xffffffff,%ecx
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4082a1:	41 83 fb 08          	cmp    $0x8,%r11d
  4082a5:	0f 85 b5 fe ff ff    	jne    408160 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x4a0>
  4082ab:	45 31 db             	xor    %r11d,%r11d
  4082ae:	e9 7b ff ff ff       	jmpq   40822e <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x56e>
  4082b3:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4082ba:	00 00 00 00 
  4082be:	66 90                	xchg   %ax,%ax
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  4082c0:	41 83 fb 03          	cmp    $0x3,%r11d
  4082c4:	0f 8f 66 02 00 00    	jg     408530 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x870>
  4082ca:	41 8d 73 01          	lea    0x1(%r11),%esi
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  4082ce:	49 63 eb             	movslq %r11d,%rbp
  4082d1:	80 7c 2a 40 00       	cmpb   $0x0,0x40(%rdx,%rbp,1)
  4082d6:	0f 84 04 03 00 00    	je     4085e0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x920>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  4082dc:	83 fe 04             	cmp    $0x4,%esi
  4082df:	74 3c                	je     40831d <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x65d>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  4082e1:	48 63 f6             	movslq %esi,%rsi
  4082e4:	80 7c 32 40 00       	cmpb   $0x0,0x40(%rdx,%rsi,1)
  4082e9:	0f 84 11 03 00 00    	je     408600 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x940>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  4082ef:	41 8d 73 02          	lea    0x2(%r11),%esi
  4082f3:	83 fe 04             	cmp    $0x4,%esi
  4082f6:	74 25                	je     40831d <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x65d>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  4082f8:	48 63 f6             	movslq %esi,%rsi
  4082fb:	80 7c 32 40 00       	cmpb   $0x0,0x40(%rdx,%rsi,1)
  408300:	0f 84 4a 03 00 00    	je     408650 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x990>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  408306:	41 8d 73 03          	lea    0x3(%r11),%esi
  40830a:	83 fe 03             	cmp    $0x3,%esi
  40830d:	0f 85 20 02 00 00    	jne    408533 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x873>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  408313:	80 7a 43 00          	cmpb   $0x0,0x43(%rdx)
  408317:	0f 84 03 04 00 00    	je     408720 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xa60>
  40831d:	84 c9                	test   %cl,%cl
  40831f:	0f 85 ff 05 00 00    	jne    408924 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xc64>
    char *const indirect_stacks_buffer =
  408325:	48 8b 4c 24 38       	mov    0x38(%rsp),%rcx
    int put_cards_in_col_idx = 0;
  40832a:	45 31 db             	xor    %r11d,%r11d
  40832d:	48 8b b4 24 80 00 00 	mov    0x80(%rsp),%rsi
  408334:	00 
    char *const indirect_stacks_buffer =
  408335:	48 81 c1 00 01 00 00 	add    $0x100,%rcx
  40833c:	48 89 4c 24 38       	mov    %rcx,0x38(%rsp)
  408341:	49 63 cb             	movslq %r11d,%rcx
  408344:	4c 8d 14 ce          	lea    (%rsi,%rcx,8),%r10
        if (fcs_state_col_is_empty(state, ret))
  408348:	49 8b 2a             	mov    (%r10),%rbp
  40834b:	41 8d 4b 01          	lea    0x1(%r11),%ecx
  40834f:	80 7d 00 00          	cmpb   $0x0,0x0(%rbp)
  408353:	0f 84 d7 04 00 00    	je     408830 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xb70>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  408359:	83 f9 08             	cmp    $0x8,%ecx
  40835c:	0f 84 0e 04 00 00    	je     408770 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xab0>
        if (fcs_state_col_is_empty(state, ret))
  408362:	49 8b 6a 08          	mov    0x8(%r10),%rbp
  408366:	80 7d 00 00          	cmpb   $0x0,0x0(%rbp)
  40836a:	0f 84 f2 04 00 00    	je     408862 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xba2>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  408370:	41 8d 4b 02          	lea    0x2(%r11),%ecx
  408374:	83 f9 08             	cmp    $0x8,%ecx
  408377:	0f 84 f3 03 00 00    	je     408770 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xab0>
        if (fcs_state_col_is_empty(state, ret))
  40837d:	49 8b 6a 10          	mov    0x10(%r10),%rbp
  408381:	80 7d 00 00          	cmpb   $0x0,0x0(%rbp)
  408385:	0f 84 e9 04 00 00    	je     408874 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xbb4>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  40838b:	41 8d 4b 03          	lea    0x3(%r11),%ecx
  40838f:	83 f9 07             	cmp    $0x7,%ecx
  408392:	0f 8f d8 03 00 00    	jg     408770 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xab0>
        if (fcs_state_col_is_empty(state, ret))
  408398:	49 8b 6a 18          	mov    0x18(%r10),%rbp
  40839c:	80 7d 00 00          	cmpb   $0x0,0x0(%rbp)
  4083a0:	0f 84 d7 04 00 00    	je     40887d <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xbbd>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4083a6:	41 8d 4b 04          	lea    0x4(%r11),%ecx
  4083aa:	83 f9 07             	cmp    $0x7,%ecx
  4083ad:	0f 8f bd 03 00 00    	jg     408770 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xab0>
        if (fcs_state_col_is_empty(state, ret))
  4083b3:	49 8b 6a 20          	mov    0x20(%r10),%rbp
  4083b7:	80 7d 00 00          	cmpb   $0x0,0x0(%rbp)
  4083bb:	0f 84 eb 04 00 00    	je     4088ac <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xbec>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4083c1:	41 8d 4b 05          	lea    0x5(%r11),%ecx
  4083c5:	83 f9 07             	cmp    $0x7,%ecx
  4083c8:	0f 8f a2 03 00 00    	jg     408770 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xab0>
        if (fcs_state_col_is_empty(state, ret))
  4083ce:	49 8b 6a 28          	mov    0x28(%r10),%rbp
  4083d2:	80 7d 00 00          	cmpb   $0x0,0x0(%rbp)
  4083d6:	0f 84 e2 04 00 00    	je     4088be <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xbfe>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4083dc:	41 8d 4b 06          	lea    0x6(%r11),%ecx
  4083e0:	83 f9 07             	cmp    $0x7,%ecx
  4083e3:	0f 8f 87 03 00 00    	jg     408770 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xab0>
        if (fcs_state_col_is_empty(state, ret))
  4083e9:	4d 8b 52 30          	mov    0x30(%r10),%r10
  4083ed:	41 80 3a 00          	cmpb   $0x0,(%r10)
  4083f1:	0f 84 d9 04 00 00    	je     4088d0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xc10>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4083f7:	45 85 db             	test   %r11d,%r11d
  4083fa:	0f 85 70 03 00 00    	jne    408770 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xab0>
        if (fcs_state_col_is_empty(state, ret))
  408400:	48 8b 4e 38          	mov    0x38(%rsi),%rcx
  408404:	be 08 00 00 00       	mov    $0x8,%esi
  408409:	80 39 00             	cmpb   $0x0,(%rcx)
  40840c:	44 0f 44 de          	cmove  %esi,%r11d
  408410:	80 39 01             	cmpb   $0x1,(%rcx)
  408413:	19 c9                	sbb    %ecx,%ecx
  408415:	83 e1 08             	and    $0x8,%ecx
  408418:	83 e9 01             	sub    $0x1,%ecx
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  40841b:	48 8b b4 24 88 00 00 	mov    0x88(%rsp),%rsi
  408422:	00 
  408423:	48 63 e9             	movslq %ecx,%rbp
  408426:	44 8b 56 14          	mov    0x14(%rsi),%r10d
  40842a:	41 0f a3 ca          	bt     %ecx,%r10d
  40842e:	0f 83 8c 02 00 00    	jae    4086c0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xa00>
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  408434:	48 63 cf             	movslq %edi,%rcx
        --(*col_num_cards);
  408437:	83 e8 01             	sub    $0x1,%eax
  40843a:	48 8b 34 ca          	mov    (%rdx,%rcx,8),%rsi
    fcs_col_pop_card(col, ret);
  40843e:	44 0f be 16          	movsbl (%rsi),%r10d
  408442:	44 89 d1             	mov    %r10d,%ecx
  408445:	41 83 ea 01          	sub    $0x1,%r10d
  408449:	83 e9 01             	sub    $0x1,%ecx
  40844c:	4d 63 d2             	movslq %r10d,%r10
  40844f:	46 0f b6 54 16 01    	movzbl 0x1(%rsi,%r10,1),%r10d
  408455:	88 0e                	mov    %cl,(%rsi)
  408457:	48 0f be c9          	movsbq %cl,%rcx
  40845b:	c6 44 0e 01 00       	movb   $0x0,0x1(%rsi,%rcx,1)
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  408460:	48 8b 34 ea          	mov    (%rdx,%rbp,8),%rsi
    fcs_col_push_card(col, card);
  408464:	48 0f be 0e          	movsbq (%rsi),%rcx
  408468:	8d 69 01             	lea    0x1(%rcx),%ebp
  40846b:	40 88 2e             	mov    %bpl,(%rsi)
  40846e:	44 88 54 0e 01       	mov    %r10b,0x1(%rsi,%rcx,1)
  408473:	48 8b b4 24 80 00 00 	mov    0x80(%rsp),%rsi
  40847a:	00 
  40847b:	89 84 24 90 00 00 00 	mov    %eax,0x90(%rsp)
        while ((*col_num_cards) == 0)
  408482:	85 c0                	test   %eax,%eax
  408484:	0f 84 a6 f9 ff ff    	je     407e30 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x170>
    return -1;
  40848a:	b9 ff ff ff ff       	mov    $0xffffffff,%ecx
    for (int ret = start_from; ret < local_stacks_num; ret++)
  40848f:	41 83 fb 08          	cmp    $0x8,%r11d
  408493:	0f 85 a8 fe ff ff    	jne    408341 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x681>
  408499:	45 31 db             	xor    %r11d,%r11d
  40849c:	e9 7a ff ff ff       	jmpq   40841b <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x75b>
  4084a1:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4084a8:	00 00 00 00 
  4084ac:	0f 1f 40 00          	nopl   0x0(%rax)
  4084b0:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
        for (int c = start_dc + 2; c < cards_num; c++)
  4084b5:	48 8b 5c 24 48       	mov    0x48(%rsp),%rbx
  4084ba:	48 89 c2             	mov    %rax,%rdx
  4084bd:	48 39 d8             	cmp    %rbx,%rax
  4084c0:	0f 84 7a 02 00 00    	je     408740 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xa80>
  4084c6:	48 83 c0 01          	add    $0x1,%rax
  4084ca:	48 89 44 24 20       	mov    %rax,0x20(%rsp)
  4084cf:	e9 ac f8 ff ff       	jmpq   407d80 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xc0>
  4084d4:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4084db:	00 00 00 00 
  4084df:	90                   	nop
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  4084e0:	41 89 f8             	mov    %edi,%r8d
            if (dest_fc_idx == LOCAL_FREECELLS_NUM)
  4084e3:	41 83 f8 04          	cmp    $0x4,%r8d
  4084e7:	0f 84 4e fc ff ff    	je     40813b <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x47b>
  4084ed:	41 8d 78 01          	lea    0x1(%r8),%edi
  4084f1:	49 63 f0             	movslq %r8d,%rsi
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  4084f4:	4b 8b 0c ca          	mov    (%r10,%r9,8),%rcx
            --(*col_num_cards);
  4084f8:	83 e8 01             	sub    $0x1,%eax
    fcs_col_pop_card(col, ret);
  4084fb:	44 0f be 19          	movsbl (%rcx),%r11d
  4084ff:	44 89 da             	mov    %r11d,%edx
  408502:	41 83 eb 01          	sub    $0x1,%r11d
  408506:	4d 63 db             	movslq %r11d,%r11
  408509:	83 ea 01             	sub    $0x1,%edx
  40850c:	46 0f b6 5c 19 01    	movzbl 0x1(%rcx,%r11,1),%r11d
  408512:	88 11                	mov    %dl,(%rcx)
  408514:	48 0f be d2          	movsbq %dl,%rdx
  408518:	c6 44 11 01 00       	movb   $0x0,0x1(%rcx,%rdx,1)
  40851d:	ba 01 00 00 00       	mov    $0x1,%edx
            fcs_put_card_in_freecell(*new_key, dest_fc_idx, top_card);
  408522:	45 88 5c 32 40       	mov    %r11b,0x40(%r10,%rsi,1)
  408527:	e9 a4 fb ff ff       	jmpq   4080d0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x410>
  40852c:	0f 1f 40 00          	nopl   0x0(%rax)
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  408530:	44 89 de             	mov    %r11d,%esi
            if (dest_fc_idx == LOCAL_FREECELLS_NUM)
  408533:	83 fe 04             	cmp    $0x4,%esi
  408536:	0f 84 e1 fd ff ff    	je     40831d <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x65d>
  40853c:	44 8d 5e 01          	lea    0x1(%rsi),%r11d
  408540:	48 63 f6             	movslq %esi,%rsi
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  408543:	4e 8b 14 f2          	mov    (%rdx,%r14,8),%r10
            --(*col_num_cards);
  408547:	83 e8 01             	sub    $0x1,%eax
    fcs_col_pop_card(col, ret);
  40854a:	41 0f be 2a          	movsbl (%r10),%ebp
  40854e:	89 e9                	mov    %ebp,%ecx
  408550:	83 ed 01             	sub    $0x1,%ebp
  408553:	48 63 ed             	movslq %ebp,%rbp
  408556:	83 e9 01             	sub    $0x1,%ecx
  408559:	41 0f b6 6c 2a 01    	movzbl 0x1(%r10,%rbp,1),%ebp
  40855f:	41 88 0a             	mov    %cl,(%r10)
  408562:	48 0f be c9          	movsbq %cl,%rcx
  408566:	41 c6 44 0a 01 00    	movb   $0x0,0x1(%r10,%rcx,1)
  40856c:	b9 01 00 00 00       	mov    $0x1,%ecx
  408571:	41 89 c2             	mov    %eax,%r10d
            fcs_put_card_in_freecell(*new_key, dest_fc_idx, top_card);
  408574:	40 88 6c 32 40       	mov    %bpl,0x40(%rdx,%rsi,1)
  408579:	e9 a2 f8 ff ff       	jmpq   407e20 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x160>
  40857e:	66 90                	xchg   %ax,%ax
                my_copy_stack(ds);
  408580:	48 8b 54 06 f8       	mov    -0x8(%rsi,%rax,1),%rdx
  408585:	48 8d 48 ff          	lea    -0x1(%rax),%rcx
  408589:	48 8b 7c 24 28       	mov    0x28(%rsp),%rdi
  40858e:	48 c1 e9 03          	shr    $0x3,%rcx
  408592:	48 89 54 07 f8       	mov    %rdx,-0x8(%rdi,%rax,1)
  408597:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  40859a:	e9 d6 fa ff ff       	jmpq   408075 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x3b5>
  40859f:	90                   	nop
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  4085a0:	48 8b 9c 24 80 00 00 	mov    0x80(%rsp),%rbx
  4085a7:	00 
  4085a8:	e9 25 f9 ff ff       	jmpq   407ed2 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x212>
  4085ad:	0f 1f 00             	nopl   (%rax)
                    moved_card = fcs_freecell_card(new_state_key, s_idx);
  4085b0:	42 0f b6 54 06 40    	movzbl 0x40(%rsi,%r8,1),%edx
                    fcs_empty_freecell(new_state_key, s_idx);
  4085b6:	42 c6 44 06 40 00    	movb   $0x0,0x40(%rsi,%r8,1)
  4085bc:	e9 a1 f8 ff ff       	jmpq   407e62 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x1a2>
  4085c1:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4085c8:	00 00 00 00 
  4085cc:	0f 1f 40 00          	nopl   0x0(%rax)
            FCS_S_NEXT(instance->list_of_vacant_states);
  4085d0:	48 8b 42 48          	mov    0x48(%rdx),%rax
        instance->list_of_vacant_states =
  4085d4:	48 89 87 b0 00 00 00 	mov    %rax,0xb0(%rdi)
  4085db:	e9 d6 f9 ff ff       	jmpq   407fb6 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x2f6>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  4085e0:	89 f1                	mov    %esi,%ecx
  4085e2:	49 63 f3             	movslq %r11d,%rsi
  4085e5:	41 89 cb             	mov    %ecx,%r11d
  4085e8:	e9 56 ff ff ff       	jmpq   408543 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x883>
  4085ed:	0f 1f 00             	nopl   (%rax)
  4085f0:	44 89 c2             	mov    %r8d,%edx
  4085f3:	48 63 f7             	movslq %edi,%rsi
  4085f6:	49 89 f0             	mov    %rsi,%r8
  4085f9:	89 d7                	mov    %edx,%edi
  4085fb:	e9 f4 fe ff ff       	jmpq   4084f4 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x834>
  408600:	41 83 c3 02          	add    $0x2,%r11d
  408604:	e9 3a ff ff ff       	jmpq   408543 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x883>
  408609:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
  408610:	83 c7 02             	add    $0x2,%edi
  408613:	e9 dc fe ff ff       	jmpq   4084f4 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x834>
  408618:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40861f:	00 
    allocator->ptr = allocator->rollback_ptr;
  408620:	48 8b 83 f0 00 00 00 	mov    0xf0(%rbx),%rax
  408627:	48 89 83 e8 00 00 00 	mov    %rax,0xe8(%rbx)
  40862e:	e9 97 f8 ff ff       	jmpq   407eca <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x20a>
  408633:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40863a:	00 00 00 00 
  40863e:	66 90                	xchg   %ax,%ax
  408640:	83 c7 03             	add    $0x3,%edi
  408643:	e9 ac fe ff ff       	jmpq   4084f4 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x834>
  408648:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40864f:	00 
  408650:	41 83 c3 03          	add    $0x3,%r11d
  408654:	e9 ea fe ff ff       	jmpq   408543 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x883>
  408659:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
  408660:	4b 8d 2c c2          	lea    (%r10,%r8,8),%rbp
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  408664:	bf 01 00 00 00       	mov    $0x1,%edi
  408669:	d3 e7                	shl    %cl,%edi
  40866b:	c1 e1 07             	shl    $0x7,%ecx
  40866e:	09 fa                	or     %edi,%edx
  408670:	89 56 14             	mov    %edx,0x14(%rsi)
  408673:	48 8b 75 00          	mov    0x0(%rbp),%rsi
  408677:	48 63 d1             	movslq %ecx,%rdx
  40867a:	48 03 54 24 38       	add    0x38(%rsp),%rdx
  40867f:	0f be 0e             	movsbl (%rsi),%ecx
  408682:	83 c1 01             	add    $0x1,%ecx
  408685:	48 63 c9             	movslq %ecx,%rcx
  408688:	48 83 f9 08          	cmp    $0x8,%rcx
  40868c:	0f 83 6b 01 00 00    	jae    4087fd <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xb3d>
  408692:	f6 c1 04             	test   $0x4,%cl
  408695:	0f 85 55 02 00 00    	jne    4088f0 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xc30>
  40869b:	48 85 c9             	test   %rcx,%rcx
  40869e:	74 0f                	je     4086af <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x9ef>
  4086a0:	0f b6 3e             	movzbl (%rsi),%edi
  4086a3:	40 88 3a             	mov    %dil,(%rdx)
  4086a6:	f6 c1 02             	test   $0x2,%cl
  4086a9:	0f 85 52 02 00 00    	jne    408901 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xc41>
  4086af:	48 89 55 00          	mov    %rdx,0x0(%rbp)
  4086b3:	e9 8d fb ff ff       	jmpq   408245 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x585>
  4086b8:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  4086bf:	00 
  4086c0:	41 be 01 00 00 00    	mov    $0x1,%r14d
  4086c6:	41 d3 e6             	shl    %cl,%r14d
  4086c9:	c1 e1 07             	shl    $0x7,%ecx
  4086cc:	45 09 f2             	or     %r14d,%r10d
  4086cf:	4c 8d 34 ea          	lea    (%rdx,%rbp,8),%r14
  4086d3:	44 89 56 14          	mov    %r10d,0x14(%rsi)
  4086d7:	4c 63 d1             	movslq %ecx,%r10
  4086da:	4c 03 54 24 38       	add    0x38(%rsp),%r10
  4086df:	49 8b 36             	mov    (%r14),%rsi
  4086e2:	0f be 0e             	movsbl (%rsi),%ecx
  4086e5:	83 c1 01             	add    $0x1,%ecx
  4086e8:	48 63 c9             	movslq %ecx,%rcx
  4086eb:	48 83 f9 08          	cmp    $0x8,%rcx
  4086ef:	0f 83 e7 00 00 00    	jae    4087dc <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xb1c>
  4086f5:	f6 c1 04             	test   $0x4,%cl
  4086f8:	0f 85 db 01 00 00    	jne    4088d9 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xc19>
  4086fe:	48 85 c9             	test   %rcx,%rcx
  408701:	74 13                	je     408716 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xa56>
  408703:	0f b6 3e             	movzbl (%rsi),%edi
  408706:	41 88 3a             	mov    %dil,(%r10)
  408709:	8b 7c 24 74          	mov    0x74(%rsp),%edi
  40870d:	f6 c1 02             	test   $0x2,%cl
  408710:	0f 85 fa 01 00 00    	jne    408910 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xc50>
  408716:	4d 89 16             	mov    %r10,(%r14)
  408719:	e9 16 fd ff ff       	jmpq   408434 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x774>
  40871e:	66 90                	xchg   %ax,%ax
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  408720:	41 bb 04 00 00 00    	mov    $0x4,%r11d
  408726:	be 03 00 00 00       	mov    $0x3,%esi
  40872b:	e9 13 fe ff ff       	jmpq   408543 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x883>
  408730:	bf 04 00 00 00       	mov    $0x4,%edi
  408735:	be 03 00 00 00       	mov    $0x3,%esi
  40873a:	e9 b5 fd ff ff       	jmpq   4084f4 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x834>
  40873f:	90                   	nop
  408740:	48 83 44 24 60 01    	addq   $0x1,0x60(%rsp)
  408746:	48 8b 44 24 60       	mov    0x60(%rsp),%rax
  40874b:	48 83 6c 24 28 80    	subq   $0xffffffffffffff80,0x28(%rsp)
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  408751:	48 83 f8 08          	cmp    $0x8,%rax
  408755:	0f 85 c5 f5 ff ff    	jne    407d20 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x60>
}
  40875b:	48 81 c4 a8 00 00 00 	add    $0xa8,%rsp
  408762:	5b                   	pop    %rbx
  408763:	5d                   	pop    %rbp
  408764:	41 5c                	pop    %r12
  408766:	41 5d                	pop    %r13
  408768:	41 5e                	pop    %r14
  40876a:	41 5f                	pop    %r15
  40876c:	c3                   	retq   
  40876d:	0f 1f 00             	nopl   (%rax)
    for (int ret = start_from; ret < local_stacks_num; ret++)
  408770:	45 31 db             	xor    %r11d,%r11d
    return -1;
  408773:	b9 ff ff ff ff       	mov    $0xffffffff,%ecx
  408778:	e9 9e fc ff ff       	jmpq   40841b <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x75b>
  40877d:	0f 1f 00             	nopl   (%rax)
    for (int ret = start_from; ret < local_stacks_num; ret++)
  408780:	45 31 db             	xor    %r11d,%r11d
    return -1;
  408783:	b9 ff ff ff ff       	mov    $0xffffffff,%ecx
  408788:	e9 a1 fa ff ff       	jmpq   40822e <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x56e>
  40878d:	0f 1f 00             	nopl   (%rax)
  408790:	48 8b 90 f8 00 00 00 	mov    0xf8(%rax),%rdx
    char *const ret = meta_alloc->recycle_bin;
  408797:	48 8b 02             	mov    (%rdx),%rax
    if (ret)
  40879a:	48 85 c0             	test   %rax,%rax
  40879d:	0f 84 a7 00 00 00    	je     40884a <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xb8a>
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  4087a3:	48 8b 08             	mov    (%rax),%rcx
  4087a6:	48 89 0a             	mov    %rcx,(%rdx)
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  4087a9:	48 8b 7c 24 10       	mov    0x10(%rsp),%rdi
  4087ae:	48 8b 97 d8 00 00 00 	mov    0xd8(%rdi),%rdx
  4087b5:	48 89 10             	mov    %rdx,(%rax)
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  4087b8:	48 8d 50 08          	lea    0x8(%rax),%rdx
    allocator->old_list = new_data;
  4087bc:	48 89 87 d8 00 00 00 	mov    %rax,0xd8(%rdi)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  4087c3:	48 05 80 fe 00 00    	add    $0xfe80,%rax
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  4087c9:	48 89 97 f0 00 00 00 	mov    %rdx,0xf0(%rdi)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  4087d0:	48 89 87 e0 00 00 00 	mov    %rax,0xe0(%rdi)
  4087d7:	e9 cf f7 ff ff       	jmpq   407fab <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x2eb>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  4087dc:	48 8b 7c 0e f8       	mov    -0x8(%rsi,%rcx,1),%rdi
  4087e1:	49 89 7c 0a f8       	mov    %rdi,-0x8(%r10,%rcx,1)
  4087e6:	48 83 e9 01          	sub    $0x1,%rcx
  4087ea:	4c 89 d7             	mov    %r10,%rdi
  4087ed:	48 c1 e9 03          	shr    $0x3,%rcx
  4087f1:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  4087f4:	8b 7c 24 74          	mov    0x74(%rsp),%edi
  4087f8:	e9 19 ff ff ff       	jmpq   408716 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xa56>
  4087fd:	48 8b 7c 0e f8       	mov    -0x8(%rsi,%rcx,1),%rdi
  408802:	48 89 7c 0a f8       	mov    %rdi,-0x8(%rdx,%rcx,1)
  408807:	48 83 e9 01          	sub    $0x1,%rcx
  40880b:	48 89 d7             	mov    %rdx,%rdi
  40880e:	48 c1 e9 03          	shr    $0x3,%rcx
  408812:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  408815:	e9 95 fe ff ff       	jmpq   4086af <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x9ef>
                my_copy_stack(ds);
  40881a:	8b 16                	mov    (%rsi),%edx
  40881c:	48 8b 7c 24 28       	mov    0x28(%rsp),%rdi
  408821:	89 17                	mov    %edx,(%rdi)
  408823:	8b 54 06 fc          	mov    -0x4(%rsi,%rax,1),%edx
  408827:	89 54 07 fc          	mov    %edx,-0x4(%rdi,%rax,1)
  40882b:	e9 45 f8 ff ff       	jmpq   408075 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x3b5>
        if (fcs_state_col_is_empty(state, ret))
  408830:	89 ce                	mov    %ecx,%esi
  408832:	44 89 d9             	mov    %r11d,%ecx
  408835:	41 89 f3             	mov    %esi,%r11d
  408838:	e9 de fb ff ff       	jmpq   40841b <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x75b>
  40883d:	89 ca                	mov    %ecx,%edx
  40883f:	44 89 d9             	mov    %r11d,%ecx
  408842:	41 89 d3             	mov    %edx,%r11d
  408845:	e9 e4 f9 ff ff       	jmpq   40822e <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x56e>
        return malloc(ALLOCED_SIZE);
  40884a:	bf 80 fe 00 00       	mov    $0xfe80,%edi
  40884f:	e8 9c 88 ff ff       	callq  4010f0 <malloc@plt>
  408854:	e9 50 ff ff ff       	jmpq   4087a9 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xae9>
  408859:	41 83 c3 02          	add    $0x2,%r11d
  40885d:	e9 cc f9 ff ff       	jmpq   40822e <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x56e>
  408862:	41 83 c3 02          	add    $0x2,%r11d
  408866:	e9 b0 fb ff ff       	jmpq   40841b <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x75b>
  40886b:	41 83 c3 03          	add    $0x3,%r11d
  40886f:	e9 ba f9 ff ff       	jmpq   40822e <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x56e>
  408874:	41 83 c3 03          	add    $0x3,%r11d
  408878:	e9 9e fb ff ff       	jmpq   40841b <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x75b>
  40887d:	41 83 c3 04          	add    $0x4,%r11d
  408881:	e9 95 fb ff ff       	jmpq   40841b <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x75b>
  408886:	41 83 c3 04          	add    $0x4,%r11d
  40888a:	e9 9f f9 ff ff       	jmpq   40822e <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x56e>
  40888f:	41 83 c3 05          	add    $0x5,%r11d
  408893:	e9 96 f9 ff ff       	jmpq   40822e <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x56e>
                my_copy_stack(ds);
  408898:	0f b7 54 06 fe       	movzwl -0x2(%rsi,%rax,1),%edx
  40889d:	48 8b 7c 24 28       	mov    0x28(%rsp),%rdi
  4088a2:	66 89 54 07 fe       	mov    %dx,-0x2(%rdi,%rax,1)
  4088a7:	e9 c9 f7 ff ff       	jmpq   408075 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x3b5>
  4088ac:	41 83 c3 05          	add    $0x5,%r11d
  4088b0:	e9 66 fb ff ff       	jmpq   40841b <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x75b>
  4088b5:	41 83 c3 06          	add    $0x6,%r11d
  4088b9:	e9 70 f9 ff ff       	jmpq   40822e <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x56e>
  4088be:	41 83 c3 06          	add    $0x6,%r11d
  4088c2:	e9 54 fb ff ff       	jmpq   40841b <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x75b>
  4088c7:	41 83 c3 07          	add    $0x7,%r11d
  4088cb:	e9 5e f9 ff ff       	jmpq   40822e <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x56e>
  4088d0:	41 83 c3 07          	add    $0x7,%r11d
  4088d4:	e9 42 fb ff ff       	jmpq   40841b <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x75b>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  4088d9:	8b 3e                	mov    (%rsi),%edi
  4088db:	41 89 3a             	mov    %edi,(%r10)
  4088de:	8b 74 0e fc          	mov    -0x4(%rsi,%rcx,1),%esi
  4088e2:	41 89 74 0a fc       	mov    %esi,-0x4(%r10,%rcx,1)
  4088e7:	8b 7c 24 74          	mov    0x74(%rsp),%edi
  4088eb:	e9 26 fe ff ff       	jmpq   408716 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xa56>
  4088f0:	8b 3e                	mov    (%rsi),%edi
  4088f2:	89 3a                	mov    %edi,(%rdx)
  4088f4:	8b 74 0e fc          	mov    -0x4(%rsi,%rcx,1),%esi
  4088f8:	89 74 0a fc          	mov    %esi,-0x4(%rdx,%rcx,1)
  4088fc:	e9 ae fd ff ff       	jmpq   4086af <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x9ef>
  408901:	0f b7 74 0e fe       	movzwl -0x2(%rsi,%rcx,1),%esi
  408906:	66 89 74 0a fe       	mov    %si,-0x2(%rdx,%rcx,1)
  40890b:	e9 9f fd ff ff       	jmpq   4086af <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x9ef>
  408910:	0f b7 74 0e fe       	movzwl -0x2(%rsi,%rcx,1),%esi
  408915:	66 41 89 74 0a fe    	mov    %si,-0x2(%r10,%rcx,1)
  40891b:	8b 7c 24 74          	mov    0x74(%rsp),%edi
  40891f:	e9 f2 fd ff ff       	jmpq   408716 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0xa56>
  408924:	44 89 94 24 90 00 00 	mov    %r10d,0x90(%rsp)
  40892b:	00 
  40892c:	e9 f4 f9 ff ff       	jmpq   408325 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x665>
  408931:	89 84 24 90 00 00 00 	mov    %eax,0x90(%rsp)
  408938:	e9 06 f8 ff ff       	jmpq   408143 <fc_solve_sfs_move_stack_cards_to_a_parent_on_the_same_stack+0x483>
  40893d:	0f 1f 00             	nopl   (%rax)

0000000000408940 <fc_solve_sfs_move_non_top_stack_cards_to_founds>:
{
  408940:	41 57                	push   %r15
  408942:	49 89 ff             	mov    %rdi,%r15
  408945:	41 56                	push   %r14
  408947:	49 89 f6             	mov    %rsi,%r14
  40894a:	41 55                	push   %r13
  40894c:	49 89 cd             	mov    %rcx,%r13
  40894f:	41 54                	push   %r12
  408951:	55                   	push   %rbp
    const_AUTO(num_vacant_slots_plus_1, num_vacant_slots + 1);
  408952:	31 ed                	xor    %ebp,%ebp
{
  408954:	53                   	push   %rbx
  408955:	48 83 ec 78          	sub    $0x78,%rsp
    tests_define_accessors();
  408959:	4c 8b 27             	mov    (%rdi),%r12
{
  40895c:	48 89 54 24 10       	mov    %rdx,0x10(%rsp)
    tests_define_accessors();
  408961:	49 8d 84 24 00 01 00 	lea    0x100(%r12),%rax
  408968:	00 
  408969:	48 89 44 24 18       	mov    %rax,0x18(%rsp)
    const size_t derived_start_idx = derived_states_list->num_states;
  40896e:	48 8b 01             	mov    (%rcx),%rax
  408971:	48 89 04 24          	mov    %rax,(%rsp)
    return (soft_thread->num_vacant_freecells +
  408975:	0f b6 87 e4 01 00 00 	movzbl 0x1e4(%rdi),%eax
  40897c:	02 87 e3 01 00 00    	add    0x1e3(%rdi),%al
    const_AUTO(num_vacant_slots_plus_1, num_vacant_slots + 1);
  408982:	0f b6 c0             	movzbl %al,%eax
  408985:	83 c0 01             	add    $0x1,%eax
  408988:	89 44 24 0c          	mov    %eax,0xc(%rsp)
        var_AUTO(col, fcs_state_get_col(state, stack_idx));
  40898c:	49 8b 34 ee          	mov    (%r14,%rbp,8),%rsi
  408990:	b8 00 00 00 00       	mov    $0x0,%eax
  408995:	89 6c 24 20          	mov    %ebp,0x20(%rsp)
        const int cards_num = fcs_col_len(col);
  408999:	44 0f be 16          	movsbl (%rsi),%r10d
        for (int c = cards_num - 2; c >= c_bottom; c--)
  40899d:	45 8d 4a fe          	lea    -0x2(%r10),%r9d
  4089a1:	44 89 d1             	mov    %r10d,%ecx
  4089a4:	2b 4c 24 0c          	sub    0xc(%rsp),%ecx
  4089a8:	0f 48 c8             	cmovs  %eax,%ecx
  4089ab:	41 39 c9             	cmp    %ecx,%r9d
  4089ae:	0f 8c d6 01 00 00    	jl     408b8a <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x24a>
            const fcs_card card = fcs_col_get_card(col, c);
  4089b4:	49 63 c1             	movslq %r9d,%rax
  4089b7:	0f b6 44 06 01       	movzbl 0x1(%rsi,%rax,1),%eax
                const int dest_found = deck * 4 + fcs_card_suit(card);
  4089bc:	89 c7                	mov    %eax,%edi
                    fcs_card_rank(card) - 1)
  4089be:	c0 f8 02             	sar    $0x2,%al
                const int dest_found = deck * 4 + fcs_card_suit(card);
  4089c1:	83 e7 03             	and    $0x3,%edi
                    fcs_card_rank(card) - 1)
  4089c4:	44 0f be d8          	movsbl %al,%r11d
  4089c8:	41 8d 43 ff          	lea    -0x1(%r11),%eax
                if (fcs_foundation_value(state, dest_found) !=
  4089cc:	48 63 df             	movslq %edi,%rbx
                const int dest_found = deck * 4 + fcs_card_suit(card);
  4089cf:	89 7c 24 38          	mov    %edi,0x38(%rsp)
                if (fcs_foundation_value(state, dest_found) !=
  4089d3:	41 0f be 54 1e 44    	movsbl 0x44(%r14,%rbx,1),%edx
  4089d9:	39 c2                	cmp    %eax,%edx
  4089db:	74 3c                	je     408a19 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0xd9>
  4089dd:	41 8d 42 fd          	lea    -0x3(%r10),%eax
  4089e1:	48 98                	cltq   
        for (int c = cards_num - 2; c >= c_bottom; c--)
  4089e3:	41 89 c1             	mov    %eax,%r9d
  4089e6:	39 c8                	cmp    %ecx,%eax
  4089e8:	0f 8c 9c 01 00 00    	jl     408b8a <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x24a>
            const fcs_card card = fcs_col_get_card(col, c);
  4089ee:	0f b6 54 06 01       	movzbl 0x1(%rsi,%rax,1),%edx
  4089f3:	48 83 e8 01          	sub    $0x1,%rax
                const int dest_found = deck * 4 + fcs_card_suit(card);
  4089f7:	89 d7                	mov    %edx,%edi
                    fcs_card_rank(card) - 1)
  4089f9:	c0 fa 02             	sar    $0x2,%dl
                const int dest_found = deck * 4 + fcs_card_suit(card);
  4089fc:	83 e7 03             	and    $0x3,%edi
                    fcs_card_rank(card) - 1)
  4089ff:	44 0f be da          	movsbl %dl,%r11d
  408a03:	41 8d 53 ff          	lea    -0x1(%r11),%edx
                if (fcs_foundation_value(state, dest_found) !=
  408a07:	48 63 df             	movslq %edi,%rbx
  408a0a:	45 0f be 44 1e 44    	movsbl 0x44(%r14,%rbx,1),%r8d
  408a10:	41 39 d0             	cmp    %edx,%r8d
  408a13:	75 ce                	jne    4089e3 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0xa3>
  408a15:	89 7c 24 38          	mov    %edi,0x38(%rsp)
                sfs_check_state_begin();
  408a19:	48 8b 4c 24 10       	mov    0x10(%rsp),%rcx
  408a1e:	4c 89 f2             	mov    %r14,%rdx
  408a21:	4c 89 e7             	mov    %r12,%rdi
  408a24:	44 89 5c 24 3c       	mov    %r11d,0x3c(%rsp)
  408a29:	48 8d 74 24 50       	lea    0x50(%rsp),%rsi
  408a2e:	44 89 4c 24 30       	mov    %r9d,0x30(%rsp)
  408a33:	44 89 54 24 28       	mov    %r10d,0x28(%rsp)
  408a38:	e8 c3 8e ff ff       	callq  401900 <fc_solve_sfs_check_state_begin>
                my_copy_stack(stack_idx);
  408a3d:	48 8b 44 24 58       	mov    0x58(%rsp),%rax
  408a42:	8b 7c 24 20          	mov    0x20(%rsp),%edi
  408a46:	44 8b 54 24 28       	mov    0x28(%rsp),%r10d
  408a4b:	44 8b 4c 24 30       	mov    0x30(%rsp),%r9d
  408a50:	8b 50 14             	mov    0x14(%rax),%edx
  408a53:	44 8b 5c 24 3c       	mov    0x3c(%rsp),%r11d
  408a58:	0f a3 fa             	bt     %edi,%edx
  408a5b:	0f 83 bd 03 00 00    	jae    408e1e <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x4de>
  408a61:	48 8b 54 24 50       	mov    0x50(%rsp),%rdx
  408a66:	4c 63 c7             	movslq %edi,%r8
  408a69:	89 f8                	mov    %edi,%eax
  408a6b:	49 8b 3f             	mov    (%r15),%rdi
                    cards_num - (c + 1), 0);
  408a6e:	41 83 c1 01          	add    $0x1,%r9d
                const int cols_indexes[3] = {stack_idx, -1, -1};
  408a72:	89 44 24 44          	mov    %eax,0x44(%rsp)
                empty_two_cols_from_new_state(soft_thread,
  408a76:	44 89 d0             	mov    %r10d,%eax
                const int cols_indexes[3] = {stack_idx, -1, -1};
  408a79:	48 c7 44 24 48 ff ff 	movq   $0xffffffffffffffff,0x48(%rsp)
  408a80:	ff ff 
                empty_two_cols_from_new_state(soft_thread,
  408a82:	44 29 c8             	sub    %r9d,%eax
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  408a85:	31 c9                	xor    %ecx,%ecx
        int dest_fc_idx = 0;
  408a87:	45 31 c9             	xor    %r9d,%r9d
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  408a8a:	89 44 24 60          	mov    %eax,0x60(%rsp)
  408a8e:	48 89 7c 24 20       	mov    %rdi,0x20(%rsp)
  408a93:	48 bf 00 00 00 00 ff 	movabs $0xffffffff00000000,%rdi
  408a9a:	ff ff ff 
  408a9d:	48 89 7c 24 64       	mov    %rdi,0x64(%rsp)
  408aa2:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  408aa9:	00 00 00 00 
  408aad:	0f 1f 00             	nopl   (%rax)
            while ((*col_num_cards) == 0)
  408ab0:	85 c0                	test   %eax,%eax
  408ab2:	0f 85 58 01 00 00    	jne    408c10 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x2d0>
  408ab8:	4c 8b 4c 24 50       	mov    0x50(%rsp),%r9
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  408abd:	4b 8b 14 c1          	mov    (%r9,%r8,8),%rdx
    if (!fc_solve_check_and_add_state(
  408ac1:	48 8d 74 24 50       	lea    0x50(%rsp),%rsi
    fcs_col_pop_top(col);
  408ac6:	0f b6 02             	movzbl (%rdx),%eax
  408ac9:	83 e8 01             	sub    $0x1,%eax
  408acc:	88 02                	mov    %al,(%rdx)
  408ace:	48 0f be c0          	movsbq %al,%rax
  408ad2:	c6 44 02 01 00       	movb   $0x0,0x1(%rdx,%rax,1)
                fcs_increment_foundation(new_state_key, dest_found);
  408ad7:	48 8b 44 24 50       	mov    0x50(%rsp),%rax
  408adc:	48 8d 54 24 60       	lea    0x60(%rsp),%rdx
  408ae1:	80 44 18 44 01       	addb   $0x1,0x44(%rax,%rbx,1)
                    (((fcs_card_rank(card)) << 8) | fcs_card_suit(card));
  408ae6:	44 89 db             	mov    %r11d,%ebx
    const_SLOT(hard_thread, soft_thread);
  408ae9:	49 8b 0f             	mov    (%r15),%rcx
  408aec:	c1 e3 08             	shl    $0x8,%ebx
                state_context_value =
  408aef:	0b 5c 24 38          	or     0x38(%rsp),%ebx
    if (!fc_solve_check_and_add_state(
  408af3:	48 89 cf             	mov    %rcx,%rdi
  408af6:	48 89 4c 24 20       	mov    %rcx,0x20(%rsp)
  408afb:	e8 50 8f ff ff       	callq  401a50 <fc_solve_check_and_add_state>
  408b00:	84 c0                	test   %al,%al
  408b02:	75 27                	jne    408b2b <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x1eb>
        if (HT_FIELD(hard_thread, allocated_from_list))
  408b04:	48 8b 4c 24 20       	mov    0x20(%rsp),%rcx
  408b09:	80 b9 18 05 00 00 00 	cmpb   $0x0,0x518(%rcx)
  408b10:	0f 85 79 03 00 00    	jne    408e8f <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x54f>
  408b16:	48 8b 81 f0 00 00 00 	mov    0xf0(%rcx),%rax
  408b1d:	48 89 81 e8 00 00 00 	mov    %rax,0xe8(%rcx)
  408b24:	4c 8b 44 24 60       	mov    0x60(%rsp),%r8
  408b29:	eb 05                	jmp    408b30 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x1f0>
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  408b2b:	4c 8b 44 24 50       	mov    0x50(%rsp),%r8
    if ((!((list->num_states + (list->states != NULL)) &
  408b30:	49 8b 45 08          	mov    0x8(%r13),%rax
  408b34:	31 c9                	xor    %ecx,%ecx
  408b36:	49 8b 55 00          	mov    0x0(%r13),%rdx
  408b3a:	48 85 c0             	test   %rax,%rax
  408b3d:	0f 95 c1             	setne  %cl
  408b40:	48 01 d1             	add    %rdx,%rcx
  408b43:	f6 c1 0f             	test   $0xf,%cl
  408b46:	75 25                	jne    408b6d <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x22d>
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  408b48:	48 83 c1 10          	add    $0x10,%rcx
  408b4c:	48 89 c7             	mov    %rax,%rdi
  408b4f:	4c 89 44 24 20       	mov    %r8,0x20(%rsp)
  408b54:	48 89 ce             	mov    %rcx,%rsi
  408b57:	48 c1 e6 04          	shl    $0x4,%rsi
  408b5b:	e8 10 86 ff ff       	callq  401170 <realloc@plt>
  408b60:	49 8b 55 00          	mov    0x0(%r13),%rdx
  408b64:	4c 8b 44 24 20       	mov    0x20(%rsp),%r8
        list->states =
  408b69:	49 89 45 08          	mov    %rax,0x8(%r13)
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  408b6d:	48 8d 4a 01          	lea    0x1(%rdx),%rcx
  408b71:	48 c1 e2 04          	shl    $0x4,%rdx
  408b75:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  408b79:	48 01 d0             	add    %rdx,%rax
  408b7c:	49 89 4d 00          	mov    %rcx,0x0(%r13)
  408b80:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  408b84:	4c 89 00             	mov    %r8,(%rax)
  408b87:	89 58 08             	mov    %ebx,0x8(%rax)
  408b8a:	48 83 c5 01          	add    $0x1,%rbp
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  408b8e:	48 83 fd 08          	cmp    $0x8,%rbp
  408b92:	0f 85 f4 fd ff ff    	jne    40898c <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x4c>
    var_AUTO(start, d->states + derived_start_idx);
  408b98:	48 8b 14 24          	mov    (%rsp),%rdx
  408b9c:	49 8b 45 08          	mov    0x8(%r13),%rax
    const_AUTO(limit, d->states + d->num_states);
  408ba0:	49 8b 75 00          	mov    0x0(%r13),%rsi
    var_AUTO(start, d->states + derived_start_idx);
  408ba4:	48 c1 e2 04          	shl    $0x4,%rdx
  408ba8:	48 01 c2             	add    %rax,%rdx
    for (var_AUTO(b, start + 1); b < limit; b++)
  408bab:	48 8d 4a 10          	lea    0x10(%rdx),%rcx
    const_AUTO(limit, d->states + d->num_states);
  408baf:	48 c1 e6 04          	shl    $0x4,%rsi
  408bb3:	48 01 c6             	add    %rax,%rsi
    for (var_AUTO(b, start + 1); b < limit; b++)
  408bb6:	48 39 ce             	cmp    %rcx,%rsi
  408bb9:	76 42                	jbe    408bfd <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x2bd>
  408bbb:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
        for (var_AUTO(c, b); (c > start) && (c[0].context.i < c[-1].context.i);
  408bc0:	8b 41 08             	mov    0x8(%rcx),%eax
  408bc3:	39 41 f8             	cmp    %eax,-0x8(%rcx)
  408bc6:	7e 2c                	jle    408bf4 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x2b4>
  408bc8:	48 89 c8             	mov    %rcx,%rax
  408bcb:	eb 0b                	jmp    408bd8 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x298>
  408bcd:	0f 1f 00             	nopl   (%rax)
  408bd0:	8b 58 08             	mov    0x8(%rax),%ebx
  408bd3:	39 58 f8             	cmp    %ebx,-0x8(%rax)
  408bd6:	7e 1c                	jle    408bf4 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x2b4>
            const_AUTO(swap_temp, c[-1]);
  408bd8:	c5 fa 6f 40 f0       	vmovdqu -0x10(%rax),%xmm0
             c--)
  408bdd:	48 83 e8 10          	sub    $0x10,%rax
            c[-1] = c[0];
  408be1:	c5 fa 6f 48 10       	vmovdqu 0x10(%rax),%xmm1
            c[0] = swap_temp;
  408be6:	c5 f8 11 40 10       	vmovups %xmm0,0x10(%rax)
            c[-1] = c[0];
  408beb:	c5 f8 11 08          	vmovups %xmm1,(%rax)
        for (var_AUTO(c, b); (c > start) && (c[0].context.i < c[-1].context.i);
  408bef:	48 39 c2             	cmp    %rax,%rdx
  408bf2:	72 dc                	jb     408bd0 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x290>
    for (var_AUTO(b, start + 1); b < limit; b++)
  408bf4:	48 83 c1 10          	add    $0x10,%rcx
  408bf8:	48 39 ce             	cmp    %rcx,%rsi
  408bfb:	77 c3                	ja     408bc0 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x280>
}
  408bfd:	48 83 c4 78          	add    $0x78,%rsp
  408c01:	5b                   	pop    %rbx
  408c02:	5d                   	pop    %rbp
  408c03:	41 5c                	pop    %r12
  408c05:	41 5d                	pop    %r13
  408c07:	41 5e                	pop    %r14
  408c09:	41 5f                	pop    %r15
  408c0b:	c3                   	retq   
  408c0c:	0f 1f 40 00          	nopl   0x0(%rax)
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  408c10:	41 83 f9 03          	cmp    $0x3,%r9d
  408c14:	0f 8f b9 01 00 00    	jg     408dd3 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x493>
  408c1a:	41 8d 71 01          	lea    0x1(%r9),%esi
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  408c1e:	49 63 f9             	movslq %r9d,%rdi
  408c21:	80 7c 3a 40 00       	cmpb   $0x0,0x40(%rdx,%rdi,1)
  408c26:	0f 84 56 02 00 00    	je     408e82 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x542>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  408c2c:	83 fe 04             	cmp    $0x4,%esi
  408c2f:	74 3c                	je     408c6d <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x32d>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  408c31:	48 63 f6             	movslq %esi,%rsi
  408c34:	80 7c 32 40 00       	cmpb   $0x0,0x40(%rdx,%rsi,1)
  408c39:	0f 84 b8 02 00 00    	je     408ef7 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x5b7>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  408c3f:	41 8d 71 02          	lea    0x2(%r9),%esi
  408c43:	83 fe 04             	cmp    $0x4,%esi
  408c46:	74 25                	je     408c6d <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x32d>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  408c48:	48 63 f6             	movslq %esi,%rsi
  408c4b:	80 7c 32 40 00       	cmpb   $0x0,0x40(%rdx,%rsi,1)
  408c50:	0f 84 aa 02 00 00    	je     408f00 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x5c0>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  408c56:	41 8d 71 03          	lea    0x3(%r9),%esi
  408c5a:	83 fe 03             	cmp    $0x3,%esi
  408c5d:	0f 85 73 01 00 00    	jne    408dd6 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x496>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  408c63:	80 7a 43 00          	cmpb   $0x0,0x43(%rdx)
  408c67:	0f 84 a9 02 00 00    	je     408f16 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x5d6>
  408c6d:	84 c9                	test   %cl,%cl
  408c6f:	0f 85 ad 03 00 00    	jne    409022 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x6e2>
    char *const indirect_stacks_buffer =
  408c75:	48 8b 7c 24 20       	mov    0x20(%rsp),%rdi
    int put_cards_in_col_idx = 0;
  408c7a:	45 31 d2             	xor    %r10d,%r10d
  408c7d:	44 89 5c 24 20       	mov    %r11d,0x20(%rsp)
  408c82:	4c 8b 4c 24 50       	mov    0x50(%rsp),%r9
    char *const indirect_stacks_buffer =
  408c87:	48 81 c7 00 01 00 00 	add    $0x100,%rdi
  408c8e:	48 89 7c 24 30       	mov    %rdi,0x30(%rsp)
  408c93:	49 63 ca             	movslq %r10d,%rcx
  408c96:	49 8d 3c c9          	lea    (%r9,%rcx,8),%rdi
        if (fcs_state_col_is_empty(state, ret))
  408c9a:	48 8b 37             	mov    (%rdi),%rsi
  408c9d:	41 8d 4a 01          	lea    0x1(%r10),%ecx
  408ca1:	80 3e 00             	cmpb   $0x0,(%rsi)
  408ca4:	0f 84 f1 02 00 00    	je     408f9b <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x65b>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  408caa:	83 f9 08             	cmp    $0x8,%ecx
  408cad:	0f 84 56 02 00 00    	je     408f09 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x5c9>
        if (fcs_state_col_is_empty(state, ret))
  408cb3:	48 8b 77 08          	mov    0x8(%rdi),%rsi
  408cb7:	80 3e 00             	cmpb   $0x0,(%rsi)
  408cba:	0f 84 10 03 00 00    	je     408fd0 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x690>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  408cc0:	41 8d 4a 02          	lea    0x2(%r10),%ecx
  408cc4:	83 f9 08             	cmp    $0x8,%ecx
  408cc7:	0f 84 3c 02 00 00    	je     408f09 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x5c9>
        if (fcs_state_col_is_empty(state, ret))
  408ccd:	48 8b 77 10          	mov    0x10(%rdi),%rsi
  408cd1:	80 3e 00             	cmpb   $0x0,(%rsi)
  408cd4:	0f 84 ed 02 00 00    	je     408fc7 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x687>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  408cda:	41 8d 4a 03          	lea    0x3(%r10),%ecx
  408cde:	83 f9 07             	cmp    $0x7,%ecx
  408ce1:	0f 8f 22 02 00 00    	jg     408f09 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x5c9>
        if (fcs_state_col_is_empty(state, ret))
  408ce7:	48 8b 77 18          	mov    0x18(%rdi),%rsi
  408ceb:	80 3e 00             	cmpb   $0x0,(%rsi)
  408cee:	0f 84 b4 02 00 00    	je     408fa8 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x668>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  408cf4:	41 8d 4a 04          	lea    0x4(%r10),%ecx
  408cf8:	83 f9 07             	cmp    $0x7,%ecx
  408cfb:	0f 8f 08 02 00 00    	jg     408f09 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x5c9>
        if (fcs_state_col_is_empty(state, ret))
  408d01:	48 8b 77 20          	mov    0x20(%rdi),%rsi
  408d05:	80 3e 00             	cmpb   $0x0,(%rsi)
  408d08:	0f 84 c0 01 00 00    	je     408ece <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x58e>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  408d0e:	41 8d 4a 05          	lea    0x5(%r10),%ecx
  408d12:	83 f9 07             	cmp    $0x7,%ecx
  408d15:	0f 8f ee 01 00 00    	jg     408f09 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x5c9>
        if (fcs_state_col_is_empty(state, ret))
  408d1b:	48 8b 77 28          	mov    0x28(%rdi),%rsi
  408d1f:	80 3e 00             	cmpb   $0x0,(%rsi)
  408d22:	0f 84 ba 02 00 00    	je     408fe2 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x6a2>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  408d28:	41 8d 4a 06          	lea    0x6(%r10),%ecx
  408d2c:	83 f9 07             	cmp    $0x7,%ecx
  408d2f:	0f 8f d4 01 00 00    	jg     408f09 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x5c9>
        if (fcs_state_col_is_empty(state, ret))
  408d35:	48 8b 77 30          	mov    0x30(%rdi),%rsi
  408d39:	80 3e 00             	cmpb   $0x0,(%rsi)
  408d3c:	0f 84 97 02 00 00    	je     408fd9 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x699>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  408d42:	45 85 d2             	test   %r10d,%r10d
  408d45:	0f 85 be 01 00 00    	jne    408f09 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x5c9>
        if (fcs_state_col_is_empty(state, ret))
  408d4b:	49 8b 49 38          	mov    0x38(%r9),%rcx
  408d4f:	bf 08 00 00 00       	mov    $0x8,%edi
  408d54:	80 39 00             	cmpb   $0x0,(%rcx)
  408d57:	44 0f 44 d7          	cmove  %edi,%r10d
  408d5b:	80 39 01             	cmpb   $0x1,(%rcx)
  408d5e:	19 c9                	sbb    %ecx,%ecx
  408d60:	83 e1 08             	and    $0x8,%ecx
  408d63:	83 e9 01             	sub    $0x1,%ecx
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  408d66:	48 8b 74 24 58       	mov    0x58(%rsp),%rsi
  408d6b:	4c 63 d9             	movslq %ecx,%r11
  408d6e:	8b 7e 14             	mov    0x14(%rsi),%edi
  408d71:	0f a3 cf             	bt     %ecx,%edi
  408d74:	0f 83 ac 01 00 00    	jae    408f26 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x5e6>
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  408d7a:	48 63 4c 24 44       	movslq 0x44(%rsp),%rcx
        --(*col_num_cards);
  408d7f:	83 e8 01             	sub    $0x1,%eax
  408d82:	48 8b 34 ca          	mov    (%rdx,%rcx,8),%rsi
    fcs_col_pop_card(col, ret);
  408d86:	0f be 3e             	movsbl (%rsi),%edi
  408d89:	89 f9                	mov    %edi,%ecx
  408d8b:	83 ef 01             	sub    $0x1,%edi
  408d8e:	83 e9 01             	sub    $0x1,%ecx
  408d91:	48 63 ff             	movslq %edi,%rdi
  408d94:	0f b6 7c 3e 01       	movzbl 0x1(%rsi,%rdi,1),%edi
  408d99:	88 0e                	mov    %cl,(%rsi)
  408d9b:	48 0f be c9          	movsbq %cl,%rcx
  408d9f:	c6 44 0e 01 00       	movb   $0x0,0x1(%rsi,%rcx,1)
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  408da4:	4a 8b 34 da          	mov    (%rdx,%r11,8),%rsi
    fcs_col_push_card(col, card);
  408da8:	48 0f be 0e          	movsbq (%rsi),%rcx
  408dac:	44 8d 49 01          	lea    0x1(%rcx),%r9d
  408db0:	44 88 0e             	mov    %r9b,(%rsi)
  408db3:	40 88 7c 0e 01       	mov    %dil,0x1(%rsi,%rcx,1)
  408db8:	4c 8b 4c 24 50       	mov    0x50(%rsp),%r9
  408dbd:	89 44 24 60          	mov    %eax,0x60(%rsp)
        while ((*col_num_cards) == 0)
  408dc1:	85 c0                	test   %eax,%eax
  408dc3:	0f 85 17 01 00 00    	jne    408ee0 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x5a0>
  408dc9:	44 8b 5c 24 20       	mov    0x20(%rsp),%r11d
  408dce:	e9 ea fc ff ff       	jmpq   408abd <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x17d>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  408dd3:	44 89 ce             	mov    %r9d,%esi
            if (dest_fc_idx == LOCAL_FREECELLS_NUM)
  408dd6:	83 fe 04             	cmp    $0x4,%esi
  408dd9:	0f 84 8e fe ff ff    	je     408c6d <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x32d>
  408ddf:	44 8d 4e 01          	lea    0x1(%rsi),%r9d
  408de3:	48 63 f6             	movslq %esi,%rsi
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  408de6:	4a 8b 3c c2          	mov    (%rdx,%r8,8),%rdi
            --(*col_num_cards);
  408dea:	83 e8 01             	sub    $0x1,%eax
    fcs_col_pop_card(col, ret);
  408ded:	44 0f be 17          	movsbl (%rdi),%r10d
  408df1:	44 89 d1             	mov    %r10d,%ecx
  408df4:	41 83 ea 01          	sub    $0x1,%r10d
  408df8:	4d 63 d2             	movslq %r10d,%r10
  408dfb:	83 e9 01             	sub    $0x1,%ecx
  408dfe:	46 0f b6 54 17 01    	movzbl 0x1(%rdi,%r10,1),%r10d
  408e04:	88 0f                	mov    %cl,(%rdi)
  408e06:	48 0f be c9          	movsbq %cl,%rcx
  408e0a:	c6 44 0f 01 00       	movb   $0x0,0x1(%rdi,%rcx,1)
  408e0f:	b9 01 00 00 00       	mov    $0x1,%ecx
            fcs_put_card_in_freecell(*new_key, dest_fc_idx, top_card);
  408e14:	44 88 54 32 40       	mov    %r10b,0x40(%rdx,%rsi,1)
  408e19:	e9 92 fc ff ff       	jmpq   408ab0 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x170>
  408e1e:	4c 63 c7             	movslq %edi,%r8
                my_copy_stack(stack_idx);
  408e21:	bf 01 00 00 00       	mov    $0x1,%edi
  408e26:	44 89 c1             	mov    %r8d,%ecx
  408e29:	d3 e7                	shl    %cl,%edi
  408e2b:	09 fa                	or     %edi,%edx
  408e2d:	89 50 14             	mov    %edx,0x14(%rax)
  408e30:	48 8b 54 24 50       	mov    0x50(%rsp),%rdx
  408e35:	48 89 e8             	mov    %rbp,%rax
  408e38:	48 c1 e0 07          	shl    $0x7,%rax
  408e3c:	48 03 44 24 18       	add    0x18(%rsp),%rax
  408e41:	4a 8b 34 c2          	mov    (%rdx,%r8,8),%rsi
  408e45:	0f be 0e             	movsbl (%rsi),%ecx
  408e48:	83 c1 01             	add    $0x1,%ecx
  408e4b:	48 63 c9             	movslq %ecx,%rcx
  408e4e:	48 83 f9 08          	cmp    $0x8,%rcx
  408e52:	73 5b                	jae    408eaf <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x56f>
  408e54:	f6 c1 04             	test   $0x4,%cl
  408e57:	0f 85 54 01 00 00    	jne    408fb1 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x671>
  408e5d:	48 85 c9             	test   %rcx,%rcx
  408e60:	74 13                	je     408e75 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x535>
  408e62:	0f b6 16             	movzbl (%rsi),%edx
  408e65:	88 10                	mov    %dl,(%rax)
  408e67:	48 8b 54 24 50       	mov    0x50(%rsp),%rdx
  408e6c:	f6 c1 02             	test   $0x2,%cl
  408e6f:	0f 85 86 01 00 00    	jne    408ffb <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x6bb>
  408e75:	4a 89 04 c2          	mov    %rax,(%rdx,%r8,8)
  408e79:	8b 44 24 20          	mov    0x20(%rsp),%eax
  408e7d:	e9 e9 fb ff ff       	jmpq   408a6b <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x12b>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  408e82:	89 f1                	mov    %esi,%ecx
  408e84:	49 63 f1             	movslq %r9d,%rsi
  408e87:	41 89 c9             	mov    %ecx,%r9d
  408e8a:	e9 57 ff ff ff       	jmpq   408de6 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x4a6>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  408e8f:	48 8b 91 b0 00 00 00 	mov    0xb0(%rcx),%rdx
  408e96:	48 8b 44 24 58       	mov    0x58(%rsp),%rax
  408e9b:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  408e9e:	48 8b 44 24 50       	mov    0x50(%rsp),%rax
  408ea3:	48 89 81 b0 00 00 00 	mov    %rax,0xb0(%rcx)
  408eaa:	e9 75 fc ff ff       	jmpq   408b24 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x1e4>
                my_copy_stack(stack_idx);
  408eaf:	48 8b 54 0e f8       	mov    -0x8(%rsi,%rcx,1),%rdx
  408eb4:	48 89 c7             	mov    %rax,%rdi
  408eb7:	48 89 54 08 f8       	mov    %rdx,-0x8(%rax,%rcx,1)
  408ebc:	48 83 e9 01          	sub    $0x1,%rcx
  408ec0:	48 c1 e9 03          	shr    $0x3,%rcx
  408ec4:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  408ec7:	48 8b 54 24 50       	mov    0x50(%rsp),%rdx
  408ecc:	eb a7                	jmp    408e75 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x535>
  408ece:	41 83 c2 05          	add    $0x5,%r10d
  408ed2:	e9 8f fe ff ff       	jmpq   408d66 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x426>
  408ed7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  408ede:	00 00 
    return -1;
  408ee0:	b9 ff ff ff ff       	mov    $0xffffffff,%ecx
    for (int ret = start_from; ret < local_stacks_num; ret++)
  408ee5:	41 83 fa 08          	cmp    $0x8,%r10d
  408ee9:	0f 85 a4 fd ff ff    	jne    408c93 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x353>
  408eef:	45 31 d2             	xor    %r10d,%r10d
  408ef2:	e9 6f fe ff ff       	jmpq   408d66 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x426>
  408ef7:	41 83 c1 02          	add    $0x2,%r9d
  408efb:	e9 e6 fe ff ff       	jmpq   408de6 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x4a6>
  408f00:	41 83 c1 03          	add    $0x3,%r9d
  408f04:	e9 dd fe ff ff       	jmpq   408de6 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x4a6>
  408f09:	45 31 d2             	xor    %r10d,%r10d
    return -1;
  408f0c:	b9 ff ff ff ff       	mov    $0xffffffff,%ecx
  408f11:	e9 50 fe ff ff       	jmpq   408d66 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x426>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  408f16:	41 b9 04 00 00 00    	mov    $0x4,%r9d
  408f1c:	be 03 00 00 00       	mov    $0x3,%esi
  408f21:	e9 c0 fe ff ff       	jmpq   408de6 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x4a6>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  408f26:	41 b9 01 00 00 00    	mov    $0x1,%r9d
  408f2c:	41 d3 e1             	shl    %cl,%r9d
  408f2f:	c1 e1 07             	shl    $0x7,%ecx
  408f32:	44 09 cf             	or     %r9d,%edi
  408f35:	4c 63 c9             	movslq %ecx,%r9
  408f38:	4c 03 4c 24 30       	add    0x30(%rsp),%r9
  408f3d:	89 7e 14             	mov    %edi,0x14(%rsi)
  408f40:	4a 8d 3c da          	lea    (%rdx,%r11,8),%rdi
  408f44:	48 8b 37             	mov    (%rdi),%rsi
  408f47:	48 89 7c 24 28       	mov    %rdi,0x28(%rsp)
  408f4c:	0f be 0e             	movsbl (%rsi),%ecx
  408f4f:	83 c1 01             	add    $0x1,%ecx
  408f52:	48 63 c9             	movslq %ecx,%rcx
  408f55:	48 83 f9 08          	cmp    $0x8,%rcx
  408f59:	73 26                	jae    408f81 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x641>
  408f5b:	f6 c1 04             	test   $0x4,%cl
  408f5e:	0f 85 ab 00 00 00    	jne    40900f <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x6cf>
  408f64:	48 85 c9             	test   %rcx,%rcx
  408f67:	74 0b                	je     408f74 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x634>
  408f69:	0f b6 3e             	movzbl (%rsi),%edi
  408f6c:	41 88 39             	mov    %dil,(%r9)
  408f6f:	f6 c1 02             	test   $0x2,%cl
  408f72:	75 77                	jne    408feb <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x6ab>
  408f74:	48 8b 7c 24 28       	mov    0x28(%rsp),%rdi
  408f79:	4c 89 0f             	mov    %r9,(%rdi)
  408f7c:	e9 f9 fd ff ff       	jmpq   408d7a <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x43a>
  408f81:	48 8b 7c 0e f8       	mov    -0x8(%rsi,%rcx,1),%rdi
  408f86:	49 89 7c 09 f8       	mov    %rdi,-0x8(%r9,%rcx,1)
  408f8b:	48 83 e9 01          	sub    $0x1,%rcx
  408f8f:	4c 89 cf             	mov    %r9,%rdi
  408f92:	48 c1 e9 03          	shr    $0x3,%rcx
  408f96:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  408f99:	eb d9                	jmp    408f74 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x634>
        if (fcs_state_col_is_empty(state, ret))
  408f9b:	89 ce                	mov    %ecx,%esi
  408f9d:	44 89 d1             	mov    %r10d,%ecx
  408fa0:	41 89 f2             	mov    %esi,%r10d
  408fa3:	e9 be fd ff ff       	jmpq   408d66 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x426>
  408fa8:	41 83 c2 04          	add    $0x4,%r10d
  408fac:	e9 b5 fd ff ff       	jmpq   408d66 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x426>
                my_copy_stack(stack_idx);
  408fb1:	8b 16                	mov    (%rsi),%edx
  408fb3:	89 10                	mov    %edx,(%rax)
  408fb5:	8b 54 0e fc          	mov    -0x4(%rsi,%rcx,1),%edx
  408fb9:	89 54 08 fc          	mov    %edx,-0x4(%rax,%rcx,1)
  408fbd:	48 8b 54 24 50       	mov    0x50(%rsp),%rdx
  408fc2:	e9 ae fe ff ff       	jmpq   408e75 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x535>
  408fc7:	41 83 c2 03          	add    $0x3,%r10d
  408fcb:	e9 96 fd ff ff       	jmpq   408d66 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x426>
  408fd0:	41 83 c2 02          	add    $0x2,%r10d
  408fd4:	e9 8d fd ff ff       	jmpq   408d66 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x426>
  408fd9:	41 83 c2 07          	add    $0x7,%r10d
  408fdd:	e9 84 fd ff ff       	jmpq   408d66 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x426>
  408fe2:	41 83 c2 06          	add    $0x6,%r10d
  408fe6:	e9 7b fd ff ff       	jmpq   408d66 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x426>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  408feb:	0f b7 74 0e fe       	movzwl -0x2(%rsi,%rcx,1),%esi
  408ff0:	66 41 89 74 09 fe    	mov    %si,-0x2(%r9,%rcx,1)
  408ff6:	e9 79 ff ff ff       	jmpq   408f74 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x634>
                my_copy_stack(stack_idx);
  408ffb:	0f b7 54 0e fe       	movzwl -0x2(%rsi,%rcx,1),%edx
  409000:	66 89 54 08 fe       	mov    %dx,-0x2(%rax,%rcx,1)
  409005:	48 8b 54 24 50       	mov    0x50(%rsp),%rdx
  40900a:	e9 66 fe ff ff       	jmpq   408e75 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x535>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  40900f:	8b 3e                	mov    (%rsi),%edi
  409011:	41 89 39             	mov    %edi,(%r9)
  409014:	8b 74 0e fc          	mov    -0x4(%rsi,%rcx,1),%esi
  409018:	41 89 74 09 fc       	mov    %esi,-0x4(%r9,%rcx,1)
  40901d:	e9 52 ff ff ff       	jmpq   408f74 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x634>
  409022:	89 44 24 60          	mov    %eax,0x60(%rsp)
  409026:	e9 4a fc ff ff       	jmpq   408c75 <fc_solve_sfs_move_non_top_stack_cards_to_founds+0x335>
  40902b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)

0000000000409030 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks>:
{
  409030:	41 57                	push   %r15
  409032:	41 56                	push   %r14
  409034:	41 55                	push   %r13
  409036:	41 54                	push   %r12
  409038:	49 89 fc             	mov    %rdi,%r12
  40903b:	55                   	push   %rbp
  40903c:	48 89 f5             	mov    %rsi,%rbp
  40903f:	53                   	push   %rbx
  409040:	48 81 ec 88 00 00 00 	sub    $0x88,%rsp
    MOVE_FUNCS__define_common();
  409047:	48 8b 07             	mov    (%rdi),%rax
{
  40904a:	48 89 54 24 28       	mov    %rdx,0x28(%rsp)
  40904f:	48 89 4c 24 40       	mov    %rcx,0x40(%rsp)
    MOVE_FUNCS__define_common();
  409054:	48 89 44 24 20       	mov    %rax,0x20(%rsp)
  409059:	48 05 00 01 00 00    	add    $0x100,%rax
  40905f:	48 89 44 24 48       	mov    %rax,0x48(%rsp)
    return (soft_thread->num_vacant_freecells +
  409064:	0f b6 87 e3 01 00 00 	movzbl 0x1e3(%rdi),%eax
  40906b:	02 87 e4 01 00 00    	add    0x1e4(%rdi),%al
  409071:	88 44 24 12          	mov    %al,0x12(%rsp)
        return (BEFS_M_VAR(soft_thread, befs_positions_by_rank));
  409075:	48 8d 47 60          	lea    0x60(%rdi),%rax
  409079:	48 89 44 24 30       	mov    %rax,0x30(%rsp)
    if (soft_thread->super_method_type == FCS_SUPER_METHOD_DFS)
  40907e:	8b 47 20             	mov    0x20(%rdi),%eax
  409081:	85 c0                	test   %eax,%eax
  409083:	75 1d                	jne    4090a2 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x72>
        return (DFS_VAR(soft_thread, soft_dfs_info)[DFS_VAR(soft_thread, depth)]
  409085:	48 8b 47 38          	mov    0x38(%rdi),%rax
  409089:	48 8d 14 80          	lea    (%rax,%rax,4),%rdx
  40908d:	48 8d 04 50          	lea    (%rax,%rdx,2),%rax
  409091:	48 c1 e0 04          	shl    $0x4,%rax
  409095:	48 03 47 30          	add    0x30(%rdi),%rax
  409099:	48 83 c0 40          	add    $0x40,%rax
  40909d:	48 89 44 24 30       	mov    %rax,0x30(%rsp)
{
  4090a2:	45 31 ed             	xor    %r13d,%r13d
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  4090a5:	4c 89 64 24 18       	mov    %r12,0x18(%rsp)
        const fcs_card src_card = fcs_freecell_card(state, fc);
  4090aa:	4a 0f be 44 2d 40    	movsbq 0x40(%rbp,%r13,1),%rax
  4090b0:	44 89 6c 24 14       	mov    %r13d,0x14(%rsp)
  4090b5:	88 44 24 13          	mov    %al,0x13(%rsp)
        if (!(
  4090b9:	84 c0                	test   %al,%al
  4090bb:	0f 84 04 04 00 00    	je     4094c5 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x495>
  4090c1:	80 b8 00 fb 40 00 00 	cmpb   $0x0,0x40fb00(%rax)
  4090c8:	0f 85 f7 03 00 00    	jne    4094c5 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x495>
        FCS_POS_IDX_TO_CHECK_START_LOOP(src_card)
  4090ce:	48 c1 e0 04          	shl    $0x4,%rax
  4090d2:	48 8b 7c 24 30       	mov    0x30(%rsp),%rdi
  4090d7:	48 8b 98 40 fb 40 00 	mov    0x40fb40(%rax),%rbx
  4090de:	48 01 fb             	add    %rdi,%rbx
  4090e1:	48 03 b8 48 fb 40 00 	add    0x40fb48(%rax),%rdi
  4090e8:	48 89 7c 24 08       	mov    %rdi,0x8(%rsp)
  4090ed:	48 39 fb             	cmp    %rdi,%rbx
  4090f0:	0f 83 cf 03 00 00    	jae    4094c5 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x495>
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  4090f6:	4c 89 6c 24 38       	mov    %r13,0x38(%rsp)
  4090fb:	4c 8b 64 24 40       	mov    0x40(%rsp),%r12
  409100:	e9 e1 00 00 00       	jmpq   4091e6 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x1b6>
  409105:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40910c:	00 00 00 00 
  409110:	48 8b 74 24 60       	mov    0x60(%rsp),%rsi
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  409115:	4a 8b 14 c6          	mov    (%rsi,%r8,8),%rdx
    if (!fc_solve_check_and_add_state(
  409119:	48 8d 74 24 60       	lea    0x60(%rsp),%rsi
    fcs_col_push_card(col, card);
  40911e:	0f b6 7c 24 13       	movzbl 0x13(%rsp),%edi
  409123:	48 0f be 02          	movsbq (%rdx),%rax
  409127:	8d 48 01             	lea    0x1(%rax),%ecx
  40912a:	88 0a                	mov    %cl,(%rdx)
  40912c:	40 88 7c 02 01       	mov    %dil,0x1(%rdx,%rax,1)
            fcs_empty_freecell(new_state_key, fc);
  409131:	48 63 44 24 14       	movslq 0x14(%rsp),%rax
  409136:	48 8b 54 24 60       	mov    0x60(%rsp),%rdx
  40913b:	c6 44 02 40 00       	movb   $0x0,0x40(%rdx,%rax,1)
    const_SLOT(hard_thread, soft_thread);
  409140:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
    if (!fc_solve_check_and_add_state(
  409145:	48 8d 54 24 70       	lea    0x70(%rsp),%rdx
    const_SLOT(hard_thread, soft_thread);
  40914a:	4c 8b 38             	mov    (%rax),%r15
    if (!fc_solve_check_and_add_state(
  40914d:	4c 89 ff             	mov    %r15,%rdi
  409150:	e8 fb 88 ff ff       	callq  401a50 <fc_solve_check_and_add_state>
  409155:	84 c0                	test   %al,%al
  409157:	0f 85 e3 03 00 00    	jne    409540 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x510>
        if (HT_FIELD(hard_thread, allocated_from_list))
  40915d:	41 80 bf 18 05 00 00 	cmpb   $0x0,0x518(%r15)
  409164:	00 
  409165:	0f 84 75 04 00 00    	je     4095e0 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x5b0>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  40916b:	49 8b 97 b0 00 00 00 	mov    0xb0(%r15),%rdx
  409172:	48 8b 44 24 68       	mov    0x68(%rsp),%rax
  409177:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  40917a:	48 8b 44 24 60       	mov    0x60(%rsp),%rax
  40917f:	49 89 87 b0 00 00 00 	mov    %rax,0xb0(%r15)
  409186:	4c 8b 7c 24 70       	mov    0x70(%rsp),%r15
    if ((!((list->num_states + (list->states != NULL)) &
  40918b:	49 8b 44 24 08       	mov    0x8(%r12),%rax
  409190:	31 c9                	xor    %ecx,%ecx
  409192:	49 8b 14 24          	mov    (%r12),%rdx
  409196:	48 85 c0             	test   %rax,%rax
  409199:	0f 95 c1             	setne  %cl
  40919c:	48 01 d1             	add    %rdx,%rcx
  40919f:	f6 c1 0f             	test   $0xf,%cl
  4091a2:	75 19                	jne    4091bd <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x18d>
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  4091a4:	48 8d 71 10          	lea    0x10(%rcx),%rsi
  4091a8:	48 89 c7             	mov    %rax,%rdi
  4091ab:	48 c1 e6 04          	shl    $0x4,%rsi
  4091af:	e8 bc 7f ff ff       	callq  401170 <realloc@plt>
  4091b4:	49 8b 14 24          	mov    (%r12),%rdx
        list->states =
  4091b8:	49 89 44 24 08       	mov    %rax,0x8(%r12)
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  4091bd:	48 8d 4a 01          	lea    0x1(%rdx),%rcx
  4091c1:	48 c1 e2 04          	shl    $0x4,%rdx
  4091c5:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  4091c9:	48 01 d0             	add    %rdx,%rax
  4091cc:	49 89 0c 24          	mov    %rcx,(%r12)
  4091d0:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  4091d4:	4c 89 38             	mov    %r15,(%rax)
        FCS_POS_IDX_TO_CHECK_START_LOOP(src_card)
  4091d7:	48 83 c3 04          	add    $0x4,%rbx
  4091db:	48 39 5c 24 08       	cmp    %rbx,0x8(%rsp)
  4091e0:	0f 86 da 02 00 00    	jbe    4094c0 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x490>
            const int_fast32_t ds = pos_idx_to_check[0];
  4091e6:	4c 0f be 03          	movsbq (%rbx),%r8
  4091ea:	4d 89 c7             	mov    %r8,%r15
            if (ds == -1)
  4091ed:	49 83 f8 ff          	cmp    $0xffffffffffffffff,%r8
  4091f1:	74 e4                	je     4091d7 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x1a7>
            const int dest_cards_num = fcs_col_len(dest_col);
  4091f3:	4a 8b 54 c5 00       	mov    0x0(%rbp,%r8,8),%rdx
  4091f8:	4c 89 04 24          	mov    %r8,(%rsp)
            const int next_dc = dc + 1;
  4091fc:	44 0f be 73 01       	movsbl 0x1(%rbx),%r14d
            if (!(dest_cards_num <= next_dc + num_vacant_slots))
  409201:	0f b6 44 24 12       	movzbl 0x12(%rsp),%eax
            const int dest_cards_num = fcs_col_len(dest_col);
  409206:	44 0f be 2a          	movsbl (%rdx),%r13d
            if (!(dest_cards_num <= next_dc + num_vacant_slots))
  40920a:	41 8d 44 06 01       	lea    0x1(%r14,%rax,1),%eax
  40920f:	44 39 e8             	cmp    %r13d,%eax
  409212:	7c c3                	jl     4091d7 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x1a7>
            sfs_check_state_begin();
  409214:	48 8b 4c 24 28       	mov    0x28(%rsp),%rcx
  409219:	48 8d 74 24 60       	lea    0x60(%rsp),%rsi
  40921e:	48 89 ea             	mov    %rbp,%rdx
  409221:	48 8b 7c 24 20       	mov    0x20(%rsp),%rdi
  409226:	e8 d5 86 ff ff       	callq  401900 <fc_solve_sfs_check_state_begin>
            my_copy_stack(ds);
  40922b:	48 8b 44 24 68       	mov    0x68(%rsp),%rax
  409230:	4c 8b 04 24          	mov    (%rsp),%r8
  409234:	8b 50 14             	mov    0x14(%rax),%edx
  409237:	44 0f a3 fa          	bt     %r15d,%edx
  40923b:	0f 83 0f 03 00 00    	jae    409550 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x520>
  409241:	48 8b 54 24 60       	mov    0x60(%rsp),%rdx
  409246:	48 8b 7c 24 18       	mov    0x18(%rsp),%rdi
                dest_cards_num - dc - 1, 0);
  40924b:	41 f7 d6             	not    %r14d
            const int cols_indexes[3] = {ds, -1, -1};
  40924e:	4d 0f be c7          	movsbq %r15b,%r8
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  409252:	31 c9                	xor    %ecx,%ecx
                dest_cards_num - dc - 1, 0);
  409254:	43 8d 04 2e          	lea    (%r14,%r13,1),%eax
            const int cols_indexes[3] = {ds, -1, -1};
  409258:	44 89 44 24 54       	mov    %r8d,0x54(%rsp)
        int dest_fc_idx = 0;
  40925d:	45 31 d2             	xor    %r10d,%r10d
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  409260:	48 be 00 00 00 00 ff 	movabs $0xffffffff00000000,%rsi
  409267:	ff ff ff 
            const int cols_indexes[3] = {ds, -1, -1};
  40926a:	48 c7 44 24 58 ff ff 	movq   $0xffffffffffffffff,0x58(%rsp)
  409271:	ff ff 
    int num_cards_to_move_from_columns[3] = {num_cards_1, num_cards_2, -1};
  409273:	89 44 24 70          	mov    %eax,0x70(%rsp)
  409277:	48 8b 3f             	mov    (%rdi),%rdi
  40927a:	48 89 74 24 74       	mov    %rsi,0x74(%rsp)
  40927f:	90                   	nop
            while ((*col_num_cards) == 0)
  409280:	85 c0                	test   %eax,%eax
  409282:	0f 84 88 fe ff ff    	je     409110 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0xe0>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  409288:	41 83 fa 03          	cmp    $0x3,%r10d
  40928c:	0f 8f 5e 02 00 00    	jg     4094f0 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x4c0>
  409292:	45 8d 4a 01          	lea    0x1(%r10),%r9d
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  409296:	49 63 f2             	movslq %r10d,%rsi
  409299:	80 7c 32 40 00       	cmpb   $0x0,0x40(%rdx,%rsi,1)
  40929e:	0f 84 1c 03 00 00    	je     4095c0 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x590>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  4092a4:	41 83 f9 04          	cmp    $0x4,%r9d
  4092a8:	74 40                	je     4092ea <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x2ba>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  4092aa:	4d 63 c9             	movslq %r9d,%r9
  4092ad:	42 80 7c 0a 40 00    	cmpb   $0x0,0x40(%rdx,%r9,1)
  4092b3:	0f 84 17 03 00 00    	je     4095d0 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x5a0>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  4092b9:	45 8d 4a 02          	lea    0x2(%r10),%r9d
  4092bd:	41 83 f9 04          	cmp    $0x4,%r9d
  4092c1:	74 27                	je     4092ea <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x2ba>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  4092c3:	4d 63 c9             	movslq %r9d,%r9
  4092c6:	42 80 7c 0a 40 00    	cmpb   $0x0,0x40(%rdx,%r9,1)
  4092cc:	0f 84 2e 03 00 00    	je     409600 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x5d0>
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  4092d2:	45 8d 4a 03          	lea    0x3(%r10),%r9d
  4092d6:	41 83 f9 03          	cmp    $0x3,%r9d
  4092da:	0f 85 13 02 00 00    	jne    4094f3 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x4c3>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  4092e0:	80 7a 43 00          	cmpb   $0x0,0x43(%rdx)
  4092e4:	0f 84 26 03 00 00    	je     409610 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x5e0>
  4092ea:	84 c9                	test   %cl,%cl
  4092ec:	0f 85 0a 04 00 00    	jne    4096fc <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x6cc>
  4092f2:	48 8b 74 24 60       	mov    0x60(%rsp),%rsi
    char *const indirect_stacks_buffer =
  4092f7:	48 81 c7 00 01 00 00 	add    $0x100,%rdi
    int put_cards_in_col_idx = 0;
  4092fe:	45 31 d2             	xor    %r10d,%r10d
    char *const indirect_stacks_buffer =
  409301:	49 89 fe             	mov    %rdi,%r14
  409304:	49 63 ca             	movslq %r10d,%rcx
  409307:	48 8d 3c ce          	lea    (%rsi,%rcx,8),%rdi
        if (fcs_state_col_is_empty(state, ret))
  40930b:	4c 8b 0f             	mov    (%rdi),%r9
  40930e:	41 8d 4a 01          	lea    0x1(%r10),%ecx
  409312:	41 80 39 00          	cmpb   $0x0,(%r9)
  409316:	0f 84 8a 03 00 00    	je     4096a6 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x676>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  40931c:	83 f9 08             	cmp    $0x8,%ecx
  40931f:	0f 84 0b 03 00 00    	je     409630 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x600>
        if (fcs_state_col_is_empty(state, ret))
  409325:	4c 8b 4f 08          	mov    0x8(%rdi),%r9
  409329:	41 80 39 00          	cmpb   $0x0,(%r9)
  40932d:	0f 84 80 03 00 00    	je     4096b3 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x683>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  409333:	41 8d 4a 02          	lea    0x2(%r10),%ecx
  409337:	83 f9 08             	cmp    $0x8,%ecx
  40933a:	0f 84 f0 02 00 00    	je     409630 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x600>
        if (fcs_state_col_is_empty(state, ret))
  409340:	4c 8b 4f 10          	mov    0x10(%rdi),%r9
  409344:	41 80 39 00          	cmpb   $0x0,(%r9)
  409348:	0f 84 6e 03 00 00    	je     4096bc <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x68c>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  40934e:	41 8d 4a 03          	lea    0x3(%r10),%ecx
  409352:	83 f9 07             	cmp    $0x7,%ecx
  409355:	0f 8f d5 02 00 00    	jg     409630 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x600>
        if (fcs_state_col_is_empty(state, ret))
  40935b:	4c 8b 4f 18          	mov    0x18(%rdi),%r9
  40935f:	41 80 39 00          	cmpb   $0x0,(%r9)
  409363:	0f 84 5c 03 00 00    	je     4096c5 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x695>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  409369:	41 8d 4a 04          	lea    0x4(%r10),%ecx
  40936d:	83 f9 07             	cmp    $0x7,%ecx
  409370:	0f 8f ba 02 00 00    	jg     409630 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x600>
        if (fcs_state_col_is_empty(state, ret))
  409376:	4c 8b 4f 20          	mov    0x20(%rdi),%r9
  40937a:	41 80 39 00          	cmpb   $0x0,(%r9)
  40937e:	0f 84 4a 03 00 00    	je     4096ce <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x69e>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  409384:	41 8d 4a 05          	lea    0x5(%r10),%ecx
  409388:	83 f9 07             	cmp    $0x7,%ecx
  40938b:	0f 8f 9f 02 00 00    	jg     409630 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x600>
        if (fcs_state_col_is_empty(state, ret))
  409391:	4c 8b 4f 28          	mov    0x28(%rdi),%r9
  409395:	41 80 39 00          	cmpb   $0x0,(%r9)
  409399:	0f 84 38 03 00 00    	je     4096d7 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x6a7>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  40939f:	41 8d 4a 06          	lea    0x6(%r10),%ecx
  4093a3:	83 f9 07             	cmp    $0x7,%ecx
  4093a6:	0f 8f 84 02 00 00    	jg     409630 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x600>
        if (fcs_state_col_is_empty(state, ret))
  4093ac:	48 8b 7f 30          	mov    0x30(%rdi),%rdi
  4093b0:	80 3f 00             	cmpb   $0x0,(%rdi)
  4093b3:	0f 84 27 03 00 00    	je     4096e0 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x6b0>
    for (int ret = start_from; ret < local_stacks_num; ret++)
  4093b9:	45 85 d2             	test   %r10d,%r10d
  4093bc:	0f 85 6e 02 00 00    	jne    409630 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x600>
        if (fcs_state_col_is_empty(state, ret))
  4093c2:	48 8b 4e 38          	mov    0x38(%rsi),%rcx
  4093c6:	bf 08 00 00 00       	mov    $0x8,%edi
  4093cb:	80 39 00             	cmpb   $0x0,(%rcx)
  4093ce:	44 0f 44 d7          	cmove  %edi,%r10d
  4093d2:	80 39 01             	cmpb   $0x1,(%rcx)
  4093d5:	19 c9                	sbb    %ecx,%ecx
  4093d7:	83 e1 08             	and    $0x8,%ecx
  4093da:	83 e9 01             	sub    $0x1,%ecx
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  4093dd:	48 8b 74 24 68       	mov    0x68(%rsp),%rsi
  4093e2:	4c 63 c9             	movslq %ecx,%r9
  4093e5:	8b 7e 14             	mov    0x14(%rsi),%edi
  4093e8:	0f a3 cf             	bt     %ecx,%edi
  4093eb:	73 73                	jae    409460 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x430>
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  4093ed:	48 63 4c 24 54       	movslq 0x54(%rsp),%rcx
        --(*col_num_cards);
  4093f2:	83 e8 01             	sub    $0x1,%eax
  4093f5:	48 8b 3c ca          	mov    (%rdx,%rcx,8),%rdi
    fcs_col_pop_card(col, ret);
  4093f9:	0f be 37             	movsbl (%rdi),%esi
  4093fc:	89 f1                	mov    %esi,%ecx
  4093fe:	83 ee 01             	sub    $0x1,%esi
  409401:	83 e9 01             	sub    $0x1,%ecx
  409404:	48 63 f6             	movslq %esi,%rsi
  409407:	0f b6 74 37 01       	movzbl 0x1(%rdi,%rsi,1),%esi
  40940c:	88 0f                	mov    %cl,(%rdi)
  40940e:	48 0f be c9          	movsbq %cl,%rcx
  409412:	c6 44 0f 01 00       	movb   $0x0,0x1(%rdi,%rcx,1)
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  409417:	4a 8b 3c ca          	mov    (%rdx,%r9,8),%rdi
    fcs_col_push_card(col, card);
  40941b:	48 0f be 0f          	movsbq (%rdi),%rcx
  40941f:	44 8d 49 01          	lea    0x1(%rcx),%r9d
  409423:	44 88 0f             	mov    %r9b,(%rdi)
  409426:	40 88 74 0f 01       	mov    %sil,0x1(%rdi,%rcx,1)
  40942b:	48 8b 74 24 60       	mov    0x60(%rsp),%rsi
  409430:	89 44 24 70          	mov    %eax,0x70(%rsp)
        while ((*col_num_cards) == 0)
  409434:	85 c0                	test   %eax,%eax
  409436:	0f 84 d9 fc ff ff    	je     409115 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0xe5>
    return -1;
  40943c:	b9 ff ff ff ff       	mov    $0xffffffff,%ecx
    for (int ret = start_from; ret < local_stacks_num; ret++)
  409441:	41 83 fa 08          	cmp    $0x8,%r10d
  409445:	0f 85 b9 fe ff ff    	jne    409304 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x2d4>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  40944b:	48 8b 74 24 68       	mov    0x68(%rsp),%rsi
    for (int ret = start_from; ret < local_stacks_num; ret++)
  409450:	45 31 d2             	xor    %r10d,%r10d
  409453:	4c 63 c9             	movslq %ecx,%r9
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  409456:	8b 7e 14             	mov    0x14(%rsi),%edi
  409459:	0f a3 cf             	bt     %ecx,%edi
  40945c:	72 8f                	jb     4093ed <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x3bd>
  40945e:	66 90                	xchg   %ax,%ax
  409460:	4e 8d 2c ca          	lea    (%rdx,%r9,8),%r13
  409464:	41 bb 01 00 00 00    	mov    $0x1,%r11d
  40946a:	41 d3 e3             	shl    %cl,%r11d
  40946d:	c1 e1 07             	shl    $0x7,%ecx
  409470:	44 09 df             	or     %r11d,%edi
  409473:	4c 63 d9             	movslq %ecx,%r11
  409476:	89 7e 14             	mov    %edi,0x14(%rsi)
  409479:	49 8b 75 00          	mov    0x0(%r13),%rsi
  40947d:	4d 01 f3             	add    %r14,%r11
  409480:	0f be 0e             	movsbl (%rsi),%ecx
  409483:	83 c1 01             	add    $0x1,%ecx
  409486:	48 63 c9             	movslq %ecx,%rcx
  409489:	48 83 f9 08          	cmp    $0x8,%rcx
  40948d:	0f 82 d3 01 00 00    	jb     409666 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x636>
  409493:	48 8b 7c 0e f8       	mov    -0x8(%rsi,%rcx,1),%rdi
  409498:	49 89 7c 0b f8       	mov    %rdi,-0x8(%r11,%rcx,1)
  40949d:	48 83 e9 01          	sub    $0x1,%rcx
  4094a1:	4c 89 df             	mov    %r11,%rdi
  4094a4:	48 c1 e9 03          	shr    $0x3,%rcx
  4094a8:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  4094ab:	4d 89 5d 00          	mov    %r11,0x0(%r13)
  4094af:	e9 39 ff ff ff       	jmpq   4093ed <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x3bd>
  4094b4:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4094bb:	00 00 00 00 
  4094bf:	90                   	nop
  4094c0:	4c 8b 6c 24 38       	mov    0x38(%rsp),%r13
  4094c5:	49 83 c5 01          	add    $0x1,%r13
    for (int fc = 0; fc < LOCAL_FREECELLS_NUM; fc++)
  4094c9:	49 83 fd 04          	cmp    $0x4,%r13
  4094cd:	0f 85 d7 fb ff ff    	jne    4090aa <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x7a>
}
  4094d3:	48 81 c4 88 00 00 00 	add    $0x88,%rsp
  4094da:	5b                   	pop    %rbx
  4094db:	5d                   	pop    %rbp
  4094dc:	41 5c                	pop    %r12
  4094de:	41 5d                	pop    %r13
  4094e0:	41 5e                	pop    %r14
  4094e2:	41 5f                	pop    %r15
  4094e4:	c3                   	retq   
  4094e5:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4094ec:	00 00 00 00 
            for (; dest_fc_idx < LOCAL_FREECELLS_NUM; dest_fc_idx++)
  4094f0:	45 89 d1             	mov    %r10d,%r9d
            if (dest_fc_idx == LOCAL_FREECELLS_NUM)
  4094f3:	41 83 f9 04          	cmp    $0x4,%r9d
  4094f7:	0f 84 ed fd ff ff    	je     4092ea <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x2ba>
  4094fd:	45 8d 51 01          	lea    0x1(%r9),%r10d
  409501:	4d 63 c9             	movslq %r9d,%r9
    var_AUTO(col, fcs_state_get_col(*state, col_idx));
  409504:	4e 8b 1c c2          	mov    (%rdx,%r8,8),%r11
            --(*col_num_cards);
  409508:	83 e8 01             	sub    $0x1,%eax
    fcs_col_pop_card(col, ret);
  40950b:	41 0f be 33          	movsbl (%r11),%esi
  40950f:	89 f1                	mov    %esi,%ecx
  409511:	83 ee 01             	sub    $0x1,%esi
  409514:	48 63 f6             	movslq %esi,%rsi
  409517:	83 e9 01             	sub    $0x1,%ecx
  40951a:	41 0f b6 74 33 01    	movzbl 0x1(%r11,%rsi,1),%esi
  409520:	41 88 0b             	mov    %cl,(%r11)
  409523:	48 0f be c9          	movsbq %cl,%rcx
  409527:	41 c6 44 0b 01 00    	movb   $0x0,0x1(%r11,%rcx,1)
  40952d:	b9 01 00 00 00       	mov    $0x1,%ecx
            fcs_put_card_in_freecell(*new_key, dest_fc_idx, top_card);
  409532:	42 88 74 0a 40       	mov    %sil,0x40(%rdx,%r9,1)
  409537:	e9 44 fd ff ff       	jmpq   409280 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x250>
  40953c:	0f 1f 40 00          	nopl   0x0(%rax)
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  409540:	4c 8b 7c 24 60       	mov    0x60(%rsp),%r15
  409545:	e9 41 fc ff ff       	jmpq   40918b <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x15b>
  40954a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
            my_copy_stack(ds);
  409550:	44 89 f9             	mov    %r15d,%ecx
  409553:	bf 01 00 00 00       	mov    $0x1,%edi
  409558:	d3 e7                	shl    %cl,%edi
  40955a:	09 fa                	or     %edi,%edx
  40955c:	89 50 14             	mov    %edx,0x14(%rax)
  40955f:	48 8b 54 24 60       	mov    0x60(%rsp),%rdx
  409564:	4c 89 c0             	mov    %r8,%rax
  409567:	48 c1 e0 07          	shl    $0x7,%rax
  40956b:	48 03 44 24 48       	add    0x48(%rsp),%rax
  409570:	4a 8b 34 c2          	mov    (%rdx,%r8,8),%rsi
  409574:	0f be 0e             	movsbl (%rsi),%ecx
  409577:	83 c1 01             	add    $0x1,%ecx
  40957a:	48 63 c9             	movslq %ecx,%rcx
  40957d:	48 83 f9 08          	cmp    $0x8,%rcx
  409581:	0f 83 b9 00 00 00    	jae    409640 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x610>
  409587:	f6 c1 04             	test   $0x4,%cl
  40958a:	0f 85 03 01 00 00    	jne    409693 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x663>
  409590:	48 85 c9             	test   %rcx,%rcx
  409593:	0f 84 c4 00 00 00    	je     40965d <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x62d>
  409599:	0f b6 16             	movzbl (%rsi),%edx
  40959c:	88 10                	mov    %dl,(%rax)
  40959e:	48 8b 54 24 60       	mov    0x60(%rsp),%rdx
  4095a3:	f6 c1 02             	test   $0x2,%cl
  4095a6:	0f 84 b1 00 00 00    	je     40965d <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x62d>
  4095ac:	0f b7 54 0e fe       	movzwl -0x2(%rsi,%rcx,1),%edx
  4095b1:	66 89 54 08 fe       	mov    %dx,-0x2(%rax,%rcx,1)
  4095b6:	48 8b 54 24 60       	mov    0x60(%rsp),%rdx
  4095bb:	e9 9d 00 00 00       	jmpq   40965d <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x62d>
                if (fcs_freecell_is_empty(*new_key, dest_fc_idx))
  4095c0:	44 89 c9             	mov    %r9d,%ecx
  4095c3:	4d 63 ca             	movslq %r10d,%r9
  4095c6:	41 89 ca             	mov    %ecx,%r10d
  4095c9:	e9 36 ff ff ff       	jmpq   409504 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x4d4>
  4095ce:	66 90                	xchg   %ax,%ax
  4095d0:	41 83 c2 02          	add    $0x2,%r10d
  4095d4:	e9 2b ff ff ff       	jmpq   409504 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x4d4>
  4095d9:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
  4095e0:	49 8b 87 f0 00 00 00 	mov    0xf0(%r15),%rax
  4095e7:	49 89 87 e8 00 00 00 	mov    %rax,0xe8(%r15)
  4095ee:	e9 93 fb ff ff       	jmpq   409186 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x156>
  4095f3:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4095fa:	00 00 00 00 
  4095fe:	66 90                	xchg   %ax,%ax
  409600:	41 83 c2 03          	add    $0x3,%r10d
  409604:	e9 fb fe ff ff       	jmpq   409504 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x4d4>
  409609:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
  409610:	41 ba 04 00 00 00    	mov    $0x4,%r10d
  409616:	41 b9 03 00 00 00    	mov    $0x3,%r9d
  40961c:	e9 e3 fe ff ff       	jmpq   409504 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x4d4>
  409621:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  409628:	00 00 00 00 
  40962c:	0f 1f 40 00          	nopl   0x0(%rax)
    for (int ret = start_from; ret < local_stacks_num; ret++)
  409630:	45 31 d2             	xor    %r10d,%r10d
    return -1;
  409633:	b9 ff ff ff ff       	mov    $0xffffffff,%ecx
  409638:	e9 a0 fd ff ff       	jmpq   4093dd <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x3ad>
  40963d:	0f 1f 00             	nopl   (%rax)
            my_copy_stack(ds);
  409640:	48 8b 54 0e f8       	mov    -0x8(%rsi,%rcx,1),%rdx
  409645:	48 89 c7             	mov    %rax,%rdi
  409648:	48 89 54 08 f8       	mov    %rdx,-0x8(%rax,%rcx,1)
  40964d:	48 83 e9 01          	sub    $0x1,%rcx
  409651:	48 c1 e9 03          	shr    $0x3,%rcx
  409655:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  409658:	48 8b 54 24 60       	mov    0x60(%rsp),%rdx
  40965d:	4a 89 04 c2          	mov    %rax,(%rdx,%r8,8)
  409661:	e9 e0 fb ff ff       	jmpq   409246 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x216>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  409666:	f6 c1 04             	test   $0x4,%cl
  409669:	75 7e                	jne    4096e9 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x6b9>
  40966b:	48 85 c9             	test   %rcx,%rcx
  40966e:	0f 84 37 fe ff ff    	je     4094ab <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x47b>
  409674:	0f b6 3e             	movzbl (%rsi),%edi
  409677:	41 88 3b             	mov    %dil,(%r11)
  40967a:	f6 c1 02             	test   $0x2,%cl
  40967d:	0f 84 28 fe ff ff    	je     4094ab <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x47b>
  409683:	0f b7 74 0e fe       	movzwl -0x2(%rsi,%rcx,1),%esi
  409688:	66 41 89 74 0b fe    	mov    %si,-0x2(%r11,%rcx,1)
  40968e:	e9 18 fe ff ff       	jmpq   4094ab <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x47b>
            my_copy_stack(ds);
  409693:	8b 16                	mov    (%rsi),%edx
  409695:	89 10                	mov    %edx,(%rax)
  409697:	8b 54 0e fc          	mov    -0x4(%rsi,%rcx,1),%edx
  40969b:	89 54 08 fc          	mov    %edx,-0x4(%rax,%rcx,1)
  40969f:	48 8b 54 24 60       	mov    0x60(%rsp),%rdx
  4096a4:	eb b7                	jmp    40965d <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x62d>
        if (fcs_state_col_is_empty(state, ret))
  4096a6:	89 ce                	mov    %ecx,%esi
  4096a8:	44 89 d1             	mov    %r10d,%ecx
  4096ab:	41 89 f2             	mov    %esi,%r10d
  4096ae:	e9 2a fd ff ff       	jmpq   4093dd <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x3ad>
  4096b3:	41 83 c2 02          	add    $0x2,%r10d
  4096b7:	e9 21 fd ff ff       	jmpq   4093dd <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x3ad>
  4096bc:	41 83 c2 03          	add    $0x3,%r10d
  4096c0:	e9 18 fd ff ff       	jmpq   4093dd <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x3ad>
  4096c5:	41 83 c2 04          	add    $0x4,%r10d
  4096c9:	e9 0f fd ff ff       	jmpq   4093dd <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x3ad>
  4096ce:	41 83 c2 05          	add    $0x5,%r10d
  4096d2:	e9 06 fd ff ff       	jmpq   4093dd <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x3ad>
  4096d7:	41 83 c2 06          	add    $0x6,%r10d
  4096db:	e9 fd fc ff ff       	jmpq   4093dd <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x3ad>
  4096e0:	41 83 c2 07          	add    $0x7,%r10d
  4096e4:	e9 f4 fc ff ff       	jmpq   4093dd <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x3ad>
        fcs_copy_stack(*new_key, *(kv_ptr_new_state->val), put_cards_in_col_idx,
  4096e9:	8b 3e                	mov    (%rsi),%edi
  4096eb:	41 89 3b             	mov    %edi,(%r11)
  4096ee:	8b 74 0e fc          	mov    -0x4(%rsi,%rcx,1),%esi
  4096f2:	41 89 74 0b fc       	mov    %esi,-0x4(%r11,%rcx,1)
  4096f7:	e9 af fd ff ff       	jmpq   4094ab <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x47b>
  4096fc:	89 44 24 70          	mov    %eax,0x70(%rsp)
  409700:	e9 ed fb ff ff       	jmpq   4092f2 <fc_solve_sfs_move_freecell_cards_on_top_of_stacks+0x2c2>
  409705:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40970c:	00 00 00 00 

0000000000409710 <fc_solve_sfs_move_freecell_cards_to_founds>:
{
  409710:	41 55                	push   %r13
  409712:	41 54                	push   %r12
  409714:	55                   	push   %rbp
  409715:	53                   	push   %rbx
  409716:	48 83 ec 28          	sub    $0x28,%rsp
        const fcs_card card = fcs_freecell_card(state, fc);
  40971a:	0f b6 46 43          	movzbl 0x43(%rsi),%eax
        if (fcs_card_is_empty(card))
  40971e:	84 c0                	test   %al,%al
  409720:	75 3e                	jne    409760 <fc_solve_sfs_move_freecell_cards_to_founds+0x50>
        const fcs_card card = fcs_freecell_card(state, fc);
  409722:	0f b6 46 42          	movzbl 0x42(%rsi),%eax
        if (fcs_card_is_empty(card))
  409726:	84 c0                	test   %al,%al
  409728:	0f 85 22 01 00 00    	jne    409850 <fc_solve_sfs_move_freecell_cards_to_founds+0x140>
        const fcs_card card = fcs_freecell_card(state, fc);
  40972e:	0f b6 46 41          	movzbl 0x41(%rsi),%eax
        if (fcs_card_is_empty(card))
  409732:	84 c0                	test   %al,%al
  409734:	0f 85 46 01 00 00    	jne    409880 <fc_solve_sfs_move_freecell_cards_to_founds+0x170>
        const fcs_card card = fcs_freecell_card(state, fc);
  40973a:	0f b6 46 40          	movzbl 0x40(%rsi),%eax
        if (fcs_card_is_empty(card))
  40973e:	84 c0                	test   %al,%al
  409740:	0f 85 6a 01 00 00    	jne    4098b0 <fc_solve_sfs_move_freecell_cards_to_founds+0x1a0>
}
  409746:	48 83 c4 28          	add    $0x28,%rsp
  40974a:	5b                   	pop    %rbx
  40974b:	5d                   	pop    %rbp
  40974c:	41 5c                	pop    %r12
  40974e:	41 5d                	pop    %r13
  409750:	c3                   	retq   
  409751:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  409758:	00 00 00 00 
  40975c:	0f 1f 40 00          	nopl   0x0(%rax)
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409760:	48 89 c3             	mov    %rax,%rbx
                fcs_card_rank(card) - 1)
  409763:	41 89 c0             	mov    %eax,%r8d
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409766:	83 e3 03             	and    $0x3,%ebx
                fcs_card_rank(card) - 1)
  409769:	41 c0 f8 02          	sar    $0x2,%r8b
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  40976d:	0f be 44 1e 44       	movsbl 0x44(%rsi,%rbx,1),%eax
                fcs_card_rank(card) - 1)
  409772:	45 0f be c0          	movsbl %r8b,%r8d
  409776:	41 83 e8 01          	sub    $0x1,%r8d
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  40977a:	41 39 c0             	cmp    %eax,%r8d
  40977d:	75 a3                	jne    409722 <fc_solve_sfs_move_freecell_cards_to_founds+0x12>
    for (int fc = LOCAL_FREECELLS_NUM - 1; fc >= 0; --fc)
  40977f:	bd 03 00 00 00       	mov    $0x3,%ebp
  409784:	49 89 fd             	mov    %rdi,%r13
            sfs_check_state_begin();
  409787:	48 8b 3f             	mov    (%rdi),%rdi
  40978a:	49 89 cc             	mov    %rcx,%r12
  40978d:	48 89 d1             	mov    %rdx,%rcx
  409790:	48 89 f2             	mov    %rsi,%rdx
  409793:	48 89 e6             	mov    %rsp,%rsi
  409796:	e8 65 81 ff ff       	callq  401900 <fc_solve_sfs_check_state_begin>
            fcs_empty_freecell(new_state_key, fc);
  40979b:	48 8b 04 24          	mov    (%rsp),%rax
    if (!fc_solve_check_and_add_state(
  40979f:	48 8d 54 24 10       	lea    0x10(%rsp),%rdx
  4097a4:	48 89 e6             	mov    %rsp,%rsi
  4097a7:	c6 44 28 40 00       	movb   $0x0,0x40(%rax,%rbp,1)
            fcs_increment_foundation(
  4097ac:	80 44 18 44 01       	addb   $0x1,0x44(%rax,%rbx,1)
    const_SLOT(hard_thread, soft_thread);
  4097b1:	49 8b 5d 00          	mov    0x0(%r13),%rbx
    if (!fc_solve_check_and_add_state(
  4097b5:	48 89 df             	mov    %rbx,%rdi
  4097b8:	e8 93 82 ff ff       	callq  401a50 <fc_solve_check_and_add_state>
  4097bd:	84 c0                	test   %al,%al
  4097bf:	0f 85 1b 01 00 00    	jne    4098e0 <fc_solve_sfs_move_freecell_cards_to_founds+0x1d0>
        if (HT_FIELD(hard_thread, allocated_from_list))
  4097c5:	80 bb 18 05 00 00 00 	cmpb   $0x0,0x518(%rbx)
  4097cc:	0f 84 1e 01 00 00    	je     4098f0 <fc_solve_sfs_move_freecell_cards_to_founds+0x1e0>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  4097d2:	48 8b 93 b0 00 00 00 	mov    0xb0(%rbx),%rdx
  4097d9:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
  4097de:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  4097e1:	48 8b 04 24          	mov    (%rsp),%rax
  4097e5:	48 89 83 b0 00 00 00 	mov    %rax,0xb0(%rbx)
  4097ec:	48 8b 5c 24 10       	mov    0x10(%rsp),%rbx
    if ((!((list->num_states + (list->states != NULL)) &
  4097f1:	49 8b 44 24 08       	mov    0x8(%r12),%rax
  4097f6:	31 c9                	xor    %ecx,%ecx
  4097f8:	49 8b 14 24          	mov    (%r12),%rdx
  4097fc:	48 85 c0             	test   %rax,%rax
  4097ff:	0f 95 c1             	setne  %cl
  409802:	48 01 d1             	add    %rdx,%rcx
  409805:	f6 c1 0f             	test   $0xf,%cl
  409808:	75 19                	jne    409823 <fc_solve_sfs_move_freecell_cards_to_founds+0x113>
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  40980a:	48 8d 71 10          	lea    0x10(%rcx),%rsi
  40980e:	48 89 c7             	mov    %rax,%rdi
  409811:	48 c1 e6 04          	shl    $0x4,%rsi
  409815:	e8 56 79 ff ff       	callq  401170 <realloc@plt>
  40981a:	49 8b 14 24          	mov    (%r12),%rdx
        list->states =
  40981e:	49 89 44 24 08       	mov    %rax,0x8(%r12)
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  409823:	48 8d 4a 01          	lea    0x1(%rdx),%rcx
  409827:	48 c1 e2 04          	shl    $0x4,%rdx
  40982b:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  40982f:	48 01 d0             	add    %rdx,%rax
  409832:	49 89 0c 24          	mov    %rcx,(%r12)
  409836:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  40983a:	48 89 18             	mov    %rbx,(%rax)
}
  40983d:	48 83 c4 28          	add    $0x28,%rsp
  409841:	5b                   	pop    %rbx
  409842:	5d                   	pop    %rbp
  409843:	41 5c                	pop    %r12
  409845:	41 5d                	pop    %r13
  409847:	c3                   	retq   
  409848:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40984f:	00 
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409850:	48 89 c3             	mov    %rax,%rbx
                fcs_card_rank(card) - 1)
  409853:	41 89 c0             	mov    %eax,%r8d
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409856:	83 e3 03             	and    $0x3,%ebx
                fcs_card_rank(card) - 1)
  409859:	41 c0 f8 02          	sar    $0x2,%r8b
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  40985d:	0f be 44 1e 44       	movsbl 0x44(%rsi,%rbx,1),%eax
                fcs_card_rank(card) - 1)
  409862:	45 0f be c0          	movsbl %r8b,%r8d
  409866:	41 83 e8 01          	sub    $0x1,%r8d
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  40986a:	41 39 c0             	cmp    %eax,%r8d
  40986d:	0f 85 bb fe ff ff    	jne    40972e <fc_solve_sfs_move_freecell_cards_to_founds+0x1e>
    for (int fc = LOCAL_FREECELLS_NUM - 1; fc >= 0; --fc)
  409873:	bd 02 00 00 00       	mov    $0x2,%ebp
  409878:	e9 07 ff ff ff       	jmpq   409784 <fc_solve_sfs_move_freecell_cards_to_founds+0x74>
  40987d:	0f 1f 00             	nopl   (%rax)
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409880:	48 89 c3             	mov    %rax,%rbx
                fcs_card_rank(card) - 1)
  409883:	c0 f8 02             	sar    $0x2,%al
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409886:	83 e3 03             	and    $0x3,%ebx
                fcs_card_rank(card) - 1)
  409889:	0f be c0             	movsbl %al,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  40988c:	44 0f be 44 1e 44    	movsbl 0x44(%rsi,%rbx,1),%r8d
                fcs_card_rank(card) - 1)
  409892:	83 e8 01             	sub    $0x1,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409895:	41 39 c0             	cmp    %eax,%r8d
  409898:	0f 85 9c fe ff ff    	jne    40973a <fc_solve_sfs_move_freecell_cards_to_founds+0x2a>
    for (int fc = LOCAL_FREECELLS_NUM - 1; fc >= 0; --fc)
  40989e:	bd 01 00 00 00       	mov    $0x1,%ebp
  4098a3:	e9 dc fe ff ff       	jmpq   409784 <fc_solve_sfs_move_freecell_cards_to_founds+0x74>
  4098a8:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  4098af:	00 
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  4098b0:	48 89 c3             	mov    %rax,%rbx
                fcs_card_rank(card) - 1)
  4098b3:	c0 f8 02             	sar    $0x2,%al
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  4098b6:	83 e3 03             	and    $0x3,%ebx
                fcs_card_rank(card) - 1)
  4098b9:	0f be c0             	movsbl %al,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  4098bc:	44 0f be 44 1e 44    	movsbl 0x44(%rsi,%rbx,1),%r8d
                fcs_card_rank(card) - 1)
  4098c2:	83 e8 01             	sub    $0x1,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  4098c5:	41 39 c0             	cmp    %eax,%r8d
  4098c8:	0f 85 78 fe ff ff    	jne    409746 <fc_solve_sfs_move_freecell_cards_to_founds+0x36>
    for (int fc = LOCAL_FREECELLS_NUM - 1; fc >= 0; --fc)
  4098ce:	31 ed                	xor    %ebp,%ebp
  4098d0:	e9 af fe ff ff       	jmpq   409784 <fc_solve_sfs_move_freecell_cards_to_founds+0x74>
  4098d5:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4098dc:	00 00 00 00 
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  4098e0:	48 8b 1c 24          	mov    (%rsp),%rbx
  4098e4:	e9 08 ff ff ff       	jmpq   4097f1 <fc_solve_sfs_move_freecell_cards_to_founds+0xe1>
  4098e9:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
  4098f0:	48 8b 83 f0 00 00 00 	mov    0xf0(%rbx),%rax
  4098f7:	48 89 83 e8 00 00 00 	mov    %rax,0xe8(%rbx)
  4098fe:	e9 e9 fe ff ff       	jmpq   4097ec <fc_solve_sfs_move_freecell_cards_to_founds+0xdc>
  409903:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40990a:	00 00 00 00 
  40990e:	66 90                	xchg   %ax,%ax

0000000000409910 <fc_solve_sfs_move_top_stack_cards_to_founds>:
{
  409910:	41 56                	push   %r14
  409912:	41 55                	push   %r13
  409914:	41 54                	push   %r12
  409916:	55                   	push   %rbp
  409917:	53                   	push   %rbx
  409918:	48 83 ec 20          	sub    $0x20,%rsp
        var_AUTO(col, fcs_state_get_col(state, stack_idx));
  40991c:	4c 8b 06             	mov    (%rsi),%r8
        const size_t cards_num = fcs_col_len(col);
  40991f:	49 0f be 00          	movsbq (%r8),%rax
        if (!cards_num)
  409923:	48 85 c0             	test   %rax,%rax
  409926:	0f 85 84 00 00 00    	jne    4099b0 <fc_solve_sfs_move_top_stack_cards_to_founds+0xa0>
        var_AUTO(col, fcs_state_get_col(state, stack_idx));
  40992c:	4c 8b 46 08          	mov    0x8(%rsi),%r8
        const size_t cards_num = fcs_col_len(col);
  409930:	49 0f be 00          	movsbq (%r8),%rax
        if (!cards_num)
  409934:	48 85 c0             	test   %rax,%rax
  409937:	0f 85 93 01 00 00    	jne    409ad0 <fc_solve_sfs_move_top_stack_cards_to_founds+0x1c0>
        var_AUTO(col, fcs_state_get_col(state, stack_idx));
  40993d:	4c 8b 46 10          	mov    0x10(%rsi),%r8
        const size_t cards_num = fcs_col_len(col);
  409941:	49 0f be 00          	movsbq (%r8),%rax
        if (!cards_num)
  409945:	48 85 c0             	test   %rax,%rax
  409948:	0f 85 b2 01 00 00    	jne    409b00 <fc_solve_sfs_move_top_stack_cards_to_founds+0x1f0>
        var_AUTO(col, fcs_state_get_col(state, stack_idx));
  40994e:	4c 8b 46 18          	mov    0x18(%rsi),%r8
        const size_t cards_num = fcs_col_len(col);
  409952:	49 0f be 00          	movsbq (%r8),%rax
        if (!cards_num)
  409956:	48 85 c0             	test   %rax,%rax
  409959:	0f 85 d1 01 00 00    	jne    409b30 <fc_solve_sfs_move_top_stack_cards_to_founds+0x220>
        var_AUTO(col, fcs_state_get_col(state, stack_idx));
  40995f:	4c 8b 46 20          	mov    0x20(%rsi),%r8
        const size_t cards_num = fcs_col_len(col);
  409963:	49 0f be 00          	movsbq (%r8),%rax
        if (!cards_num)
  409967:	48 85 c0             	test   %rax,%rax
  40996a:	0f 85 f0 01 00 00    	jne    409b60 <fc_solve_sfs_move_top_stack_cards_to_founds+0x250>
        var_AUTO(col, fcs_state_get_col(state, stack_idx));
  409970:	4c 8b 46 28          	mov    0x28(%rsi),%r8
        const size_t cards_num = fcs_col_len(col);
  409974:	49 0f be 00          	movsbq (%r8),%rax
        if (!cards_num)
  409978:	48 85 c0             	test   %rax,%rax
  40997b:	0f 85 0f 02 00 00    	jne    409b90 <fc_solve_sfs_move_top_stack_cards_to_founds+0x280>
        var_AUTO(col, fcs_state_get_col(state, stack_idx));
  409981:	4c 8b 46 30          	mov    0x30(%rsi),%r8
        const size_t cards_num = fcs_col_len(col);
  409985:	49 0f be 00          	movsbq (%r8),%rax
        if (!cards_num)
  409989:	48 85 c0             	test   %rax,%rax
  40998c:	0f 85 2e 02 00 00    	jne    409bc0 <fc_solve_sfs_move_top_stack_cards_to_founds+0x2b0>
        var_AUTO(col, fcs_state_get_col(state, stack_idx));
  409992:	4c 8b 46 38          	mov    0x38(%rsi),%r8
        const size_t cards_num = fcs_col_len(col);
  409996:	49 0f be 00          	movsbq (%r8),%rax
        if (!cards_num)
  40999a:	48 85 c0             	test   %rax,%rax
  40999d:	0f 85 5d 02 00 00    	jne    409c00 <fc_solve_sfs_move_top_stack_cards_to_founds+0x2f0>
}
  4099a3:	48 83 c4 20          	add    $0x20,%rsp
  4099a7:	5b                   	pop    %rbx
  4099a8:	5d                   	pop    %rbp
  4099a9:	41 5c                	pop    %r12
  4099ab:	41 5d                	pop    %r13
  4099ad:	41 5e                	pop    %r14
  4099af:	c3                   	retq   
        const fcs_card card = fcs_col_get_card(col, cards_num - 1);
  4099b0:	41 0f b6 1c 00       	movzbl (%r8,%rax,1),%ebx
                fcs_card_rank(card) - 1)
  4099b5:	89 d8                	mov    %ebx,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  4099b7:	83 e3 03             	and    $0x3,%ebx
  4099ba:	44 0f be 44 1e 44    	movsbl 0x44(%rsi,%rbx,1),%r8d
                fcs_card_rank(card) - 1)
  4099c0:	c0 f8 02             	sar    $0x2,%al
  4099c3:	0f be c0             	movsbl %al,%eax
  4099c6:	83 e8 01             	sub    $0x1,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  4099c9:	44 39 c0             	cmp    %r8d,%eax
  4099cc:	0f 85 5a ff ff ff    	jne    40992c <fc_solve_sfs_move_top_stack_cards_to_founds+0x1c>
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  4099d2:	31 ed                	xor    %ebp,%ebp
  4099d4:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  4099db:	00 00 00 00 
  4099df:	90                   	nop
    tests_define_accessors();
  4099e0:	4c 8b 37             	mov    (%rdi),%r14
  4099e3:	49 89 cc             	mov    %rcx,%r12
  4099e6:	49 89 fd             	mov    %rdi,%r13
  4099e9:	48 89 d1             	mov    %rdx,%rcx
  4099ec:	48 89 f2             	mov    %rsi,%rdx
            sfs_check_state_begin();
  4099ef:	48 89 e6             	mov    %rsp,%rsi
  4099f2:	4c 89 f7             	mov    %r14,%rdi
  4099f5:	e8 06 7f ff ff       	callq  401900 <fc_solve_sfs_check_state_begin>
            my_copy_stack(stack_idx);
  4099fa:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
  4099ff:	8b 50 14             	mov    0x14(%rax),%edx
  409a02:	0f a3 ea             	bt     %ebp,%edx
  409a05:	0f 83 25 02 00 00    	jae    409c30 <fc_solve_sfs_move_top_stack_cards_to_founds+0x320>
  409a0b:	48 8b 04 24          	mov    (%rsp),%rax
  409a0f:	48 8b 14 e8          	mov    (%rax,%rbp,8),%rdx
    fcs_col_pop_top(col);
  409a13:	0f b6 02             	movzbl (%rdx),%eax
    if (!fc_solve_check_and_add_state(
  409a16:	48 89 e6             	mov    %rsp,%rsi
  409a19:	83 e8 01             	sub    $0x1,%eax
  409a1c:	88 02                	mov    %al,(%rdx)
  409a1e:	48 0f be c0          	movsbq %al,%rax
  409a22:	c6 44 02 01 00       	movb   $0x0,0x1(%rdx,%rax,1)
            fcs_increment_foundation(
  409a27:	48 8b 04 24          	mov    (%rsp),%rax
  409a2b:	48 8d 54 24 10       	lea    0x10(%rsp),%rdx
  409a30:	80 44 18 44 01       	addb   $0x1,0x44(%rax,%rbx,1)
    const_SLOT(hard_thread, soft_thread);
  409a35:	49 8b 5d 00          	mov    0x0(%r13),%rbx
    if (!fc_solve_check_and_add_state(
  409a39:	48 89 df             	mov    %rbx,%rdi
  409a3c:	e8 0f 80 ff ff       	callq  401a50 <fc_solve_check_and_add_state>
  409a41:	84 c0                	test   %al,%al
  409a43:	0f 85 a7 01 00 00    	jne    409bf0 <fc_solve_sfs_move_top_stack_cards_to_founds+0x2e0>
        if (HT_FIELD(hard_thread, allocated_from_list))
  409a49:	80 bb 18 05 00 00 00 	cmpb   $0x0,0x518(%rbx)
  409a50:	0f 84 3a 02 00 00    	je     409c90 <fc_solve_sfs_move_top_stack_cards_to_founds+0x380>
            ptr_new_state_foo->parent = instance->list_of_vacant_states;
  409a56:	48 8b 93 b0 00 00 00 	mov    0xb0(%rbx),%rdx
  409a5d:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
  409a62:	48 89 10             	mov    %rdx,(%rax)
            instance->list_of_vacant_states =
  409a65:	48 8b 04 24          	mov    (%rsp),%rax
  409a69:	48 89 83 b0 00 00 00 	mov    %rax,0xb0(%rbx)
  409a70:	48 8b 5c 24 10       	mov    0x10(%rsp),%rbx
    if ((!((list->num_states + (list->states != NULL)) &
  409a75:	49 8b 44 24 08       	mov    0x8(%r12),%rax
  409a7a:	31 c9                	xor    %ecx,%ecx
  409a7c:	49 8b 14 24          	mov    (%r12),%rdx
  409a80:	48 85 c0             	test   %rax,%rax
  409a83:	0f 95 c1             	setne  %cl
  409a86:	48 01 d1             	add    %rdx,%rcx
  409a89:	f6 c1 0f             	test   $0xf,%cl
  409a8c:	75 19                	jne    409aa7 <fc_solve_sfs_move_top_stack_cards_to_founds+0x197>
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  409a8e:	48 8d 71 10          	lea    0x10(%rcx),%rsi
  409a92:	48 89 c7             	mov    %rax,%rdi
  409a95:	48 c1 e6 04          	shl    $0x4,%rsi
  409a99:	e8 d2 76 ff ff       	callq  401170 <realloc@plt>
  409a9e:	49 8b 14 24          	mov    (%r12),%rdx
        list->states =
  409aa2:	49 89 44 24 08       	mov    %rax,0x8(%r12)
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  409aa7:	48 8d 4a 01          	lea    0x1(%rdx),%rcx
  409aab:	48 c1 e2 04          	shl    $0x4,%rdx
  409aaf:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  409ab3:	48 01 d0             	add    %rdx,%rax
  409ab6:	49 89 0c 24          	mov    %rcx,(%r12)
  409aba:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  409abe:	48 89 18             	mov    %rbx,(%rax)
}
  409ac1:	48 83 c4 20          	add    $0x20,%rsp
  409ac5:	5b                   	pop    %rbx
  409ac6:	5d                   	pop    %rbp
  409ac7:	41 5c                	pop    %r12
  409ac9:	41 5d                	pop    %r13
  409acb:	41 5e                	pop    %r14
  409acd:	c3                   	retq   
  409ace:	66 90                	xchg   %ax,%ax
        const fcs_card card = fcs_col_get_card(col, cards_num - 1);
  409ad0:	41 0f b6 1c 00       	movzbl (%r8,%rax,1),%ebx
                fcs_card_rank(card) - 1)
  409ad5:	89 d8                	mov    %ebx,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409ad7:	83 e3 03             	and    $0x3,%ebx
  409ada:	44 0f be 44 1e 44    	movsbl 0x44(%rsi,%rbx,1),%r8d
                fcs_card_rank(card) - 1)
  409ae0:	c0 f8 02             	sar    $0x2,%al
  409ae3:	0f be c0             	movsbl %al,%eax
  409ae6:	83 e8 01             	sub    $0x1,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409ae9:	44 39 c0             	cmp    %r8d,%eax
  409aec:	0f 85 4b fe ff ff    	jne    40993d <fc_solve_sfs_move_top_stack_cards_to_founds+0x2d>
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  409af2:	bd 01 00 00 00       	mov    $0x1,%ebp
  409af7:	e9 e4 fe ff ff       	jmpq   4099e0 <fc_solve_sfs_move_top_stack_cards_to_founds+0xd0>
  409afc:	0f 1f 40 00          	nopl   0x0(%rax)
        const fcs_card card = fcs_col_get_card(col, cards_num - 1);
  409b00:	41 0f b6 1c 00       	movzbl (%r8,%rax,1),%ebx
                fcs_card_rank(card) - 1)
  409b05:	89 d8                	mov    %ebx,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409b07:	83 e3 03             	and    $0x3,%ebx
  409b0a:	44 0f be 44 1e 44    	movsbl 0x44(%rsi,%rbx,1),%r8d
                fcs_card_rank(card) - 1)
  409b10:	c0 f8 02             	sar    $0x2,%al
  409b13:	0f be c0             	movsbl %al,%eax
  409b16:	83 e8 01             	sub    $0x1,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409b19:	44 39 c0             	cmp    %r8d,%eax
  409b1c:	0f 85 2c fe ff ff    	jne    40994e <fc_solve_sfs_move_top_stack_cards_to_founds+0x3e>
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  409b22:	bd 02 00 00 00       	mov    $0x2,%ebp
  409b27:	e9 b4 fe ff ff       	jmpq   4099e0 <fc_solve_sfs_move_top_stack_cards_to_founds+0xd0>
  409b2c:	0f 1f 40 00          	nopl   0x0(%rax)
        const fcs_card card = fcs_col_get_card(col, cards_num - 1);
  409b30:	41 0f b6 04 00       	movzbl (%r8,%rax,1),%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409b35:	48 89 c3             	mov    %rax,%rbx
                fcs_card_rank(card) - 1)
  409b38:	c0 f8 02             	sar    $0x2,%al
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409b3b:	83 e3 03             	and    $0x3,%ebx
                fcs_card_rank(card) - 1)
  409b3e:	0f be c0             	movsbl %al,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409b41:	44 0f be 44 1e 44    	movsbl 0x44(%rsi,%rbx,1),%r8d
                fcs_card_rank(card) - 1)
  409b47:	83 e8 01             	sub    $0x1,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409b4a:	41 39 c0             	cmp    %eax,%r8d
  409b4d:	0f 85 0c fe ff ff    	jne    40995f <fc_solve_sfs_move_top_stack_cards_to_founds+0x4f>
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  409b53:	bd 03 00 00 00       	mov    $0x3,%ebp
  409b58:	e9 83 fe ff ff       	jmpq   4099e0 <fc_solve_sfs_move_top_stack_cards_to_founds+0xd0>
  409b5d:	0f 1f 00             	nopl   (%rax)
        const fcs_card card = fcs_col_get_card(col, cards_num - 1);
  409b60:	41 0f b6 04 00       	movzbl (%r8,%rax,1),%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409b65:	48 89 c3             	mov    %rax,%rbx
                fcs_card_rank(card) - 1)
  409b68:	c0 f8 02             	sar    $0x2,%al
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409b6b:	83 e3 03             	and    $0x3,%ebx
                fcs_card_rank(card) - 1)
  409b6e:	0f be c0             	movsbl %al,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409b71:	44 0f be 44 1e 44    	movsbl 0x44(%rsi,%rbx,1),%r8d
                fcs_card_rank(card) - 1)
  409b77:	83 e8 01             	sub    $0x1,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409b7a:	41 39 c0             	cmp    %eax,%r8d
  409b7d:	0f 85 ed fd ff ff    	jne    409970 <fc_solve_sfs_move_top_stack_cards_to_founds+0x60>
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  409b83:	bd 04 00 00 00       	mov    $0x4,%ebp
  409b88:	e9 53 fe ff ff       	jmpq   4099e0 <fc_solve_sfs_move_top_stack_cards_to_founds+0xd0>
  409b8d:	0f 1f 00             	nopl   (%rax)
        const fcs_card card = fcs_col_get_card(col, cards_num - 1);
  409b90:	41 0f b6 04 00       	movzbl (%r8,%rax,1),%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409b95:	48 89 c3             	mov    %rax,%rbx
                fcs_card_rank(card) - 1)
  409b98:	c0 f8 02             	sar    $0x2,%al
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409b9b:	83 e3 03             	and    $0x3,%ebx
                fcs_card_rank(card) - 1)
  409b9e:	0f be c0             	movsbl %al,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409ba1:	44 0f be 44 1e 44    	movsbl 0x44(%rsi,%rbx,1),%r8d
                fcs_card_rank(card) - 1)
  409ba7:	83 e8 01             	sub    $0x1,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409baa:	41 39 c0             	cmp    %eax,%r8d
  409bad:	0f 85 ce fd ff ff    	jne    409981 <fc_solve_sfs_move_top_stack_cards_to_founds+0x71>
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  409bb3:	bd 05 00 00 00       	mov    $0x5,%ebp
  409bb8:	e9 23 fe ff ff       	jmpq   4099e0 <fc_solve_sfs_move_top_stack_cards_to_founds+0xd0>
  409bbd:	0f 1f 00             	nopl   (%rax)
        const fcs_card card = fcs_col_get_card(col, cards_num - 1);
  409bc0:	41 0f b6 04 00       	movzbl (%r8,%rax,1),%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409bc5:	48 89 c3             	mov    %rax,%rbx
                fcs_card_rank(card) - 1)
  409bc8:	c0 f8 02             	sar    $0x2,%al
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409bcb:	83 e3 03             	and    $0x3,%ebx
                fcs_card_rank(card) - 1)
  409bce:	0f be c0             	movsbl %al,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409bd1:	44 0f be 44 1e 44    	movsbl 0x44(%rsi,%rbx,1),%r8d
                fcs_card_rank(card) - 1)
  409bd7:	83 e8 01             	sub    $0x1,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409bda:	41 39 c0             	cmp    %eax,%r8d
  409bdd:	0f 85 af fd ff ff    	jne    409992 <fc_solve_sfs_move_top_stack_cards_to_founds+0x82>
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  409be3:	bd 06 00 00 00       	mov    $0x6,%ebp
  409be8:	e9 f3 fd ff ff       	jmpq   4099e0 <fc_solve_sfs_move_top_stack_cards_to_founds+0xd0>
  409bed:	0f 1f 00             	nopl   (%rax)
        return INFO_STATE_PTR(raw_ptr_new_state_raw);
  409bf0:	48 8b 1c 24          	mov    (%rsp),%rbx
  409bf4:	e9 7c fe ff ff       	jmpq   409a75 <fc_solve_sfs_move_top_stack_cards_to_founds+0x165>
  409bf9:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
        const fcs_card card = fcs_col_get_card(col, cards_num - 1);
  409c00:	41 0f b6 04 00       	movzbl (%r8,%rax,1),%eax
    for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  409c05:	bd 07 00 00 00       	mov    $0x7,%ebp
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409c0a:	48 89 c3             	mov    %rax,%rbx
                fcs_card_rank(card) - 1)
  409c0d:	c0 f8 02             	sar    $0x2,%al
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409c10:	83 e3 03             	and    $0x3,%ebx
                fcs_card_rank(card) - 1)
  409c13:	0f be c0             	movsbl %al,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409c16:	44 0f be 44 1e 44    	movsbl 0x44(%rsi,%rbx,1),%r8d
                fcs_card_rank(card) - 1)
  409c1c:	83 e8 01             	sub    $0x1,%eax
            if (fcs_foundation_value(state, deck * 4 + fcs_card_suit(card)) !=
  409c1f:	41 39 c0             	cmp    %eax,%r8d
  409c22:	0f 85 7b fd ff ff    	jne    4099a3 <fc_solve_sfs_move_top_stack_cards_to_founds+0x93>
  409c28:	e9 b3 fd ff ff       	jmpq   4099e0 <fc_solve_sfs_move_top_stack_cards_to_founds+0xd0>
  409c2d:	0f 1f 00             	nopl   (%rax)
            my_copy_stack(stack_idx);
  409c30:	89 e9                	mov    %ebp,%ecx
  409c32:	be 01 00 00 00       	mov    $0x1,%esi
  409c37:	4c 63 c5             	movslq %ebp,%r8
  409c3a:	d3 e6                	shl    %cl,%esi
  409c3c:	48 8b 0c 24          	mov    (%rsp),%rcx
  409c40:	c1 e5 07             	shl    $0x7,%ebp
  409c43:	09 f2                	or     %esi,%edx
  409c45:	89 50 14             	mov    %edx,0x14(%rax)
  409c48:	48 63 c5             	movslq %ebp,%rax
  409c4b:	49 8d 94 06 00 01 00 	lea    0x100(%r14,%rax,1),%rdx
  409c52:	00 
  409c53:	4a 8b 34 c1          	mov    (%rcx,%r8,8),%rsi
  409c57:	0f be 06             	movsbl (%rsi),%eax
  409c5a:	83 c0 01             	add    $0x1,%eax
  409c5d:	48 98                	cltq   
  409c5f:	48 83 f8 08          	cmp    $0x8,%rax
  409c63:	73 4b                	jae    409cb0 <fc_solve_sfs_move_top_stack_cards_to_founds+0x3a0>
  409c65:	a8 04                	test   $0x4,%al
  409c67:	75 65                	jne    409cce <fc_solve_sfs_move_top_stack_cards_to_founds+0x3be>
  409c69:	48 85 c0             	test   %rax,%rax
  409c6c:	74 0d                	je     409c7b <fc_solve_sfs_move_top_stack_cards_to_founds+0x36b>
  409c6e:	0f b6 0e             	movzbl (%rsi),%ecx
  409c71:	88 0a                	mov    %cl,(%rdx)
  409c73:	48 8b 0c 24          	mov    (%rsp),%rcx
  409c77:	a8 02                	test   $0x2,%al
  409c79:	75 65                	jne    409ce0 <fc_solve_sfs_move_top_stack_cards_to_founds+0x3d0>
  409c7b:	4a 89 14 c1          	mov    %rdx,(%rcx,%r8,8)
  409c7f:	e9 8f fd ff ff       	jmpq   409a13 <fc_solve_sfs_move_top_stack_cards_to_founds+0x103>
  409c84:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  409c8b:	00 00 00 00 
  409c8f:	90                   	nop
  409c90:	48 8b 83 f0 00 00 00 	mov    0xf0(%rbx),%rax
  409c97:	48 89 83 e8 00 00 00 	mov    %rax,0xe8(%rbx)
  409c9e:	e9 cd fd ff ff       	jmpq   409a70 <fc_solve_sfs_move_top_stack_cards_to_founds+0x160>
  409ca3:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  409caa:	00 00 00 00 
  409cae:	66 90                	xchg   %ax,%ax
  409cb0:	48 8b 4c 06 f8       	mov    -0x8(%rsi,%rax,1),%rcx
  409cb5:	48 89 d7             	mov    %rdx,%rdi
  409cb8:	48 89 4c 02 f8       	mov    %rcx,-0x8(%rdx,%rax,1)
  409cbd:	48 8d 48 ff          	lea    -0x1(%rax),%rcx
  409cc1:	48 c1 e9 03          	shr    $0x3,%rcx
  409cc5:	f3 48 a5             	rep movsq %ds:(%rsi),%es:(%rdi)
  409cc8:	48 8b 0c 24          	mov    (%rsp),%rcx
  409ccc:	eb ad                	jmp    409c7b <fc_solve_sfs_move_top_stack_cards_to_founds+0x36b>
  409cce:	8b 0e                	mov    (%rsi),%ecx
  409cd0:	89 0a                	mov    %ecx,(%rdx)
  409cd2:	8b 4c 06 fc          	mov    -0x4(%rsi,%rax,1),%ecx
  409cd6:	89 4c 02 fc          	mov    %ecx,-0x4(%rdx,%rax,1)
  409cda:	48 8b 0c 24          	mov    (%rsp),%rcx
  409cde:	eb 9b                	jmp    409c7b <fc_solve_sfs_move_top_stack_cards_to_founds+0x36b>
  409ce0:	0f b7 4c 06 fe       	movzwl -0x2(%rsi,%rax,1),%ecx
  409ce5:	66 89 4c 02 fe       	mov    %cx,-0x2(%rdx,%rax,1)
  409cea:	48 8b 0c 24          	mov    (%rsp),%rcx
  409cee:	eb 8b                	jmp    409c7b <fc_solve_sfs_move_top_stack_cards_to_founds+0x36b>

0000000000409cf0 <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))
{
  409cf0:	41 57                	push   %r15
  409cf2:	41 56                	push   %r14
  409cf4:	41 55                	push   %r13
  409cf6:	41 54                	push   %r12
  409cf8:	49 89 f4             	mov    %rsi,%r12
  409cfb:	55                   	push   %rbp
  409cfc:	48 89 fd             	mov    %rdi,%rbp
  409cff:	53                   	push   %rbx
  409d00:	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);
  409d04:	4c 8b 2f             	mov    (%rdi),%r13
    const_SLOT(groups, moves_order);
  409d07:	4c 8b 77 08          	mov    0x8(%rdi),%r14
    for (size_t group_idx = 0; group_idx < num; ++group_idx)
  409d0b:	4d 85 ed             	test   %r13,%r13
  409d0e:	74 24                	je     409d34 <fc_solve_apply_moves_order+0x44>
  409d10:	4d 69 ed e8 00 00 00 	imul   $0xe8,%r13,%r13
  409d17:	4c 89 f3             	mov    %r14,%rbx
  409d1a:	4d 01 f5             	add    %r14,%r13
  409d1d:	0f 1f 00             	nopl   (%rax)
    {
        free(groups[group_idx].move_funcs);
  409d20:	48 8b 3b             	mov    (%rbx),%rdi
  409d23:	48 81 c3 e8 00 00 00 	add    $0xe8,%rbx
  409d2a:	e8 21 73 ff ff       	callq  401050 <free@plt>
    for (size_t group_idx = 0; group_idx < num; ++group_idx)
  409d2f:	49 39 dd             	cmp    %rbx,%r13
  409d32:	75 ec                	jne    409d20 <fc_solve_apply_moves_order+0x30>
    }
    free(groups);
  409d34:	4c 89 f7             	mov    %r14,%rdi
  409d37:	e8 14 73 ff ff       	callq  401050 <free@plt>
    size_t i;
    moves_order__free(moves_order);
    moves_order->groups = SMALLOC(moves_order->groups, MOVES_GROW_BY);
  409d3c:	bf 80 0e 00 00       	mov    $0xe80,%edi
  409d41:	e8 aa 73 ff ff       	callq  4010f0 <malloc@plt>
    moves_order->groups[moves_order->num].num = 0;
    moves_order->groups[moves_order->num].move_funcs = SMALLOC(
  409d46:	bf 80 00 00 00       	mov    $0x80,%edi
    moves_order->groups = SMALLOC(moves_order->groups, MOVES_GROW_BY);
  409d4b:	48 89 45 08          	mov    %rax,0x8(%rbp)
  409d4f:	49 89 c5             	mov    %rax,%r13
    moves_order->groups[moves_order->num].num = 0;
  409d52:	48 c7 40 08 00 00 00 	movq   $0x0,0x8(%rax)
  409d59:	00 
    moves_order->groups[moves_order->num].move_funcs = SMALLOC(
  409d5a:	e8 91 73 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;
  409d5f:	41 c7 45 10 00 00 00 	movl   $0x0,0x10(%r13)
  409d66:	00 

    ++moves_order->num;

    const_AUTO(len, strlen(string));
  409d67:	4c 89 e7             	mov    %r12,%rdi
    moves_order->groups[moves_order->num].move_funcs = SMALLOC(
  409d6a:	49 89 45 00          	mov    %rax,0x0(%r13)
    ++moves_order->num;
  409d6e:	48 c7 45 00 01 00 00 	movq   $0x1,0x0(%rbp)
  409d75:	00 
    const_AUTO(len, strlen(string));
  409d76:	e8 f5 72 ff ff       	callq  401070 <strlen@plt>
  409d7b:	48 89 44 24 08       	mov    %rax,0x8(%rsp)
#else
#define SET_ERR(s)
#endif
#endif

    for (i = 0; i < len; i++)
  409d80:	48 85 c0             	test   %rax,%rax
  409d83:	0f 84 87 03 00 00    	je     40a110 <fc_solve_apply_moves_order+0x420>
  409d89:	ba 01 00 00 00       	mov    $0x1,%edx
  409d8e:	31 c9                	xor    %ecx,%ecx
  409d90:	eb 4f                	jmp    409de1 <fc_solve_apply_moves_order+0xf1>
  409d92:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  409d99:	00 00 00 00 
  409d9d:	0f 1f 00             	nopl   (%rax)
    {
        if ((string[i] == '(') || (string[i] == '['))
  409da0:	3c 5b                	cmp    $0x5b,%al
  409da2:	74 5c                	je     409e00 <fc_solve_apply_moves_order+0x110>
            }
            moves_order->groups[moves_order->num - 1].shuffling_type = FCS_RAND;
            continue;
        }

        if ((string[i] == ')') || (string[i] == ']'))
  409da4:	3c 29                	cmp    $0x29,%al
  409da6:	0f 84 d4 00 00 00    	je     409e80 <fc_solve_apply_moves_order+0x190>
  409dac:	3c 5d                	cmp    $0x5d,%al
  409dae:	0f 84 cc 00 00 00    	je     409e80 <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 &
  409db4:	48 8b 4b 08          	mov    0x8(%rbx),%rcx
  409db8:	48 8b 3b             	mov    (%rbx),%rdi
  409dbb:	f6 c1 0f             	test   $0xf,%cl
  409dbe:	0f 84 2c 01 00 00    	je     409ef0 <fc_solve_apply_moves_order+0x200>
#include "fcs_back_compat.h"
#include "instance.h"

static inline int fc_solve_string_to_move_num(const char needle)
{
    return fc_solve_sfs_move_funcs_aliases[(size_t)(uint8_t)needle];
  409dc4:	0f b6 80 00 fa 40 00 	movzbl 0x40fa00(%rax),%eax
                moves_order->groups[moves_order->num - 1].move_funcs,
                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++]
  409dcb:	48 8d 71 01          	lea    0x1(%rcx),%rsi
  409dcf:	48 89 73 08          	mov    %rsi,0x8(%rbx)
            .idx = fc_solve_string_to_move_num(string[i]);
  409dd3:	48 89 04 cf          	mov    %rax,(%rdi,%rcx,8)
  409dd7:	4c 89 f1             	mov    %r14,%rcx
    for (i = 0; i < len; i++)
  409dda:	4c 39 74 24 08       	cmp    %r14,0x8(%rsp)
  409ddf:	76 79                	jbe    409e5a <fc_solve_apply_moves_order+0x16a>
        if ((string[i] == '(') || (string[i] == '['))
  409de1:	4d 8d 0c 0c          	lea    (%r12,%rcx,1),%r9
  409de5:	4c 69 fa e8 00 00 00 	imul   $0xe8,%rdx,%r15
  409dec:	41 0f b6 01          	movzbl (%r9),%eax
  409df0:	4c 8d 71 01          	lea    0x1(%rcx),%r14
  409df4:	4b 8d 9c 3d 18 ff ff 	lea    -0xe8(%r13,%r15,1),%rbx
  409dfb:	ff 
  409dfc:	3c 28                	cmp    $0x28,%al
  409dfe:	75 a0                	jne    409da0 <fc_solve_apply_moves_order+0xb0>
            if (moves_order->groups[moves_order->num - 1].num)
  409e00:	48 83 7b 08 00       	cmpq   $0x0,0x8(%rbx)
  409e05:	74 42                	je     409e49 <fc_solve_apply_moves_order+0x159>
                if (!(moves_order->num & (MOVES_GROW_BY - 1)))
  409e07:	f6 c2 0f             	test   $0xf,%dl
  409e0a:	0f 84 e0 01 00 00    	je     409ff0 <fc_solve_apply_moves_order+0x300>
                moves_order->groups[moves_order->num].num = 0;
  409e10:	4d 01 ef             	add    %r13,%r15
                    SMALLOC(moves_order->groups[moves_order->num].move_funcs,
  409e13:	bf 80 00 00 00       	mov    $0x80,%edi
  409e18:	48 89 54 24 10       	mov    %rdx,0x10(%rsp)
                moves_order->groups[moves_order->num].num = 0;
  409e1d:	49 c7 47 08 00 00 00 	movq   $0x0,0x8(%r15)
  409e24:	00 
                    SMALLOC(moves_order->groups[moves_order->num].move_funcs,
  409e25:	e8 c6 72 ff ff       	callq  4010f0 <malloc@plt>
                moves_order->num++;
  409e2a:	48 8b 54 24 10       	mov    0x10(%rsp),%rdx
                moves_order->groups[moves_order->num].move_funcs =
  409e2f:	49 89 07             	mov    %rax,(%r15)
                moves_order->num++;
  409e32:	48 83 c2 01          	add    $0x1,%rdx
  409e36:	48 69 c2 e8 00 00 00 	imul   $0xe8,%rdx,%rax
  409e3d:	48 89 55 00          	mov    %rdx,0x0(%rbp)
  409e41:	49 8d 9c 05 18 ff ff 	lea    -0xe8(%r13,%rax,1),%rbx
  409e48:	ff 
            moves_order->groups[moves_order->num - 1].shuffling_type = FCS_RAND;
  409e49:	c7 43 10 01 00 00 00 	movl   $0x1,0x10(%rbx)
  409e50:	4c 89 f1             	mov    %r14,%rcx
    for (i = 0; i < len; i++)
  409e53:	4c 39 74 24 08       	cmp    %r14,0x8(%rsp)
  409e58:	77 87                	ja     409de1 <fc_solve_apply_moves_order+0xf1>
        SET_ERR("The Input string is too long.");
        return 4;
    }
#endif

    if (!moves_order->groups[moves_order->num - 1].num)
  409e5a:	48 83 7b 08 00       	cmpq   $0x0,0x8(%rbx)
  409e5f:	0f 84 bb 01 00 00    	je     40a020 <fc_solve_apply_moves_order+0x330>
#ifdef FCS_WITH_ERROR_STRS
    error_string[0] = '\0';
#endif

    return 0;
}
  409e65:	48 83 c4 38          	add    $0x38,%rsp
  409e69:	31 c0                	xor    %eax,%eax
  409e6b:	5b                   	pop    %rbx
  409e6c:	5d                   	pop    %rbp
  409e6d:	41 5c                	pop    %r12
  409e6f:	41 5d                	pop    %r13
  409e71:	41 5e                	pop    %r14
  409e73:	41 5f                	pop    %r15
  409e75:	c3                   	retq   
  409e76:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  409e7d:	00 00 00 
            if (string[i + 1] == '=')
  409e80:	43 80 3c 34 3d       	cmpb   $0x3d,(%r12,%r14,1)
  409e85:	0f 84 e5 00 00 00    	je     409f70 <fc_solve_apply_moves_order+0x280>
            if (moves_order->groups[moves_order->num - 1].num)
  409e8b:	48 83 7b 08 00       	cmpq   $0x0,0x8(%rbx)
  409e90:	74 42                	je     409ed4 <fc_solve_apply_moves_order+0x1e4>
                if (!(moves_order->num & (MOVES_GROW_BY - 1)))
  409e92:	f6 c2 0f             	test   $0xf,%dl
  409e95:	0f 84 a5 00 00 00    	je     409f40 <fc_solve_apply_moves_order+0x250>
                moves_order->groups[moves_order->num].num = 0;
  409e9b:	4d 01 ef             	add    %r13,%r15
                    SMALLOC(moves_order->groups[moves_order->num].move_funcs,
  409e9e:	bf 80 00 00 00       	mov    $0x80,%edi
  409ea3:	48 89 54 24 10       	mov    %rdx,0x10(%rsp)
                moves_order->groups[moves_order->num].num = 0;
  409ea8:	49 c7 47 08 00 00 00 	movq   $0x0,0x8(%r15)
  409eaf:	00 
                    SMALLOC(moves_order->groups[moves_order->num].move_funcs,
  409eb0:	e8 3b 72 ff ff       	callq  4010f0 <malloc@plt>
                moves_order->num++;
  409eb5:	48 8b 54 24 10       	mov    0x10(%rsp),%rdx
                moves_order->groups[moves_order->num].move_funcs =
  409eba:	49 89 07             	mov    %rax,(%r15)
                moves_order->num++;
  409ebd:	48 83 c2 01          	add    $0x1,%rdx
  409ec1:	48 69 c2 e8 00 00 00 	imul   $0xe8,%rdx,%rax
  409ec8:	48 89 55 00          	mov    %rdx,0x0(%rbp)
  409ecc:	49 8d 9c 05 18 ff ff 	lea    -0xe8(%r13,%rax,1),%rbx
  409ed3:	ff 
            moves_order->groups[moves_order->num - 1].shuffling_type =
  409ed4:	c7 43 10 00 00 00 00 	movl   $0x0,0x10(%rbx)
  409edb:	4c 89 f1             	mov    %r14,%rcx
  409ede:	e9 f7 fe ff ff       	jmpq   409dda <fc_solve_apply_moves_order+0xea>
  409ee3:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  409eea:	00 00 00 00 
  409eee:	66 90                	xchg   %ax,%ax
            moves_order->groups[moves_order->num - 1].move_funcs = SREALLOC(
  409ef0:	48 8d 34 cd 80 00 00 	lea    0x80(,%rcx,8),%rsi
  409ef7:	00 
  409ef8:	4c 89 4c 24 10       	mov    %r9,0x10(%rsp)
  409efd:	e8 6e 72 ff ff       	callq  401170 <realloc@plt>
  409f02:	48 8b 55 00          	mov    0x0(%rbp),%rdx
  409f06:	4c 8b 6d 08          	mov    0x8(%rbp),%r13
  409f0a:	48 89 03             	mov    %rax,(%rbx)
  409f0d:	4c 8b 4c 24 10       	mov    0x10(%rsp),%r9
  409f12:	48 69 ca e8 00 00 00 	imul   $0xe8,%rdx,%rcx
  409f19:	41 0f b6 01          	movzbl (%r9),%eax
  409f1d:	49 8d 9c 0d 18 ff ff 	lea    -0xe8(%r13,%rcx,1),%rbx
  409f24:	ff 
  409f25:	48 8b 3b             	mov    (%rbx),%rdi
  409f28:	48 8b 4b 08          	mov    0x8(%rbx),%rcx
  409f2c:	e9 93 fe ff ff       	jmpq   409dc4 <fc_solve_apply_moves_order+0xd4>
  409f31:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  409f38:	00 00 00 00 
  409f3c:	0f 1f 40 00          	nopl   0x0(%rax)
                    moves_order->groups = SREALLOC(
  409f40:	49 8d b7 80 0e 00 00 	lea    0xe80(%r15),%rsi
  409f47:	4c 89 ef             	mov    %r13,%rdi
  409f4a:	e8 21 72 ff ff       	callq  401170 <realloc@plt>
  409f4f:	48 8b 55 00          	mov    0x0(%rbp),%rdx
  409f53:	49 89 c5             	mov    %rax,%r13
  409f56:	48 89 45 08          	mov    %rax,0x8(%rbp)
  409f5a:	4c 69 fa e8 00 00 00 	imul   $0xe8,%rdx,%r15
  409f61:	e9 35 ff ff ff       	jmpq   409e9b <fc_solve_apply_moves_order+0x1ab>
  409f66:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  409f6d:	00 00 00 
                const char *const open_paren = strchr(string + i, '(');
  409f70:	4d 8d 4c 0c 02       	lea    0x2(%r12,%rcx,1),%r9
  409f75:	be 28 00 00 00       	mov    $0x28,%esi
  409f7a:	48 89 54 24 18       	mov    %rdx,0x18(%rsp)
  409f7f:	4c 89 cf             	mov    %r9,%rdi
  409f82:	4c 89 4c 24 10       	mov    %r9,0x10(%rsp)
  409f87:	e8 d4 70 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);
  409f8c:	4c 8b 4c 24 10       	mov    0x10(%rsp),%r9
  409f91:	4c 8d 70 01          	lea    0x1(%rax),%r14
  409f95:	48 89 c1             	mov    %rax,%rcx

    return (
        (check_len == strlen(prefix)) && (!strncmp(str, prefix, check_len)));
  409f98:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
    register const size_t check_len = (size_t)(end - str);
  409f9d:	4c 29 c9             	sub    %r9,%rcx
        (check_len == strlen(prefix)) && (!strncmp(str, prefix, check_len)));
  409fa0:	48 83 f9 04          	cmp    $0x4,%rcx
  409fa4:	0f 84 76 01 00 00    	je     40a120 <fc_solve_apply_moves_order+0x430>
  409faa:	48 83 f9 03          	cmp    $0x3,%rcx
  409fae:	0f 84 ac 00 00 00    	je     40a060 <fc_solve_apply_moves_order+0x370>
                const char *const close_paren = strchr(aft_open_paren, ')');
  409fb4:	be 29 00 00 00       	mov    $0x29,%esi
  409fb9:	4c 89 f7             	mov    %r14,%rdi
  409fbc:	48 89 54 24 10       	mov    %rdx,0x10(%rsp)
  409fc1:	e8 9a 70 ff ff       	callq  401060 <strchr@plt>
                if (moves_order->groups[moves_order->num - 1].shuffling_type ==
  409fc6:	83 7b 10 02          	cmpl   $0x2,0x10(%rbx)
  409fca:	48 8b 54 24 10       	mov    0x10(%rsp),%rdx
  409fcf:	0f 84 b4 00 00 00    	je     40a089 <fc_solve_apply_moves_order+0x399>
                i = close_paren - string;
  409fd5:	4c 29 e0             	sub    %r12,%rax
  409fd8:	4c 8d 70 01          	lea    0x1(%rax),%r14
  409fdc:	e9 aa fe ff ff       	jmpq   409e8b <fc_solve_apply_moves_order+0x19b>
  409fe1:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  409fe8:	00 00 00 00 
  409fec:	0f 1f 40 00          	nopl   0x0(%rax)
                    moves_order->groups = SREALLOC(
  409ff0:	49 8d b7 80 0e 00 00 	lea    0xe80(%r15),%rsi
  409ff7:	4c 89 ef             	mov    %r13,%rdi
  409ffa:	e8 71 71 ff ff       	callq  401170 <realloc@plt>
  409fff:	48 8b 55 00          	mov    0x0(%rbp),%rdx
  40a003:	49 89 c5             	mov    %rax,%r13
  40a006:	48 89 45 08          	mov    %rax,0x8(%rbp)
  40a00a:	4c 69 fa e8 00 00 00 	imul   $0xe8,%rdx,%r15
  40a011:	e9 fa fd ff ff       	jmpq   409e10 <fc_solve_apply_moves_order+0x120>
  40a016:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  40a01d:	00 00 00 
  40a020:	48 83 ea 01          	sub    $0x1,%rdx
  40a024:	48 69 c2 e8 00 00 00 	imul   $0xe8,%rdx,%rax
        free(moves_order->groups[moves_order->num].move_funcs);
  40a02b:	49 8b 7c 05 00       	mov    0x0(%r13,%rax,1),%rdi
        --moves_order->num;
  40a030:	48 89 55 00          	mov    %rdx,0x0(%rbp)
        free(moves_order->groups[moves_order->num].move_funcs);
  40a034:	e8 17 70 ff ff       	callq  401050 <free@plt>
        moves_order->groups[moves_order->num].move_funcs = NULL;
  40a039:	48 69 45 00 e8 00 00 	imul   $0xe8,0x0(%rbp),%rax
  40a040:	00 
  40a041:	48 03 45 08          	add    0x8(%rbp),%rax
  40a045:	48 c7 00 00 00 00 00 	movq   $0x0,(%rax)
  40a04c:	e9 14 fe ff ff       	jmpq   409e65 <fc_solve_apply_moves_order+0x175>
  40a051:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40a058:	00 00 00 00 
  40a05c:	0f 1f 40 00          	nopl   0x0(%rax)
  40a060:	bf 09 f0 40 00       	mov    $0x40f009,%edi
  40a065:	b9 03 00 00 00       	mov    $0x3,%ecx
  40a06a:	4c 89 ce             	mov    %r9,%rsi
  40a06d:	f3 a6                	repz cmpsb %es:(%rdi),%ds:(%rsi)
  40a06f:	0f 85 3f ff ff ff    	jne    409fb4 <fc_solve_apply_moves_order+0x2c4>
                    moves_order->groups[moves_order->num - 1].shuffling_type =
  40a075:	c7 43 10 02 00 00 00 	movl   $0x2,0x10(%rbx)
                const char *const close_paren = strchr(aft_open_paren, ')');
  40a07c:	be 29 00 00 00       	mov    $0x29,%esi
  40a081:	4c 89 f7             	mov    %r14,%rdi
  40a084:	e8 d7 6f ff ff       	callq  401060 <strchr@plt>
                        moves_order->groups[moves_order->num - 1]
  40a089:	4c 8d bb b8 00 00 00 	lea    0xb8(%rbx),%r15
  40a090:	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 == ',')
  40a093:	41 80 3e 2c          	cmpb   $0x2c,(%r14)
  40a097:	44 89 e9             	mov    %r13d,%ecx
  40a09a:	75 0e                	jne    40a0aa <fc_solve_apply_moves_order+0x3ba>
  40a09c:	0f 1f 40 00          	nopl   0x0(%rax)
        {
            start_num++;
  40a0a0:	49 83 c6 01          	add    $0x1,%r14
        while (*start_num == ',')
  40a0a4:	41 80 3e 2c          	cmpb   $0x2c,(%r14)
  40a0a8:	74 f6                	je     40a0a0 <fc_solve_apply_moves_order+0x3b0>
        }
        if (start_num >= string_end)
  40a0aa:	49 39 c6             	cmp    %rax,%r14
  40a0ad:	0f 83 cd 00 00 00    	jae    40a180 <fc_solve_apply_moves_order+0x490>
            } while (i < FCS_NUM_BEFS_WEIGHTS);

            return;
        }
        char *end_num;
        const_AUTO(val, strtod(start_num, &end_num));
  40a0b3:	48 8d 74 24 28       	lea    0x28(%rsp),%rsi
  40a0b8:	4c 89 f7             	mov    %r14,%rdi
  40a0bb:	48 89 44 24 10       	mov    %rax,0x10(%rsp)
  40a0c0:	e8 0b 70 ff ff       	callq  4010d0 <strtod@plt>
        befs_weights[i] = max(val, 0.0);
  40a0c5:	c5 f9 2e 05 0b 6c 00 	vucomisd 0x6c0b(%rip),%xmm0        # 410cd8 <fc_solve_is_parent_buf+0xe18>
  40a0cc:	00 
  40a0cd:	48 8b 44 24 10       	mov    0x10(%rsp),%rax
  40a0d2:	0f 86 88 00 00 00    	jbe    40a160 <fc_solve_apply_moves_order+0x470>
  40a0d8:	c4 81 7b 11 04 ef    	vmovsd %xmm0,(%r15,%r13,8)
  40a0de:	49 83 c5 01          	add    $0x1,%r13
        start_num = end_num;
  40a0e2:	4c 8b 74 24 28       	mov    0x28(%rsp),%r14
    for (int i = 0; i < FCS_NUM_BEFS_WEIGHTS; ++i)
  40a0e7:	49 83 fd 06          	cmp    $0x6,%r13
  40a0eb:	75 a6                	jne    40a093 <fc_solve_apply_moves_order+0x3a3>
  40a0ed:	48 8b 55 00          	mov    0x0(%rbp),%rdx
  40a0f1:	4c 8b 6d 08          	mov    0x8(%rbp),%r13
  40a0f5:	4c 69 fa e8 00 00 00 	imul   $0xe8,%rdx,%r15
  40a0fc:	4b 8d 9c 3d 18 ff ff 	lea    -0xe8(%r13,%r15,1),%rbx
  40a103:	ff 
  40a104:	e9 cc fe ff ff       	jmpq   409fd5 <fc_solve_apply_moves_order+0x2e5>
  40a109:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
    for (i = 0; i < len; i++)
  40a110:	31 c0                	xor    %eax,%eax
  40a112:	31 d2                	xor    %edx,%edx
  40a114:	e9 12 ff ff ff       	jmpq   40a02b <fc_solve_apply_moves_order+0x33b>
  40a119:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
  40a120:	bf 04 f0 40 00       	mov    $0x40f004,%edi
  40a125:	4c 89 ce             	mov    %r9,%rsi
  40a128:	f3 a6                	repz cmpsb %es:(%rdi),%ds:(%rsi)
  40a12a:	0f 85 84 fe ff ff    	jne    409fb4 <fc_solve_apply_moves_order+0x2c4>
                    moves_order->groups[moves_order->num - 1].shuffling_type =
  40a130:	c7 43 10 01 00 00 00 	movl   $0x1,0x10(%rbx)
                const char *const close_paren = strchr(aft_open_paren, ')');
  40a137:	be 29 00 00 00       	mov    $0x29,%esi
  40a13c:	4c 89 f7             	mov    %r14,%rdi
  40a13f:	48 89 54 24 10       	mov    %rdx,0x10(%rsp)
  40a144:	e8 17 6f ff ff       	callq  401060 <strchr@plt>
  40a149:	48 8b 54 24 10       	mov    0x10(%rsp),%rdx
  40a14e:	e9 82 fe ff ff       	jmpq   409fd5 <fc_solve_apply_moves_order+0x2e5>
  40a153:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40a15a:	00 00 00 00 
  40a15e:	66 90                	xchg   %ax,%ax
        befs_weights[i] = max(val, 0.0);
  40a160:	4b c7 04 ef 00 00 00 	movq   $0x0,(%r15,%r13,8)
  40a167:	00 
  40a168:	49 83 c5 01          	add    $0x1,%r13
        start_num = end_num;
  40a16c:	4c 8b 74 24 28       	mov    0x28(%rsp),%r14
    for (int i = 0; i < FCS_NUM_BEFS_WEIGHTS; ++i)
  40a171:	49 83 fd 06          	cmp    $0x6,%r13
  40a175:	0f 85 18 ff ff ff    	jne    40a093 <fc_solve_apply_moves_order+0x3a3>
  40a17b:	e9 6d ff ff ff       	jmpq   40a0ed <fc_solve_apply_moves_order+0x3fd>
                befs_weights[i++] = 0.0;
  40a180:	48 63 f1             	movslq %ecx,%rsi
  40a183:	48 8d 14 f5 00 00 00 	lea    0x0(,%rsi,8),%rdx
  40a18a:	00 
  40a18b:	49 c7 04 f7 00 00 00 	movq   $0x0,(%r15,%rsi,8)
  40a192:	00 
            } while (i < FCS_NUM_BEFS_WEIGHTS);
  40a193:	83 f9 05             	cmp    $0x5,%ecx
  40a196:	0f 84 51 ff ff ff    	je     40a0ed <fc_solve_apply_moves_order+0x3fd>
                befs_weights[i++] = 0.0;
  40a19c:	49 c7 44 17 08 00 00 	movq   $0x0,0x8(%r15,%rdx,1)
  40a1a3:	00 00 
            } while (i < FCS_NUM_BEFS_WEIGHTS);
  40a1a5:	83 f9 04             	cmp    $0x4,%ecx
  40a1a8:	0f 84 3f ff ff ff    	je     40a0ed <fc_solve_apply_moves_order+0x3fd>
                befs_weights[i++] = 0.0;
  40a1ae:	49 c7 44 17 10 00 00 	movq   $0x0,0x10(%r15,%rdx,1)
  40a1b5:	00 00 
            } while (i < FCS_NUM_BEFS_WEIGHTS);
  40a1b7:	83 f9 02             	cmp    $0x2,%ecx
  40a1ba:	0f 8f 2d ff ff ff    	jg     40a0ed <fc_solve_apply_moves_order+0x3fd>
                befs_weights[i++] = 0.0;
  40a1c0:	49 c7 44 17 18 00 00 	movq   $0x0,0x18(%r15,%rdx,1)
  40a1c7:	00 00 
            } while (i < FCS_NUM_BEFS_WEIGHTS);
  40a1c9:	83 f9 01             	cmp    $0x1,%ecx
  40a1cc:	0f 8f 1b ff ff ff    	jg     40a0ed <fc_solve_apply_moves_order+0x3fd>
                befs_weights[i++] = 0.0;
  40a1d2:	49 c7 44 17 20 00 00 	movq   $0x0,0x20(%r15,%rdx,1)
  40a1d9:	00 00 
            } while (i < FCS_NUM_BEFS_WEIGHTS);
  40a1db:	85 c9                	test   %ecx,%ecx
  40a1dd:	0f 85 0a ff ff ff    	jne    40a0ed <fc_solve_apply_moves_order+0x3fd>
                befs_weights[i++] = 0.0;
  40a1e3:	48 c7 83 e0 00 00 00 	movq   $0x0,0xe0(%rbx)
  40a1ea:	00 00 00 00 
  40a1ee:	e9 fa fe ff ff       	jmpq   40a0ed <fc_solve_apply_moves_order+0x3fd>
  40a1f3:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40a1fa:	00 00 00 00 
  40a1fe:	66 90                	xchg   %ax,%ax

000000000040a200 <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))
{
  40a200:	41 57                	push   %r15
  40a202:	41 56                	push   %r14
  40a204:	41 55                	push   %r13
  40a206:	41 54                	push   %r12
  40a208:	55                   	push   %rbp
  40a209:	89 f5                	mov    %esi,%ebp
  40a20b:	53                   	push   %rbx
  40a20c:	48 83 ec 28          	sub    $0x28,%rsp
    return ((fcs_user *const)api_instance)->soft_thread;
  40a210:	4c 8b a7 40 06 00 00 	mov    0x640(%rdi),%r12
  40a217:	4d 8b 6c 24 10       	mov    0x10(%r12),%r13
  40a21c:	49 8b 7c 24 18       	mov    0x18(%r12),%rdi
        ALLOC_ERROR_STRING(error_string, "Depth is negative.");
        return 1;
    }

    size_t depth_idx = 0;
    if (min_depth > 0)
  40a221:	85 f6                	test   %esi,%esi
  40a223:	0f 84 b7 00 00 00    	je     40a2e0 <freecell_solver_user_set_depth_tests_order+0xe0>
    {
        for (;; ++depth_idx)
        {
            if (depth_idx == soft_thread->by_depth_moves_order.num - 1)
  40a229:	4c 89 e8             	mov    %r13,%rax
  40a22c:	48 83 e8 01          	sub    $0x1,%rax
  40a230:	0f 84 fb 01 00 00    	je     40a431 <freecell_solver_user_set_depth_tests_order+0x231>
            {
                break;
            }
            else if (min_depth <=
  40a236:	4c 63 ce             	movslq %esi,%r9
    size_t depth_idx = 0;
  40a239:	45 31 c0             	xor    %r8d,%r8d
  40a23c:	48 8d 77 18          	lea    0x18(%rdi),%rsi
            else if (min_depth <=
  40a240:	4c 39 0f             	cmp    %r9,(%rdi)
  40a243:	0f 8d 0f 02 00 00    	jge    40a458 <freecell_solver_user_set_depth_tests_order+0x258>
        for (;; ++depth_idx)
  40a249:	49 8d 48 01          	lea    0x1(%r8),%rcx
            if (depth_idx == soft_thread->by_depth_moves_order.num - 1)
  40a24d:	48 39 c1             	cmp    %rax,%rcx
  40a250:	74 1a                	je     40a26c <freecell_solver_user_set_depth_tests_order+0x6c>
  40a252:	48 83 c6 18          	add    $0x18,%rsi
            else if (min_depth <=
  40a256:	4c 39 4e e8          	cmp    %r9,-0x18(%rsi)
  40a25a:	0f 8d 7d 01 00 00    	jge    40a3dd <freecell_solver_user_set_depth_tests_order+0x1dd>
  40a260:	49 89 c8             	mov    %rcx,%r8
        for (;; ++depth_idx)
  40a263:	49 8d 48 01          	lea    0x1(%r8),%rcx
            if (depth_idx == soft_thread->by_depth_moves_order.num - 1)
  40a267:	48 39 c1             	cmp    %rax,%rcx
  40a26a:	75 e6                	jne    40a252 <freecell_solver_user_set_depth_tests_order+0x52>
  40a26c:	49 8d 45 01          	lea    0x1(%r13),%rax
  40a270:	4d 89 ee             	mov    %r13,%r14
  40a273:	48 89 44 24 08       	mov    %rax,0x8(%rsp)
  40a278:	48 8d 04 40          	lea    (%rax,%rax,2),%rax
  40a27c:	48 c1 e0 03          	shl    $0x3,%rax
  40a280:	48 89 44 24 10       	mov    %rax,0x10(%rsp)
  40a285:	48 8d 58 e8          	lea    -0x18(%rax),%rbx
  40a289:	48 89 c6             	mov    %rax,%rsi
        ++depth_idx;
    }

    if (depth_idx == soft_thread->by_depth_moves_order.num)
    {
        soft_thread->by_depth_moves_order.by_depth_moves =
  40a28c:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
  40a291:	48 89 14 24          	mov    %rdx,(%rsp)
  40a295:	49 89 44 24 10       	mov    %rax,0x10(%r12)
            SREALLOC(soft_thread->by_depth_moves_order.by_depth_moves,
  40a29a:	e8 d1 6e ff ff       	callq  401170 <realloc@plt>
  40a29f:	48 8b 14 24          	mov    (%rsp),%rdx
        soft_thread->by_depth_moves_order.by_depth_moves =
  40a2a3:	49 89 44 24 18       	mov    %rax,0x18(%r12)
            SREALLOC(soft_thread->by_depth_moves_order.by_depth_moves,
  40a2a8:	48 89 c7             	mov    %rax,%rdi
                ++soft_thread->by_depth_moves_order.num);

        soft_thread->by_depth_moves_order.by_depth_moves[depth_idx]
  40a2ab:	4b 8d 44 6d 00       	lea    0x0(%r13,%r13,2),%rax
  40a2b0:	48 8d 04 c7          	lea    (%rdi,%rax,8),%rax
            .moves_order.num = 0;
  40a2b4:	48 c7 40 08 00 00 00 	movq   $0x0,0x8(%rax)
  40a2bb:	00 
        soft_thread->by_depth_moves_order.by_depth_moves[depth_idx]
            .moves_order.groups = NULL;
  40a2bc:	48 c7 40 10 00 00 00 	movq   $0x0,0x10(%rax)
  40a2c3:	00 
    }

    if (depth_idx > 0)
  40a2c4:	4d 85 f6             	test   %r14,%r14
  40a2c7:	74 34                	je     40a2fd <freecell_solver_user_set_depth_tests_order+0xfd>
  40a2c9:	4c 63 cd             	movslq %ebp,%r9
    {
        soft_thread->by_depth_moves_order.by_depth_moves[depth_idx - 1]
            .max_depth = min_depth;
  40a2cc:	4c 89 4c 1f e8       	mov    %r9,-0x18(%rdi,%rbx,1)
  40a2d1:	eb 2a                	jmp    40a2fd <freecell_solver_user_set_depth_tests_order+0xfd>
  40a2d3:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40a2da:	00 00 00 00 
  40a2de:	66 90                	xchg   %ax,%ax
    if (depth_idx == soft_thread->by_depth_moves_order.num)
  40a2e0:	4d 85 ed             	test   %r13,%r13
  40a2e3:	0f 84 27 01 00 00    	je     40a410 <freecell_solver_user_set_depth_tests_order+0x210>
  40a2e9:	48 c7 44 24 08 01 00 	movq   $0x1,0x8(%rsp)
  40a2f0:	00 00 
  40a2f2:	31 db                	xor    %ebx,%ebx
  40a2f4:	48 c7 44 24 10 18 00 	movq   $0x18,0x10(%rsp)
  40a2fb:	00 00 
    }

    soft_thread->by_depth_moves_order.by_depth_moves[depth_idx].max_depth =
  40a2fd:	48 b8 ff ff ff ff ff 	movabs $0x7fffffffffffffff,%rax
  40a304:	ff ff 7f 
  40a307:	48 01 df             	add    %rbx,%rdi
        SSIZE_MAX;

    FCS__DECL_ERR_BUF(static_error_string);
    const int ret_code = fc_solve_apply_moves_order(
  40a30a:	48 89 d6             	mov    %rdx,%rsi
    soft_thread->by_depth_moves_order.by_depth_moves[depth_idx].max_depth =
  40a30d:	48 89 07             	mov    %rax,(%rdi)
    const int ret_code = fc_solve_apply_moves_order(
  40a310:	48 83 c7 08          	add    $0x8,%rdi
  40a314:	e8 d7 f9 ff ff       	callq  409cf0 <fc_solve_apply_moves_order>
                .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;
  40a319:	4c 8b 7c 24 08       	mov    0x8(%rsp),%r15
    const int ret_code = fc_solve_apply_moves_order(
  40a31e:	89 44 24 1c          	mov    %eax,0x1c(%rsp)
    for (size_t d = depth_idx + 1; d < soft_thread->by_depth_moves_order.num;
  40a322:	4d 39 7c 24 10       	cmp    %r15,0x10(%r12)
  40a327:	0f 86 7f 00 00 00    	jbe    40a3ac <freecell_solver_user_set_depth_tests_order+0x1ac>
  40a32d:	4f 8d 34 7f          	lea    (%r15,%r15,2),%r14
  40a331:	4a 8d 04 f5 00 00 00 	lea    0x0(,%r14,8),%rax
  40a338:	00 
  40a339:	48 89 04 24          	mov    %rax,(%rsp)
  40a33d:	0f 1f 00             	nopl   (%rax)
         ++d)
    {
        moves_order__free(
            &(soft_thread->by_depth_moves_order.by_depth_moves[d].moves_order));
  40a340:	48 8b 2c 24          	mov    (%rsp),%rbp
  40a344:	49 03 6c 24 18       	add    0x18(%r12),%rbp
    const_SLOT(num, moves_order);
  40a349:	48 8b 5d 08          	mov    0x8(%rbp),%rbx
    const_SLOT(groups, moves_order);
  40a34d:	4c 8b 6d 10          	mov    0x10(%rbp),%r13
    for (size_t group_idx = 0; group_idx < num; ++group_idx)
  40a351:	48 85 db             	test   %rbx,%rbx
  40a354:	74 2e                	je     40a384 <freecell_solver_user_set_depth_tests_order+0x184>
  40a356:	48 69 db e8 00 00 00 	imul   $0xe8,%rbx,%rbx
  40a35d:	4d 89 ee             	mov    %r13,%r14
  40a360:	4c 01 eb             	add    %r13,%rbx
  40a363:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40a36a:	00 00 00 00 
  40a36e:	66 90                	xchg   %ax,%ax
        free(groups[group_idx].move_funcs);
  40a370:	49 8b 3e             	mov    (%r14),%rdi
  40a373:	49 81 c6 e8 00 00 00 	add    $0xe8,%r14
  40a37a:	e8 d1 6c ff ff       	callq  401050 <free@plt>
    for (size_t group_idx = 0; group_idx < num; ++group_idx)
  40a37f:	49 39 de             	cmp    %rbx,%r14
  40a382:	75 ec                	jne    40a370 <freecell_solver_user_set_depth_tests_order+0x170>
    free(groups);
  40a384:	4c 89 ef             	mov    %r13,%rdi
         ++d)
  40a387:	49 83 c7 01          	add    $0x1,%r15
  40a38b:	e8 c0 6c ff ff       	callq  401050 <free@plt>
    moves_order->groups = NULL;
  40a390:	48 c7 45 10 00 00 00 	movq   $0x0,0x10(%rbp)
  40a397:	00 
  40a398:	48 83 04 24 18       	addq   $0x18,(%rsp)
    moves_order->num = 0;
  40a39d:	48 c7 45 08 00 00 00 	movq   $0x0,0x8(%rbp)
  40a3a4:	00 
    for (size_t d = depth_idx + 1; d < soft_thread->by_depth_moves_order.num;
  40a3a5:	4d 39 7c 24 10       	cmp    %r15,0x10(%r12)
  40a3aa:	77 94                	ja     40a340 <freecell_solver_user_set_depth_tests_order+0x140>
    }

    soft_thread->by_depth_moves_order.by_depth_moves =
        SREALLOC(soft_thread->by_depth_moves_order.by_depth_moves,
  40a3ac:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
  40a3b1:	49 8b 7c 24 18       	mov    0x18(%r12),%rdi
  40a3b6:	48 8b 74 24 10       	mov    0x10(%rsp),%rsi
  40a3bb:	49 89 44 24 10       	mov    %rax,0x10(%r12)
  40a3c0:	e8 ab 6d ff ff       	callq  401170 <realloc@plt>
    soft_thread->by_depth_moves_order.by_depth_moves =
  40a3c5:	49 89 44 24 18       	mov    %rax,0x18(%r12)
            soft_thread->by_depth_moves_order.num = depth_idx + 1);

    return ret_code;
}
  40a3ca:	8b 44 24 1c          	mov    0x1c(%rsp),%eax
  40a3ce:	48 83 c4 28          	add    $0x28,%rsp
  40a3d2:	5b                   	pop    %rbx
  40a3d3:	5d                   	pop    %rbp
  40a3d4:	41 5c                	pop    %r12
  40a3d6:	41 5d                	pop    %r13
  40a3d8:	41 5e                	pop    %r14
  40a3da:	41 5f                	pop    %r15
  40a3dc:	c3                   	retq   
  40a3dd:	49 8d 40 03          	lea    0x3(%r8),%rax
  40a3e1:	48 89 44 24 08       	mov    %rax,0x8(%rsp)
  40a3e6:	48 8d 04 40          	lea    (%rax,%rax,2),%rax
  40a3ea:	4d 8d 70 02          	lea    0x2(%r8),%r14
  40a3ee:	48 c1 e0 03          	shl    $0x3,%rax
  40a3f2:	48 89 44 24 10       	mov    %rax,0x10(%rsp)
  40a3f7:	48 8d 58 e8          	lea    -0x18(%rax),%rbx
    if (depth_idx == soft_thread->by_depth_moves_order.num)
  40a3fb:	4d 39 f5             	cmp    %r14,%r13
  40a3fe:	0f 85 c0 fe ff ff    	jne    40a2c4 <freecell_solver_user_set_depth_tests_order+0xc4>
  40a404:	e9 80 fe ff ff       	jmpq   40a289 <freecell_solver_user_set_depth_tests_order+0x89>
  40a409:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
  40a410:	48 c7 44 24 10 18 00 	movq   $0x18,0x10(%rsp)
  40a417:	00 00 
  40a419:	31 db                	xor    %ebx,%ebx
    size_t depth_idx = 0;
  40a41b:	45 31 f6             	xor    %r14d,%r14d
  40a41e:	48 8b 74 24 10       	mov    0x10(%rsp),%rsi
    if (depth_idx == soft_thread->by_depth_moves_order.num)
  40a423:	48 c7 44 24 08 01 00 	movq   $0x1,0x8(%rsp)
  40a42a:	00 00 
  40a42c:	e9 5b fe ff ff       	jmpq   40a28c <freecell_solver_user_set_depth_tests_order+0x8c>
            if (depth_idx == soft_thread->by_depth_moves_order.num - 1)
  40a431:	48 c7 44 24 10 30 00 	movq   $0x30,0x10(%rsp)
  40a438:	00 00 
  40a43a:	bb 18 00 00 00       	mov    $0x18,%ebx
  40a43f:	48 8b 74 24 10       	mov    0x10(%rsp),%rsi
  40a444:	41 be 01 00 00 00    	mov    $0x1,%r14d
  40a44a:	48 c7 44 24 08 02 00 	movq   $0x2,0x8(%rsp)
  40a451:	00 00 
  40a453:	e9 34 fe ff ff       	jmpq   40a28c <freecell_solver_user_set_depth_tests_order+0x8c>
            else if (min_depth <=
  40a458:	48 c7 44 24 10 30 00 	movq   $0x30,0x10(%rsp)
  40a45f:	00 00 
  40a461:	bb 18 00 00 00       	mov    $0x18,%ebx
  40a466:	48 c7 44 24 08 02 00 	movq   $0x2,0x8(%rsp)
  40a46d:	00 00 
  40a46f:	e9 58 fe ff ff       	jmpq   40a2cc <freecell_solver_user_set_depth_tests_order+0xcc>
  40a474:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40a47b:	00 00 00 00 
  40a47f:	90                   	nop

000000000040a480 <resume_solution>:
    continue
#else
#define BUMP_CURR_INST() break
#endif
static inline fc_solve_solve_process_ret_t resume_solution(fcs_user *const user)
{
  40a480:	4c 8d 54 24 08       	lea    0x8(%rsp),%r10
  40a485:	48 83 e4 e0          	and    $0xffffffffffffffe0,%rsp
  40a489:	48 89 f8             	mov    %rdi,%rax
  40a48c:	41 ff 72 f8          	pushq  -0x8(%r10)
  40a490:	55                   	push   %rbp
    return (const fcs_kv_state){.key = &(s->s), .val = &(s->info)};
  40a491:	48 05 98 05 00 00    	add    $0x598,%rax
  40a497:	48 89 e5             	mov    %rsp,%rbp
  40a49a:	41 57                	push   %r15
  40a49c:	41 56                	push   %r14
  40a49e:	41 55                	push   %r13
  40a4a0:	41 54                	push   %r12
  40a4a2:	41 52                	push   %r10
  40a4a4:	53                   	push   %rbx
  40a4a5:	48 8d 9f 50 05 00 00 	lea    0x550(%rdi),%rbx
        pass_copy = FCS_STATE_keyval_pair_to_kv(&instance->state_copy);
  40a4ac:	c4 e1 f9 6e f3       	vmovq  %rbx,%xmm6
{
  40a4b1:	48 81 ec c0 01 00 00 	sub    $0x1c0,%rsp
  40a4b8:	48 89 bd f0 fe ff ff 	mov    %rdi,-0x110(%rbp)
        pass_copy = FCS_STATE_keyval_pair_to_kv(&instance->state_copy);
  40a4bf:	c4 e3 c9 22 f0 01    	vpinsrq $0x1,%rax,%xmm6,%xmm6
  40a4c5:	48 89 9d 38 fe ff ff 	mov    %rbx,-0x1c8(%rbp)
  40a4cc:	c5 f8 29 b5 20 fe ff 	vmovaps %xmm6,-0x1e0(%rbp)
  40a4d3:	ff 

        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)
  40a4d4:	48 8b 85 f0 fe ff ff 	mov    -0x110(%rbp),%rax
  40a4db:	8b 98 b8 05 00 00    	mov    0x5b8(%rax),%ebx
  40a4e1:	85 db                	test   %ebx,%ebx
  40a4e3:	0f 84 45 35 00 00    	je     40da2e <resume_solution+0x35ae>
            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)
  40a4e9:	83 fb 01             	cmp    $0x1,%ebx
  40a4ec:	0f 84 00 35 00 00    	je     40d9f2 <resume_solution+0x3572>

        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)
  40a4f2:	83 fb 09             	cmp    $0x9,%ebx
  40a4f5:	0f 84 61 25 00 00    	je     40ca5c <resume_solution+0x25dc>
  40a4fb:	48 89 c7             	mov    %rax,%rdi
                                   user->iterations_board_started_at
                                       .num_checked_states));
        }
#endif

        user->init_num_checked_states.num_checked_states =
  40a4fe:	48 8b 00             	mov    (%rax),%rax
  40a501:	48 89 87 d0 05 00 00 	mov    %rax,0x5d0(%rdi)
#endif
            );
        }

        const bool was_run_now =
            ((flare->ret_code == FCS_STATE_SUSPEND_PROCESS) ||
  40a508:	83 eb 05             	sub    $0x5,%ebx
                (flare->ret_code == FCS_STATE_NOT_BEGAN_YET));

        if (was_run_now)
  40a50b:	83 e3 fb             	and    $0xfffffffb,%ebx
  40a50e:	89 9d 44 fe ff ff    	mov    %ebx,-0x1bc(%rbp)
  40a514:	0f 84 84 00 00 00    	je     40a59e <resume_solution+0x11e>
  40a51a:	48 8b 85 f0 fe ff ff 	mov    -0x110(%rbp),%rax
  40a521:	bb 01 00 00 00       	mov    $0x1,%ebx
  40a526:	48 8b 30             	mov    (%rax),%rsi
  40a529:	8b 80 38 06 00 00    	mov    0x638(%rax),%eax
        {
            user->all_instances_were_suspended = FALSE;
        }
#endif

        flare->obj_stats.num_checked_states = instance->i__num_checked_states;
  40a52f:	48 8b bd f0 fe ff ff 	mov    -0x110(%rbp),%rdi
#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 -
  40a536:	48 89 f2             	mov    %rsi,%rdx
        flare->obj_stats.num_checked_states = instance->i__num_checked_states;
  40a539:	48 89 b7 c0 05 00 00 	mov    %rsi,0x5c0(%rdi)
        const_AUTO(delta, flare->obj_stats.num_checked_states -
  40a540:	48 2b 97 d0 05 00 00 	sub    0x5d0(%rdi),%rdx
                              user->init_num_checked_states.num_checked_states);
        user->iterations_board_started_at.num_checked_states += delta;
  40a547:	48 01 97 c8 05 00 00 	add    %rdx,0x5c8(%rdi)
#ifndef FCS_DISABLE_NUM_STORED_STATES
        user->iterations_board_started_at.num_states_in_collection +=
            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;
  40a54e:	48 89 b7 d0 05 00 00 	mov    %rsi,0x5d0(%rdi)

        if (user->ret_code == FCS_STATE_WAS_SOLVED)
  40a555:	85 c0                	test   %eax,%eax
  40a557:	75 0f                	jne    40a568 <resume_solution+0xe8>
                    get_flare_move_count(user, flare)))
            {
                instance_item->minimal_flare = flare;
            }
#endif
            ret = user->ret_code = FCS_STATE_IS_NOT_SOLVEABLE;
  40a559:	c7 87 38 06 00 00 01 	movl   $0x1,0x638(%rdi)
  40a560:	00 00 00 
  40a563:	e9 6c ff ff ff       	jmpq   40a4d4 <resume_solution+0x54>
        }
        else if (user->ret_code == FCS_STATE_IS_NOT_SOLVEABLE)
        {
            if (was_run_now)
  40a568:	8b 95 44 fe ff ff    	mov    -0x1bc(%rbp),%edx
  40a56e:	85 d2                	test   %edx,%edx
  40a570:	75 09                	jne    40a57b <resume_solution+0xfb>
  40a572:	83 f8 01             	cmp    $0x1,%eax
  40a575:	0f 84 5c 2e 00 00    	je     40d3d7 <resume_solution+0x2f57>

    } while (
#ifdef FCS_WITH_NI
        (user->current_instance < end_of_instances_list) &&
#endif
        ret == FCS_STATE_IS_NOT_SOLVEABLE);
  40a57b:	83 fb 01             	cmp    $0x1,%ebx
  40a57e:	0f 84 50 ff ff ff    	je     40a4d4 <resume_solution+0x54>
    return (
        user->all_instances_were_suspended ? FCS_STATE_SUSPEND_PROCESS : ret);
#else
    return ret;
#endif
}
  40a584:	48 81 c4 c0 01 00 00 	add    $0x1c0,%rsp
  40a58b:	89 d8                	mov    %ebx,%eax
  40a58d:	5b                   	pop    %rbx
  40a58e:	41 5a                	pop    %r10
  40a590:	41 5c                	pop    %r12
  40a592:	41 5d                	pop    %r13
  40a594:	41 5e                	pop    %r14
  40a596:	41 5f                	pop    %r15
  40a598:	5d                   	pop    %rbp
  40a599:	49 8d 62 f8          	lea    -0x8(%r10),%rsp
  40a59d:	c3                   	retq   
    fc_solve_solve_process_ret_t ret = FCS_STATE_SUSPEND_PROCESS;
  40a59e:	bb 05 00 00 00       	mov    $0x5,%ebx
        while (instance->num_hard_threads_finished < NUM_HARD_THREADS())
  40a5a3:	48 8b 85 f0 fe ff ff 	mov    -0x110(%rbp),%rax
  40a5aa:	48 8b 80 40 05 00 00 	mov    0x540(%rax),%rax
  40a5b1:	48 85 c0             	test   %rax,%rax
  40a5b4:	0f 85 46 27 00 00    	jne    40cd00 <resume_solution+0x2880>
    const size_t prelude_num_items = HT_FIELD(hard_thread, prelude_num_items);
  40a5ba:	48 8b 85 f0 fe ff ff 	mov    -0x110(%rbp),%rax
  40a5c1:	48 8b 98 00 05 00 00 	mov    0x500(%rax),%rbx
  40a5c8:	48 63 88 28 05 00 00 	movslq 0x528(%rax),%rcx
  40a5cf:	48 89 9d 68 fe ff ff 	mov    %rbx,-0x198(%rbp)
    const int_fast32_t num_soft_threads =
  40a5d6:	48 8b 98 20 05 00 00 	mov    0x520(%rax),%rbx
  40a5dd:	48 89 9d 88 fe ff ff 	mov    %rbx,-0x178(%rbp)
    const fc_solve_prelude_item *const prelude = HT_FIELD(hard_thread, prelude);
  40a5e4:	48 8b 98 10 05 00 00 	mov    0x510(%rax),%rbx
  40a5eb:	48 89 9d 48 fe ff ff 	mov    %rbx,-0x1b8(%rbp)
    fcs_soft_thread *const soft_threads = HT_FIELD(hard_thread, soft_threads);
  40a5f2:	48 8b 98 c0 00 00 00 	mov    0xc0(%rax),%rbx
  40a5f9:	48 89 9d 80 fe ff ff 	mov    %rbx,-0x180(%rbp)
    fc_solve_solve_process_ret_t ret = FCS_STATE_SUSPEND_PROCESS;
  40a600:	bb 05 00 00 00       	mov    $0x5,%ebx
    while (HT_FIELD(hard_thread, num_soft_threads_finished) < num_soft_threads)
  40a605:	48 39 8d 88 fe ff ff 	cmp    %rcx,-0x178(%rbp)
  40a60c:	0f 8e a2 03 00 00    	jle    40a9b4 <resume_solution+0x534>
        fcs_soft_thread *const soft_thread = &(soft_threads[*st_idx_ptr]);
  40a612:	48 8b 85 f0 fe ff ff 	mov    -0x110(%rbp),%rax
  40a619:	48 8b bd 80 fe ff ff 	mov    -0x180(%rbp),%rdi
  40a620:	48 8b 90 d0 00 00 00 	mov    0xd0(%rax),%rdx
  40a627:	48 89 d0             	mov    %rdx,%rax
  40a62a:	48 c1 e0 06          	shl    $0x6,%rax
  40a62e:	48 29 d0             	sub    %rdx,%rax
  40a631:	4c 8d 3c c7          	lea    (%rdi,%rax,8),%r15
        if (STRUCT_QUERY_FLAG(soft_thread, FCS_SOFT_THREAD_IS_FINISHED))
  40a635:	41 80 bf e0 01 00 00 	cmpb   $0x0,0x1e0(%r15)
  40a63c:	00 
  40a63d:	0f 85 8d 1c 00 00    	jne    40c2d0 <resume_solution+0x1e50>
        if (!STRUCT_QUERY_FLAG(soft_thread, FCS_SOFT_THREAD_INITIALIZED))
  40a643:	41 80 bf e1 01 00 00 	cmpb   $0x0,0x1e1(%r15)
  40a64a:	00 
  40a64b:	0f 84 cc 15 00 00    	je     40bc1d <resume_solution+0x179d>
  40a651:	49 8b 07             	mov    (%r15),%rax
  40a654:	48 89 85 28 ff ff ff 	mov    %rax,-0xd8(%rbp)
    switch (soft_thread->super_method_type)
  40a65b:	41 8b 4f 20          	mov    0x20(%r15),%ecx
  40a65f:	85 c9                	test   %ecx,%ecx
  40a661:	0f 84 81 0a 00 00    	je     40b0e8 <resume_solution+0xc68>
    const bool scans_synergy =
  40a667:	48 8b 85 28 ff ff ff 	mov    -0xd8(%rbp),%rax
    PTR_STATE = BEFS_M_VAR(soft_thread, first_state_to_check);
  40a66e:	49 8b 9f d8 01 00 00 	mov    0x1d8(%r15),%rbx
    const_AUTO(soft_thread_id, soft_thread->id);
  40a675:	41 8b 4f 08          	mov    0x8(%r15),%ecx
    const bool scans_synergy =
  40a679:	0f b6 80 b8 00 00 00 	movzbl 0xb8(%rax),%eax
    FCS_ASSIGN_STATE_KEY();
  40a680:	c4 e1 f9 6e f3       	vmovq  %rbx,%xmm6
    const bool scans_synergy =
  40a685:	88 85 d3 fe ff ff    	mov    %al,-0x12d(%rbp)
    const bool is_a_complete_scan =
  40a68b:	41 0f b6 87 e2 01 00 	movzbl 0x1e2(%r15),%eax
  40a692:	00 
    fcs_derived_states_list derived = {.num_states = 0, .states = NULL};
  40a693:	48 c7 85 50 ff ff ff 	movq   $0x0,-0xb0(%rbp)
  40a69a:	00 00 00 00 
  40a69e:	48 c7 85 58 ff ff ff 	movq   $0x0,-0xa8(%rbp)
  40a6a5:	00 00 00 00 
    const bool is_a_complete_scan =
  40a6a9:	88 85 d4 fe ff ff    	mov    %al,-0x12c(%rbp)
    const fcs_move_func *const moves_list = BEFS_M_VAR(soft_thread, moves_list);
  40a6af:	49 8b 87 c8 00 00 00 	mov    0xc8(%r15),%rax
  40a6b6:	48 89 85 c0 fe ff ff 	mov    %rax,-0x140(%rbp)
    const fcs_move_func *const moves_list_end =
  40a6bd:	49 8b 87 d0 00 00 00 	mov    0xd0(%r15),%rax
  40a6c4:	48 89 85 b8 fe ff ff 	mov    %rax,-0x148(%rbp)
    FCS_ASSIGN_STATE_KEY();
  40a6cb:	48 8d 43 48          	lea    0x48(%rbx),%rax
  40a6cf:	c4 e3 c9 22 d0 01    	vpinsrq $0x1,%rax,%xmm6,%xmm2
    const bool enable_pruning = soft_thread->enable_pruning;
  40a6d5:	41 0f b6 87 f0 01 00 	movzbl 0x1f0(%r15),%eax
  40a6dc:	00 
    FCS_ASSIGN_STATE_KEY();
  40a6dd:	c5 f8 29 95 30 ff ff 	vmovaps %xmm2,-0xd0(%rbp)
  40a6e4:	ff 
    const bool enable_pruning = soft_thread->enable_pruning;
  40a6e5:	88 85 10 ff ff ff    	mov    %al,-0xf0(%rbp)
    const_SLOT(is_befs, soft_thread);
  40a6eb:	41 0f b6 87 f2 01 00 	movzbl 0x1f2(%r15),%eax
  40a6f2:	00 
  40a6f3:	88 85 20 ff ff ff    	mov    %al,-0xe0(%rbp)
    if (is_befs)
  40a6f9:	84 c0                	test   %al,%al
  40a6fb:	0f 84 81 1b 00 00    	je     40c282 <resume_solution+0x1e02>
        pqueue = &(BEFS_VAR(soft_thread, pqueue));
  40a701:	49 8d 87 f0 00 00 00 	lea    0xf0(%r15),%rax
  40a708:	48 89 85 08 ff ff ff 	mov    %rax,-0xf8(%rbp)
  40a70f:	48 8b 85 28 ff ff ff 	mov    -0xd8(%rbp),%rax
    int8_t *const befs_positions_by_rank =
  40a716:	4d 8d 6f 60          	lea    0x60(%r15),%r13
  40a71a:	48 8b 80 c8 00 00 00 	mov    0xc8(%rax),%rax
  40a721:	48 89 85 a8 fe ff ff 	mov    %rax,-0x158(%rbp)
    while (PTR_STATE != NULL)
  40a728:	48 85 db             	test   %rbx,%rbx
  40a72b:	0f 84 a7 09 00 00    	je     40b0d8 <resume_solution+0xc58>
    fcs_states_linked_list_item *queue_last_item = NULL;
  40a731:	48 c7 85 18 ff ff ff 	movq   $0x0,-0xe8(%rbp)
  40a738:	00 00 00 00 
    fcs_states_linked_list_item *queue = NULL;
  40a73c:	48 c7 85 00 ff ff ff 	movq   $0x0,-0x100(%rbp)
  40a743:	00 00 00 00 
                        (is_scan_visited(PTR_STATE, soft_thread_id))))
  40a747:	89 c8                	mov    %ecx,%eax
  40a749:	83 e1 07             	and    $0x7,%ecx
    memset(positions_by_rank, -1, sizeof(fcs__positions_by_rank));
  40a74c:	4c 89 ad a0 fe ff ff 	mov    %r13,-0x160(%rbp)
  40a753:	0f b6 53 56          	movzbl 0x56(%rbx),%edx
  40a757:	c1 f8 03             	sar    $0x3,%eax
  40a75a:	89 85 e0 fe ff ff    	mov    %eax,-0x120(%rbp)
  40a760:	b8 01 00 00 00       	mov    $0x1,%eax
  40a765:	d3 e0                	shl    %cl,%eax
    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));
  40a767:	80 bd 10 ff ff ff 00 	cmpb   $0x0,-0xf0(%rbp)
  40a76e:	89 85 e8 fe ff ff    	mov    %eax,-0x118(%rbp)
    (FCS_S_SCAN_VISITED(ptr_state))[scan_id >> FCS_CHAR_BIT_SIZE_LOG2] |=
  40a774:	88 85 b0 fe ff ff    	mov    %al,-0x150(%rbp)
  40a77a:	74 46                	je     40a7c2 <resume_solution+0x342>
  40a77c:	0f 1f 40 00          	nopl   0x0(%rax)
  40a780:	f6 c2 10             	test   $0x10,%dl
  40a783:	75 3d                	jne    40a7c2 <resume_solution+0x342>
            fcs_collectible_state *const after_pruning_state =
  40a785:	48 8b b5 30 ff ff ff 	mov    -0xd0(%rbp),%rsi
  40a78c:	4c 89 ff             	mov    %r15,%rdi
  40a78f:	48 8b 95 38 ff ff ff 	mov    -0xc8(%rbp),%rdx
  40a796:	e8 85 7f ff ff       	callq  402720 <fc_solve_sfs_raymond_prune>
            if (after_pruning_state)
  40a79b:	48 85 c0             	test   %rax,%rax
  40a79e:	0f 84 ef 08 00 00    	je     40b093 <resume_solution+0xc13>
                ASSIGN_ptr_state(after_pruning_state);
  40a7a4:	48 8d 50 48          	lea    0x48(%rax),%rdx
  40a7a8:	c4 e1 f9 6e d8       	vmovq  %rax,%xmm3
  40a7ad:	48 89 c3             	mov    %rax,%rbx
  40a7b0:	c4 e3 e1 22 d2 01    	vpinsrq $0x1,%rdx,%xmm3,%xmm2
  40a7b6:	0f b6 50 56          	movzbl 0x56(%rax),%edx
  40a7ba:	c5 f8 29 95 30 ff ff 	vmovaps %xmm2,-0xd0(%rbp)
  40a7c1:	ff 
            if (
  40a7c2:	83 e2 04             	and    $0x4,%edx
  40a7c5:	75 21                	jne    40a7e8 <resume_solution+0x368>
                        (is_scan_visited(PTR_STATE, soft_thread_id))))
  40a7c7:	48 63 85 e0 fe ff ff 	movslq -0x120(%rbp),%rax
  40a7ce:	48 89 85 f8 fe ff ff 	mov    %rax,-0x108(%rbp)
  40a7d5:	44 0f b6 64 03 57    	movzbl 0x57(%rbx,%rax,1),%r12d
                    ((temp_visited & FCS_VISITED_DEAD_END) ||
  40a7db:	44 23 a5 e8 fe ff ff 	and    -0x118(%rbp),%r12d
  40a7e2:	0f 84 f8 01 00 00    	je     40a9e0 <resume_solution+0x560>
            if (is_befs)
  40a7e8:	80 bd 20 ff ff ff 00 	cmpb   $0x0,-0xe0(%rbp)
  40a7ef:	75 6f                	jne    40a860 <resume_solution+0x3e0>
                const_AUTO(save_item, queue->next);
  40a7f1:	48 8b bd 00 ff ff ff 	mov    -0x100(%rbp),%rdi
  40a7f8:	48 8b 47 08          	mov    0x8(%rdi),%rax
                if (save_item != queue_last_item)
  40a7fc:	48 3b 85 18 ff ff ff 	cmp    -0xe8(%rbp),%rax
  40a803:	0f 84 57 12 00 00    	je     40ba60 <resume_solution+0x15e0>
                    queue->next = save_item->next;
  40a809:	48 8b 50 08          	mov    0x8(%rax),%rdx
                    new_ptr_state = save_item->s;
  40a80d:	48 8b 18             	mov    (%rax),%rbx
                    queue->next = save_item->next;
  40a810:	48 89 57 08          	mov    %rdx,0x8(%rdi)
                    save_item->next = my_brfs_recycle_bin;
  40a814:	49 8b 97 e8 00 00 00 	mov    0xe8(%r15),%rdx
  40a81b:	48 89 50 08          	mov    %rdx,0x8(%rax)
                    my_brfs_recycle_bin = save_item;
  40a81f:	49 89 87 e8 00 00 00 	mov    %rax,0xe8(%r15)
            ASSIGN_ptr_state(new_ptr_state);
  40a826:	48 85 db             	test   %rbx,%rbx
  40a829:	0f 84 0c 01 00 00    	je     40a93b <resume_solution+0x4bb>
  40a82f:	80 bd 10 ff ff ff 00 	cmpb   $0x0,-0xf0(%rbp)
  40a836:	48 8d 43 48          	lea    0x48(%rbx),%rax
  40a83a:	c4 e1 f9 6e f3       	vmovq  %rbx,%xmm6
  40a83f:	c4 e3 c9 22 d8 01    	vpinsrq $0x1,%rax,%xmm6,%xmm3
  40a845:	0f b6 53 56          	movzbl 0x56(%rbx),%edx
  40a849:	c5 f8 29 9d 30 ff ff 	vmovaps %xmm3,-0xd0(%rbp)
  40a850:	ff 
  40a851:	0f 84 6b ff ff ff    	je     40a7c2 <resume_solution+0x342>
  40a857:	e9 24 ff ff ff       	jmpq   40a780 <resume_solution+0x300>
  40a85c:	0f 1f 40 00          	nopl   0x0(%rax)
  40a860:	48 8b 85 08 ff ff ff 	mov    -0xf8(%rbp),%rax
  40a867:	48 8b 48 08          	mov    0x8(%rax),%rcx
 * */

static inline void fc_solve_pq_pop(
    pri_queue *const pq, fcs_collectible_state **const val)
{
    if (fc_solve_is_pqueue_empty(pq))
  40a86b:	48 85 c9             	test   %rcx,%rcx
  40a86e:	0f 84 ec 07 00 00    	je     40b060 <resume_solution+0xbe0>
    {
        *val = NULL;
        return;
    }
    const_SLOT(elems, pq);
  40a874:	4c 8b 40 10          	mov    0x10(%rax),%r8
    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]);
  40a878:	48 89 c8             	mov    %rcx,%rax

    const_AUTO(new_current_size, current_size - 1);
  40a87b:	48 83 e9 01          	sub    $0x1,%rcx
    const_AUTO(last_elem, elems[current_size]);
  40a87f:	48 c1 e0 04          	shl    $0x4,%rax
  40a883:	4c 01 c0             	add    %r8,%rax
    *val = elems[PQ_FIRST_ENTRY].val;
  40a886:	49 8b 58 10          	mov    0x10(%r8),%rbx
    const_AUTO(last_elem, elems[current_size]);
  40a88a:	4c 8b 28             	mov    (%rax),%r13
  40a88d:	44 8b 60 08          	mov    0x8(%rax),%r12d

    /*  UNTESTED */

    size_t i;
    size_t child;
    for (i = PQ_FIRST_ENTRY;
  40a891:	48 83 f9 01          	cmp    $0x1,%rcx
  40a895:	0f 86 86 1c 00 00    	jbe    40c521 <resume_solution+0x20a1>
  40a89b:	b8 01 00 00 00       	mov    $0x1,%eax
         (child = PQ_LEFT_CHILD_INDEX(i)) <= new_current_size; i = child)
  40a8a0:	ba 02 00 00 00       	mov    $0x2,%edx
  40a8a5:	eb 33                	jmp    40a8da <resume_solution+0x45a>
  40a8a7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40a8ae:	00 00 
    {
        /* set child to the smaller of the two children... */

        if ((child != new_current_size) &&
  40a8b0:	45 89 d9             	mov    %r11d,%r9d
  40a8b3:	4c 89 d7             	mov    %r10,%rdi
  40a8b6:	48 c1 e0 04          	shl    $0x4,%rax
  40a8ba:	4c 01 c0             	add    %r8,%rax
            (fcs_pq_rating(elems[child + 1]) > fcs_pq_rating(elems[child])))
        {
            child++;
        }

        if (fcs_pq_rating(last_elem) < fcs_pq_rating(elems[child]))
  40a8bd:	45 39 cc             	cmp    %r9d,%r12d
  40a8c0:	7d 5e                	jge    40a920 <resume_solution+0x4a0>
        {
            elems[i] = elems[child];
  40a8c2:	c5 fa 6f 07          	vmovdqu (%rdi),%xmm0
         (child = PQ_LEFT_CHILD_INDEX(i)) <= new_current_size; i = child)
  40a8c6:	48 8d 14 36          	lea    (%rsi,%rsi,1),%rdx
            elems[i] = elems[child];
  40a8ca:	c5 f8 11 00          	vmovups %xmm0,(%rax)
         (child = PQ_LEFT_CHILD_INDEX(i)) <= new_current_size; i = child)
  40a8ce:	48 89 f0             	mov    %rsi,%rax
    for (i = PQ_FIRST_ENTRY;
  40a8d1:	48 39 d1             	cmp    %rdx,%rcx
  40a8d4:	0f 82 f6 07 00 00    	jb     40b0d0 <resume_solution+0xc50>
  40a8da:	49 89 d2             	mov    %rdx,%r10
        if ((child != new_current_size) &&
  40a8dd:	48 89 ce             	mov    %rcx,%rsi
  40a8e0:	49 c1 e2 04          	shl    $0x4,%r10
  40a8e4:	4b 8d 3c 10          	lea    (%r8,%r10,1),%rdi
  40a8e8:	44 8b 4f 08          	mov    0x8(%rdi),%r9d
  40a8ec:	48 39 ca             	cmp    %rcx,%rdx
  40a8ef:	74 c5                	je     40a8b6 <resume_solution+0x436>
            (fcs_pq_rating(elems[child + 1]) > fcs_pq_rating(elems[child])))
  40a8f1:	4f 8d 54 10 10       	lea    0x10(%r8,%r10,1),%r10
  40a8f6:	45 8b 5a 08          	mov    0x8(%r10),%r11d
  40a8fa:	48 8d 72 01          	lea    0x1(%rdx),%rsi
        if ((child != new_current_size) &&
  40a8fe:	45 39 cb             	cmp    %r9d,%r11d
  40a901:	7f ad                	jg     40a8b0 <resume_solution+0x430>
  40a903:	48 c1 e0 04          	shl    $0x4,%rax
  40a907:	48 89 d6             	mov    %rdx,%rsi
  40a90a:	4c 01 c0             	add    %r8,%rax
        if (fcs_pq_rating(last_elem) < fcs_pq_rating(elems[child]))
  40a90d:	45 39 cc             	cmp    %r9d,%r12d
  40a910:	7c b0                	jl     40a8c2 <resume_solution+0x442>
  40a912:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40a919:	00 00 00 00 
  40a91d:	0f 1f 00             	nopl   (%rax)
        {
            break;
        }
    }

    elems[i] = last_elem;
  40a920:	44 89 60 08          	mov    %r12d,0x8(%rax)
  40a924:	4c 89 28             	mov    %r13,(%rax)
    pq->current_size = new_current_size;
  40a927:	48 8b 85 08 ff ff ff 	mov    -0xf8(%rbp),%rax
  40a92e:	48 89 48 08          	mov    %rcx,0x8(%rax)
  40a932:	48 85 db             	test   %rbx,%rbx
  40a935:	0f 85 f4 fe ff ff    	jne    40a82f <resume_solution+0x3af>
  40a93b:	bb 01 00 00 00       	mov    $0x1,%ebx
  40a940:	41 bc 01 00 00 00    	mov    $0x1,%r12d
    if (derived.states != NULL)
  40a946:	48 8b bd 58 ff ff ff 	mov    -0xa8(%rbp),%rdi
  40a94d:	48 85 ff             	test   %rdi,%rdi
  40a950:	74 05                	je     40a957 <resume_solution+0x4d7>
        free(derived.states);
  40a952:	e8 f9 66 ff ff       	callq  401050 <free@plt>
    if (!is_befs)
  40a957:	80 bd 20 ff ff ff 00 	cmpb   $0x0,-0xe0(%rbp)
  40a95e:	0f 84 76 30 00 00    	je     40d9da <resume_solution+0x355a>
  40a964:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40a96b:	00 00 00 00 
  40a96f:	90                   	nop
        if (NUM_CHECKED_STATES >=
  40a970:	48 8b 85 f0 fe ff ff 	mov    -0x110(%rbp),%rax
  40a977:	48 8b 30             	mov    (%rax),%rsi
  40a97a:	48 3b b0 c8 00 00 00 	cmp    0xc8(%rax),%rsi
  40a981:	0f 8d 2e 12 00 00    	jge    40bbb5 <resume_solution+0x1735>
        if (ret == FCS_STATE_IS_NOT_SOLVEABLE)
  40a987:	41 83 fc 01          	cmp    $0x1,%r12d
  40a98b:	0f 84 c4 11 00 00    	je     40bb55 <resume_solution+0x16d5>
  40a991:	48 8b 85 f0 fe ff ff 	mov    -0x110(%rbp),%rax
        if (was_solved || instance__check_exceeded_stats(instance))
  40a998:	85 db                	test   %ebx,%ebx
  40a99a:	0f 84 81 20 00 00    	je     40ca21 <resume_solution+0x25a1>
  40a9a0:	48 63 88 28 05 00 00 	movslq 0x528(%rax),%rcx
    while (HT_FIELD(hard_thread, num_soft_threads_finished) < num_soft_threads)
  40a9a7:	48 39 8d 88 fe ff ff 	cmp    %rcx,-0x178(%rbp)
  40a9ae:	0f 8f 5e fc ff ff    	jg     40a612 <resume_solution+0x192>
                if ((ret == FCS_STATE_IS_NOT_SOLVEABLE) ||
  40a9b4:	83 fb 01             	cmp    $0x1,%ebx
  40a9b7:	0f 85 e6 fb ff ff    	jne    40a5a3 <resume_solution+0x123>
  40a9bd:	48 8b bd f0 fe ff ff 	mov    -0x110(%rbp),%rdi
  40a9c4:	48 8b 87 40 05 00 00 	mov    0x540(%rdi),%rax
  40a9cb:	48 8b 37             	mov    (%rdi),%rsi
  40a9ce:	e9 55 20 00 00       	jmpq   40ca28 <resume_solution+0x25a8>
  40a9d3:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40a9da:	00 00 00 00 
  40a9de:	66 90                	xchg   %ax,%ax
        if (check_if_limits_exceeded())
  40a9e0:	48 8b 85 28 ff ff ff 	mov    -0xd8(%rbp),%rax
  40a9e7:	48 8b 08             	mov    (%rax),%rcx
  40a9ea:	48 3b 8d a8 fe ff ff 	cmp    -0x158(%rbp),%rcx
  40a9f1:	0f 84 70 1f 00 00    	je     40c967 <resume_solution+0x24e7>
        if (fcs_freecell_is_empty(*state_ptr, i))
  40a9f7:	80 7b 40 00          	cmpb   $0x0,0x40(%rbx)
        if (fcs_state_col_is_empty(*state_ptr, i))
  40a9fb:	48 8b 03             	mov    (%rbx),%rax
  40a9fe:	48 8b 73 08          	mov    0x8(%rbx),%rsi
        if (fcs_freecell_is_empty(*state_ptr, i))
  40aa02:	0f 94 c2             	sete   %dl
            num_vacant_freecells++;
  40aa05:	80 7b 41 01          	cmpb   $0x1,0x41(%rbx)
  40aa09:	80 d2 00             	adc    $0x0,%dl
  40aa0c:	80 7b 42 01          	cmpb   $0x1,0x42(%rbx)
  40aa10:	80 d2 00             	adc    $0x0,%dl
  40aa13:	80 7b 43 01          	cmpb   $0x1,0x43(%rbx)
  40aa17:	80 d2 00             	adc    $0x0,%dl
        if (fcs_state_col_is_empty(*state_ptr, i))
  40aa1a:	80 38 00             	cmpb   $0x0,(%rax)
  40aa1d:	0f 94 c0             	sete   %al
            ++num_vacant_stacks;
  40aa20:	80 3e 01             	cmpb   $0x1,(%rsi)
        if (fcs_state_col_is_empty(*state_ptr, i))
  40aa23:	48 8b 73 10          	mov    0x10(%rbx),%rsi
            ++num_vacant_stacks;
  40aa27:	14 00                	adc    $0x0,%al
  40aa29:	80 3e 01             	cmpb   $0x1,(%rsi)
        if (fcs_state_col_is_empty(*state_ptr, i))
  40aa2c:	48 8b 73 18          	mov    0x18(%rbx),%rsi
            ++num_vacant_stacks;
  40aa30:	14 00                	adc    $0x0,%al
  40aa32:	80 3e 01             	cmpb   $0x1,(%rsi)
        if (fcs_state_col_is_empty(*state_ptr, i))
  40aa35:	48 8b 73 20          	mov    0x20(%rbx),%rsi
            ++num_vacant_stacks;
  40aa39:	14 00                	adc    $0x0,%al
  40aa3b:	80 3e 01             	cmpb   $0x1,(%rsi)
        if (fcs_state_col_is_empty(*state_ptr, i))
  40aa3e:	48 8b 73 28          	mov    0x28(%rbx),%rsi
            ++num_vacant_stacks;
  40aa42:	14 00                	adc    $0x0,%al
  40aa44:	80 3e 01             	cmpb   $0x1,(%rsi)
        if (fcs_state_col_is_empty(*state_ptr, i))
  40aa47:	48 8b 73 30          	mov    0x30(%rbx),%rsi
            ++num_vacant_stacks;
  40aa4b:	14 00                	adc    $0x0,%al
  40aa4d:	80 3e 01             	cmpb   $0x1,(%rsi)
        if (fcs_state_col_is_empty(*state_ptr, i))
  40aa50:	48 8b 73 38          	mov    0x38(%rbx),%rsi
            ++num_vacant_stacks;
  40aa54:	14 00                	adc    $0x0,%al
        if (fcs_state_col_is_empty(*state_ptr, i))
  40aa56:	80 3e 00             	cmpb   $0x0,(%rsi)
  40aa59:	75 10                	jne    40aa6b <resume_solution+0x5eb>
            ++num_vacant_stacks;
  40aa5b:	83 c0 01             	add    $0x1,%eax
        if ((num_vacant_stacks == LOCAL_STACKS_NUM) &&
  40aa5e:	3c 08                	cmp    $0x8,%al
  40aa60:	75 09                	jne    40aa6b <resume_solution+0x5eb>
  40aa62:	80 fa 04             	cmp    $0x4,%dl
  40aa65:	0f 84 5a 1f 00 00    	je     40c9c5 <resume_solution+0x2545>
  40aa6b:	4c 8b a5 a0 fe ff ff 	mov    -0x160(%rbp),%r12
        soft_thread->num_vacant_freecells = num_vacant_freecells;
  40aa72:	41 88 97 e4 01 00 00 	mov    %dl,0x1e4(%r15)
  40aa79:	c5 f9 76 c0          	vpcmpeqd %xmm0,%xmm0,%xmm0
  40aa7d:	45 31 d2             	xor    %r10d,%r10d
        soft_thread->num_vacant_stacks = num_vacant_stacks;
  40aa80:	41 88 87 e3 01 00 00 	mov    %al,0x1e3(%r15)
  40aa87:	c4 c1 78 11 04 24    	vmovups %xmm0,(%r12)
  40aa8d:	c4 c1 78 11 44 24 10 	vmovups %xmm0,0x10(%r12)
  40aa94:	c4 c1 78 11 44 24 20 	vmovups %xmm0,0x20(%r12)
  40aa9b:	c4 c1 78 11 44 24 30 	vmovups %xmm0,0x30(%r12)
  40aaa2:	c4 c1 78 11 44 24 40 	vmovups %xmm0,0x40(%r12)
  40aaa9:	c4 c1 78 11 44 24 50 	vmovups %xmm0,0x50(%r12)
  40aab0:	49 c7 44 24 60 ff ff 	movq   $0xffffffffffffffff,0x60(%r12)
  40aab7:	ff ff 
  40aab9:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
            const_AUTO(dest_col, fcs_state_get_col(state_key, ds));
  40aac0:	4e 8b 04 d3          	mov    (%rbx,%r10,8),%r8
            int top_card_idx = fcs_col_len(dest_col);
  40aac4:	41 0f be 00          	movsbl (%r8),%eax
            if (unlikely((top_card_idx--) == 0))
  40aac8:	44 8d 68 ff          	lea    -0x1(%rax),%r13d
  40aacc:	85 c0                	test   %eax,%eax
  40aace:	74 67                	je     40ab37 <resume_solution+0x6b7>
                dest_card = fcs_col_get_card(dest_col, 0);
  40aad0:	41 0f be 48 01       	movsbl 0x1(%r8),%ecx
  40aad5:	45 89 d3             	mov    %r10d,%r11d
                for (int dc = 0; dc < top_card_idx;
  40aad8:	45 85 ed             	test   %r13d,%r13d
  40aadb:	0f 8e 6f 05 00 00    	jle    40b050 <resume_solution+0xbd0>
  40aae1:	44 8d 48 fe          	lea    -0x2(%rax),%r9d
  40aae5:	31 d2                	xor    %edx,%edx
  40aae7:	49 83 c1 01          	add    $0x1,%r9
  40aaeb:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
                    dest_below_card = fcs_col_get_card(dest_col, dc + 1);
  40aaf0:	49 0f be 7c 10 02    	movsbq 0x2(%r8,%rdx,1),%rdi
    return fc_solve_is_parent_buf[(size_t)parent][(size_t)child];
  40aaf6:	48 0f be c1          	movsbq %cl,%rax
  40aafa:	48 c1 e0 06          	shl    $0x6,%rax
                    if (!fcs_is_parent_card(dest_below_card, dest_card))
  40aafe:	80 bc 07 c0 fe 40 00 	cmpb   $0x0,0x40fec0(%rdi,%rax,1)
  40ab05:	00 
                    dest_below_card = fcs_col_get_card(dest_col, dc + 1);
  40ab06:	48 89 fe             	mov    %rdi,%rsi
                    if (!fcs_is_parent_card(dest_below_card, dest_card))
  40ab09:	75 0f                	jne    40ab1a <resume_solution+0x69a>
    int8_t *ptr = &positions_by_rank[(dest_card - 4) << 1];
  40ab0b:	8d 44 09 f8          	lea    -0x8(%rcx,%rcx,1),%eax
  40ab0f:	48 98                	cltq   
  40ab11:	4c 01 e0             	add    %r12,%rax
    *(ptr++) = dest_stack;
  40ab14:	44 88 18             	mov    %r11b,(%rax)
                        fc_solve__assign_dest_stack_and_col_ptr(
  40ab17:	88 50 01             	mov    %dl,0x1(%rax)
  40ab1a:	48 83 c2 01          	add    $0x1,%rdx
                    dest_below_card = fcs_col_get_card(dest_col, dc + 1);
  40ab1e:	40 0f be ce          	movsbl %sil,%ecx
                for (int dc = 0; dc < top_card_idx;
  40ab22:	49 39 d1             	cmp    %rdx,%r9
  40ab25:	75 c9                	jne    40aaf0 <resume_solution+0x670>
    int8_t *ptr = &positions_by_rank[(dest_card - 4) << 1];
  40ab27:	8d 44 36 f8          	lea    -0x8(%rsi,%rsi,1),%eax
  40ab2b:	48 98                	cltq   
  40ab2d:	4c 01 e0             	add    %r12,%rax
    *(ptr++) = dest_stack;
  40ab30:	44 88 18             	mov    %r11b,(%rax)
            fc_solve__assign_dest_stack_and_col_ptr(
  40ab33:	44 88 68 01          	mov    %r13b,0x1(%rax)
  40ab37:	49 83 c2 01          	add    $0x1,%r10
        for (int ds = 0; ds < LOCAL_STACKS_NUM; ds++)
  40ab3b:	49 83 fa 08          	cmp    $0x8,%r10
  40ab3f:	0f 85 7b ff ff ff    	jne    40aac0 <resume_solution+0x640>
        for (const fcs_move_func *move_func_ptr = moves_list;
  40ab45:	48 8b 85 c0 fe ff ff 	mov    -0x140(%rbp),%rax
        derived.num_states = 0;
  40ab4c:	48 c7 85 50 ff ff ff 	movq   $0x0,-0xb0(%rbp)
  40ab53:	00 00 00 00 
        for (const fcs_move_func *move_func_ptr = moves_list;
  40ab57:	48 8b bd b8 fe ff ff 	mov    -0x148(%rbp),%rdi
  40ab5e:	48 39 f8             	cmp    %rdi,%rax
  40ab61:	73 4f                	jae    40abb2 <resume_solution+0x732>
            move_func_ptr->f(soft_thread, pass, &derived);
  40ab63:	4c 8b a5 30 ff ff ff 	mov    -0xd0(%rbp),%r12
  40ab6a:	48 89 9d d8 fe ff ff 	mov    %rbx,-0x128(%rbp)
  40ab71:	4c 8d ad 50 ff ff ff 	lea    -0xb0(%rbp),%r13
  40ab78:	48 89 c3             	mov    %rax,%rbx
  40ab7b:	4d 89 e6             	mov    %r12,%r14
  40ab7e:	49 89 fc             	mov    %rdi,%r12
  40ab81:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40ab88:	00 00 00 00 
  40ab8c:	0f 1f 40 00          	nopl   0x0(%rax)
  40ab90:	4c 89 e9             	mov    %r13,%rcx
  40ab93:	4c 89 f6             	mov    %r14,%rsi
  40ab96:	48 8b 95 38 ff ff ff 	mov    -0xc8(%rbp),%rdx
  40ab9d:	4c 89 ff             	mov    %r15,%rdi
  40aba0:	ff 13                	callq  *(%rbx)
             move_func_ptr < moves_list_end; move_func_ptr++)
  40aba2:	48 83 c3 08          	add    $0x8,%rbx
        for (const fcs_move_func *move_func_ptr = moves_list;
  40aba6:	49 39 dc             	cmp    %rbx,%r12
  40aba9:	77 e5                	ja     40ab90 <resume_solution+0x710>
  40abab:	48 8b 9d d8 fe ff ff 	mov    -0x128(%rbp),%rbx
        if (is_a_complete_scan)
  40abb2:	80 bd d4 fe ff ff 00 	cmpb   $0x0,-0x12c(%rbp)
  40abb9:	74 04                	je     40abbf <resume_solution+0x73f>
            FCS_S_VISITED(PTR_STATE) |= FCS_VISITED_ALL_TESTS_DONE;
  40abbb:	80 4b 56 08          	orb    $0x8,0x56(%rbx)
        BUMP_NUM_CHECKED_STATES();
  40abbf:	48 8b 85 28 ff ff ff 	mov    -0xd8(%rbp),%rax
        for (derived_end = (derived_iter = derived.states) + derived.num_states;
  40abc6:	4c 8b b5 58 ff ff ff 	mov    -0xa8(%rbp),%r14
        BUMP_NUM_CHECKED_STATES();
  40abcd:	48 83 00 01          	addq   $0x1,(%rax)
        for (derived_end = (derived_iter = derived.states) + derived.num_states;
  40abd1:	48 8b 85 50 ff ff ff 	mov    -0xb0(%rbp),%rax
  40abd8:	48 89 c2             	mov    %rax,%rdx
  40abdb:	48 c1 e2 04          	shl    $0x4,%rdx
  40abdf:	49 8d 3c 16          	lea    (%r14,%rdx,1),%rdi
  40abe3:	48 89 bd 30 ff ff ff 	mov    %rdi,-0xd0(%rbp)
  40abea:	49 39 fe             	cmp    %rdi,%r14
  40abed:	0f 83 5b 03 00 00    	jae    40af4e <resume_solution+0xace>
                fc_solve_pq_push(pqueue, scans_ptr_new_state,
  40abf3:	48 89 9d c8 fe ff ff 	mov    %rbx,-0x138(%rbp)
  40abfa:	eb 4d                	jmp    40ac49 <resume_solution+0x7c9>
  40abfc:	0f 1f 40 00          	nopl   0x0(%rax)
                if (my_brfs_recycle_bin)
  40ac00:	49 8b 97 e8 00 00 00 	mov    0xe8(%r15),%rdx
  40ac07:	48 85 d2             	test   %rdx,%rdx
  40ac0a:	0f 84 f0 03 00 00    	je     40b000 <resume_solution+0xb80>
                    my_brfs_recycle_bin = my_brfs_recycle_bin->next;
  40ac10:	48 8b 42 08          	mov    0x8(%rdx),%rax
  40ac14:	49 89 87 e8 00 00 00 	mov    %rax,0xe8(%r15)
                queue_last_item->next = last_item_next;
  40ac1b:	48 8b 85 18 ff ff ff 	mov    -0xe8(%rbp),%rax
             derived_iter < derived_end; derived_iter++)
  40ac22:	49 83 c6 10          	add    $0x10,%r14
                last_item_next->next = NULL;
  40ac26:	48 89 95 18 ff ff ff 	mov    %rdx,-0xe8(%rbp)
                queue_last_item->next = last_item_next;
  40ac2d:	48 89 50 08          	mov    %rdx,0x8(%rax)
                queue_last_item->s = scans_ptr_new_state;
  40ac31:	48 89 18             	mov    %rbx,(%rax)
                last_item_next->next = NULL;
  40ac34:	48 c7 42 08 00 00 00 	movq   $0x0,0x8(%rdx)
  40ac3b:	00 
        for (derived_end = (derived_iter = derived.states) + derived.num_states;
  40ac3c:	4c 39 b5 30 ff ff ff 	cmp    %r14,-0xd0(%rbp)
  40ac43:	0f 86 f7 02 00 00    	jbe    40af40 <resume_solution+0xac0>
            if (is_befs)
  40ac49:	80 bd 20 ff ff ff 00 	cmpb   $0x0,-0xe0(%rbp)
            const_AUTO(scans_ptr_new_state, derived_iter->state_ptr);
  40ac50:	49 8b 1e             	mov    (%r14),%rbx
            if (is_befs)
  40ac53:	74 ab                	je     40ac00 <resume_solution+0x780>
    double sum = (max(0, negated_depth) * weighting->depth_factor);
  40ac55:	b8 20 4e 00 00       	mov    $0x4e20,%eax
  40ac5a:	2b 43 50             	sub    0x50(%rbx),%eax
  40ac5d:	0f 88 23 04 00 00    	js     40b086 <resume_solution+0xc06>
  40ac63:	c5 d9 57 e4          	vxorpd %xmm4,%xmm4,%xmm4
  40ac67:	c5 d1 57 ed          	vxorpd %xmm5,%xmm5,%xmm5
  40ac6b:	c5 db 2a e0          	vcvtsi2sd %eax,%xmm4,%xmm4
    if (num_cards_out_lookup_table[1])
  40ac6f:	c4 c1 79 2e af 40 01 	vucomisd 0x140(%r15),%xmm5
  40ac76:	00 00 
    double sum = (max(0, negated_depth) * weighting->depth_factor);
  40ac78:	c4 c1 5b 59 a7 28 01 	vmulsd 0x128(%r15),%xmm4,%xmm4
  40ac7f:	00 00 
    if (num_cards_out_lookup_table[1])
  40ac81:	7a 02                	jp     40ac85 <resume_solution+0x805>
  40ac83:	74 2f                	je     40acb4 <resume_solution+0x834>
            sum += num_cards_out_lookup_table[(
  40ac85:	48 0f be 53 44       	movsbq 0x44(%rbx),%rdx
    const_PTR(
  40ac8a:	49 8d 87 38 01 00 00 	lea    0x138(%r15),%rax
            sum += num_cards_out_lookup_table[(
  40ac91:	c5 db 58 24 d0       	vaddsd (%rax,%rdx,8),%xmm4,%xmm4
  40ac96:	48 0f be 53 45       	movsbq 0x45(%rbx),%rdx
  40ac9b:	c5 db 58 24 d0       	vaddsd (%rax,%rdx,8),%xmm4,%xmm4
  40aca0:	48 0f be 53 46       	movsbq 0x46(%rbx),%rdx
  40aca5:	c5 db 58 24 d0       	vaddsd (%rax,%rdx,8),%xmm4,%xmm4
  40acaa:	48 0f be 53 47       	movsbq 0x47(%rbx),%rdx
  40acaf:	c5 db 58 24 d0       	vaddsd (%rax,%rdx,8),%xmm4,%xmm4
    if (weighting->should_go_over_stacks)
  40acb4:	41 80 bf 08 01 00 00 	cmpb   $0x0,0x108(%r15)
  40acbb:	00 
  40acbc:	0f 84 e1 00 00 00    	je     40ada3 <resume_solution+0x923>
  40acc2:	49 89 dc             	mov    %rbx,%r12
    fcs_game_limit num_vacant_stacks = 0;
  40acc5:	31 c9                	xor    %ecx,%ecx
    fcs_seq_cards_power_type seqs_over_renegade_cards = 0;
  40acc7:	c5 f1 57 c9          	vxorpd %xmm1,%xmm1,%xmm1
    fcs_seq_cards_power_type cards_under_sequences = 0;
  40accb:	c5 f9 57 c0          	vxorpd %xmm0,%xmm0,%xmm0
  40accf:	4c 8d 6b 40          	lea    0x40(%rbx),%r13
  40acd3:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40acda:	00 00 00 00 
  40acde:	66 90                	xchg   %ax,%ax
            const_AUTO(col, fcs_state_get_col(*state, a));
  40ace0:	4d 8b 04 24          	mov    (%r12),%r8
            const int cards_num = fcs_col_len(col);
  40ace4:	45 0f be 10          	movsbl (%r8),%r10d
            if (cards_num <= 1)
  40ace8:	41 83 fa 01          	cmp    $0x1,%r10d
  40acec:	0f 8e fe 02 00 00    	jle    40aff0 <resume_solution+0xb70>
            const int c = update_col_cards_under_sequences(
  40acf2:	41 8d 42 ff          	lea    -0x1(%r10),%eax
  40acf6:	41 8d 72 fe          	lea    -0x2(%r10),%esi
    fcs_card this_card = fcs_col_get_card(col, d);
  40acfa:	48 98                	cltq   
  40acfc:	49 0f be 54 00 01    	movsbq 0x1(%r8,%rax,1),%rdx
  40ad02:	4c 8d 48 ff          	lea    -0x1(%rax),%r9
  40ad06:	49 29 f1             	sub    %rsi,%r9
  40ad09:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
             prev_card = fcs_col_get_card(col, d - 1);
  40ad10:	49 0f be 34 00       	movsbq (%r8,%rax,1),%rsi
  40ad15:	41 89 c3             	mov    %eax,%r11d
  40ad18:	48 89 f7             	mov    %rsi,%rdi
  40ad1b:	48 c1 e6 06          	shl    $0x6,%rsi
    for (; (d > 0) && ({
  40ad1f:	80 bc 32 c0 fe 40 00 	cmpb   $0x0,0x40fec0(%rdx,%rsi,1)
  40ad26:	00 
  40ad27:	0f 84 a3 02 00 00    	je     40afd0 <resume_solution+0xb50>
  40ad2d:	48 83 e8 01          	sub    $0x1,%rax
         d--, this_card = prev_card)
  40ad31:	48 0f be d7          	movsbq %dil,%rdx
    for (; (d > 0) && ({
  40ad35:	49 39 c1             	cmp    %rax,%r9
  40ad38:	75 d6                	jne    40ad10 <resume_solution+0x890>
            cards_under_sequences += FCS_SEQS_OVER_RENEGADE_POWER(c);
  40ad3a:	c5 fb 58 c5          	vaddsd %xmm5,%xmm0,%xmm0
  40ad3e:	49 83 c4 08          	add    $0x8,%r12
        for (int a = 0; a < LOCAL_STACKS_NUM; ++a)
  40ad42:	4d 39 e5             	cmp    %r12,%r13
  40ad45:	75 99                	jne    40ace0 <resume_solution+0x860>
        if (fcs_freecell_is_empty(*state_ptr, i))
  40ad47:	80 7b 40 00          	cmpb   $0x0,0x40(%rbx)
        sum += ((CALC_VACANCY_VAL() * weighting->max_sequence_move_factor) +
  40ad4b:	c5 e9 57 d2          	vxorpd %xmm2,%xmm2,%xmm2
                (seqs_over_renegade_cards *
  40ad4f:	c4 c1 73 59 8f 20 01 	vmulsd 0x120(%r15),%xmm1,%xmm1
  40ad56:	00 00 
        if (fcs_freecell_is_empty(*state_ptr, i))
  40ad58:	0f 94 c0             	sete   %al
            num_vacant_freecells++;
  40ad5b:	80 7b 41 01          	cmpb   $0x1,0x41(%rbx)
  40ad5f:	14 00                	adc    $0x0,%al
  40ad61:	80 7b 42 01          	cmpb   $0x1,0x42(%rbx)
  40ad65:	14 00                	adc    $0x0,%al
  40ad67:	80 7b 43 01          	cmpb   $0x1,0x43(%rbx)
  40ad6b:	14 00                	adc    $0x0,%al
        sum += ((CALC_VACANCY_VAL() * weighting->max_sequence_move_factor) +
  40ad6d:	0f b6 c0             	movzbl %al,%eax
  40ad70:	83 c0 01             	add    $0x1,%eax
  40ad73:	d3 e0                	shl    %cl,%eax
  40ad75:	c5 eb 2a d0          	vcvtsi2sd %eax,%xmm2,%xmm2
                ((instance->initial_cards_under_sequences_value -
  40ad79:	49 8b 07             	mov    (%r15),%rax
        sum += ((CALC_VACANCY_VAL() * weighting->max_sequence_move_factor) +
  40ad7c:	c4 c1 6b 59 97 10 01 	vmulsd 0x110(%r15),%xmm2,%xmm2
  40ad83:	00 00 
                ((instance->initial_cards_under_sequences_value -
  40ad85:	c5 fb 10 58 08       	vmovsd 0x8(%rax),%xmm3
  40ad8a:	c5 e3 5c c0          	vsubsd %xmm0,%xmm3,%xmm0
                     cards_under_sequences) *
  40ad8e:	c4 c1 7b 59 87 18 01 	vmulsd 0x118(%r15),%xmm0,%xmm0
  40ad95:	00 00 
        sum += ((CALC_VACANCY_VAL() * weighting->max_sequence_move_factor) +
  40ad97:	c5 eb 58 c0          	vaddsd %xmm0,%xmm2,%xmm0
                    weighting->cards_under_sequences_factor) +
  40ad9b:	c5 fb 58 c1          	vaddsd %xmm1,%xmm0,%xmm0
        sum += ((CALC_VACANCY_VAL() * weighting->max_sequence_move_factor) +
  40ad9f:	c5 db 58 e0          	vaddsd %xmm0,%xmm4,%xmm4
    const double num_cards_not_on_parents_weight =
  40ada3:	c4 c1 7b 10 87 30 01 	vmovsd 0x130(%r15),%xmm0
  40adaa:	00 00 
    if (num_cards_not_on_parents_weight)
  40adac:	c5 f9 2e c5          	vucomisd %xmm5,%xmm0
  40adb0:	7a 06                	jp     40adb8 <resume_solution+0x938>
  40adb2:	0f 84 db 00 00 00    	je     40ae93 <resume_solution+0xa13>
  40adb8:	4c 8d 63 40          	lea    0x40(%rbx),%r12
  40adbc:	49 89 db             	mov    %rbx,%r11
        int num_cards_not_on_parents = (LOCAL_DECKS_NUM * 52);
  40adbf:	ba 34 00 00 00       	mov    $0x34,%edx
  40adc4:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40adcb:	00 00 00 00 
  40adcf:	90                   	nop
            const_AUTO(col, fcs_state_get_col(*state, stack_idx));
  40add0:	49 8b 0b             	mov    (%r11),%rcx
            const uint_fast16_t col_len = fcs_col_len(col);
  40add3:	4c 0f be 01          	movsbq (%rcx),%r8
            for (uint_fast16_t h = 1; h < col_len; h++)
  40add7:	49 83 f8 01          	cmp    $0x1,%r8
  40addb:	0f 86 95 00 00 00    	jbe    40ae76 <resume_solution+0x9f6>
  40ade1:	41 80 f8 03          	cmp    $0x3,%r8b
  40ade5:	0f 86 91 02 00 00    	jbe    40b07c <resume_solution+0xbfc>
  40adeb:	48 0f be 71 01       	movsbq 0x1(%rcx),%rsi
  40adf0:	4d 8d 50 fc          	lea    -0x4(%r8),%r10
  40adf4:	b8 01 00 00 00       	mov    $0x1,%eax
  40adf9:	49 83 e2 fe          	and    $0xfffffffffffffffe,%r10
  40adfd:	49 83 c2 03          	add    $0x3,%r10
  40ae01:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40ae08:	00 00 00 00 
  40ae0c:	0f 1f 40 00          	nopl   0x0(%rax)
  40ae10:	48 0f be 7c 01 01    	movsbq 0x1(%rcx,%rax,1),%rdi
  40ae16:	49 89 f9             	mov    %rdi,%r9
  40ae19:	49 c1 e1 06          	shl    $0x6,%r9
  40ae1d:	49 8d b4 31 c0 fe 40 	lea    0x40fec0(%r9,%rsi,1),%rsi
  40ae24:	00 
                    num_cards_not_on_parents--;
  40ae25:	80 3e 01             	cmpb   $0x1,(%rsi)
  40ae28:	83 da 00             	sbb    $0x0,%edx
  40ae2b:	48 83 c0 02          	add    $0x2,%rax
  40ae2f:	48 0f be 34 01       	movsbq (%rcx,%rax,1),%rsi
  40ae34:	49 89 f1             	mov    %rsi,%r9
  40ae37:	49 c1 e1 06          	shl    $0x6,%r9
  40ae3b:	4a 8d bc 0f c0 fe 40 	lea    0x40fec0(%rdi,%r9,1),%rdi
  40ae42:	00 
  40ae43:	80 3f 01             	cmpb   $0x1,(%rdi)
  40ae46:	83 da 00             	sbb    $0x0,%edx
  40ae49:	49 39 c2             	cmp    %rax,%r10
  40ae4c:	75 c2                	jne    40ae10 <resume_solution+0x990>
  40ae4e:	66 90                	xchg   %ax,%ax
                        fcs_col_get_card(col, h - 1), fcs_col_get_card(col, h)))
  40ae50:	48 83 c0 01          	add    $0x1,%rax
  40ae54:	48 0f be 34 01       	movsbq (%rcx,%rax,1),%rsi
  40ae59:	48 0f be 7c 01 ff    	movsbq -0x1(%rcx,%rax,1),%rdi
  40ae5f:	48 c1 e6 06          	shl    $0x6,%rsi
  40ae63:	48 8d b4 37 c0 fe 40 	lea    0x40fec0(%rdi,%rsi,1),%rsi
  40ae6a:	00 
                    num_cards_not_on_parents--;
  40ae6b:	80 3e 01             	cmpb   $0x1,(%rsi)
  40ae6e:	83 da 00             	sbb    $0x0,%edx
            for (uint_fast16_t h = 1; h < col_len; h++)
  40ae71:	49 39 c0             	cmp    %rax,%r8
  40ae74:	77 da                	ja     40ae50 <resume_solution+0x9d0>
  40ae76:	49 83 c3 08          	add    $0x8,%r11
        for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  40ae7a:	4d 39 dc             	cmp    %r11,%r12
  40ae7d:	0f 85 4d ff ff ff    	jne    40add0 <resume_solution+0x950>
        sum += num_cards_not_on_parents * num_cards_not_on_parents_weight;
  40ae83:	c5 f1 57 c9          	vxorpd %xmm1,%xmm1,%xmm1
  40ae87:	c5 f3 2a ca          	vcvtsi2sd %edx,%xmm1,%xmm1
  40ae8b:	c5 f3 59 c0          	vmulsd %xmm0,%xmm1,%xmm0
  40ae8f:	c5 db 58 e0          	vaddsd %xmm0,%xmm4,%xmm4
    return ((int)sum);
  40ae93:	c5 7b 2c ec          	vcvttsd2si %xmm4,%r13d
    var_AUTO(i, ++(pq->current_size));
  40ae97:	48 8b 85 08 ff ff ff 	mov    -0xf8(%rbp),%rax
  40ae9e:	48 8b 78 08          	mov    0x8(%rax),%rdi
    if (i > pq->max_size)
  40aea2:	48 8b 10             	mov    (%rax),%rdx
    var_AUTO(i, ++(pq->current_size));
  40aea5:	4c 8d 67 01          	lea    0x1(%rdi),%r12
  40aea9:	48 89 bd d8 fe ff ff 	mov    %rdi,-0x128(%rbp)
  40aeb0:	4c 89 60 08          	mov    %r12,0x8(%rax)
  40aeb4:	48 8b 40 10          	mov    0x10(%rax),%rax
    if (i > pq->max_size)
  40aeb8:	49 39 d4             	cmp    %rdx,%r12
  40aebb:	0f 87 db 01 00 00    	ja     40b09c <resume_solution+0xc1c>
                             : (fcs_pq_rating(elems[PQ_PARENT_INDEX(i)]))) < r)
  40aec1:	49 83 fc 01          	cmp    $0x1,%r12
  40aec5:	74 59                	je     40af20 <resume_solution+0xaa0>
  40aec7:	4c 89 e2             	mov    %r12,%rdx
  40aeca:	48 d1 ea             	shr    %rdx
    while (
  40aecd:	48 c1 e2 04          	shl    $0x4,%rdx
  40aed1:	44 39 6c 10 08       	cmp    %r13d,0x8(%rax,%rdx,1)
  40aed6:	0f 8d 0a 2b 00 00    	jge    40d9e6 <resume_solution+0x3566>
  40aedc:	0f 1f 40 00          	nopl   0x0(%rax)
        elems[i] = elems[PQ_PARENT_INDEX(i)];
  40aee0:	4c 89 e2             	mov    %r12,%rdx
  40aee3:	4c 89 e1             	mov    %r12,%rcx
  40aee6:	48 d1 ea             	shr    %rdx
  40aee9:	48 c1 e1 04          	shl    $0x4,%rcx
  40aeed:	48 89 d6             	mov    %rdx,%rsi
  40aef0:	48 c1 e6 04          	shl    $0x4,%rsi
  40aef4:	c5 fa 6f 04 30       	vmovdqu (%rax,%rsi,1),%xmm0
  40aef9:	c5 f8 11 04 08       	vmovups %xmm0,(%rax,%rcx,1)
                             : (fcs_pq_rating(elems[PQ_PARENT_INDEX(i)]))) < r)
  40aefe:	48 83 fa 01          	cmp    $0x1,%rdx
  40af02:	74 1c                	je     40af20 <resume_solution+0xaa0>
  40af04:	49 c1 ec 02          	shr    $0x2,%r12
  40af08:	4c 89 e1             	mov    %r12,%rcx
  40af0b:	49 89 d4             	mov    %rdx,%r12
  40af0e:	48 c1 e1 04          	shl    $0x4,%rcx
    while (
  40af12:	44 39 6c 08 08       	cmp    %r13d,0x8(%rax,%rcx,1)
  40af17:	7c c7                	jl     40aee0 <resume_solution+0xa60>
  40af19:	eb 0a                	jmp    40af25 <resume_solution+0xaa5>
  40af1b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
            for (uint_fast16_t h = 1; h < col_len; h++)
  40af20:	be 10 00 00 00       	mov    $0x10,%esi
    elems[i].val = val;
  40af25:	48 01 f0             	add    %rsi,%rax
             derived_iter < derived_end; derived_iter++)
  40af28:	49 83 c6 10          	add    $0x10,%r14
  40af2c:	48 89 18             	mov    %rbx,(%rax)
    elems[i].rating = r;
  40af2f:	44 89 68 08          	mov    %r13d,0x8(%rax)
        for (derived_end = (derived_iter = derived.states) + derived.num_states;
  40af33:	4c 39 b5 30 ff ff ff 	cmp    %r14,-0xd0(%rbp)
  40af3a:	0f 87 09 fd ff ff    	ja     40ac49 <resume_solution+0x7c9>
  40af40:	48 8b 9d c8 fe ff ff 	mov    -0x138(%rbp),%rbx
  40af47:	48 8b 85 50 ff ff ff 	mov    -0xb0(%rbp),%rax
    (FCS_S_SCAN_VISITED(ptr_state))[scan_id >> FCS_CHAR_BIT_SIZE_LOG2] |=
  40af4e:	48 8b bd f8 fe ff ff 	mov    -0x108(%rbp),%rdi
  40af55:	0f b6 8d b0 fe ff ff 	movzbl -0x150(%rbp),%ecx
  40af5c:	08 4c 3b 57          	or     %cl,0x57(%rbx,%rdi,1)
                    MARK_AS_DEAD_END(PTR_STATE);
  40af60:	0f b6 8d d4 fe ff ff 	movzbl -0x12c(%rbp),%ecx
  40af67:	84 8d d3 fe ff ff    	test   %cl,-0x12d(%rbp)
  40af6d:	0f 84 75 f8 ff ff    	je     40a7e8 <resume_solution+0x368>
  40af73:	48 85 c0             	test   %rax,%rax
  40af76:	0f 85 6c f8 ff ff    	jne    40a7e8 <resume_solution+0x368>
  40af7c:	48 8b 43 48          	mov    0x48(%rbx),%rax
    FCS_S_VISITED(temp_state) |= FCS_VISITED_DEAD_END;
  40af80:	80 4b 56 04          	orb    $0x4,0x56(%rbx)
    if (temp_state != NULL)
  40af84:	48 85 c0             	test   %rax,%rax
  40af87:	75 25                	jne    40afae <resume_solution+0xb2e>
  40af89:	e9 5a f8 ff ff       	jmpq   40a7e8 <resume_solution+0x368>
               (FCS_S_VISITED(temp_state) & FCS_VISITED_ALL_TESTS_DONE))
  40af8e:	0f b6 50 56          	movzbl 0x56(%rax),%edx
        while ((FCS_S_NUM_ACTIVE_CHILDREN(temp_state) == 0) &&
  40af92:	f6 c2 08             	test   $0x8,%dl
  40af95:	0f 84 4d f8 ff ff    	je     40a7e8 <resume_solution+0x368>
            FCS_S_VISITED(temp_state) |= FCS_VISITED_DEAD_END;
  40af9b:	83 ca 04             	or     $0x4,%edx
  40af9e:	88 50 56             	mov    %dl,0x56(%rax)
            temp_state = FCS_S_PARENT(temp_state);
  40afa1:	48 8b 40 48          	mov    0x48(%rax),%rax
            if (temp_state == NULL)
  40afa5:	48 85 c0             	test   %rax,%rax
  40afa8:	0f 84 3a f8 ff ff    	je     40a7e8 <resume_solution+0x368>
            (FCS_S_NUM_ACTIVE_CHILDREN(temp_state))--;
  40afae:	0f b7 58 54          	movzwl 0x54(%rax),%ebx
  40afb2:	8d 53 ff             	lea    -0x1(%rbx),%edx
  40afb5:	66 89 50 54          	mov    %dx,0x54(%rax)
        while ((FCS_S_NUM_ACTIVE_CHILDREN(temp_state) == 0) &&
  40afb9:	66 85 d2             	test   %dx,%dx
  40afbc:	74 d0                	je     40af8e <resume_solution+0xb0e>
  40afbe:	e9 25 f8 ff ff       	jmpq   40a7e8 <resume_solution+0x368>
  40afc3:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40afca:	00 00 00 00 
  40afce:	66 90                	xchg   %ax,%ax
                            : FCS_SEQS_OVER_RENEGADE_POWER(cards_num - c));
  40afd0:	45 29 da             	sub    %r11d,%r10d
            cards_under_sequences += FCS_SEQS_OVER_RENEGADE_POWER(c);
  40afd3:	48 98                	cltq   
  40afd5:	c5 fb 58 04 c5 a0 f6 	vaddsd 0x40f6a0(,%rax,8),%xmm0,%xmm0
  40afdc:	40 00 
                            : FCS_SEQS_OVER_RENEGADE_POWER(cards_num - c));
  40afde:	4d 63 d2             	movslq %r10d,%r10
                seqs_over_renegade_cards +=
  40afe1:	c4 a1 73 58 0c d5 a0 	vaddsd 0x40f6a0(,%r10,8),%xmm1,%xmm1
  40afe8:	f6 40 00 
  40afeb:	e9 4e fd ff ff       	jmpq   40ad3e <resume_solution+0x8be>
                    ++num_vacant_stacks;
  40aff0:	80 d1 00             	adc    $0x0,%cl
  40aff3:	e9 46 fd ff ff       	jmpq   40ad3e <resume_solution+0x8be>
  40aff8:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40afff:	00 
    if ((size_t)(allocator->max_ptr - allocator->ptr) < how_much)
  40b000:	48 8b 85 28 ff ff ff 	mov    -0xd8(%rbp),%rax
  40b007:	48 8b 90 e8 00 00 00 	mov    0xe8(%rax),%rdx
  40b00e:	48 8b 80 e0 00 00 00 	mov    0xe0(%rax),%rax
  40b015:	48 89 85 d8 fe ff ff 	mov    %rax,-0x128(%rbp)
  40b01c:	48 29 d0             	sub    %rdx,%rax
  40b01f:	48 83 f8 0f          	cmp    $0xf,%rax
    char *const new_data = meta_request_new_buffer(allocator->meta);
  40b023:	48 8b 85 28 ff ff ff 	mov    -0xd8(%rbp),%rax
  40b02a:	0f 86 57 0a 00 00    	jbe    40ba87 <resume_solution+0x1607>
        allocator->rollback_ptr = allocator->ptr;
  40b030:	48 89 90 f0 00 00 00 	mov    %rdx,0xf0(%rax)
  40b037:	48 89 c7             	mov    %rax,%rdi
    allocator->ptr += how_much;
  40b03a:	48 8d 42 10          	lea    0x10(%rdx),%rax
  40b03e:	48 89 87 e8 00 00 00 	mov    %rax,0xe8(%rdi)
  40b045:	e9 d1 fb ff ff       	jmpq   40ac1b <resume_solution+0x79b>
  40b04a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
                dest_card = fcs_col_get_card(dest_col, 0);
  40b050:	0f be f1             	movsbl %cl,%esi
  40b053:	e9 cf fa ff ff       	jmpq   40ab27 <resume_solution+0x6a7>
  40b058:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40b05f:	00 
    if (derived.states != NULL)
  40b060:	48 8b bd 58 ff ff ff 	mov    -0xa8(%rbp),%rdi
  40b067:	48 85 ff             	test   %rdi,%rdi
  40b06a:	74 6c                	je     40b0d8 <resume_solution+0xc58>
  40b06c:	bb 01 00 00 00       	mov    $0x1,%ebx
  40b071:	41 bc 01 00 00 00    	mov    $0x1,%r12d
  40b077:	e9 d6 f8 ff ff       	jmpq   40a952 <resume_solution+0x4d2>
            for (uint_fast16_t h = 1; h < col_len; h++)
  40b07c:	b8 01 00 00 00       	mov    $0x1,%eax
  40b081:	e9 ca fd ff ff       	jmpq   40ae50 <resume_solution+0x9d0>
    double sum = (max(0, negated_depth) * weighting->depth_factor);
  40b086:	c5 d1 57 ed          	vxorpd %xmm5,%xmm5,%xmm5
  40b08a:	c5 d9 57 e4          	vxorpd %xmm4,%xmm4,%xmm4
  40b08e:	e9 dc fb ff ff       	jmpq   40ac6f <resume_solution+0x7ef>
  40b093:	0f b6 53 56          	movzbl 0x56(%rbx),%edx
  40b097:	e9 26 f7 ff ff       	jmpq   40a7c2 <resume_solution+0x342>
        pq->elems = SREALLOC(pq->elems, (pq->max_size += 256) + 1);
  40b09c:	48 8b bd 08 ff ff ff 	mov    -0xf8(%rbp),%rdi
  40b0a3:	48 8d 8a 00 01 00 00 	lea    0x100(%rdx),%rcx
  40b0aa:	48 8d b2 01 01 00 00 	lea    0x101(%rdx),%rsi
  40b0b1:	48 c1 e6 04          	shl    $0x4,%rsi
  40b0b5:	48 89 0f             	mov    %rcx,(%rdi)
  40b0b8:	48 89 c7             	mov    %rax,%rdi
  40b0bb:	e8 b0 60 ff ff       	callq  401170 <realloc@plt>
  40b0c0:	48 8b bd 08 ff ff ff 	mov    -0xf8(%rbp),%rdi
  40b0c7:	48 89 47 10          	mov    %rax,0x10(%rdi)
  40b0cb:	e9 f1 fd ff ff       	jmpq   40aec1 <resume_solution+0xa41>
    for (i = PQ_FIRST_ENTRY;
  40b0d0:	48 89 f8             	mov    %rdi,%rax
  40b0d3:	e9 48 f8 ff ff       	jmpq   40a920 <resume_solution+0x4a0>
  40b0d8:	bb 01 00 00 00       	mov    $0x1,%ebx
  40b0dd:	41 bc 01 00 00 00    	mov    $0x1,%r12d
  40b0e3:	e9 88 f8 ff ff       	jmpq   40a970 <resume_solution+0x4f0>
    const bool scans_synergy =
  40b0e8:	48 8b b5 28 ff ff ff 	mov    -0xd8(%rbp),%rsi
    ssize_t dfs_max_depth = DFS_VAR(soft_thread, dfs_max_depth);
  40b0ef:	49 8b 7f 28          	mov    0x28(%r15),%rdi
    var_AUTO(
  40b0f3:	49 8b 5f 30          	mov    0x30(%r15),%rbx
    const_AUTO(soft_thread_id, soft_thread->id);
  40b0f7:	41 8b 4f 08          	mov    0x8(%r15),%ecx
    const bool scans_synergy =
  40b0fb:	0f b6 86 b8 00 00 00 	movzbl 0xb8(%rsi),%eax
    ssize_t dfs_max_depth = DFS_VAR(soft_thread, dfs_max_depth);
  40b102:	48 89 bd 20 ff ff ff 	mov    %rdi,-0xe0(%rbp)
    const_SLOT(enable_pruning, soft_thread);
  40b109:	41 0f b6 bf f0 01 00 	movzbl 0x1f0(%r15),%edi
  40b110:	00 
    const bool scans_synergy =
  40b111:	88 85 d1 fe ff ff    	mov    %al,-0x12f(%rbp)
    const bool is_a_complete_scan =
  40b117:	41 0f b6 87 e2 01 00 	movzbl 0x1e2(%r15),%eax
  40b11e:	00 
    const_SLOT(enable_pruning, soft_thread);
  40b11f:	40 88 bd a8 fe ff ff 	mov    %dil,-0x158(%rbp)
    const bool is_a_complete_scan =
  40b126:	88 85 b8 fe ff ff    	mov    %al,-0x148(%rbp)
    var_AUTO(
  40b12c:	49 8b 47 38          	mov    0x38(%r15),%rax
  40b130:	48 8d 14 80          	lea    (%rax,%rax,4),%rdx
  40b134:	48 8d 14 50          	lea    (%rax,%rdx,2),%rdx
  40b138:	48 c1 e2 04          	shl    $0x4,%rdx
  40b13c:	48 01 d3             	add    %rdx,%rbx
    PTR_STATE = the_soft_dfs_info->state;
  40b13f:	48 8b 3b             	mov    (%rbx),%rdi
    fcs_derived_states_list derived_list =
  40b142:	c5 fa 6f 43 08       	vmovdqu 0x8(%rbx),%xmm0
  40b147:	c5 f8 29 85 50 ff ff 	vmovaps %xmm0,-0xb0(%rbp)
  40b14e:	ff 
    const_AUTO(
  40b14f:	49 8b 57 58          	mov    0x58(%r15),%rdx
    PTR_STATE = the_soft_dfs_info->state;
  40b153:	48 89 bd f8 fe ff ff 	mov    %rdi,-0x108(%rbp)
    FCS_ASSIGN_STATE_KEY();
  40b15a:	48 89 bd 18 ff ff ff 	mov    %rdi,-0xe8(%rbp)
  40b161:	48 83 c7 48          	add    $0x48,%rdi
  40b165:	48 89 bd 10 ff ff ff 	mov    %rdi,-0xf0(%rbp)
  40b16c:	48 8b be c8 00 00 00 	mov    0xc8(%rsi),%rdi
    const_AUTO(
  40b173:	48 89 95 78 fe ff ff 	mov    %rdx,-0x188(%rbp)
  40b17a:	48 89 bd c8 fe ff ff 	mov    %rdi,-0x138(%rbp)
    for (; (DEPTH() >= GET_DEPTH(curr_by_depth_unit)); ++curr_by_depth_unit)
  40b181:	48 8b 3a             	mov    (%rdx),%rdi
  40b184:	48 89 bd d8 fe ff ff 	mov    %rdi,-0x128(%rbp)
  40b18b:	48 39 f8             	cmp    %rdi,%rax
  40b18e:	0f 8c b8 13 00 00    	jl     40c54c <resume_solution+0x20cc>
  40b194:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40b19b:	00 00 00 00 
  40b19f:	90                   	nop
  40b1a0:	48 83 c2 18          	add    $0x18,%rdx
  40b1a4:	48 8b 32             	mov    (%rdx),%rsi
  40b1a7:	48 39 f0             	cmp    %rsi,%rax
  40b1aa:	7d f4                	jge    40b1a0 <resume_solution+0xd20>
  40b1ac:	48 89 95 b0 fe ff ff 	mov    %rdx,-0x150(%rbp)
  40b1b3:	48 89 b5 d8 fe ff ff 	mov    %rsi,-0x128(%rbp)
    RECALC_BY_DEPTH_LIMITS();
  40b1ba:	48 39 95 78 fe ff ff 	cmp    %rdx,-0x188(%rbp)
  40b1c1:	0f 84 72 13 00 00    	je     40c539 <resume_solution+0x20b9>
  40b1c7:	48 8b 7a e8          	mov    -0x18(%rdx),%rdi
  40b1cb:	48 89 bd c0 fe ff ff 	mov    %rdi,-0x140(%rbp)
  40b1d2:	48 89 d7             	mov    %rdx,%rdi
  40b1d5:	48 8b 77 08          	mov    0x8(%rdi),%rsi
  40b1d9:	ba 01 00 00 00       	mov    $0x1,%edx
    fcs_moves_group_kind local_shuffling_type = FCS_NO_SHUFFLING;
  40b1de:	49 89 de             	mov    %rbx,%r14
  40b1e1:	c7 85 d4 fe ff ff 00 	movl   $0x0,-0x12c(%rbp)
  40b1e8:	00 00 00 
    RECALC_BY_DEPTH_LIMITS();
  40b1eb:	48 8b 7f 10          	mov    0x10(%rdi),%rdi
  40b1ef:	48 89 b5 08 ff ff ff 	mov    %rsi,-0xf8(%rbp)
  40b1f6:	48 89 bd e0 fe ff ff 	mov    %rdi,-0x120(%rbp)
                (!is_scan_visited(single_derived_state, soft_thread_id)))
  40b1fd:	89 cf                	mov    %ecx,%edi
  40b1ff:	83 e1 07             	and    $0x7,%ecx
  40b202:	d3 e2                	shl    %cl,%edx
  40b204:	c1 ff 03             	sar    $0x3,%edi
  40b207:	89 bd 00 ff ff ff    	mov    %edi,-0x100(%rbp)
  40b20d:	89 95 30 ff ff ff    	mov    %edx,-0xd0(%rbp)
  40b213:	88 95 d3 fe ff ff    	mov    %dl,-0x12d(%rbp)
  40b219:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
        if (unlikely(DEPTH() + 1 >= dfs_max_depth))
  40b220:	48 83 c0 01          	add    $0x1,%rax
  40b224:	48 3b 85 20 ff ff ff 	cmp    -0xe0(%rbp),%rax
  40b22b:	0f 8d 44 01 00 00    	jge    40b375 <resume_solution+0xef5>
        if (the_soft_dfs_info->current_state_index == derived_list.num_states)
  40b231:	49 8b 46 20          	mov    0x20(%r14),%rax
  40b235:	48 8b b5 50 ff ff ff 	mov    -0xb0(%rbp),%rsi
  40b23c:	48 39 f0             	cmp    %rsi,%rax
  40b23f:	0f 84 bb 01 00 00    	je     40b400 <resume_solution+0xf80>
  40b245:	4c 8b 85 58 ff ff ff 	mov    -0xa8(%rbp),%r8
  40b24c:	48 83 e8 01          	sub    $0x1,%rax
  40b250:	4d 8b 5e 38          	mov    0x38(%r14),%r11
  40b254:	48 8d 14 c5 00 00 00 	lea    0x0(,%rax,8),%rdx
  40b25b:	00 
  40b25c:	48 89 c1             	mov    %rax,%rcx
                (!is_scan_visited(single_derived_state, soft_thread_id)))
  40b25f:	4c 63 95 00 ff ff ff 	movslq -0x100(%rbp),%r10
  40b266:	48 f7 d9             	neg    %rcx
  40b269:	48 8d 3c ca          	lea    (%rdx,%rcx,8),%rdi
  40b26d:	4c 01 df             	add    %r11,%rdi
        while (++state_idx < num_states)
  40b270:	48 83 c0 01          	add    $0x1,%rax
  40b274:	48 39 f0             	cmp    %rsi,%rax
  40b277:	0f 83 53 02 00 00    	jae    40b4d0 <resume_solution+0x1050>
                derived_states[(*(++rand_int_ptr)).idx].state_ptr;
  40b27d:	48 63 14 c7          	movslq (%rdi,%rax,8),%rdx
            fcs_collectible_state *const single_derived_state =
  40b281:	48 c1 e2 04          	shl    $0x4,%rdx
  40b285:	49 8b 14 10          	mov    (%r8,%rdx,1),%rdx
            if ((!fcs__is_state_a_dead_end(single_derived_state)) &&
  40b289:	f6 42 56 04          	testb  $0x4,0x56(%rdx)
  40b28d:	75 e1                	jne    40b270 <resume_solution+0xdf0>
                (!is_scan_visited(single_derived_state, soft_thread_id)))
  40b28f:	46 0f b6 4c 12 57    	movzbl 0x57(%rdx,%r10,1),%r9d
  40b295:	44 89 c9             	mov    %r9d,%ecx
            if ((!fcs__is_state_a_dead_end(single_derived_state)) &&
  40b298:	44 85 8d 30 ff ff ff 	test   %r9d,-0xd0(%rbp)
  40b29f:	75 cf                	jne    40b270 <resume_solution+0xdf0>
                BUMP_NUM_CHECKED_STATES();
  40b2a1:	48 8b 9d 28 ff ff ff 	mov    -0xd8(%rbp),%rbx
  40b2a8:	0a 8d d3 fe ff ff    	or     -0x12d(%rbp),%cl
  40b2ae:	48 83 03 01          	addq   $0x1,(%rbx)
                if (unlikely(++DEPTH() >= by_depth_max_depth))
  40b2b2:	49 8b 5f 38          	mov    0x38(%r15),%rbx
  40b2b6:	42 88 4c 12 57       	mov    %cl,0x57(%rdx,%r10,1)
  40b2bb:	48 8d 4b 01          	lea    0x1(%rbx),%rcx
  40b2bf:	49 89 4f 38          	mov    %rcx,0x38(%r15)
  40b2c3:	48 3b 8d d8 fe ff ff 	cmp    -0x128(%rbp),%rcx
  40b2ca:	0f 8d eb 0b 00 00    	jge    40bebb <resume_solution+0x1a3b>
                the_soft_dfs_info->current_state_index = state_idx;
  40b2d0:	49 89 46 20          	mov    %rax,0x20(%r14)
                the_soft_dfs_info->derived_states_list = derived_list;
  40b2d4:	c5 f9 6f 85 50 ff ff 	vmovdqa -0xb0(%rbp),%xmm0
  40b2db:	ff 
                FCS_ASSIGN_STATE_KEY();
  40b2dc:	48 8d 42 48          	lea    0x48(%rdx),%rax
                the_soft_dfs_info->state = PTR_STATE = single_derived_state;
  40b2e0:	49 89 96 b0 00 00 00 	mov    %rdx,0xb0(%r14)
                if (check_if_limits_exceeded())
  40b2e7:	48 8b bd c8 fe ff ff 	mov    -0x138(%rbp),%rdi
                FCS_ASSIGN_STATE_KEY();
  40b2ee:	48 89 85 10 ff ff ff 	mov    %rax,-0xf0(%rbp)
                if (check_if_limits_exceeded())
  40b2f5:	48 8b 85 28 ff ff ff 	mov    -0xd8(%rbp),%rax
                ++the_soft_dfs_info;
  40b2fc:	49 8d 8e b0 00 00 00 	lea    0xb0(%r14),%rcx
                the_soft_dfs_info->derived_states_list = derived_list;
  40b303:	c4 c1 78 11 46 08    	vmovups %xmm0,0x8(%r14)
                derived_list = the_soft_dfs_info->derived_states_list;
  40b309:	c4 c1 7a 6f 86 b8 00 	vmovdqu 0xb8(%r14),%xmm0
  40b310:	00 00 
                the_soft_dfs_info->move_func_list_idx = 0;
  40b312:	49 c7 86 c8 00 00 00 	movq   $0x0,0xc8(%r14)
  40b319:	00 00 00 00 
                the_soft_dfs_info->move_func_idx = 0;
  40b31d:	49 c7 86 d8 00 00 00 	movq   $0x0,0xd8(%r14)
  40b324:	00 00 00 00 
                the_soft_dfs_info->current_state_index = 0;
  40b328:	49 c7 86 d0 00 00 00 	movq   $0x0,0xd0(%r14)
  40b32f:	00 00 00 00 
                FCS_ASSIGN_STATE_KEY();
  40b333:	48 89 95 18 ff ff ff 	mov    %rdx,-0xe8(%rbp)
                derived_list = the_soft_dfs_info->derived_states_list;
  40b33a:	c5 f8 29 85 50 ff ff 	vmovaps %xmm0,-0xb0(%rbp)
  40b341:	ff 
                derived_list.num_states = 0;
  40b342:	48 c7 85 50 ff ff ff 	movq   $0x0,-0xb0(%rbp)
  40b349:	00 00 00 00 
                if (check_if_limits_exceeded())
  40b34d:	48 3b 38             	cmp    (%rax),%rdi
  40b350:	0f 84 25 11 00 00    	je     40c47b <resume_solution+0x1ffb>
  40b356:	49 8b 47 38          	mov    0x38(%r15),%rax
  40b35a:	48 89 95 f8 fe ff ff 	mov    %rdx,-0x108(%rbp)
                ++the_soft_dfs_info;
  40b361:	49 89 ce             	mov    %rcx,%r14
        if (unlikely(DEPTH() + 1 >= dfs_max_depth))
  40b364:	48 83 c0 01          	add    $0x1,%rax
  40b368:	48 3b 85 20 ff ff ff 	cmp    -0xe0(%rbp),%rax
  40b36f:	0f 8c bc fe ff ff    	jl     40b231 <resume_solution+0xdb1>
    const_AUTO(new_dfs_max_depth,
  40b375:	49 8b 47 28          	mov    0x28(%r15),%rax
        SREALLOC(DFS_VAR(soft_thread, soft_dfs_info), new_dfs_max_depth);
  40b379:	49 8b 7f 30          	mov    0x30(%r15),%rdi
    const_AUTO(new_dfs_max_depth,
  40b37d:	48 8d 58 40          	lea    0x40(%rax),%rbx
        SREALLOC(DFS_VAR(soft_thread, soft_dfs_info), new_dfs_max_depth);
  40b381:	48 8d 04 9b          	lea    (%rbx,%rbx,4),%rax
    const_AUTO(new_dfs_max_depth,
  40b385:	48 89 9d 20 ff ff ff 	mov    %rbx,-0xe0(%rbp)
        SREALLOC(DFS_VAR(soft_thread, soft_dfs_info), new_dfs_max_depth);
  40b38c:	48 8d 34 43          	lea    (%rbx,%rax,2),%rsi
  40b390:	48 c1 e6 04          	shl    $0x4,%rsi
  40b394:	e8 d7 5d ff ff       	callq  401170 <realloc@plt>
    memset(DFS_VAR(soft_thread, soft_dfs_info) +
  40b399:	49 8b 57 28          	mov    0x28(%r15),%rdx
  40b39d:	31 f6                	xor    %esi,%esi
    DFS_VAR(soft_thread, soft_dfs_info) =
  40b39f:	49 89 47 30          	mov    %rax,0x30(%r15)
    memset(DFS_VAR(soft_thread, soft_dfs_info) +
  40b3a3:	48 8d 0c 92          	lea    (%rdx,%rdx,4),%rcx
  40b3a7:	48 8d 3c 4a          	lea    (%rdx,%rcx,2),%rdi
  40b3ab:	ba 00 2c 00 00       	mov    $0x2c00,%edx
  40b3b0:	48 c1 e7 04          	shl    $0x4,%rdi
  40b3b4:	48 01 c7             	add    %rax,%rdi
  40b3b7:	e8 e4 5c ff ff       	callq  4010a0 <memset@plt>
            the_soft_dfs_info = &(DFS_VAR(soft_thread, soft_dfs_info)[DEPTH()]);
  40b3bc:	49 8b 47 38          	mov    0x38(%r15),%rax
    DFS_VAR(soft_thread, dfs_max_depth) = new_dfs_max_depth;
  40b3c0:	49 89 5f 28          	mov    %rbx,0x28(%r15)
            the_soft_dfs_info = &(DFS_VAR(soft_thread, soft_dfs_info)[DEPTH()]);
  40b3c4:	48 8d 14 80          	lea    (%rax,%rax,4),%rdx
  40b3c8:	48 8d 04 50          	lea    (%rax,%rdx,2),%rax
  40b3cc:	48 c1 e0 04          	shl    $0x4,%rax
  40b3d0:	49 03 47 30          	add    0x30(%r15),%rax
            derived_list = the_soft_dfs_info->derived_states_list;
  40b3d4:	c5 fa 6f 40 08       	vmovdqu 0x8(%rax),%xmm0
            the_soft_dfs_info = &(DFS_VAR(soft_thread, soft_dfs_info)[DEPTH()]);
  40b3d9:	49 89 c6             	mov    %rax,%r14
            derived_list = the_soft_dfs_info->derived_states_list;
  40b3dc:	c5 f8 29 85 50 ff ff 	vmovaps %xmm0,-0xb0(%rbp)
  40b3e3:	ff 
        if (the_soft_dfs_info->current_state_index == derived_list.num_states)
  40b3e4:	49 8b 46 20          	mov    0x20(%r14),%rax
  40b3e8:	48 8b b5 50 ff ff ff 	mov    -0xb0(%rbp),%rsi
  40b3ef:	48 39 f0             	cmp    %rsi,%rax
  40b3f2:	0f 85 4d fe ff ff    	jne    40b245 <resume_solution+0xdc5>
  40b3f8:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40b3ff:	00 
            if (the_soft_dfs_info->move_func_list_idx ==
  40b400:	49 8b 5e 18          	mov    0x18(%r14),%rbx
  40b404:	48 3b 9d 08 ff ff ff 	cmp    -0xf8(%rbp),%rbx
  40b40b:	0f 84 cf 00 00 00    	je     40b4e0 <resume_solution+0x1060>
            derived_list.num_states = 0;
  40b411:	48 c7 85 50 ff ff ff 	movq   $0x0,-0xb0(%rbp)
  40b418:	00 00 00 00 
            if ((the_soft_dfs_info->move_func_idx == 0) &&
  40b41c:	48 89 d8             	mov    %rbx,%rax
  40b41f:	49 0b 46 28          	or     0x28(%r14),%rax
  40b423:	0f 84 c7 01 00 00    	je     40b5f0 <resume_solution+0x1170>
                &(THE_MOVE_FUNCS_LIST.groups[orig_idx].weighting);
  40b429:	48 69 c3 e8 00 00 00 	imul   $0xe8,%rbx,%rax
  40b430:	48 03 85 e0 fe ff ff 	add    -0x120(%rbp),%rax
  40b437:	48 89 85 e8 fe ff ff 	mov    %rax,-0x118(%rbp)
            if (the_soft_dfs_info->move_func_list_idx < THE_MOVE_FUNCS_LIST.num)
  40b43e:	48 3b 9d 08 ff ff ff 	cmp    -0xf8(%rbp),%rbx
  40b445:	0f 82 55 04 00 00    	jb     40b8a0 <resume_solution+0x1420>
  40b44b:	4d 8b 5e 38          	mov    0x38(%r14),%r11
            const_AUTO(num_states, derived_list.num_states);
  40b44f:	45 31 ed             	xor    %r13d,%r13d
  40b452:	31 f6                	xor    %esi,%esi
  40b454:	4c 8b 85 58 ff ff ff 	mov    -0xa8(%rbp),%r8
            for (size_t i = 0; i < num_states; i++)
  40b45b:	4d 85 ed             	test   %r13,%r13
  40b45e:	74 50                	je     40b4b0 <resume_solution+0x1030>
            if (num_states >
  40b460:	31 c0                	xor    %eax,%eax
  40b462:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40b469:	00 00 00 00 
  40b46d:	0f 1f 00             	nopl   (%rax)
                rand_array[i].idx = i;
  40b470:	41 89 04 c3          	mov    %eax,(%r11,%rax,8)
            for (size_t i = 0; i < num_states; i++)
  40b474:	48 83 c0 01          	add    $0x1,%rax
  40b478:	4c 39 e8             	cmp    %r13,%rax
  40b47b:	72 f3                	jb     40b470 <resume_solution+0xff0>
            if (num_states > 1)
  40b47d:	49 83 fd 01          	cmp    $0x1,%r13
  40b481:	76 2d                	jbe    40b4b0 <resume_solution+0x1030>
                switch (local_shuffling_type)
  40b483:	8b 85 d4 fe ff ff    	mov    -0x12c(%rbp),%eax
  40b489:	83 f8 01             	cmp    $0x1,%eax
  40b48c:	0f 84 c6 04 00 00    	je     40b958 <resume_solution+0x14d8>
  40b492:	83 f8 02             	cmp    $0x2,%eax
  40b495:	75 19                	jne    40b4b0 <resume_solution+0x1030>
                    if (orig_idx < THE_MOVE_FUNCS_LIST.num)
  40b497:	48 3b 9d 08 ff ff ff 	cmp    -0xf8(%rbp),%rbx
  40b49e:	0f 82 74 0a 00 00    	jb     40bf18 <resume_solution+0x1a98>
  40b4a4:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40b4ab:	00 00 00 00 
  40b4af:	90                   	nop
            the_soft_dfs_info->current_state_index = 0;
  40b4b0:	49 c7 46 20 00 00 00 	movq   $0x0,0x20(%r14)
  40b4b7:	00 
  40b4b8:	48 c7 c2 f8 ff ff ff 	mov    $0xfffffffffffffff8,%rdx
  40b4bf:	48 c7 c0 ff ff ff ff 	mov    $0xffffffffffffffff,%rax
  40b4c6:	e9 91 fd ff ff       	jmpq   40b25c <resume_solution+0xddc>
  40b4cb:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
        the_soft_dfs_info->current_state_index = num_states;
  40b4d0:	49 89 76 20          	mov    %rsi,0x20(%r14)
  40b4d4:	49 8b 47 38          	mov    0x38(%r15),%rax
  40b4d8:	e9 43 fd ff ff       	jmpq   40b220 <resume_solution+0xda0>
  40b4dd:	0f 1f 00             	nopl   (%rax)
                if (is_a_complete_scan)
  40b4e0:	80 bd b8 fe ff ff 00 	cmpb   $0x0,-0x148(%rbp)
  40b4e7:	74 20                	je     40b509 <resume_solution+0x1089>
                    FCS_S_VISITED(PTR_STATE) |= FCS_VISITED_ALL_TESTS_DONE;
  40b4e9:	48 8b 9d f8 fe ff ff 	mov    -0x108(%rbp),%rbx
  40b4f0:	0f b6 43 56          	movzbl 0x56(%rbx),%eax
  40b4f4:	89 c2                	mov    %eax,%edx
  40b4f6:	83 ca 08             	or     $0x8,%edx
                    MARK_AS_DEAD_END(PTR_STATE);
  40b4f9:	80 bd d1 fe ff ff 00 	cmpb   $0x0,-0x12f(%rbp)
                    FCS_S_VISITED(PTR_STATE) |= FCS_VISITED_ALL_TESTS_DONE;
  40b500:	88 53 56             	mov    %dl,0x56(%rbx)
                    MARK_AS_DEAD_END(PTR_STATE);
  40b503:	0f 85 cc 05 00 00    	jne    40bad5 <resume_solution+0x1655>
                the_soft_dfs_info->derived_states_list = derived_list;
  40b509:	c5 f9 6f 85 50 ff ff 	vmovdqa -0xb0(%rbp),%xmm0
  40b510:	ff 
  40b511:	c4 c1 78 11 46 08    	vmovups %xmm0,0x8(%r14)
                if (unlikely(--DEPTH() < 0))
  40b517:	49 8b 47 38          	mov    0x38(%r15),%rax
  40b51b:	48 83 e8 01          	sub    $0x1,%rax
  40b51f:	49 89 47 38          	mov    %rax,0x38(%r15)
  40b523:	48 85 c0             	test   %rax,%rax
  40b526:	0f 88 05 0e 00 00    	js     40c331 <resume_solution+0x1eb1>
                derived_list = the_soft_dfs_info->derived_states_list;
  40b52c:	c4 c1 7a 6f 86 58 ff 	vmovdqu -0xa8(%r14),%xmm0
  40b533:	ff ff 
                --the_soft_dfs_info;
  40b535:	49 8d 96 50 ff ff ff 	lea    -0xb0(%r14),%rdx
                derived_list = the_soft_dfs_info->derived_states_list;
  40b53c:	c5 f8 29 85 50 ff ff 	vmovaps %xmm0,-0xb0(%rbp)
  40b543:	ff 
                soft_thread->num_vacant_freecells =
  40b544:	41 0f b6 4e f9       	movzbl -0x7(%r14),%ecx
                PTR_STATE = the_soft_dfs_info->state;
  40b549:	49 8b 9e 50 ff ff ff 	mov    -0xb0(%r14),%rbx
                soft_thread->num_vacant_freecells =
  40b550:	41 88 8f e4 01 00 00 	mov    %cl,0x1e4(%r15)
                soft_thread->num_vacant_stacks =
  40b557:	41 0f b6 4e f8       	movzbl -0x8(%r14),%ecx
                --the_soft_dfs_info;
  40b55c:	49 89 d6             	mov    %rdx,%r14
                PTR_STATE = the_soft_dfs_info->state;
  40b55f:	48 89 9d f8 fe ff ff 	mov    %rbx,-0x108(%rbp)
                FCS_ASSIGN_STATE_KEY();
  40b566:	48 89 9d 18 ff ff ff 	mov    %rbx,-0xe8(%rbp)
  40b56d:	48 83 c3 48          	add    $0x48,%rbx
  40b571:	48 89 9d 10 ff ff ff 	mov    %rbx,-0xf0(%rbp)
                soft_thread->num_vacant_stacks =
  40b578:	41 88 8f e3 01 00 00 	mov    %cl,0x1e3(%r15)
                if (unlikely(DEPTH() < by_depth_min_depth))
  40b57f:	48 3b 85 c0 fe ff ff 	cmp    -0x140(%rbp),%rax
  40b586:	0f 8d 94 fc ff ff    	jge    40b220 <resume_solution+0xda0>
                    curr_by_depth_unit--;
  40b58c:	48 8b 9d b0 fe ff ff 	mov    -0x150(%rbp),%rbx
                    RECALC_BY_DEPTH_LIMITS();
  40b593:	48 c7 85 c0 fe ff ff 	movq   $0x0,-0x140(%rbp)
  40b59a:	00 00 00 00 
  40b59e:	48 8b 7b e8          	mov    -0x18(%rbx),%rdi
                    curr_by_depth_unit--;
  40b5a2:	48 8d 4b e8          	lea    -0x18(%rbx),%rcx
                    RECALC_BY_DEPTH_LIMITS();
  40b5a6:	48 89 bd d8 fe ff ff 	mov    %rdi,-0x128(%rbp)
  40b5ad:	48 39 8d 78 fe ff ff 	cmp    %rcx,-0x188(%rbp)
  40b5b4:	74 12                	je     40b5c8 <resume_solution+0x1148>
  40b5b6:	48 8b 5b d0          	mov    -0x30(%rbx),%rbx
  40b5ba:	48 89 9d c0 fe ff ff 	mov    %rbx,-0x140(%rbp)
  40b5c1:	48 8b 9d b0 fe ff ff 	mov    -0x150(%rbp),%rbx
  40b5c8:	48 8b 7b f0          	mov    -0x10(%rbx),%rdi
                    curr_by_depth_unit--;
  40b5cc:	48 89 8d b0 fe ff ff 	mov    %rcx,-0x150(%rbp)
                --the_soft_dfs_info;
  40b5d3:	49 89 d6             	mov    %rdx,%r14
                    RECALC_BY_DEPTH_LIMITS();
  40b5d6:	48 8b 5b f8          	mov    -0x8(%rbx),%rbx
  40b5da:	48 89 bd 08 ff ff ff 	mov    %rdi,-0xf8(%rbp)
  40b5e1:	48 89 9d e0 fe ff ff 	mov    %rbx,-0x120(%rbp)
  40b5e8:	e9 33 fc ff ff       	jmpq   40b220 <resume_solution+0xda0>
  40b5ed:	0f 1f 00             	nopl   (%rax)
    return (enable_pruning && fcs__should_state_be_pruned__state(ptr_state));
  40b5f0:	80 bd a8 fe ff ff 00 	cmpb   $0x0,-0x158(%rbp)
  40b5f7:	0f 84 33 01 00 00    	je     40b730 <resume_solution+0x12b0>
  40b5fd:	48 8b 85 f8 fe ff ff 	mov    -0x108(%rbp),%rax
  40b604:	f6 40 56 10          	testb  $0x10,0x56(%rax)
  40b608:	0f 85 22 01 00 00    	jne    40b730 <resume_solution+0x12b0>
                    fcs_collectible_state *const derived =
  40b60e:	48 8b b5 18 ff ff ff 	mov    -0xe8(%rbp),%rsi
  40b615:	4c 89 ff             	mov    %r15,%rdi
  40b618:	48 8b 95 10 ff ff ff 	mov    -0xf0(%rbp),%rdx
  40b61f:	e8 fc 70 ff ff       	callq  402720 <fc_solve_sfs_raymond_prune>
  40b624:	48 89 c3             	mov    %rax,%rbx
                    if (derived)
  40b627:	48 85 c0             	test   %rax,%rax
  40b62a:	0f 84 00 01 00 00    	je     40b730 <resume_solution+0x12b0>
                        the_soft_dfs_info->move_func_list_idx =
  40b630:	48 8b 85 08 ff ff ff 	mov    -0xf8(%rbp),%rax
    if ((!((list->num_states + (list->states != NULL)) &
  40b637:	31 c9                	xor    %ecx,%ecx
  40b639:	49 89 46 18          	mov    %rax,0x18(%r14)
  40b63d:	48 8b 85 58 ff ff ff 	mov    -0xa8(%rbp),%rax
  40b644:	48 8b 95 50 ff ff ff 	mov    -0xb0(%rbp),%rdx
  40b64b:	48 85 c0             	test   %rax,%rax
  40b64e:	0f 95 c1             	setne  %cl
  40b651:	48 01 d1             	add    %rdx,%rcx
  40b654:	f6 c1 0f             	test   $0xf,%cl
  40b657:	75 21                	jne    40b67a <resume_solution+0x11fa>
            SREALLOC(list->states, list->num_states + (list->states != NULL) +
  40b659:	48 83 c1 10          	add    $0x10,%rcx
  40b65d:	48 89 c7             	mov    %rax,%rdi
  40b660:	48 c1 e1 04          	shl    $0x4,%rcx
  40b664:	48 89 ce             	mov    %rcx,%rsi
  40b667:	e8 04 5b ff ff       	callq  401170 <realloc@plt>
  40b66c:	48 8b 95 50 ff ff ff 	mov    -0xb0(%rbp),%rdx
        list->states =
  40b673:	48 89 85 58 ff ff ff 	mov    %rax,-0xa8(%rbp)
    list->states[list->num_states++] = (fcs_derived_states_list_item){
  40b67a:	48 8d 4a 01          	lea    0x1(%rdx),%rcx
  40b67e:	48 c1 e2 04          	shl    $0x4,%rdx
  40b682:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  40b686:	48 01 d0             	add    %rdx,%rax
  40b689:	48 89 8d 50 ff ff ff 	mov    %rcx,-0xb0(%rbp)
                        if (the_soft_dfs_info
  40b690:	49 83 7e 30 00       	cmpq   $0x0,0x30(%r14)
  40b695:	c5 f8 11 00          	vmovups %xmm0,(%rax)
  40b699:	48 89 18             	mov    %rbx,(%rax)
  40b69c:	49 8b 46 38          	mov    0x38(%r14),%rax
  40b6a0:	75 19                	jne    40b6bb <resume_solution+0x123b>
                                ->derived_states_random_indexes_max_size = 1;
  40b6a2:	49 c7 46 30 01 00 00 	movq   $0x1,0x30(%r14)
  40b6a9:	00 
                                ->derived_states_random_indexes = SREALLOC(
  40b6aa:	be 08 00 00 00       	mov    $0x8,%esi
  40b6af:	48 89 c7             	mov    %rax,%rdi
  40b6b2:	e8 b9 5a ff ff       	callq  401170 <realloc@plt>
  40b6b7:	49 89 46 38          	mov    %rax,0x38(%r14)
  40b6bb:	49 8b 5e 18          	mov    0x18(%r14),%rbx
                            .idx = 0;
  40b6bf:	c7 00 00 00 00 00    	movl   $0x0,(%rax)
                &(THE_MOVE_FUNCS_LIST.groups[orig_idx].weighting);
  40b6c5:	48 69 c3 e8 00 00 00 	imul   $0xe8,%rbx,%rax
  40b6cc:	48 03 85 e0 fe ff ff 	add    -0x120(%rbp),%rax
  40b6d3:	48 89 85 e8 fe ff ff 	mov    %rax,-0x118(%rbp)
            if (the_soft_dfs_info->move_func_list_idx < THE_MOVE_FUNCS_LIST.num)
  40b6da:	48 39 9d 08 ff ff ff 	cmp    %rbx,-0xf8(%rbp)
  40b6e1:	0f 87 b9 01 00 00    	ja     40b8a0 <resume_solution+0x1420>
            const_AUTO(num_states, derived_list.num_states);
  40b6e7:	4c 8b ad 50 ff ff ff 	mov    -0xb0(%rbp),%r13
  40b6ee:	4d 8b 5e 38          	mov    0x38(%r14),%r11
            if (num_states >
  40b6f2:	4c 89 ee             	mov    %r13,%rsi
  40b6f5:	4d 3b 6e 30          	cmp    0x30(%r14),%r13
  40b6f9:	0f 86 55 fd ff ff    	jbe    40b454 <resume_solution+0xfd4>
                the_soft_dfs_info->derived_states_random_indexes = SREALLOC(
  40b6ff:	4c 89 df             	mov    %r11,%rdi
                the_soft_dfs_info->derived_states_random_indexes_max_size =
  40b702:	4d 89 6e 30          	mov    %r13,0x30(%r14)
                the_soft_dfs_info->derived_states_random_indexes = SREALLOC(
  40b706:	4a 8d 34 ed 00 00 00 	lea    0x0(,%r13,8),%rsi
  40b70d:	00 
  40b70e:	e8 5d 5a ff ff       	callq  401170 <realloc@plt>
  40b713:	48 8b b5 50 ff ff ff 	mov    -0xb0(%rbp),%rsi
  40b71a:	49 89 c3             	mov    %rax,%r11
  40b71d:	49 89 46 38          	mov    %rax,0x38(%r14)
  40b721:	e9 2e fd ff ff       	jmpq   40b454 <resume_solution+0xfd4>
  40b726:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  40b72d:	00 00 00 
        if (fcs_freecell_is_empty(*state_ptr, i))
  40b730:	48 8b 9d f8 fe ff ff 	mov    -0x108(%rbp),%rbx
  40b737:	80 7b 40 00          	cmpb   $0x0,0x40(%rbx)
        if (fcs_state_col_is_empty(*state_ptr, i))
  40b73b:	48 8b 03             	mov    (%rbx),%rax
  40b73e:	48 8b 4b 08          	mov    0x8(%rbx),%rcx
        if (fcs_freecell_is_empty(*state_ptr, i))
  40b742:	0f 94 c2             	sete   %dl
            num_vacant_freecells++;
  40b745:	80 7b 41 01          	cmpb   $0x1,0x41(%rbx)
  40b749:	80 d2 00             	adc    $0x0,%dl
  40b74c:	80 7b 42 01          	cmpb   $0x1,0x42(%rbx)
  40b750:	80 d2 00             	adc    $0x0,%dl
  40b753:	80 7b 43 01          	cmpb   $0x1,0x43(%rbx)
  40b757:	80 d2 00             	adc    $0x0,%dl
        if (fcs_state_col_is_empty(*state_ptr, i))
  40b75a:	80 38 00             	cmpb   $0x0,(%rax)
  40b75d:	0f 94 c0             	sete   %al
            ++num_vacant_stacks;
  40b760:	80 39 01             	cmpb   $0x1,(%rcx)
        if (fcs_state_col_is_empty(*state_ptr, i))
  40b763:	48 8b 4b 10          	mov    0x10(%rbx),%rcx
            ++num_vacant_stacks;
  40b767:	14 00                	adc    $0x0,%al
  40b769:	80 39 01             	cmpb   $0x1,(%rcx)
        if (fcs_state_col_is_empty(*state_ptr, i))
  40b76c:	48 8b 4b 18          	mov    0x18(%rbx),%rcx
            ++num_vacant_stacks;
  40b770:	14 00                	adc    $0x0,%al
  40b772:	80 39 01             	cmpb   $0x1,(%rcx)
        if (fcs_state_col_is_empty(*state_ptr, i))
  40b775:	48 8b 4b 20          	mov    0x20(%rbx),%rcx
            ++num_vacant_stacks;
  40b779:	14 00                	adc    $0x0,%al
  40b77b:	80 39 01             	cmpb   $0x1,(%rcx)
        if (fcs_state_col_is_empty(*state_ptr, i))
  40b77e:	48 8b 4b 28          	mov    0x28(%rbx),%rcx
            ++num_vacant_stacks;
  40b782:	14 00                	adc    $0x0,%al
  40b784:	80 39 01             	cmpb   $0x1,(%rcx)
        if (fcs_state_col_is_empty(*state_ptr, i))
  40b787:	48 8b 4b 30          	mov    0x30(%rbx),%rcx
            ++num_vacant_stacks;
  40b78b:	14 00                	adc    $0x0,%al
  40b78d:	80 39 01             	cmpb   $0x1,(%rcx)
        if (fcs_state_col_is_empty(*state_ptr, i))
  40b790:	48 8b 4b 38          	mov    0x38(%rbx),%rcx
            ++num_vacant_stacks;
  40b794:	14 00                	adc    $0x0,%al
        if (fcs_state_col_is_empty(*state_ptr, i))
  40b796:	80 39 00             	cmpb   $0x0,(%rcx)
  40b799:	75 15                	jne    40b7b0 <resume_solution+0x1330>
            ++num_vacant_stacks;
  40b79b:	83 c0 01             	add    $0x1,%eax
                    if (unlikely((num_vacant_stacks == LOCAL_STACKS_NUM) &&
  40b79e:	3c 08                	cmp    $0x8,%al
  40b7a0:	75 0e                	jne    40b7b0 <resume_solution+0x1330>
  40b7a2:	80 fa 04             	cmp    $0x4,%dl
  40b7a5:	0f 84 25 0d 00 00    	je     40c4d0 <resume_solution+0x2050>
  40b7ab:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
    memset(positions_by_rank, -1, sizeof(fcs__positions_by_rank));
  40b7b0:	4c 8b ad f8 fe ff ff 	mov    -0x108(%rbp),%r13
                        (the_soft_dfs_info->positions_by_rank)
  40b7b7:	49 8d 5e 40          	lea    0x40(%r14),%rbx
  40b7bb:	c5 f9 76 c0          	vpcmpeqd %xmm0,%xmm0,%xmm0
  40b7bf:	45 31 d2             	xor    %r10d,%r10d
                        the_soft_dfs_info->num_vacant_freecells =
  40b7c2:	41 88 96 a9 00 00 00 	mov    %dl,0xa9(%r14)
                    soft_thread->num_vacant_freecells =
  40b7c9:	41 88 97 e4 01 00 00 	mov    %dl,0x1e4(%r15)
                        the_soft_dfs_info->num_vacant_stacks =
  40b7d0:	41 88 86 a8 00 00 00 	mov    %al,0xa8(%r14)
                    soft_thread->num_vacant_stacks =
  40b7d7:	41 88 87 e3 01 00 00 	mov    %al,0x1e3(%r15)
  40b7de:	c4 c1 78 11 46 40    	vmovups %xmm0,0x40(%r14)
  40b7e4:	c5 f8 11 43 10       	vmovups %xmm0,0x10(%rbx)
  40b7e9:	c5 f8 11 43 20       	vmovups %xmm0,0x20(%rbx)
  40b7ee:	c5 f8 11 43 30       	vmovups %xmm0,0x30(%rbx)
  40b7f3:	c5 f8 11 43 40       	vmovups %xmm0,0x40(%rbx)
  40b7f8:	c5 f8 11 43 50       	vmovups %xmm0,0x50(%rbx)
  40b7fd:	48 c7 43 60 ff ff ff 	movq   $0xffffffffffffffff,0x60(%rbx)
  40b804:	ff 
  40b805:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40b80c:	00 00 00 00 
            const_AUTO(dest_col, fcs_state_get_col(state_key, ds));
  40b810:	4f 8b 44 d5 00       	mov    0x0(%r13,%r10,8),%r8
            int top_card_idx = fcs_col_len(dest_col);
  40b815:	41 0f be 00          	movsbl (%r8),%eax
            if (unlikely((top_card_idx--) == 0))
  40b819:	44 8d 60 ff          	lea    -0x1(%rax),%r12d
  40b81d:	85 c0                	test   %eax,%eax
  40b81f:	74 66                	je     40b887 <resume_solution+0x1407>
                dest_card = fcs_col_get_card(dest_col, 0);
  40b821:	41 0f be 48 01       	movsbl 0x1(%r8),%ecx
  40b826:	45 89 d3             	mov    %r10d,%r11d
                for (int dc = 0; dc < top_card_idx;
  40b829:	45 85 e4             	test   %r12d,%r12d
  40b82c:	0f 8e 1e 01 00 00    	jle    40b950 <resume_solution+0x14d0>
  40b832:	44 8d 48 fe          	lea    -0x2(%rax),%r9d
  40b836:	31 d2                	xor    %edx,%edx
  40b838:	49 83 c1 01          	add    $0x1,%r9
  40b83c:	0f 1f 40 00          	nopl   0x0(%rax)
                    dest_below_card = fcs_col_get_card(dest_col, dc + 1);
  40b840:	49 0f be 7c 10 02    	movsbq 0x2(%r8,%rdx,1),%rdi
    return fc_solve_is_parent_buf[(size_t)parent][(size_t)child];
  40b846:	48 0f be c1          	movsbq %cl,%rax
  40b84a:	48 c1 e0 06          	shl    $0x6,%rax
                    if (!fcs_is_parent_card(dest_below_card, dest_card))
  40b84e:	80 bc 07 c0 fe 40 00 	cmpb   $0x0,0x40fec0(%rdi,%rax,1)
  40b855:	00 
                    dest_below_card = fcs_col_get_card(dest_col, dc + 1);
  40b856:	48 89 fe             	mov    %rdi,%rsi
                    if (!fcs_is_parent_card(dest_below_card, dest_card))
  40b859:	75 0f                	jne    40b86a <resume_solution+0x13ea>
    int8_t *ptr = &positions_by_rank[(dest_card - 4) << 1];
  40b85b:	8d 44 09 f8          	lea    -0x8(%rcx,%rcx,1),%eax
  40b85f:	48 98                	cltq   
  40b861:	48 01 d8             	add    %rbx,%rax
    *(ptr++) = dest_stack;
  40b864:	44 88 18             	mov    %r11b,(%rax)
                        fc_solve__assign_dest_stack_and_col_ptr(
  40b867:	88 50 01             	mov    %dl,0x1(%rax)
  40b86a:	48 83 c2 01          	add    $0x1,%rdx
                    dest_below_card = fcs_col_get_card(dest_col, dc + 1);
  40b86e:	40 0f be ce          	movsbl %sil,%ecx
                for (int dc = 0; dc < top_card_idx;
  40b872:	49 39 d1             	cmp    %rdx,%r9
  40b875:	75 c9                	jne    40b840 <resume_solution+0x13c0>
    int8_t *ptr = &positions_by_rank[(dest_card - 4) << 1];
  40b877:	8d 44 36 f8          	lea    -0x8(%rsi,%rsi,1),%eax
  40b87b:	48 98                	cltq   
  40b87d:	48 01 d8             	add    %rbx,%rax
    *(ptr++) = dest_stack;
  40b880:	44 88 18             	mov    %r11b,(%rax)
            fc_solve__assign_dest_stack_and_col_ptr(
  40b883:	44 88 60 01          	mov    %r12b,0x1(%rax)
  40b887:	49 83 c2 01          	add    $0x1,%r10
        for (int ds = 0; ds < LOCAL_STACKS_NUM; ds++)
  40b88b:	49 83 fa 08          	cmp    $0x8,%r10
  40b88f:	0f 85 7b ff ff ff    	jne    40b810 <resume_solution+0x1390>
  40b895:	49 8b 5e 18          	mov    0x18(%r14),%rbx
  40b899:	e9 27 fe ff ff       	jmpq   40b6c5 <resume_solution+0x1245>
  40b89e:	66 90                	xchg   %ax,%ax
                local_shuffling_type =
  40b8a0:	8b 40 10             	mov    0x10(%rax),%eax
  40b8a3:	4c 8d a5 50 ff ff ff 	lea    -0xb0(%rbp),%r12
  40b8aa:	48 89 da             	mov    %rbx,%rdx
  40b8ad:	89 c7                	mov    %eax,%edi
  40b8af:	89 85 d4 fe ff ff    	mov    %eax,-0x12c(%rbp)
  40b8b5:	49 8b 46 28          	mov    0x28(%r14),%rax
  40b8b9:	85 ff                	test   %edi,%edi
  40b8bb:	0f 85 0c 01 00 00    	jne    40b9cd <resume_solution+0x154d>
  40b8c1:	48 89 9d a0 fe ff ff 	mov    %rbx,-0x160(%rbp)
  40b8c8:	4c 8b ad e0 fe ff ff 	mov    -0x120(%rbp),%r13
  40b8cf:	4c 89 e3             	mov    %r12,%rbx
  40b8d2:	4c 8b a5 10 ff ff ff 	mov    -0xf0(%rbp),%r12
                        .move_funcs[the_soft_dfs_info->move_func_idx]
  40b8d9:	48 69 d2 e8 00 00 00 	imul   $0xe8,%rdx,%rdx
                    THE_MOVE_FUNCS_LIST
  40b8e0:	48 89 d9             	mov    %rbx,%rcx
  40b8e3:	48 8b b5 18 ff ff ff 	mov    -0xe8(%rbp),%rsi
  40b8ea:	4c 89 ff             	mov    %r15,%rdi
                        .f(soft_thread, pass, &derived_list);
  40b8ed:	4d 8b 4c 15 00       	mov    0x0(%r13,%rdx,1),%r9
                    THE_MOVE_FUNCS_LIST
  40b8f2:	4c 89 e2             	mov    %r12,%rdx
  40b8f5:	41 ff 14 c1          	callq  *(%r9,%rax,8)
                            .groups[the_soft_dfs_info->move_func_list_idx]
  40b8f9:	49 8b 56 18          	mov    0x18(%r14),%rdx
                    if ((++the_soft_dfs_info->move_func_idx) ==
  40b8fd:	49 8b 46 28          	mov    0x28(%r14),%rax
                            .num)
  40b901:	48 69 ca e8 00 00 00 	imul   $0xe8,%rdx,%rcx
                    if ((++the_soft_dfs_info->move_func_idx) ==
  40b908:	48 83 c0 01          	add    $0x1,%rax
  40b90c:	49 89 46 28          	mov    %rax,0x28(%r14)
  40b910:	49 39 44 0d 08       	cmp    %rax,0x8(%r13,%rcx,1)
  40b915:	0f 84 34 01 00 00    	je     40ba4f <resume_solution+0x15cf>
                         (derived_list.num_states == 0));
  40b91b:	48 8b 8d 50 ff ff ff 	mov    -0xb0(%rbp),%rcx
                } while ((local_shuffling_type != FCS_NO_SHUFFLING) ||
  40b922:	48 85 c9             	test   %rcx,%rcx
  40b925:	74 b2                	je     40b8d9 <resume_solution+0x1459>
  40b927:	49 89 cd             	mov    %rcx,%r13
  40b92a:	48 8b 9d a0 fe ff ff 	mov    -0x160(%rbp),%rbx
  40b931:	4d 8b 5e 38          	mov    0x38(%r14),%r11
            if (num_states >
  40b935:	49 39 4e 30          	cmp    %rcx,0x30(%r14)
  40b939:	0f 82 c0 fd ff ff    	jb     40b6ff <resume_solution+0x127f>
  40b93f:	4c 8b 85 58 ff ff ff 	mov    -0xa8(%rbp),%r8
  40b946:	4c 89 ee             	mov    %r13,%rsi
  40b949:	e9 12 fb ff ff       	jmpq   40b460 <resume_solution+0xfe0>
  40b94e:	66 90                	xchg   %ax,%ax
                dest_card = fcs_col_get_card(dest_col, 0);
  40b950:	0f be f1             	movsbl %cl,%esi
  40b953:	e9 1f ff ff ff       	jmpq   40b877 <resume_solution+0x13f7>
  40b958:	49 8b 4f 40          	mov    0x40(%r15),%rcx
  40b95c:	0f 1f 40 00          	nopl   0x0(%rax)
    *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);
  40b960:	48 69 c9 fd 43 03 00 	imul   $0x343fd,%rcx,%rcx
                        const_AUTO(swap_save, rand_array[i]);
  40b967:	47 8b 4c eb f8       	mov    -0x8(%r11,%r13,8),%r9d
  40b96c:	43 8b 7c eb fc       	mov    -0x4(%r11,%r13,8),%edi
  40b971:	48 8d 91 c3 9e 26 00 	lea    0x269ec3(%rcx),%rdx
  40b978:	48 69 ca fd 43 03 00 	imul   $0x343fd,%rdx,%rcx
  40b97f:	48 c1 fa 10          	sar    $0x10,%rdx
  40b983:	81 e2 ff 7f 00 00    	and    $0x7fff,%edx
  40b989:	48 81 c1 c3 9e 26 00 	add    $0x269ec3,%rcx
  40b990:	48 89 c8             	mov    %rcx,%rax
  40b993:	49 89 4f 40          	mov    %rcx,0x40(%r15)
  40b997:	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));
  40b99b:	c1 e0 0f             	shl    $0xf,%eax
  40b99e:	25 00 80 ff 3f       	and    $0x3fff8000,%eax
  40b9a3:	09 d0                	or     %edx,%eax
                        const typeof(i) j =
  40b9a5:	31 d2                	xor    %edx,%edx
                            (fc_solve_rand_get_random_number(rand_gen) %
  40b9a7:	48 98                	cltq   
                        const typeof(i) j =
  40b9a9:	49 f7 f5             	div    %r13
                        rand_array[i] = rand_array[j];
  40b9ac:	49 8d 04 d3          	lea    (%r11,%rdx,8),%rax
  40b9b0:	48 8b 10             	mov    (%rax),%rdx
  40b9b3:	4b 89 54 eb f8       	mov    %rdx,-0x8(%r11,%r13,8)
  40b9b8:	49 83 ed 01          	sub    $0x1,%r13
                        rand_array[j] = swap_save;
  40b9bc:	44 89 08             	mov    %r9d,(%rax)
  40b9bf:	89 78 04             	mov    %edi,0x4(%rax)
                    for (size_t i = num_states - 1; i > 0; i--)
  40b9c2:	49 83 fd 01          	cmp    $0x1,%r13
  40b9c6:	75 98                	jne    40b960 <resume_solution+0x14e0>
  40b9c8:	e9 e3 fa ff ff       	jmpq   40b4b0 <resume_solution+0x1030>
  40b9cd:	48 89 9d a0 fe ff ff 	mov    %rbx,-0x160(%rbp)
  40b9d4:	4c 8b ad 18 ff ff ff 	mov    -0xe8(%rbp),%r13
  40b9db:	4c 89 e7             	mov    %r12,%rdi
  40b9de:	4d 89 f4             	mov    %r14,%r12
  40b9e1:	48 8b 9d e0 fe ff ff 	mov    -0x120(%rbp),%rbx
  40b9e8:	49 89 fe             	mov    %rdi,%r14
  40b9eb:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
                        .move_funcs[the_soft_dfs_info->move_func_idx]
  40b9f0:	48 69 d2 e8 00 00 00 	imul   $0xe8,%rdx,%rdx
                    THE_MOVE_FUNCS_LIST
  40b9f7:	4c 89 f1             	mov    %r14,%rcx
  40b9fa:	4c 89 ee             	mov    %r13,%rsi
  40b9fd:	4c 89 ff             	mov    %r15,%rdi
                        .f(soft_thread, pass, &derived_list);
  40ba00:	4c 8b 0c 13          	mov    (%rbx,%rdx,1),%r9
                    THE_MOVE_FUNCS_LIST
  40ba04:	48 8b 95 10 ff ff ff 	mov    -0xf0(%rbp),%rdx
  40ba0b:	41 ff 14 c1          	callq  *(%r9,%rax,8)
                            .groups[the_soft_dfs_info->move_func_list_idx]
  40ba0f:	49 8b 54 24 18       	mov    0x18(%r12),%rdx
                    if ((++the_soft_dfs_info->move_func_idx) ==
  40ba14:	49 8b 44 24 28       	mov    0x28(%r12),%rax
                            .num)
  40ba19:	48 69 ca e8 00 00 00 	imul   $0xe8,%rdx,%rcx
                    if ((++the_soft_dfs_info->move_func_idx) ==
  40ba20:	48 83 c0 01          	add    $0x1,%rax
  40ba24:	49 89 44 24 28       	mov    %rax,0x28(%r12)
  40ba29:	48 3b 44 0b 08       	cmp    0x8(%rbx,%rcx,1),%rax
  40ba2e:	75 c0                	jne    40b9f0 <resume_solution+0x1570>
  40ba30:	48 8b 9d a0 fe ff ff 	mov    -0x160(%rbp),%rbx
  40ba37:	4d 89 e6             	mov    %r12,%r14
                        the_soft_dfs_info->move_func_list_idx++;
  40ba3a:	48 83 c2 01          	add    $0x1,%rdx
                        the_soft_dfs_info->move_func_idx = 0;
  40ba3e:	49 c7 46 28 00 00 00 	movq   $0x0,0x28(%r14)
  40ba45:	00 
                        the_soft_dfs_info->move_func_list_idx++;
  40ba46:	49 89 56 18          	mov    %rdx,0x18(%r14)
  40ba4a:	e9 98 fc ff ff       	jmpq   40b6e7 <resume_solution+0x1267>
  40ba4f:	48 8b 9d a0 fe ff ff 	mov    -0x160(%rbp),%rbx
  40ba56:	eb e2                	jmp    40ba3a <resume_solution+0x15ba>
  40ba58:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40ba5f:	00 
  40ba60:	48 8b bd 58 ff ff ff 	mov    -0xa8(%rbp),%rdi
  40ba67:	48 85 ff             	test   %rdi,%rdi
  40ba6a:	0f 85 fc f5 ff ff    	jne    40b06c <resume_solution+0xbec>
    while (PTR_STATE != NULL)
  40ba70:	bb 01 00 00 00       	mov    $0x1,%ebx
  40ba75:	41 bc 01 00 00 00    	mov    $0x1,%r12d
        my_brfs_queue_last_item = queue_last_item;
  40ba7b:	49 89 87 e0 00 00 00 	mov    %rax,0xe0(%r15)
  40ba82:	e9 e9 ee ff ff       	jmpq   40a970 <resume_solution+0x4f0>
  40ba87:	48 8b 90 f8 00 00 00 	mov    0xf8(%rax),%rdx
    char *const ret = meta_alloc->recycle_bin;
  40ba8e:	48 8b 02             	mov    (%rdx),%rax
    if (ret)
  40ba91:	48 85 c0             	test   %rax,%rax
  40ba94:	0f 84 90 0a 00 00    	je     40c52a <resume_solution+0x20aa>
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  40ba9a:	48 8b 08             	mov    (%rax),%rcx
  40ba9d:	48 89 0a             	mov    %rcx,(%rdx)
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  40baa0:	48 8b bd 28 ff ff ff 	mov    -0xd8(%rbp),%rdi
  40baa7:	48 8b 97 d8 00 00 00 	mov    0xd8(%rdi),%rdx
  40baae:	48 89 10             	mov    %rdx,(%rax)
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40bab1:	48 8d 50 08          	lea    0x8(%rax),%rdx
    allocator->old_list = new_data;
  40bab5:	48 89 87 d8 00 00 00 	mov    %rax,0xd8(%rdi)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40babc:	48 05 80 fe 00 00    	add    $0xfe80,%rax
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40bac2:	48 89 97 f0 00 00 00 	mov    %rdx,0xf0(%rdi)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40bac9:	48 89 87 e0 00 00 00 	mov    %rax,0xe0(%rdi)
  40bad0:	e9 65 f5 ff ff       	jmpq   40b03a <resume_solution+0xbba>
  40bad5:	48 8b 53 48          	mov    0x48(%rbx),%rdx
    FCS_S_VISITED(temp_state) |= FCS_VISITED_DEAD_END;
  40bad9:	83 c8 0c             	or     $0xc,%eax
  40badc:	88 43 56             	mov    %al,0x56(%rbx)
    if (temp_state != NULL)
  40badf:	48 85 d2             	test   %rdx,%rdx
  40bae2:	0f 84 21 fa ff ff    	je     40b509 <resume_solution+0x1089>
        while ((FCS_S_NUM_ACTIVE_CHILDREN(temp_state) == 0) &&
  40bae8:	66 83 6a 54 01       	subw   $0x1,0x54(%rdx)
  40baed:	0f 85 16 fa ff ff    	jne    40b509 <resume_solution+0x1089>
               (FCS_S_VISITED(temp_state) & FCS_VISITED_ALL_TESTS_DONE))
  40baf3:	0f b6 42 56          	movzbl 0x56(%rdx),%eax
        while ((FCS_S_NUM_ACTIVE_CHILDREN(temp_state) == 0) &&
  40baf7:	a8 08                	test   $0x8,%al
  40baf9:	0f 84 0a fa ff ff    	je     40b509 <resume_solution+0x1089>
            FCS_S_VISITED(temp_state) |= FCS_VISITED_DEAD_END;
  40baff:	83 c8 04             	or     $0x4,%eax
  40bb02:	88 42 56             	mov    %al,0x56(%rdx)
            temp_state = FCS_S_PARENT(temp_state);
  40bb05:	48 8b 42 48          	mov    0x48(%rdx),%rax
            if (temp_state == NULL)
  40bb09:	48 85 c0             	test   %rax,%rax
  40bb0c:	75 32                	jne    40bb40 <resume_solution+0x16c0>
  40bb0e:	e9 f6 f9 ff ff       	jmpq   40b509 <resume_solution+0x1089>
  40bb13:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40bb1a:	00 00 00 00 
  40bb1e:	66 90                	xchg   %ax,%ax
               (FCS_S_VISITED(temp_state) & FCS_VISITED_ALL_TESTS_DONE))
  40bb20:	0f b6 50 56          	movzbl 0x56(%rax),%edx
        while ((FCS_S_NUM_ACTIVE_CHILDREN(temp_state) == 0) &&
  40bb24:	f6 c2 08             	test   $0x8,%dl
  40bb27:	0f 84 dc f9 ff ff    	je     40b509 <resume_solution+0x1089>
            FCS_S_VISITED(temp_state) |= FCS_VISITED_DEAD_END;
  40bb2d:	83 ca 04             	or     $0x4,%edx
  40bb30:	88 50 56             	mov    %dl,0x56(%rax)
            temp_state = FCS_S_PARENT(temp_state);
  40bb33:	48 8b 40 48          	mov    0x48(%rax),%rax
            if (temp_state == NULL)
  40bb37:	48 85 c0             	test   %rax,%rax
  40bb3a:	0f 84 c9 f9 ff ff    	je     40b509 <resume_solution+0x1089>
            (FCS_S_NUM_ACTIVE_CHILDREN(temp_state))--;
  40bb40:	0f b7 58 54          	movzwl 0x54(%rax),%ebx
  40bb44:	8d 53 ff             	lea    -0x1(%rbx),%edx
  40bb47:	66 89 50 54          	mov    %dx,0x54(%rax)
        while ((FCS_S_NUM_ACTIVE_CHILDREN(temp_state) == 0) &&
  40bb4b:	66 85 d2             	test   %dx,%dx
  40bb4e:	74 d0                	je     40bb20 <resume_solution+0x16a0>
  40bb50:	e9 b4 f9 ff ff       	jmpq   40b509 <resume_solution+0x1089>
            if (++(HT_FIELD(hard_thread, num_soft_threads_finished)) ==
  40bb55:	48 8b 85 f0 fe ff ff 	mov    -0x110(%rbp),%rax
            STRUCT_TURN_ON_FLAG(soft_thread, FCS_SOFT_THREAD_IS_FINISHED);
  40bb5c:	41 c6 87 e0 01 00 00 	movb   $0x1,0x1e0(%r15)
  40bb63:	01 
            if (++(HT_FIELD(hard_thread, num_soft_threads_finished)) ==
  40bb64:	8b 98 28 05 00 00    	mov    0x528(%rax),%ebx
  40bb6a:	8d 4b 01             	lea    0x1(%rbx),%ecx
  40bb6d:	89 9d 30 ff ff ff    	mov    %ebx,-0xd0(%rbp)
  40bb73:	89 88 28 05 00 00    	mov    %ecx,0x528(%rax)
  40bb79:	48 63 c9             	movslq %ecx,%rcx
  40bb7c:	48 39 8d 88 fe ff ff 	cmp    %rcx,-0x178(%rbp)
  40bb83:	75 08                	jne    40bb8d <resume_solution+0x170d>
                ++instance->num_hard_threads_finished;
  40bb85:	48 83 80 40 05 00 00 	addq   $0x1,0x540(%rax)
  40bb8c:	01 
            if (STRUCT_QUERY_FLAG(
  40bb8d:	41 80 bf e2 01 00 00 	cmpb   $0x0,0x1e2(%r15)
  40bb94:	00 
  40bb95:	74 14                	je     40bbab <resume_solution+0x172b>
                    soft_thread, FCS_SOFT_THREAD_IS_A_COMPLETE_SCAN) &&
  40bb97:	48 8b 85 f0 fe ff ff 	mov    -0x110(%rbp),%rax
  40bb9e:	80 b8 b8 00 00 00 00 	cmpb   $0x0,0xb8(%rax)
  40bba5:	0f 84 73 11 00 00    	je     40cd1e <resume_solution+0x289e>
                ret = FCS_STATE_SUSPEND_PROCESS;
  40bbab:	bb 05 00 00 00       	mov    $0x5,%ebx
  40bbb0:	e9 50 ea ff ff       	jmpq   40a605 <resume_solution+0x185>
    if (HT_FIELD(hard_thread, prelude_idx) < prelude_num_items)
  40bbb5:	48 89 c7             	mov    %rax,%rdi
  40bbb8:	48 8b 80 08 05 00 00 	mov    0x508(%rax),%rax
  40bbbf:	48 39 85 68 fe ff ff 	cmp    %rax,-0x198(%rbp)
  40bbc6:	0f 87 d0 08 00 00    	ja     40c49c <resume_solution+0x201c>
            ((1 + (*st_idx_ptr)) % num_soft_threads);
  40bbcc:	48 8b bd f0 fe ff ff 	mov    -0x110(%rbp),%rdi
        set_next_soft_thread(hard_thread, next_st_idx,
  40bbd3:	48 8b 8d 80 fe ff ff 	mov    -0x180(%rbp),%rcx
            ((1 + (*st_idx_ptr)) % num_soft_threads);
  40bbda:	48 8b 87 d0 00 00 00 	mov    0xd0(%rdi),%rax
  40bbe1:	48 89 85 30 ff ff ff 	mov    %rax,-0xd0(%rbp)
  40bbe8:	48 83 c0 01          	add    $0x1,%rax
        const int_fast32_t next_st_idx =
  40bbec:	48 99                	cqto   
  40bbee:	48 f7 bd 88 fe ff ff 	idivq  -0x178(%rbp)
        set_next_soft_thread(hard_thread, next_st_idx,
  40bbf5:	48 89 d0             	mov    %rdx,%rax
  40bbf8:	48 c1 e0 06          	shl    $0x6,%rax
  40bbfc:	48 29 d0             	sub    %rdx,%rax
  40bbff:	48 8b 84 c1 e8 01 00 	mov    0x1e8(%rcx,%rax,8),%rax
  40bc06:	00 
    (*st_idx_ptr) = scan_idx;
  40bc07:	48 89 97 d0 00 00 00 	mov    %rdx,0xd0(%rdi)
        NUM_CHECKED_STATES + quota;
  40bc0e:	48 01 f0             	add    %rsi,%rax
  40bc11:	48 89 87 c8 00 00 00 	mov    %rax,0xc8(%rdi)
  40bc18:	e9 6a ed ff ff       	jmpq   40a987 <resume_solution+0x507>
    const_AUTO(new_dfs_max_depth,
  40bc1d:	49 8b 47 28          	mov    0x28(%r15),%rax
    DFS_VAR(soft_thread, depth) = 0;
  40bc21:	49 c7 47 38 00 00 00 	movq   $0x0,0x38(%r15)
  40bc28:	00 
        SREALLOC(DFS_VAR(soft_thread, soft_dfs_info), new_dfs_max_depth);
  40bc29:	49 8b 7f 30          	mov    0x30(%r15),%rdi
    fcs_instance *const instance = fcs_st_instance(soft_thread);
  40bc2d:	4d 8b 27             	mov    (%r15),%r12
    const_AUTO(new_dfs_max_depth,
  40bc30:	48 8d 58 40          	lea    0x40(%rax),%rbx
        SREALLOC(DFS_VAR(soft_thread, soft_dfs_info), new_dfs_max_depth);
  40bc34:	48 8d 04 9b          	lea    (%rbx,%rbx,4),%rax
  40bc38:	48 8d 34 43          	lea    (%rbx,%rax,2),%rsi
    [0].state = FCS_STATE_keyval_pair_to_collectible(&instance->state_copy);
  40bc3c:	49 81 c4 50 05 00 00 	add    $0x550,%r12
        SREALLOC(DFS_VAR(soft_thread, soft_dfs_info), new_dfs_max_depth);
  40bc43:	48 c1 e6 04          	shl    $0x4,%rsi
  40bc47:	e8 24 55 ff ff       	callq  401170 <realloc@plt>
    memset(DFS_VAR(soft_thread, soft_dfs_info) +
  40bc4c:	49 8b 57 28          	mov    0x28(%r15),%rdx
  40bc50:	31 f6                	xor    %esi,%esi
    DFS_VAR(soft_thread, soft_dfs_info) =
  40bc52:	49 89 47 30          	mov    %rax,0x30(%r15)
    memset(DFS_VAR(soft_thread, soft_dfs_info) +
  40bc56:	48 8d 0c 92          	lea    (%rdx,%rdx,4),%rcx
  40bc5a:	48 8d 3c 4a          	lea    (%rdx,%rcx,2),%rdi
  40bc5e:	ba 00 2c 00 00       	mov    $0x2c00,%edx
  40bc63:	48 c1 e7 04          	shl    $0x4,%rdi
  40bc67:	48 01 c7             	add    %rax,%rdi
  40bc6a:	e8 31 54 ff ff       	callq  4010a0 <memset@plt>
    [0].state = FCS_STATE_keyval_pair_to_collectible(&instance->state_copy);
  40bc6f:	49 8b 47 30          	mov    0x30(%r15),%rax
    DFS_VAR(soft_thread, dfs_max_depth) = new_dfs_max_depth;
  40bc73:	49 89 5f 28          	mov    %rbx,0x28(%r15)
    if (!DFS_VAR(soft_thread, moves_by_depth).by_depth_units)
  40bc77:	49 83 7f 58 00       	cmpq   $0x0,0x58(%r15)
    [0].state = FCS_STATE_keyval_pair_to_collectible(&instance->state_copy);
  40bc7c:	4c 89 20             	mov    %r12,(%rax)
    *my_rand = (long)seed;
  40bc7f:	41 8b 47 48          	mov    0x48(%r15),%eax
  40bc83:	49 89 47 40          	mov    %rax,0x40(%r15)
    if (!DFS_VAR(soft_thread, moves_by_depth).by_depth_units)
  40bc87:	0f 84 d9 08 00 00    	je     40c566 <resume_solution+0x20e6>
    if (soft_thread->is_befs)
  40bc8d:	41 80 bf f2 01 00 00 	cmpb   $0x0,0x1f2(%r15)
  40bc94:	00 
  40bc95:	49 8b 1f             	mov    (%r15),%rbx
  40bc98:	0f 84 b6 06 00 00    	je     40c354 <resume_solution+0x1ed4>
    pq->current_size = 0;
  40bc9e:	49 c7 87 f8 00 00 00 	movq   $0x0,0xf8(%r15)
  40bca5:	00 00 00 00 
    pq->elems = SMALLOC(pq->elems, (pq->max_size = 1024) + 1);
  40bca9:	bf 10 40 00 00       	mov    $0x4010,%edi
  40bcae:	49 c7 87 f0 00 00 00 	movq   $0x400,0xf0(%r15)
  40bcb5:	00 04 00 00 
  40bcb9:	e8 32 54 ff ff       	callq  4010f0 <malloc@plt>
        sum += befs_weights[i];
  40bcbe:	c5 d1 57 ed          	vxorpd %xmm5,%xmm5,%xmm5
  40bcc2:	c4 c1 7b 10 87 a8 01 	vmovsd 0x1a8(%r15),%xmm0
  40bcc9:	00 00 
  40bccb:	c4 41 7b 10 87 b0 01 	vmovsd 0x1b0(%r15),%xmm8
  40bcd2:	00 00 
  40bcd4:	49 89 87 00 01 00 00 	mov    %rax,0x100(%r15)
  40bcdb:	c5 fb 58 cd          	vaddsd %xmm5,%xmm0,%xmm1
  40bcdf:	c4 c1 7b 10 bf b8 01 	vmovsd 0x1b8(%r15),%xmm7
  40bce6:	00 00 
  40bce8:	c4 c1 7b 10 b7 c0 01 	vmovsd 0x1c0(%r15),%xmm6
  40bcef:	00 00 
  40bcf1:	c4 41 7b 10 8f c8 01 	vmovsd 0x1c8(%r15),%xmm9
  40bcf8:	00 00 
  40bcfa:	c4 c1 73 58 c8       	vaddsd %xmm8,%xmm1,%xmm1
    if (sum < 1e-6)
  40bcff:	c5 fb 10 1d e1 4f 00 	vmovsd 0x4fe1(%rip),%xmm3        # 410ce8 <fc_solve_is_parent_buf+0xe28>
  40bd06:	00 
        sum += befs_weights[i];
  40bd07:	c4 c1 7b 10 a7 d0 01 	vmovsd 0x1d0(%r15),%xmm4
  40bd0e:	00 00 
    if (sum < 1e-6)
  40bd10:	c5 fb 10 15 c8 4f 00 	vmovsd 0x4fc8(%rip),%xmm2        # 410ce0 <fc_solve_is_parent_buf+0xe20>
  40bd17:	00 
        sum += befs_weights[i];
  40bd18:	c5 f3 58 cf          	vaddsd %xmm7,%xmm1,%xmm1
  40bd1c:	c5 f3 58 ce          	vaddsd %xmm6,%xmm1,%xmm1
  40bd20:	c4 c1 73 58 c9       	vaddsd %xmm9,%xmm1,%xmm1
  40bd25:	c5 f3 58 cc          	vaddsd %xmm4,%xmm1,%xmm1
    if (sum < 1e-6)
  40bd29:	c5 f9 2e d9          	vucomisd %xmm1,%xmm3
  40bd2d:	77 04                	ja     40bd33 <resume_solution+0x18b3>
  40bd2f:	c5 eb 5e d1          	vdivsd %xmm1,%xmm2,%xmm2
        W(FCS_BEFS_WEIGHT_CARDS_OUT) / (LOCAL_DECKS_NUM * 52);
  40bd33:	c5 fb 59 c2          	vmulsd %xmm2,%xmm0,%xmm0
    const double num_cards_out_factor =
  40bd37:	c5 fb 10 1d b1 4f 00 	vmovsd 0x4fb1(%rip),%xmm3        # 410cf0 <fc_solve_is_parent_buf+0xe30>
  40bd3e:	00 
            weighting->cards_under_sequences_factor ||
  40bd3f:	b9 01 00 00 00       	mov    $0x1,%ecx
        num_cards_out_lookup_table[i] = out_sum;
  40bd44:	49 c7 87 38 01 00 00 	movq   $0x0,0x138(%r15)
  40bd4b:	00 00 00 00 
        W(FCS_BEFS_WEIGHT_MAX_SEQUENCE_MOVE) /
  40bd4f:	c5 3b 59 c2          	vmulsd %xmm2,%xmm8,%xmm8
        W(FCS_BEFS_WEIGHT_CARDS_UNDER_SEQUENCES) /
  40bd53:	c5 c3 59 fa          	vmulsd %xmm2,%xmm7,%xmm7
        W(FCS_BEFS_WEIGHT_MAX_SEQUENCE_MOVE) /
  40bd57:	c5 3b 5e 05 99 4f 00 	vdivsd 0x4f99(%rip),%xmm8,%xmm8        # 410cf8 <fc_solve_is_parent_buf+0xe38>
  40bd5e:	00 
            weighting->cards_under_sequences_factor ||
  40bd5f:	c5 79 2e c5          	vucomisd %xmm5,%xmm8
    weighting->max_sequence_move_factor =
  40bd63:	c4 41 7b 11 87 10 01 	vmovsd %xmm8,0x110(%r15)
  40bd6a:	00 00 
        W(FCS_BEFS_WEIGHT_SEQS_OVER_RENEGADE_CARDS) /
  40bd6c:	c5 cb 59 f2          	vmulsd %xmm2,%xmm6,%xmm6
    weighting->depth_factor = W(FCS_BEFS_WEIGHT_DEPTH) / BEFS_MAX_DEPTH;
  40bd70:	c5 33 59 ca          	vmulsd %xmm2,%xmm9,%xmm9
        W(FCS_BEFS_WEIGHT_SEQS_OVER_RENEGADE_CARDS) /
  40bd74:	c5 cb 5e 35 84 4f 00 	vdivsd 0x4f84(%rip),%xmm6,%xmm6        # 410d00 <fc_solve_is_parent_buf+0xe40>
  40bd7b:	00 
        W(FCS_BEFS_WEIGHT_NUM_CARDS_NOT_ON_PARENTS) / (LOCAL_DECKS_NUM * 52);
  40bd7c:	c5 db 59 d2          	vmulsd %xmm2,%xmm4,%xmm2
            weighting->cards_under_sequences_factor ||
  40bd80:	0f 9a c0             	setp   %al
    weighting->depth_factor = W(FCS_BEFS_WEIGHT_DEPTH) / BEFS_MAX_DEPTH;
  40bd83:	c5 33 5e 0d 7d 4f 00 	vdivsd 0x4f7d(%rip),%xmm9,%xmm9        # 410d08 <fc_solve_is_parent_buf+0xe48>
  40bd8a:	00 
            weighting->cards_under_sequences_factor ||
  40bd8b:	0f 45 c1             	cmovne %ecx,%eax
    const double num_cards_out_factor =
  40bd8e:	c5 fb 5e c3          	vdivsd %xmm3,%xmm0,%xmm0
        W(FCS_BEFS_WEIGHT_NUM_CARDS_NOT_ON_PARENTS) / (LOCAL_DECKS_NUM * 52);
  40bd92:	c5 eb 5e d3          	vdivsd %xmm3,%xmm2,%xmm2
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40bd96:	c5 fb 58 cd          	vaddsd %xmm5,%xmm0,%xmm1
        num_cards_out_lookup_table[i] = out_sum;
  40bd9a:	c4 c1 7b 11 8f 40 01 	vmovsd %xmm1,0x140(%r15)
  40bda1:	00 00 
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40bda3:	c5 fb 58 c9          	vaddsd %xmm1,%xmm0,%xmm1
        num_cards_out_lookup_table[i] = out_sum;
  40bda7:	c4 c1 7b 11 8f 48 01 	vmovsd %xmm1,0x148(%r15)
  40bdae:	00 00 
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40bdb0:	c5 fb 58 c9          	vaddsd %xmm1,%xmm0,%xmm1
        num_cards_out_lookup_table[i] = out_sum;
  40bdb4:	c4 c1 7b 11 8f 50 01 	vmovsd %xmm1,0x150(%r15)
  40bdbb:	00 00 
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40bdbd:	c5 fb 58 c9          	vaddsd %xmm1,%xmm0,%xmm1
        num_cards_out_lookup_table[i] = out_sum;
  40bdc1:	c4 c1 7b 11 8f 58 01 	vmovsd %xmm1,0x158(%r15)
  40bdc8:	00 00 
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40bdca:	c5 fb 58 c9          	vaddsd %xmm1,%xmm0,%xmm1
        num_cards_out_lookup_table[i] = out_sum;
  40bdce:	c4 c1 7b 11 8f 60 01 	vmovsd %xmm1,0x160(%r15)
  40bdd5:	00 00 
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40bdd7:	c5 fb 58 c9          	vaddsd %xmm1,%xmm0,%xmm1
        num_cards_out_lookup_table[i] = out_sum;
  40bddb:	c4 c1 7b 11 8f 68 01 	vmovsd %xmm1,0x168(%r15)
  40bde2:	00 00 
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40bde4:	c5 fb 58 c9          	vaddsd %xmm1,%xmm0,%xmm1
        num_cards_out_lookup_table[i] = out_sum;
  40bde8:	c4 c1 7b 11 8f 70 01 	vmovsd %xmm1,0x170(%r15)
  40bdef:	00 00 
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40bdf1:	c5 fb 58 c9          	vaddsd %xmm1,%xmm0,%xmm1
        num_cards_out_lookup_table[i] = out_sum;
  40bdf5:	c4 c1 7b 11 8f 78 01 	vmovsd %xmm1,0x178(%r15)
  40bdfc:	00 00 
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40bdfe:	c5 fb 58 c9          	vaddsd %xmm1,%xmm0,%xmm1
        num_cards_out_lookup_table[i] = out_sum;
  40be02:	c4 c1 7b 11 8f 80 01 	vmovsd %xmm1,0x180(%r15)
  40be09:	00 00 
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40be0b:	c5 fb 58 c9          	vaddsd %xmm1,%xmm0,%xmm1
        num_cards_out_lookup_table[i] = out_sum;
  40be0f:	c4 c1 7b 11 8f 88 01 	vmovsd %xmm1,0x188(%r15)
  40be16:	00 00 
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40be18:	c5 fb 58 c9          	vaddsd %xmm1,%xmm0,%xmm1
        num_cards_out_lookup_table[i] = out_sum;
  40be1c:	c4 c1 7b 11 8f 90 01 	vmovsd %xmm1,0x190(%r15)
  40be23:	00 00 
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40be25:	c5 fb 58 c9          	vaddsd %xmm1,%xmm0,%xmm1
        num_cards_out_lookup_table[i] = out_sum;
  40be29:	c4 c1 7b 11 8f 98 01 	vmovsd %xmm1,0x198(%r15)
  40be30:	00 00 
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40be32:	c5 fb 58 c1          	vaddsd %xmm1,%xmm0,%xmm0
        num_cards_out_lookup_table[i] = out_sum;
  40be36:	c4 c1 7b 11 87 a0 01 	vmovsd %xmm0,0x1a0(%r15)
  40be3d:	00 00 
        W(FCS_BEFS_WEIGHT_CARDS_UNDER_SEQUENCES) /
  40be3f:	c5 c3 5e 7b 08       	vdivsd 0x8(%rbx),%xmm7,%xmm7
        (weighting->max_sequence_move_factor ||
  40be44:	c5 f9 2e fd          	vucomisd %xmm5,%xmm7
    weighting->cards_under_sequences_factor =
  40be48:	c4 c1 7b 11 bf 18 01 	vmovsd %xmm7,0x118(%r15)
  40be4f:	00 00 
    weighting->seqs_over_renegade_cards_factor =
  40be51:	c4 c1 7b 11 b7 20 01 	vmovsd %xmm6,0x120(%r15)
  40be58:	00 00 
    weighting->depth_factor = W(FCS_BEFS_WEIGHT_DEPTH) / BEFS_MAX_DEPTH;
  40be5a:	c4 41 7b 11 8f 28 01 	vmovsd %xmm9,0x128(%r15)
  40be61:	00 00 
        (weighting->max_sequence_move_factor ||
  40be63:	0f 9a c2             	setp   %dl
  40be66:	0f 45 d1             	cmovne %ecx,%edx
    weighting->num_cards_not_on_parents_factor =
  40be69:	c4 c1 7b 11 97 30 01 	vmovsd %xmm2,0x130(%r15)
  40be70:	00 00 
    weighting->should_go_over_stacks =
  40be72:	09 d0                	or     %edx,%eax
            weighting->cards_under_sequences_factor ||
  40be74:	c5 f9 2e f5          	vucomisd %xmm5,%xmm6
  40be78:	0f 9a c2             	setp   %dl
  40be7b:	0f 45 d1             	cmovne %ecx,%edx
    weighting->should_go_over_stacks =
  40be7e:	09 d0                	or     %edx,%eax
  40be80:	41 88 87 08 01 00 00 	mov    %al,0x108(%r15)
    if (!BEFS_M_VAR(soft_thread, moves_list))
  40be87:	49 8b 87 c8 00 00 00 	mov    0xc8(%r15),%rax
  40be8e:	48 85 c0             	test   %rax,%rax
  40be91:	0f 84 43 05 00 00    	je     40c3da <resume_solution+0x1f5a>
        FCS_STATE_keyval_pair_to_collectible(
  40be97:	49 8b 07             	mov    (%r15),%rax
            STRUCT_TURN_ON_FLAG(soft_thread, FCS_SOFT_THREAD_INITIALIZED);
  40be9a:	41 c6 87 e1 01 00 00 	movb   $0x1,0x1e1(%r15)
  40bea1:	01 
  40bea2:	48 89 85 28 ff ff ff 	mov    %rax,-0xd8(%rbp)
  40bea9:	48 05 50 05 00 00    	add    $0x550,%rax
    BEFS_M_VAR(soft_thread, first_state_to_check) =
  40beaf:	49 89 87 d8 01 00 00 	mov    %rax,0x1d8(%r15)
  40beb6:	e9 a0 e7 ff ff       	jmpq   40a65b <resume_solution+0x1db>
                    curr_by_depth_unit++;
  40bebb:	48 8b 9d b0 fe ff ff 	mov    -0x150(%rbp),%rbx
                    RECALC_BY_DEPTH_LIMITS();
  40bec2:	48 c7 85 c0 fe ff ff 	movq   $0x0,-0x140(%rbp)
  40bec9:	00 00 00 00 
  40becd:	48 8b 7b 18          	mov    0x18(%rbx),%rdi
                    curr_by_depth_unit++;
  40bed1:	48 8d 4b 18          	lea    0x18(%rbx),%rcx
                    RECALC_BY_DEPTH_LIMITS();
  40bed5:	48 89 bd d8 fe ff ff 	mov    %rdi,-0x128(%rbp)
  40bedc:	48 39 8d 78 fe ff ff 	cmp    %rcx,-0x188(%rbp)
  40bee3:	74 11                	je     40bef6 <resume_solution+0x1a76>
  40bee5:	48 8b 1b             	mov    (%rbx),%rbx
  40bee8:	48 89 9d c0 fe ff ff 	mov    %rbx,-0x140(%rbp)
  40beef:	48 8b 9d b0 fe ff ff 	mov    -0x150(%rbp),%rbx
  40bef6:	48 8b 7b 20          	mov    0x20(%rbx),%rdi
                    curr_by_depth_unit++;
  40befa:	48 89 8d b0 fe ff ff 	mov    %rcx,-0x150(%rbp)
                    RECALC_BY_DEPTH_LIMITS();
  40bf01:	48 8b 5b 28          	mov    0x28(%rbx),%rbx
  40bf05:	48 89 bd 08 ff ff ff 	mov    %rdi,-0xf8(%rbp)
  40bf0c:	48 89 9d e0 fe ff ff 	mov    %rbx,-0x120(%rbp)
  40bf13:	e9 b8 f3 ff ff       	jmpq   40b2d0 <resume_solution+0xe50>
  40bf18:	49 8b 07             	mov    (%r15),%rax
                            rand_array[i].rating = befs_rate_state(soft_thread,
  40bf1b:	4c 89 b5 58 fe ff ff 	mov    %r14,-0x1a8(%rbp)
  40bf22:	c5 d1 57 ed          	vxorpd %xmm5,%xmm5,%xmm5
  40bf26:	4c 89 85 90 fe ff ff 	mov    %r8,-0x170(%rbp)
  40bf2d:	4c 89 bd 60 fe ff ff 	mov    %r15,-0x1a0(%rbp)
  40bf34:	4c 89 9d 98 fe ff ff 	mov    %r11,-0x168(%rbp)
  40bf3b:	48 89 85 70 fe ff ff 	mov    %rax,-0x190(%rbp)
    double sum = (max(0, negated_depth) * weighting->depth_factor);
  40bf42:	48 8b 85 e8 fe ff ff 	mov    -0x118(%rbp),%rax
  40bf49:	48 89 b5 50 fe ff ff 	mov    %rsi,-0x1b0(%rbp)
    if (weighting->should_go_over_stacks)
  40bf50:	0f b6 58 18          	movzbl 0x18(%rax),%ebx
    double sum = (max(0, negated_depth) * weighting->depth_factor);
  40bf54:	c5 7b 10 40 38       	vmovsd 0x38(%rax),%xmm8
    if (num_cards_out_lookup_table[1])
  40bf59:	c5 fb 10 78 50       	vmovsd 0x50(%rax),%xmm7
  40bf5e:	c5 fb 10 70 40       	vmovsd 0x40(%rax),%xmm6
    if (weighting->should_go_over_stacks)
  40bf63:	88 9d d2 fe ff ff    	mov    %bl,-0x12e(%rbp)
  40bf69:	48 8d 58 48          	lea    0x48(%rax),%rbx
  40bf6d:	4a 8d 04 ed 00 00 00 	lea    0x0(,%r13,8),%rax
  40bf74:	00 
  40bf75:	49 89 d8             	mov    %rbx,%r8
  40bf78:	48 89 85 a0 fe ff ff 	mov    %rax,-0x160(%rbp)
  40bf7f:	31 c0                	xor    %eax,%eax
  40bf81:	49 89 c6             	mov    %rax,%r14
  40bf84:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40bf8b:	00 00 00 00 
  40bf8f:	90                   	nop
                                    calc_depth(derived_states[i].state_ptr));
  40bf90:	48 8b 85 90 fe ff ff 	mov    -0x170(%rbp),%rax
    double sum = (max(0, negated_depth) * weighting->depth_factor);
  40bf97:	c5 d9 57 e4          	vxorpd %xmm4,%xmm4,%xmm4
  40bf9b:	4e 8b 14 70          	mov    (%rax,%r14,2),%r10
  40bf9f:	b8 20 4e 00 00       	mov    $0x4e20,%eax
  40bfa4:	41 2b 42 50          	sub    0x50(%r10),%eax
  40bfa8:	78 08                	js     40bfb2 <resume_solution+0x1b32>
  40bfaa:	c5 d9 57 e4          	vxorpd %xmm4,%xmm4,%xmm4
  40bfae:	c5 db 2a e0          	vcvtsi2sd %eax,%xmm4,%xmm4
    if (num_cards_out_lookup_table[1])
  40bfb2:	c5 f9 2e fd          	vucomisd %xmm5,%xmm7
    double sum = (max(0, negated_depth) * weighting->depth_factor);
  40bfb6:	c5 bb 59 e4          	vmulsd %xmm4,%xmm8,%xmm4
    if (num_cards_out_lookup_table[1])
  40bfba:	7a 02                	jp     40bfbe <resume_solution+0x1b3e>
  40bfbc:	74 2c                	je     40bfea <resume_solution+0x1b6a>
            sum += num_cards_out_lookup_table[(
  40bfbe:	49 0f be 42 44       	movsbq 0x44(%r10),%rax
  40bfc3:	c4 c1 5b 58 24 c0    	vaddsd (%r8,%rax,8),%xmm4,%xmm4
  40bfc9:	49 0f be 42 45       	movsbq 0x45(%r10),%rax
  40bfce:	c4 c1 5b 58 24 c0    	vaddsd (%r8,%rax,8),%xmm4,%xmm4
  40bfd4:	49 0f be 42 46       	movsbq 0x46(%r10),%rax
  40bfd9:	c4 c1 5b 58 24 c0    	vaddsd (%r8,%rax,8),%xmm4,%xmm4
  40bfdf:	49 0f be 42 47       	movsbq 0x47(%r10),%rax
  40bfe4:	c4 c1 5b 58 24 c0    	vaddsd (%r8,%rax,8),%xmm4,%xmm4
    if (weighting->should_go_over_stacks)
  40bfea:	80 bd d2 fe ff ff 00 	cmpb   $0x0,-0x12e(%rbp)
  40bff1:	0f 84 df 00 00 00    	je     40c0d6 <resume_solution+0x1c56>
  40bff7:	4d 89 d5             	mov    %r10,%r13
    fcs_game_limit num_vacant_stacks = 0;
  40bffa:	31 c9                	xor    %ecx,%ecx
    fcs_seq_cards_power_type seqs_over_renegade_cards = 0;
  40bffc:	c5 f1 57 c9          	vxorpd %xmm1,%xmm1,%xmm1
    fcs_seq_cards_power_type cards_under_sequences = 0;
  40c000:	c5 f9 57 c0          	vxorpd %xmm0,%xmm0,%xmm0
  40c004:	4d 8d 7a 40          	lea    0x40(%r10),%r15
  40c008:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
  40c00f:	00 
            const_AUTO(col, fcs_state_get_col(*state, a));
  40c010:	4d 8b 4d 00          	mov    0x0(%r13),%r9
            const int cards_num = fcs_col_len(col);
  40c014:	41 0f be 19          	movsbl (%r9),%ebx
            if (cards_num <= 1)
  40c018:	83 fb 01             	cmp    $0x1,%ebx
  40c01b:	0f 8e 4f 02 00 00    	jle    40c270 <resume_solution+0x1df0>
            const int c = update_col_cards_under_sequences(
  40c021:	8d 43 ff             	lea    -0x1(%rbx),%eax
  40c024:	8d 73 fe             	lea    -0x2(%rbx),%esi
    fcs_card this_card = fcs_col_get_card(col, d);
  40c027:	48 98                	cltq   
  40c029:	49 0f be 54 01 01    	movsbq 0x1(%r9,%rax,1),%rdx
  40c02f:	4c 8d 58 ff          	lea    -0x1(%rax),%r11
  40c033:	49 29 f3             	sub    %rsi,%r11
  40c036:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  40c03d:	00 00 00 
             prev_card = fcs_col_get_card(col, d - 1);
  40c040:	49 0f be 34 01       	movsbq (%r9,%rax,1),%rsi
  40c045:	41 89 c4             	mov    %eax,%r12d
  40c048:	48 89 f7             	mov    %rsi,%rdi
  40c04b:	48 c1 e6 06          	shl    $0x6,%rsi
    for (; (d > 0) && ({
  40c04f:	80 bc 32 c0 fe 40 00 	cmpb   $0x0,0x40fec0(%rdx,%rsi,1)
  40c056:	00 
  40c057:	0f 84 f3 01 00 00    	je     40c250 <resume_solution+0x1dd0>
  40c05d:	48 83 e8 01          	sub    $0x1,%rax
         d--, this_card = prev_card)
  40c061:	48 0f be d7          	movsbq %dil,%rdx
    for (; (d > 0) && ({
  40c065:	49 39 c3             	cmp    %rax,%r11
  40c068:	75 d6                	jne    40c040 <resume_solution+0x1bc0>
            cards_under_sequences += FCS_SEQS_OVER_RENEGADE_POWER(c);
  40c06a:	c5 fb 58 c5          	vaddsd %xmm5,%xmm0,%xmm0
  40c06e:	49 83 c5 08          	add    $0x8,%r13
        for (int a = 0; a < LOCAL_STACKS_NUM; ++a)
  40c072:	4d 39 ef             	cmp    %r13,%r15
  40c075:	75 99                	jne    40c010 <resume_solution+0x1b90>
        if (fcs_freecell_is_empty(*state_ptr, i))
  40c077:	41 80 7a 40 00       	cmpb   $0x0,0x40(%r10)
        sum += ((CALC_VACANCY_VAL() * weighting->max_sequence_move_factor) +
  40c07c:	c5 e9 57 d2          	vxorpd %xmm2,%xmm2,%xmm2
                ((instance->initial_cards_under_sequences_value -
  40c080:	48 8b 9d 70 fe ff ff 	mov    -0x190(%rbp),%rbx
        if (fcs_freecell_is_empty(*state_ptr, i))
  40c087:	0f 94 c0             	sete   %al
            num_vacant_freecells++;
  40c08a:	41 80 7a 41 01       	cmpb   $0x1,0x41(%r10)
                ((instance->initial_cards_under_sequences_value -
  40c08f:	c5 fb 10 5b 08       	vmovsd 0x8(%rbx),%xmm3
  40c094:	c5 e3 5c c0          	vsubsd %xmm0,%xmm3,%xmm0
            num_vacant_freecells++;
  40c098:	14 00                	adc    $0x0,%al
  40c09a:	41 80 7a 42 01       	cmpb   $0x1,0x42(%r10)
  40c09f:	14 00                	adc    $0x0,%al
  40c0a1:	41 80 7a 43 01       	cmpb   $0x1,0x43(%r10)
  40c0a6:	14 00                	adc    $0x0,%al
        sum += ((CALC_VACANCY_VAL() * weighting->max_sequence_move_factor) +
  40c0a8:	0f b6 c0             	movzbl %al,%eax
  40c0ab:	83 c0 01             	add    $0x1,%eax
  40c0ae:	d3 e0                	shl    %cl,%eax
  40c0b0:	c5 eb 2a d0          	vcvtsi2sd %eax,%xmm2,%xmm2
  40c0b4:	48 8b 85 e8 fe ff ff 	mov    -0x118(%rbp),%rax
  40c0bb:	c5 eb 59 50 20       	vmulsd 0x20(%rax),%xmm2,%xmm2
                     cards_under_sequences) *
  40c0c0:	c5 fb 59 40 28       	vmulsd 0x28(%rax),%xmm0,%xmm0
                (seqs_over_renegade_cards *
  40c0c5:	c5 f3 59 48 30       	vmulsd 0x30(%rax),%xmm1,%xmm1
        sum += ((CALC_VACANCY_VAL() * weighting->max_sequence_move_factor) +
  40c0ca:	c5 eb 58 c0          	vaddsd %xmm0,%xmm2,%xmm0
                    weighting->cards_under_sequences_factor) +
  40c0ce:	c5 fb 58 c1          	vaddsd %xmm1,%xmm0,%xmm0
        sum += ((CALC_VACANCY_VAL() * weighting->max_sequence_move_factor) +
  40c0d2:	c5 db 58 e0          	vaddsd %xmm0,%xmm4,%xmm4
    if (num_cards_not_on_parents_weight)
  40c0d6:	c5 f9 2e f5          	vucomisd %xmm5,%xmm6
  40c0da:	7a 06                	jp     40c0e2 <resume_solution+0x1c62>
  40c0dc:	0f 84 d1 00 00 00    	je     40c1b3 <resume_solution+0x1d33>
  40c0e2:	4d 8d 62 40          	lea    0x40(%r10),%r12
        int num_cards_not_on_parents = (LOCAL_DECKS_NUM * 52);
  40c0e6:	ba 34 00 00 00       	mov    $0x34,%edx
  40c0eb:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
            const_AUTO(col, fcs_state_get_col(*state, stack_idx));
  40c0f0:	49 8b 0a             	mov    (%r10),%rcx
            const uint_fast16_t col_len = fcs_col_len(col);
  40c0f3:	4c 0f be 09          	movsbq (%rcx),%r9
            for (uint_fast16_t h = 1; h < col_len; h++)
  40c0f7:	49 83 f9 01          	cmp    $0x1,%r9
  40c0fb:	0f 86 95 00 00 00    	jbe    40c196 <resume_solution+0x1d16>
  40c101:	41 80 f9 03          	cmp    $0x3,%r9b
  40c105:	0f 86 6d 01 00 00    	jbe    40c278 <resume_solution+0x1df8>
  40c10b:	48 0f be 71 01       	movsbq 0x1(%rcx),%rsi
  40c110:	49 8d 59 fc          	lea    -0x4(%r9),%rbx
  40c114:	b8 01 00 00 00       	mov    $0x1,%eax
  40c119:	48 83 e3 fe          	and    $0xfffffffffffffffe,%rbx
  40c11d:	48 83 c3 03          	add    $0x3,%rbx
  40c121:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40c128:	00 00 00 00 
  40c12c:	0f 1f 40 00          	nopl   0x0(%rax)
  40c130:	48 0f be 7c 01 01    	movsbq 0x1(%rcx,%rax,1),%rdi
  40c136:	49 89 fb             	mov    %rdi,%r11
  40c139:	49 c1 e3 06          	shl    $0x6,%r11
  40c13d:	49 8d b4 33 c0 fe 40 	lea    0x40fec0(%r11,%rsi,1),%rsi
  40c144:	00 
                    num_cards_not_on_parents--;
  40c145:	80 3e 01             	cmpb   $0x1,(%rsi)
  40c148:	83 da 00             	sbb    $0x0,%edx
  40c14b:	48 83 c0 02          	add    $0x2,%rax
  40c14f:	48 0f be 34 01       	movsbq (%rcx,%rax,1),%rsi
  40c154:	49 89 f3             	mov    %rsi,%r11
  40c157:	49 c1 e3 06          	shl    $0x6,%r11
  40c15b:	4a 8d bc 1f c0 fe 40 	lea    0x40fec0(%rdi,%r11,1),%rdi
  40c162:	00 
  40c163:	80 3f 01             	cmpb   $0x1,(%rdi)
  40c166:	83 da 00             	sbb    $0x0,%edx
  40c169:	48 39 d8             	cmp    %rbx,%rax
  40c16c:	75 c2                	jne    40c130 <resume_solution+0x1cb0>
  40c16e:	66 90                	xchg   %ax,%ax
                        fcs_col_get_card(col, h - 1), fcs_col_get_card(col, h)))
  40c170:	48 83 c0 01          	add    $0x1,%rax
  40c174:	48 0f be 34 01       	movsbq (%rcx,%rax,1),%rsi
  40c179:	48 0f be 7c 01 ff    	movsbq -0x1(%rcx,%rax,1),%rdi
  40c17f:	48 c1 e6 06          	shl    $0x6,%rsi
  40c183:	48 8d b4 37 c0 fe 40 	lea    0x40fec0(%rdi,%rsi,1),%rsi
  40c18a:	00 
                    num_cards_not_on_parents--;
  40c18b:	80 3e 01             	cmpb   $0x1,(%rsi)
  40c18e:	83 da 00             	sbb    $0x0,%edx
            for (uint_fast16_t h = 1; h < col_len; h++)
  40c191:	49 39 c1             	cmp    %rax,%r9
  40c194:	77 da                	ja     40c170 <resume_solution+0x1cf0>
  40c196:	49 83 c2 08          	add    $0x8,%r10
        for (int stack_idx = 0; stack_idx < LOCAL_STACKS_NUM; stack_idx++)
  40c19a:	4d 39 d4             	cmp    %r10,%r12
  40c19d:	0f 85 4d ff ff ff    	jne    40c0f0 <resume_solution+0x1c70>
        sum += num_cards_not_on_parents * num_cards_not_on_parents_weight;
  40c1a3:	c5 f9 57 c0          	vxorpd %xmm0,%xmm0,%xmm0
  40c1a7:	c5 fb 2a c2          	vcvtsi2sd %edx,%xmm0,%xmm0
  40c1ab:	c5 fb 59 c6          	vmulsd %xmm6,%xmm0,%xmm0
  40c1af:	c5 db 58 e0          	vaddsd %xmm0,%xmm4,%xmm4
    return ((int)sum);
  40c1b3:	c5 fb 2c c4          	vcvttsd2si %xmm4,%eax
  40c1b7:	48 8b 9d 98 fe ff ff 	mov    -0x168(%rbp),%rbx
  40c1be:	42 89 44 33 04       	mov    %eax,0x4(%rbx,%r14,1)
  40c1c3:	49 83 c6 08          	add    $0x8,%r14
                        for (size_t i = 0; i < num_states; i++)
  40c1c7:	4c 39 b5 a0 fe ff ff 	cmp    %r14,-0x160(%rbp)
  40c1ce:	0f 85 bc fd ff ff    	jne    40bf90 <resume_solution+0x1b10>
                        const_AUTO(end, rand_array + num_states);
  40c1d4:	4c 8b ad a0 fe ff ff 	mov    -0x160(%rbp),%r13
  40c1db:	49 89 db             	mov    %rbx,%r11
                        for (var_PTR(p, rand_array + 1); p < end; ++p)
  40c1de:	4c 8d 4b 08          	lea    0x8(%rbx),%r9
  40c1e2:	4c 8b bd 60 fe ff ff 	mov    -0x1a0(%rbp),%r15
  40c1e9:	4c 8b b5 58 fe ff ff 	mov    -0x1a8(%rbp),%r14
  40c1f0:	4c 8b 85 90 fe ff ff 	mov    -0x170(%rbp),%r8
                        const_AUTO(end, rand_array + num_states);
  40c1f7:	49 01 dd             	add    %rbx,%r13
  40c1fa:	48 8b b5 50 fe ff ff 	mov    -0x1b0(%rbp),%rsi
                        for (var_PTR(p, rand_array + 1); p < end; ++p)
  40c201:	4d 39 cd             	cmp    %r9,%r13
  40c204:	0f 86 a6 f2 ff ff    	jbe    40b4b0 <resume_solution+0x1030>
  40c20a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
                                   move->rating < move[-1].rating)
  40c210:	41 8b 51 04          	mov    0x4(%r9),%edx
                            while (move > rand_array &&
  40c214:	41 39 51 fc          	cmp    %edx,-0x4(%r9)
  40c218:	7e 24                	jle    40c23e <resume_solution+0x1dbe>
  40c21a:	4c 89 c8             	mov    %r9,%rax
  40c21d:	eb 06                	jmp    40c225 <resume_solution+0x1da5>
  40c21f:	90                   	nop
  40c220:	39 50 fc             	cmp    %edx,-0x4(%rax)
  40c223:	7e 19                	jle    40c23e <resume_solution+0x1dbe>
                                *move = move[-1];
  40c225:	48 8b 78 f8          	mov    -0x8(%rax),%rdi
                                *(--move) = temp;
  40c229:	48 83 e8 08          	sub    $0x8,%rax
                                const_AUTO(temp, *move);
  40c22d:	8b 48 08             	mov    0x8(%rax),%ecx
                                *move = move[-1];
  40c230:	48 89 78 08          	mov    %rdi,0x8(%rax)
                                *(--move) = temp;
  40c234:	89 08                	mov    %ecx,(%rax)
  40c236:	89 50 04             	mov    %edx,0x4(%rax)
                            while (move > rand_array &&
  40c239:	49 39 c3             	cmp    %rax,%r11
  40c23c:	72 e2                	jb     40c220 <resume_solution+0x1da0>
                        for (var_PTR(p, rand_array + 1); p < end; ++p)
  40c23e:	49 83 c1 08          	add    $0x8,%r9
  40c242:	4d 39 cd             	cmp    %r9,%r13
  40c245:	77 c9                	ja     40c210 <resume_solution+0x1d90>
  40c247:	e9 64 f2 ff ff       	jmpq   40b4b0 <resume_solution+0x1030>
  40c24c:	0f 1f 40 00          	nopl   0x0(%rax)
                            : FCS_SEQS_OVER_RENEGADE_POWER(cards_num - c));
  40c250:	44 29 e3             	sub    %r12d,%ebx
            cards_under_sequences += FCS_SEQS_OVER_RENEGADE_POWER(c);
  40c253:	48 98                	cltq   
  40c255:	c5 fb 58 04 c5 a0 f6 	vaddsd 0x40f6a0(,%rax,8),%xmm0,%xmm0
  40c25c:	40 00 
                            : FCS_SEQS_OVER_RENEGADE_POWER(cards_num - c));
  40c25e:	48 63 db             	movslq %ebx,%rbx
                seqs_over_renegade_cards +=
  40c261:	c5 f3 58 0c dd a0 f6 	vaddsd 0x40f6a0(,%rbx,8),%xmm1,%xmm1
  40c268:	40 00 
  40c26a:	e9 ff fd ff ff       	jmpq   40c06e <resume_solution+0x1bee>
  40c26f:	90                   	nop
                    ++num_vacant_stacks;
  40c270:	80 d1 00             	adc    $0x0,%cl
  40c273:	e9 f6 fd ff ff       	jmpq   40c06e <resume_solution+0x1bee>
            for (uint_fast16_t h = 1; h < col_len; h++)
  40c278:	b8 01 00 00 00       	mov    $0x1,%eax
  40c27d:	e9 ee fe ff ff       	jmpq   40c170 <resume_solution+0x1cf0>
        queue = my_brfs_queue;
  40c282:	49 8b 87 d8 00 00 00 	mov    0xd8(%r15),%rax
    int8_t *const befs_positions_by_rank =
  40c289:	4d 8d 6f 60          	lea    0x60(%r15),%r13
        queue = my_brfs_queue;
  40c28d:	48 89 85 00 ff ff ff 	mov    %rax,-0x100(%rbp)
        queue_last_item = my_brfs_queue_last_item;
  40c294:	49 8b 87 e0 00 00 00 	mov    0xe0(%r15),%rax
  40c29b:	48 89 85 18 ff ff ff 	mov    %rax,-0xe8(%rbp)
  40c2a2:	48 8b 85 28 ff ff ff 	mov    -0xd8(%rbp),%rax
  40c2a9:	48 8b 80 c8 00 00 00 	mov    0xc8(%rax),%rax
  40c2b0:	48 89 85 a8 fe ff ff 	mov    %rax,-0x158(%rbp)
    while (PTR_STATE != NULL)
  40c2b7:	48 85 db             	test   %rbx,%rbx
  40c2ba:	0f 84 4e 16 00 00    	je     40d90e <resume_solution+0x348e>
    pri_queue *pqueue = NULL;
  40c2c0:	48 c7 85 08 ff ff ff 	movq   $0x0,-0xf8(%rbp)
  40c2c7:	00 00 00 00 
  40c2cb:	e9 77 e4 ff ff       	jmpq   40a747 <resume_solution+0x2c7>
    if (HT_FIELD(hard_thread, prelude_idx) < prelude_num_items)
  40c2d0:	48 8b bd f0 fe ff ff 	mov    -0x110(%rbp),%rdi
  40c2d7:	48 8b 87 08 05 00 00 	mov    0x508(%rdi),%rax
  40c2de:	48 8b 37             	mov    (%rdi),%rsi
  40c2e1:	48 39 85 68 fe ff ff 	cmp    %rax,-0x198(%rbp)
  40c2e8:	0f 87 f7 01 00 00    	ja     40c4e5 <resume_solution+0x2065>
        set_next_soft_thread(hard_thread, next_st_idx,
  40c2ee:	48 8b bd 80 fe ff ff 	mov    -0x180(%rbp),%rdi
            ((1 + (*st_idx_ptr)) % num_soft_threads);
  40c2f5:	48 8d 42 01          	lea    0x1(%rdx),%rax
        const int_fast32_t next_st_idx =
  40c2f9:	48 99                	cqto   
  40c2fb:	48 f7 bd 88 fe ff ff 	idivq  -0x178(%rbp)
        set_next_soft_thread(hard_thread, next_st_idx,
  40c302:	48 89 d0             	mov    %rdx,%rax
  40c305:	48 c1 e0 06          	shl    $0x6,%rax
  40c309:	48 29 d0             	sub    %rdx,%rax
  40c30c:	48 8b 84 c7 e8 01 00 	mov    0x1e8(%rdi,%rax,8),%rax
  40c313:	00 
    (*st_idx_ptr) = scan_idx;
  40c314:	48 8b bd f0 fe ff ff 	mov    -0x110(%rbp),%rdi
        NUM_CHECKED_STATES + quota;
  40c31b:	48 01 f0             	add    %rsi,%rax
    (*st_idx_ptr) = scan_idx;
  40c31e:	48 89 97 d0 00 00 00 	mov    %rdx,0xd0(%rdi)
        NUM_CHECKED_STATES + quota;
  40c325:	48 89 87 c8 00 00 00 	mov    %rax,0xc8(%rdi)
  40c32c:	e9 d4 e2 ff ff       	jmpq   40a605 <resume_solution+0x185>
    BUMP_NUM_CHECKED_STATES();
  40c331:	48 8b 85 28 ff ff ff 	mov    -0xd8(%rbp),%rax
    DEPTH() = -1;
  40c338:	bb 01 00 00 00       	mov    $0x1,%ebx
    return FCS_STATE_IS_NOT_SOLVEABLE;
  40c33d:	41 bc 01 00 00 00    	mov    $0x1,%r12d
    BUMP_NUM_CHECKED_STATES();
  40c343:	48 83 00 01          	addq   $0x1,(%rax)
    DEPTH() = -1;
  40c347:	49 c7 47 38 ff ff ff 	movq   $0xffffffffffffffff,0x38(%r15)
  40c34e:	ff 
  40c34f:	e9 1c e6 ff ff       	jmpq   40a970 <resume_solution+0x4f0>
    if ((size_t)(allocator->max_ptr - allocator->ptr) < how_much)
  40c354:	48 8b 83 e0 00 00 00 	mov    0xe0(%rbx),%rax
  40c35b:	4c 8b a3 e8 00 00 00 	mov    0xe8(%rbx),%r12
  40c362:	48 89 c2             	mov    %rax,%rdx
  40c365:	4c 29 e2             	sub    %r12,%rdx
  40c368:	48 83 fa 0f          	cmp    $0xf,%rdx
  40c36c:	0f 86 0c 06 00 00    	jbe    40c97e <resume_solution+0x24fe>
        allocator->rollback_ptr = allocator->ptr;
  40c372:	4c 89 a3 f0 00 00 00 	mov    %r12,0xf0(%rbx)
    allocator->ptr += how_much;
  40c379:	49 8d 54 24 10       	lea    0x10(%r12),%rdx
    if ((size_t)(allocator->max_ptr - allocator->ptr) < how_much)
  40c37e:	48 29 d0             	sub    %rdx,%rax
    allocator->ptr += how_much;
  40c381:	48 89 93 e8 00 00 00 	mov    %rdx,0xe8(%rbx)
    my_brfs_queue = NEW_BRFS_QUEUE_ITEM();
  40c388:	4d 89 a7 d8 00 00 00 	mov    %r12,0xd8(%r15)
    if ((size_t)(allocator->max_ptr - allocator->ptr) < how_much)
  40c38f:	48 83 f8 0f          	cmp    $0xf,%rax
  40c393:	0f 86 41 06 00 00    	jbe    40c9da <resume_solution+0x255a>
        allocator->rollback_ptr = allocator->ptr;
  40c399:	48 89 93 f0 00 00 00 	mov    %rdx,0xf0(%rbx)
    allocator->ptr += how_much;
  40c3a0:	48 8d 42 10          	lea    0x10(%rdx),%rax
  40c3a4:	48 89 83 e8 00 00 00 	mov    %rax,0xe8(%rbx)
    if (!BEFS_M_VAR(soft_thread, moves_list))
  40c3ab:	49 8b 87 c8 00 00 00 	mov    0xc8(%r15),%rax
    my_brfs_queue_last_item = my_brfs_queue->next = NEW_BRFS_QUEUE_ITEM();
  40c3b2:	49 89 54 24 08       	mov    %rdx,0x8(%r12)
  40c3b7:	49 89 97 e0 00 00 00 	mov    %rdx,0xe0(%r15)
    my_brfs_queue_last_item->next = NULL;
  40c3be:	48 c7 42 08 00 00 00 	movq   $0x0,0x8(%rdx)
  40c3c5:	00 
    my_brfs_recycle_bin = NULL;
  40c3c6:	49 c7 87 e8 00 00 00 	movq   $0x0,0xe8(%r15)
  40c3cd:	00 00 00 00 
    if (!BEFS_M_VAR(soft_thread, moves_list))
  40c3d1:	48 85 c0             	test   %rax,%rax
  40c3d4:	0f 85 bd fa ff ff    	jne    40be97 <resume_solution+0x1a17>
             group_idx < soft_thread->by_depth_moves_order.by_depth_moves[0]
  40c3da:	49 8b 4f 18          	mov    0x18(%r15),%rcx
        for (size_t group_idx = 0;
  40c3de:	48 83 79 08 00       	cmpq   $0x0,0x8(%rcx)
  40c3e3:	0f 84 6c 06 00 00    	je     40ca55 <resume_solution+0x25d5>
        size_t num = 0;
  40c3e9:	45 31 c0             	xor    %r8d,%r8d
        for (size_t group_idx = 0;
  40c3ec:	4c 89 bd 30 ff ff ff 	mov    %r15,-0xd0(%rbp)
  40c3f3:	45 31 ed             	xor    %r13d,%r13d
  40c3f6:	4d 89 c7             	mov    %r8,%r15
                    .moves_order.groups[group_idx]
  40c3f9:	49 69 d5 e8 00 00 00 	imul   $0xe8,%r13,%rdx
static inline void add_to_move_funcs_list(
    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 =
  40c400:	48 89 c7             	mov    %rax,%rdi
  40c403:	48 03 51 10          	add    0x10(%rcx),%rdx
            add_to_move_funcs_list(&moves_list, &num,
  40c407:	48 8b 5a 08          	mov    0x8(%rdx),%rbx
                    .move_funcs,
  40c40b:	4c 8b 22             	mov    (%rdx),%r12
        SREALLOC(*out_move_funcs_list, num + count_to_add);
  40c40e:	4e 8d 34 3b          	lea    (%rbx,%r15,1),%r14
  40c412:	4a 8d 34 f5 00 00 00 	lea    0x0(,%r14,8),%rsi
  40c419:	00 
    fcs_move_func *const move_funcs_list =
  40c41a:	e8 51 4d ff ff       	callq  401170 <realloc@plt>
    for (size_t i = 0; i < count_to_add; ++i)
  40c41f:	48 85 db             	test   %rbx,%rbx
  40c422:	0f 84 f1 00 00 00    	je     40c519 <resume_solution+0x2099>
  40c428:	4a 8d 34 f8          	lea    (%rax,%r15,8),%rsi
  40c42c:	31 d2                	xor    %edx,%edx
  40c42e:	66 90                	xchg   %ax,%ax
    {
        move_funcs_list[num++].f = fc_solve_sfs_move_funcs[indexes[i].idx];
  40c430:	49 8b 0c d4          	mov    (%r12,%rdx,8),%rcx
  40c434:	48 8b 0c cd c0 f5 40 	mov    0x40f5c0(,%rcx,8),%rcx
  40c43b:	00 
  40c43c:	48 89 0c d6          	mov    %rcx,(%rsi,%rdx,8)
    for (size_t i = 0; i < count_to_add; ++i)
  40c440:	48 83 c2 01          	add    $0x1,%rdx
  40c444:	48 39 d3             	cmp    %rdx,%rbx
  40c447:	75 e7                	jne    40c430 <resume_solution+0x1fb0>
             group_idx < soft_thread->by_depth_moves_order.by_depth_moves[0]
  40c449:	48 8b 9d 30 ff ff ff 	mov    -0xd0(%rbp),%rbx
             ++group_idx)
  40c450:	49 83 c5 01          	add    $0x1,%r13
  40c454:	4d 89 f7             	mov    %r14,%r15
             group_idx < soft_thread->by_depth_moves_order.by_depth_moves[0]
  40c457:	48 8b 4b 18          	mov    0x18(%rbx),%rcx
        for (size_t group_idx = 0;
  40c45b:	4c 3b 69 08          	cmp    0x8(%rcx),%r13
  40c45f:	72 98                	jb     40c3f9 <resume_solution+0x1f79>
  40c461:	49 89 df             	mov    %rbx,%r15
  40c464:	4a 8d 14 f0          	lea    (%rax,%r14,8),%rdx
        BEFS_M_VAR(soft_thread, moves_list) = moves_list;
  40c468:	49 89 87 c8 00 00 00 	mov    %rax,0xc8(%r15)
        BEFS_M_VAR(soft_thread, moves_list_end) = moves_list + num;
  40c46f:	49 89 97 d0 00 00 00 	mov    %rdx,0xd0(%r15)
  40c476:	e9 1c fa ff ff       	jmpq   40be97 <resume_solution+0x1a17>
                    the_soft_dfs_info->derived_states_list = derived_list;
  40c47b:	c5 f9 6f 85 50 ff ff 	vmovdqa -0xb0(%rbp),%xmm0
  40c482:	ff 
  40c483:	bb 05 00 00 00       	mov    $0x5,%ebx
                    return FCS_STATE_SUSPEND_PROCESS;
  40c488:	41 bc 05 00 00 00    	mov    $0x5,%r12d
                    the_soft_dfs_info->derived_states_list = derived_list;
  40c48e:	c4 c1 78 11 86 b8 00 	vmovups %xmm0,0xb8(%r14)
  40c495:	00 00 
  40c497:	e9 d4 e4 ff ff       	jmpq   40a970 <resume_solution+0x4f0>
        prelude[HT_FIELD(hard_thread, prelude_idx)++];
  40c49c:	48 8d 50 01          	lea    0x1(%rax),%rdx
  40c4a0:	48 c1 e0 04          	shl    $0x4,%rax
  40c4a4:	48 03 85 48 fe ff ff 	add    -0x1b8(%rbp),%rax
  40c4ab:	48 89 97 08 05 00 00 	mov    %rdx,0x508(%rdi)
    set_next_soft_thread(
  40c4b2:	48 8b 50 08          	mov    0x8(%rax),%rdx
    (*st_idx_ptr) = scan_idx;
  40c4b6:	48 8b 00             	mov    (%rax),%rax
  40c4b9:	48 89 87 d0 00 00 00 	mov    %rax,0xd0(%rdi)
        NUM_CHECKED_STATES + quota;
  40c4c0:	48 8d 04 16          	lea    (%rsi,%rdx,1),%rax
  40c4c4:	48 89 87 c8 00 00 00 	mov    %rax,0xc8(%rdi)
  40c4cb:	e9 b7 e4 ff ff       	jmpq   40a987 <resume_solution+0x507>
                        BUMP_NUM_CHECKED_STATES();
  40c4d0:	48 8b 85 28 ff ff ff 	mov    -0xd8(%rbp),%rax
  40c4d7:	31 db                	xor    %ebx,%ebx
                        return FCS_STATE_WAS_SOLVED;
  40c4d9:	45 31 e4             	xor    %r12d,%r12d
                        BUMP_NUM_CHECKED_STATES();
  40c4dc:	48 83 00 01          	addq   $0x1,(%rax)
  40c4e0:	e9 8b e4 ff ff       	jmpq   40a970 <resume_solution+0x4f0>
        prelude[HT_FIELD(hard_thread, prelude_idx)++];
  40c4e5:	48 8d 50 01          	lea    0x1(%rax),%rdx
  40c4e9:	48 c1 e0 04          	shl    $0x4,%rax
  40c4ed:	48 03 85 48 fe ff ff 	add    -0x1b8(%rbp),%rax
  40c4f4:	48 89 97 08 05 00 00 	mov    %rdx,0x508(%rdi)
    set_next_soft_thread(
  40c4fb:	48 8b 50 08          	mov    0x8(%rax),%rdx
    (*st_idx_ptr) = scan_idx;
  40c4ff:	48 8b 00             	mov    (%rax),%rax
  40c502:	48 89 87 d0 00 00 00 	mov    %rax,0xd0(%rdi)
        NUM_CHECKED_STATES + quota;
  40c509:	48 8d 04 32          	lea    (%rdx,%rsi,1),%rax
  40c50d:	48 89 87 c8 00 00 00 	mov    %rax,0xc8(%rdi)
  40c514:	e9 ec e0 ff ff       	jmpq   40a605 <resume_solution+0x185>
  40c519:	4d 89 fe             	mov    %r15,%r14
  40c51c:	e9 28 ff ff ff       	jmpq   40c449 <resume_solution+0x1fc9>
  40c521:	49 8d 40 10          	lea    0x10(%r8),%rax
  40c525:	e9 f6 e3 ff ff       	jmpq   40a920 <resume_solution+0x4a0>
        return malloc(ALLOCED_SIZE);
  40c52a:	bf 80 fe 00 00       	mov    $0xfe80,%edi
  40c52f:	e8 bc 4b ff ff       	callq  4010f0 <malloc@plt>
  40c534:	e9 67 f5 ff ff       	jmpq   40baa0 <resume_solution+0x1620>
    RECALC_BY_DEPTH_LIMITS();
  40c539:	48 c7 85 c0 fe ff ff 	movq   $0x0,-0x140(%rbp)
  40c540:	00 00 00 00 
  40c544:	48 89 d7             	mov    %rdx,%rdi
  40c547:	e9 89 ec ff ff       	jmpq   40b1d5 <resume_solution+0xd55>
  40c54c:	48 89 d7             	mov    %rdx,%rdi
    for (; (DEPTH() >= GET_DEPTH(curr_by_depth_unit)); ++curr_by_depth_unit)
  40c54f:	48 89 95 b0 fe ff ff 	mov    %rdx,-0x150(%rbp)
    RECALC_BY_DEPTH_LIMITS();
  40c556:	48 c7 85 c0 fe ff ff 	movq   $0x0,-0x140(%rbp)
  40c55d:	00 00 00 00 
  40c561:	e9 6f ec ff ff       	jmpq   40b1d5 <resume_solution+0xd55>
        arr_ptr->by_depth_units = SMALLOC(arr_ptr->by_depth_units,
  40c566:	4d 8b 67 10          	mov    0x10(%r15),%r12
        const_SLOT(master_to_randomize, soft_thread);
  40c56a:	41 0f b6 87 f1 01 00 	movzbl 0x1f1(%r15),%eax
  40c571:	00 
        arr_ptr->by_depth_units = SMALLOC(arr_ptr->by_depth_units,
  40c572:	4b 8d 1c 64          	lea    (%r12,%r12,2),%rbx
  40c576:	4d 89 67 50          	mov    %r12,0x50(%r15)
  40c57a:	48 c1 e3 03          	shl    $0x3,%rbx
        const_SLOT(master_to_randomize, soft_thread);
  40c57e:	88 85 10 ff ff ff    	mov    %al,-0xf0(%rbp)
        arr_ptr->by_depth_units = SMALLOC(arr_ptr->by_depth_units,
  40c584:	48 89 df             	mov    %rbx,%rdi
  40c587:	e8 64 4b ff ff       	callq  4010f0 <malloc@plt>
  40c58c:	49 89 c6             	mov    %rax,%r14
  40c58f:	49 89 47 58          	mov    %rax,0x58(%r15)
        const fcs_by_depth_moves_order *const by_depth_moves_order =
  40c593:	49 8b 47 18          	mov    0x18(%r15),%rax
        for (size_t depth_idx = 0; depth_idx < depth_num; ++depth_idx, ++unit)
  40c597:	4d 85 e4             	test   %r12,%r12
  40c59a:	0f 84 ed f6 ff ff    	je     40bc8d <resume_solution+0x180d>
  40c5a0:	4c 01 f3             	add    %r14,%rbx
        sum += befs_weights[i];
  40c5a3:	4c 89 bd 28 ff ff ff 	mov    %r15,-0xd8(%rbp)
  40c5aa:	4d 89 f5             	mov    %r14,%r13
  40c5ad:	49 89 c7             	mov    %rax,%r15
  40c5b0:	48 89 9d 18 ff ff ff 	mov    %rbx,-0xe8(%rbp)
            unit->max_depth = by_depth_moves_order[depth_idx].max_depth;
  40c5b7:	49 8b 07             	mov    (%r15),%rax
            fcs_moves_group *const tests_order_groups =
  40c5ba:	4d 8b 77 10          	mov    0x10(%r15),%r14
            unit->max_depth = by_depth_moves_order[depth_idx].max_depth;
  40c5be:	49 89 45 00          	mov    %rax,0x0(%r13)
            const_AUTO(tests_order_num,
  40c5c2:	49 8b 5f 08          	mov    0x8(%r15),%rbx
                .groups = SMALLOC(moves_list_of_lists->groups, tests_order_num),
  40c5c6:	4c 69 e3 e8 00 00 00 	imul   $0xe8,%rbx,%r12
  40c5cd:	4c 89 e7             	mov    %r12,%rdi
  40c5d0:	e8 1b 4b ff ff       	callq  4010f0 <malloc@plt>
            *moves_list_of_lists = (typeof(*moves_list_of_lists)){
  40c5d5:	49 c7 45 08 00 00 00 	movq   $0x0,0x8(%r13)
  40c5dc:	00 
                .groups = SMALLOC(moves_list_of_lists->groups, tests_order_num),
  40c5dd:	49 89 c2             	mov    %rax,%r10
            *moves_list_of_lists = (typeof(*moves_list_of_lists)){
  40c5e0:	49 89 45 10          	mov    %rax,0x10(%r13)
            for (size_t group_idx = 0; group_idx < tests_order_num; ++group_idx)
  40c5e4:	48 85 db             	test   %rbx,%rbx
  40c5e7:	0f 84 c4 00 00 00    	je     40c6b1 <resume_solution+0x2231>
  40c5ed:	0f b6 9d 10 ff ff ff 	movzbl -0xf0(%rbp),%ebx
  40c5f4:	4b 8d 04 26          	lea    (%r14,%r12,1),%rax
  40c5f8:	4c 89 bd 20 ff ff ff 	mov    %r15,-0xe0(%rbp)
  40c5ff:	4d 89 ef             	mov    %r13,%r15
  40c602:	48 89 85 30 ff ff ff 	mov    %rax,-0xd0(%rbp)
  40c609:	4d 89 f5             	mov    %r14,%r13
  40c60c:	0f 1f 40 00          	nopl   0x0(%rax)
                add_to_move_funcs_list(&tests_list, &num,
  40c610:	4d 8b 75 08          	mov    0x8(%r13),%r14
    fcs_move_func *const move_funcs_list =
  40c614:	31 ff                	xor    %edi,%edi
                    tests_order_groups[group_idx].move_funcs,
  40c616:	4d 8b 65 00          	mov    0x0(%r13),%r12
        SREALLOC(*out_move_funcs_list, num + count_to_add);
  40c61a:	4a 8d 34 f5 00 00 00 	lea    0x0(,%r14,8),%rsi
  40c621:	00 
    fcs_move_func *const move_funcs_list =
  40c622:	e8 49 4b ff ff       	callq  401170 <realloc@plt>
  40c627:	48 89 c6             	mov    %rax,%rsi
    for (size_t i = 0; i < count_to_add; ++i)
  40c62a:	4d 85 f6             	test   %r14,%r14
  40c62d:	74 2b                	je     40c65a <resume_solution+0x21da>
    size_t num = *num_so_far;
  40c62f:	31 c0                	xor    %eax,%eax
  40c631:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40c638:	00 00 00 00 
  40c63c:	0f 1f 40 00          	nopl   0x0(%rax)
        move_funcs_list[num++].f = fc_solve_sfs_move_funcs[indexes[i].idx];
  40c640:	49 8b 14 c4          	mov    (%r12,%rax,8),%rdx
  40c644:	48 83 c0 01          	add    $0x1,%rax
  40c648:	48 8b 14 d5 c0 f5 40 	mov    0x40f5c0(,%rdx,8),%rdx
  40c64f:	00 
  40c650:	48 89 54 c6 f8       	mov    %rdx,-0x8(%rsi,%rax,8)
    for (size_t i = 0; i < count_to_add; ++i)
  40c655:	49 39 c6             	cmp    %rax,%r14
  40c658:	75 e6                	jne    40c640 <resume_solution+0x21c0>
                const_AUTO(tests_list_struct_ptr,
  40c65a:	49 8b 57 08          	mov    0x8(%r15),%rdx
  40c65e:	4d 8b 57 10          	mov    0x10(%r15),%r10
  40c662:	4c 8d 4a 01          	lea    0x1(%rdx),%r9
  40c666:	48 69 d2 e8 00 00 00 	imul   $0xe8,%rdx,%rdx
  40c66d:	4d 89 4f 08          	mov    %r9,0x8(%r15)
  40c671:	4c 01 d2             	add    %r10,%rdx
                            : FCS_NO_SHUFFLING);
  40c674:	84 db                	test   %bl,%bl
  40c676:	75 78                	jne    40c6f0 <resume_solution+0x2270>
                *tests_list_struct_ptr = (typeof(*tests_list_struct_ptr)){
  40c678:	b9 1d 00 00 00       	mov    $0x1d,%ecx
  40c67d:	31 c0                	xor    %eax,%eax
  40c67f:	48 89 d7             	mov    %rdx,%rdi
  40c682:	f3 48 ab             	rep stos %rax,%es:(%rdi)
  40c685:	48 89 32             	mov    %rsi,(%rdx)
  40c688:	4c 89 72 08          	mov    %r14,0x8(%rdx)
  40c68c:	49 81 c5 e8 00 00 00 	add    $0xe8,%r13
            for (size_t group_idx = 0; group_idx < tests_order_num; ++group_idx)
  40c693:	4c 39 ad 30 ff ff ff 	cmp    %r13,-0xd0(%rbp)
  40c69a:	0f 85 70 ff ff ff    	jne    40c610 <resume_solution+0x2190>
  40c6a0:	4d 89 fd             	mov    %r15,%r13
  40c6a3:	4c 8b bd 20 ff ff ff 	mov    -0xe0(%rbp),%r15
  40c6aa:	49 69 d9 e8 00 00 00 	imul   $0xe8,%r9,%rbx
                SREALLOC(moves_list_of_lists->groups, moves_list_of_lists->num);
  40c6b1:	48 89 de             	mov    %rbx,%rsi
  40c6b4:	4c 89 d7             	mov    %r10,%rdi
        for (size_t depth_idx = 0; depth_idx < depth_num; ++depth_idx, ++unit)
  40c6b7:	49 83 c5 18          	add    $0x18,%r13
                SREALLOC(moves_list_of_lists->groups, moves_list_of_lists->num);
  40c6bb:	e8 b0 4a ff ff       	callq  401170 <realloc@plt>
  40c6c0:	49 83 c7 18          	add    $0x18,%r15
            moves_list_of_lists->groups =
  40c6c4:	49 89 45 f8          	mov    %rax,-0x8(%r13)
        for (size_t depth_idx = 0; depth_idx < depth_num; ++depth_idx, ++unit)
  40c6c8:	4c 3b ad 18 ff ff ff 	cmp    -0xe8(%rbp),%r13
  40c6cf:	0f 85 e2 fe ff ff    	jne    40c5b7 <resume_solution+0x2137>
  40c6d5:	4c 8b bd 28 ff ff ff 	mov    -0xd8(%rbp),%r15
  40c6dc:	e9 ac f5 ff ff       	jmpq   40bc8d <resume_solution+0x180d>
  40c6e1:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40c6e8:	00 00 00 00 
  40c6ec:	0f 1f 40 00          	nopl   0x0(%rax)
                            : FCS_NO_SHUFFLING);
  40c6f0:	45 8b 5d 10          	mov    0x10(%r13),%r11d
                *tests_list_struct_ptr = (typeof(*tests_list_struct_ptr)){
  40c6f4:	b9 1d 00 00 00       	mov    $0x1d,%ecx
  40c6f9:	31 c0                	xor    %eax,%eax
  40c6fb:	48 89 d7             	mov    %rdx,%rdi
  40c6fe:	f3 48 ab             	rep stos %rax,%es:(%rdi)
  40c701:	48 89 32             	mov    %rsi,(%rdx)
  40c704:	4c 89 72 08          	mov    %r14,0x8(%rdx)
  40c708:	44 89 5a 10          	mov    %r11d,0x10(%rdx)
                if (shuffling_type == FCS_WEIGHTING)
  40c70c:	41 83 fb 02          	cmp    $0x2,%r11d
  40c710:	0f 85 76 ff ff ff    	jne    40c68c <resume_solution+0x220c>
                    tests_list_struct_ptr->weighting =
  40c716:	c4 c1 7a 6f 45 18    	vmovdqu 0x18(%r13),%xmm0
  40c71c:	c5 e9 57 d2          	vxorpd %xmm2,%xmm2,%xmm2
  40c720:	c5 f8 11 42 18       	vmovups %xmm0,0x18(%rdx)
  40c725:	c4 c1 7a 6f 45 28    	vmovdqu 0x28(%r13),%xmm0
  40c72b:	c5 f8 11 42 28       	vmovups %xmm0,0x28(%rdx)
  40c730:	c4 c1 7a 6f 45 38    	vmovdqu 0x38(%r13),%xmm0
  40c736:	c5 f8 11 42 38       	vmovups %xmm0,0x38(%rdx)
  40c73b:	c4 c1 7a 6f 45 48    	vmovdqu 0x48(%r13),%xmm0
  40c741:	c5 f8 11 42 48       	vmovups %xmm0,0x48(%rdx)
  40c746:	c4 c1 7a 6f 45 58    	vmovdqu 0x58(%r13),%xmm0
  40c74c:	c5 f8 11 42 58       	vmovups %xmm0,0x58(%rdx)
  40c751:	c4 c1 7a 6f 45 68    	vmovdqu 0x68(%r13),%xmm0
  40c757:	c5 f8 11 42 68       	vmovups %xmm0,0x68(%rdx)
  40c75c:	c4 c1 7a 6f 45 78    	vmovdqu 0x78(%r13),%xmm0
  40c762:	c5 f8 11 42 78       	vmovups %xmm0,0x78(%rdx)
  40c767:	c4 c1 7a 6f 85 88 00 	vmovdqu 0x88(%r13),%xmm0
  40c76e:	00 00 
  40c770:	c5 f8 11 82 88 00 00 	vmovups %xmm0,0x88(%rdx)
  40c777:	00 
  40c778:	c4 c1 7a 6f 85 98 00 	vmovdqu 0x98(%r13),%xmm0
  40c77f:	00 00 
  40c781:	c5 f8 11 82 98 00 00 	vmovups %xmm0,0x98(%rdx)
  40c788:	00 
  40c789:	c4 c1 7a 6f 85 a8 00 	vmovdqu 0xa8(%r13),%xmm0
  40c790:	00 00 
  40c792:	c5 f8 11 82 a8 00 00 	vmovups %xmm0,0xa8(%rdx)
  40c799:	00 
  40c79a:	c4 c1 7a 6f 85 b8 00 	vmovdqu 0xb8(%r13),%xmm0
  40c7a1:	00 00 
  40c7a3:	c5 f8 11 82 b8 00 00 	vmovups %xmm0,0xb8(%rdx)
  40c7aa:	00 
  40c7ab:	c5 fb 10 8a b8 00 00 	vmovsd 0xb8(%rdx),%xmm1
  40c7b2:	00 
  40c7b3:	c4 c1 7a 6f 85 c8 00 	vmovdqu 0xc8(%r13),%xmm0
  40c7ba:	00 00 
  40c7bc:	c5 fb 10 ba c0 00 00 	vmovsd 0xc0(%rdx),%xmm7
  40c7c3:	00 
  40c7c4:	c5 f8 11 82 c8 00 00 	vmovups %xmm0,0xc8(%rdx)
  40c7cb:	00 
  40c7cc:	c5 fb 10 b2 c8 00 00 	vmovsd 0xc8(%rdx),%xmm6
  40c7d3:	00 
  40c7d4:	c4 c1 7a 6f 85 d8 00 	vmovdqu 0xd8(%r13),%xmm0
  40c7db:	00 00 
  40c7dd:	c5 fb 10 aa d0 00 00 	vmovsd 0xd0(%rdx),%xmm5
  40c7e4:	00 
  40c7e5:	c5 f8 11 82 d8 00 00 	vmovups %xmm0,0xd8(%rdx)
  40c7ec:	00 
  40c7ed:	c5 f3 58 c2          	vaddsd %xmm2,%xmm1,%xmm0
  40c7f1:	c5 7b 10 82 d8 00 00 	vmovsd 0xd8(%rdx),%xmm8
  40c7f8:	00 
  40c7f9:	c5 fb 10 a2 e0 00 00 	vmovsd 0xe0(%rdx),%xmm4
  40c800:	00 
    if (sum < 1e-6)
  40c801:	c5 fb 10 15 d7 44 00 	vmovsd 0x44d7(%rip),%xmm2        # 410ce0 <fc_solve_is_parent_buf+0xe20>
  40c808:	00 
        sum += befs_weights[i];
  40c809:	c5 fb 58 c7          	vaddsd %xmm7,%xmm0,%xmm0
    if (sum < 1e-6)
  40c80d:	c5 fb 10 1d d3 44 00 	vmovsd 0x44d3(%rip),%xmm3        # 410ce8 <fc_solve_is_parent_buf+0xe28>
  40c814:	00 
        sum += befs_weights[i];
  40c815:	c5 fb 58 c6          	vaddsd %xmm6,%xmm0,%xmm0
  40c819:	c5 fb 58 c5          	vaddsd %xmm5,%xmm0,%xmm0
  40c81d:	c4 c1 7b 58 c0       	vaddsd %xmm8,%xmm0,%xmm0
  40c822:	c5 fb 58 c4          	vaddsd %xmm4,%xmm0,%xmm0
    if (sum < 1e-6)
  40c826:	c5 f9 2e d8          	vucomisd %xmm0,%xmm3
  40c82a:	77 04                	ja     40c830 <resume_solution+0x23b0>
  40c82c:	c5 eb 5e d0          	vdivsd %xmm0,%xmm2,%xmm2
        W(FCS_BEFS_WEIGHT_CARDS_OUT) / (LOCAL_DECKS_NUM * 52);
  40c830:	c5 f3 59 c2          	vmulsd %xmm2,%xmm1,%xmm0
    const double num_cards_out_factor =
  40c834:	c5 fb 10 1d b4 44 00 	vmovsd 0x44b4(%rip),%xmm3        # 410cf0 <fc_solve_is_parent_buf+0xe30>
  40c83b:	00 
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40c83c:	c5 f1 57 c9          	vxorpd %xmm1,%xmm1,%xmm1
            weighting->cards_under_sequences_factor ||
  40c840:	b9 01 00 00 00       	mov    $0x1,%ecx
    fcs_hard_thread *const hard_thread = soft_thread->hard_thread;
  40c845:	48 8b 85 28 ff ff ff 	mov    -0xd8(%rbp),%rax
        W(FCS_BEFS_WEIGHT_MAX_SEQUENCE_MOVE) /
  40c84c:	c5 c3 59 fa          	vmulsd %xmm2,%xmm7,%xmm7
        W(FCS_BEFS_WEIGHT_CARDS_UNDER_SEQUENCES) /
  40c850:	c5 cb 59 f2          	vmulsd %xmm2,%xmm6,%xmm6
        W(FCS_BEFS_WEIGHT_MAX_SEQUENCE_MOVE) /
  40c854:	c5 c3 5e 3d 9c 44 00 	vdivsd 0x449c(%rip),%xmm7,%xmm7        # 410cf8 <fc_solve_is_parent_buf+0xe38>
  40c85b:	00 
        W(FCS_BEFS_WEIGHT_SEQS_OVER_RENEGADE_CARDS) /
  40c85c:	c5 d3 59 ea          	vmulsd %xmm2,%xmm5,%xmm5
    weighting->depth_factor = W(FCS_BEFS_WEIGHT_DEPTH) / BEFS_MAX_DEPTH;
  40c860:	c5 3b 59 c2          	vmulsd %xmm2,%xmm8,%xmm8
        W(FCS_BEFS_WEIGHT_SEQS_OVER_RENEGADE_CARDS) /
  40c864:	c5 d3 5e 2d 94 44 00 	vdivsd 0x4494(%rip),%xmm5,%xmm5        # 410d00 <fc_solve_is_parent_buf+0xe40>
  40c86b:	00 
        W(FCS_BEFS_WEIGHT_NUM_CARDS_NOT_ON_PARENTS) / (LOCAL_DECKS_NUM * 52);
  40c86c:	c5 db 59 d2          	vmulsd %xmm2,%xmm4,%xmm2
    fcs_hard_thread *const hard_thread = soft_thread->hard_thread;
  40c870:	48 8b 00             	mov    (%rax),%rax
        num_cards_out_lookup_table[i] = out_sum;
  40c873:	48 c7 42 48 00 00 00 	movq   $0x0,0x48(%rdx)
  40c87a:	00 
    weighting->depth_factor = W(FCS_BEFS_WEIGHT_DEPTH) / BEFS_MAX_DEPTH;
  40c87b:	c5 3b 5e 05 85 44 00 	vdivsd 0x4485(%rip),%xmm8,%xmm8        # 410d08 <fc_solve_is_parent_buf+0xe48>
  40c882:	00 
    weighting->max_sequence_move_factor =
  40c883:	c5 fb 11 7a 20       	vmovsd %xmm7,0x20(%rdx)
    const double num_cards_out_factor =
  40c888:	c5 fb 5e c3          	vdivsd %xmm3,%xmm0,%xmm0
        W(FCS_BEFS_WEIGHT_NUM_CARDS_NOT_ON_PARENTS) / (LOCAL_DECKS_NUM * 52);
  40c88c:	c5 eb 5e d3          	vdivsd %xmm3,%xmm2,%xmm2
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40c890:	c5 fb 58 c9          	vaddsd %xmm1,%xmm0,%xmm1
        num_cards_out_lookup_table[i] = out_sum;
  40c894:	c5 fb 11 4a 50       	vmovsd %xmm1,0x50(%rdx)
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40c899:	c5 fb 58 c9          	vaddsd %xmm1,%xmm0,%xmm1
        num_cards_out_lookup_table[i] = out_sum;
  40c89d:	c5 fb 11 4a 58       	vmovsd %xmm1,0x58(%rdx)
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40c8a2:	c5 fb 58 c9          	vaddsd %xmm1,%xmm0,%xmm1
        num_cards_out_lookup_table[i] = out_sum;
  40c8a6:	c5 fb 11 4a 60       	vmovsd %xmm1,0x60(%rdx)
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40c8ab:	c5 fb 58 c9          	vaddsd %xmm1,%xmm0,%xmm1
        num_cards_out_lookup_table[i] = out_sum;
  40c8af:	c5 fb 11 4a 68       	vmovsd %xmm1,0x68(%rdx)
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40c8b4:	c5 fb 58 c9          	vaddsd %xmm1,%xmm0,%xmm1
        num_cards_out_lookup_table[i] = out_sum;
  40c8b8:	c5 fb 11 4a 70       	vmovsd %xmm1,0x70(%rdx)
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40c8bd:	c5 fb 58 c9          	vaddsd %xmm1,%xmm0,%xmm1
        num_cards_out_lookup_table[i] = out_sum;
  40c8c1:	c5 fb 11 4a 78       	vmovsd %xmm1,0x78(%rdx)
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40c8c6:	c5 fb 58 c9          	vaddsd %xmm1,%xmm0,%xmm1
        num_cards_out_lookup_table[i] = out_sum;
  40c8ca:	c5 fb 11 8a 80 00 00 	vmovsd %xmm1,0x80(%rdx)
  40c8d1:	00 
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40c8d2:	c5 fb 58 c9          	vaddsd %xmm1,%xmm0,%xmm1
        num_cards_out_lookup_table[i] = out_sum;
  40c8d6:	c5 fb 11 8a 88 00 00 	vmovsd %xmm1,0x88(%rdx)
  40c8dd:	00 
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40c8de:	c5 fb 58 c9          	vaddsd %xmm1,%xmm0,%xmm1
        num_cards_out_lookup_table[i] = out_sum;
  40c8e2:	c5 fb 11 8a 90 00 00 	vmovsd %xmm1,0x90(%rdx)
  40c8e9:	00 
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40c8ea:	c5 fb 58 c9          	vaddsd %xmm1,%xmm0,%xmm1
        num_cards_out_lookup_table[i] = out_sum;
  40c8ee:	c5 fb 11 8a 98 00 00 	vmovsd %xmm1,0x98(%rdx)
  40c8f5:	00 
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40c8f6:	c5 fb 58 c9          	vaddsd %xmm1,%xmm0,%xmm1
        num_cards_out_lookup_table[i] = out_sum;
  40c8fa:	c5 fb 11 8a a0 00 00 	vmovsd %xmm1,0xa0(%rdx)
  40c901:	00 
    for (int i = 0; i <= 13; i++, out_sum += num_cards_out_factor)
  40c902:	c5 fb 58 c9          	vaddsd %xmm1,%xmm0,%xmm1
  40c906:	c5 fb 58 c1          	vaddsd %xmm1,%xmm0,%xmm0
        num_cards_out_lookup_table[i] = out_sum;
  40c90a:	c5 fb 11 8a a8 00 00 	vmovsd %xmm1,0xa8(%rdx)
  40c911:	00 
  40c912:	c5 fb 11 82 b0 00 00 	vmovsd %xmm0,0xb0(%rdx)
  40c919:	00 
        W(FCS_BEFS_WEIGHT_CARDS_UNDER_SEQUENCES) /
  40c91a:	c5 cb 5e 70 08       	vdivsd 0x8(%rax),%xmm6,%xmm6
    weighting->num_cards_not_on_parents_factor =
  40c91f:	c5 fb 11 52 40       	vmovsd %xmm2,0x40(%rdx)
            weighting->cards_under_sequences_factor ||
  40c924:	c5 e9 57 d2          	vxorpd %xmm2,%xmm2,%xmm2
  40c928:	c5 f9 2e fa          	vucomisd %xmm2,%xmm7
    weighting->cards_under_sequences_factor =
  40c92c:	c5 fb 11 72 28       	vmovsd %xmm6,0x28(%rdx)
    weighting->seqs_over_renegade_cards_factor =
  40c931:	c5 fb 11 6a 30       	vmovsd %xmm5,0x30(%rdx)
            weighting->cards_under_sequences_factor ||
  40c936:	0f 9a c0             	setp   %al
    weighting->depth_factor = W(FCS_BEFS_WEIGHT_DEPTH) / BEFS_MAX_DEPTH;
  40c939:	c5 7b 11 42 38       	vmovsd %xmm8,0x38(%rdx)
            weighting->cards_under_sequences_factor ||
  40c93e:	0f 45 c1             	cmovne %ecx,%eax
        (weighting->max_sequence_move_factor ||
  40c941:	c5 f9 2e f2          	vucomisd %xmm2,%xmm6
            weighting->cards_under_sequences_factor ||
  40c945:	c5 c9 57 f6          	vxorpd %xmm6,%xmm6,%xmm6
        (weighting->max_sequence_move_factor ||
  40c949:	40 0f 9a c6          	setp   %sil
  40c94d:	0f 45 f1             	cmovne %ecx,%esi
    weighting->should_go_over_stacks =
  40c950:	09 f0                	or     %esi,%eax
            weighting->cards_under_sequences_factor ||
  40c952:	c5 f9 2e ee          	vucomisd %xmm6,%xmm5
  40c956:	40 0f 9a c6          	setp   %sil
  40c95a:	0f 44 ce             	cmove  %esi,%ecx
    weighting->should_go_over_stacks =
  40c95d:	09 c8                	or     %ecx,%eax
  40c95f:	88 42 18             	mov    %al,0x18(%rdx)
  40c962:	e9 25 fd ff ff       	jmpq   40c68c <resume_solution+0x220c>
            BEFS_M_VAR(soft_thread, first_state_to_check) = PTR_STATE;
  40c967:	49 89 9f d8 01 00 00 	mov    %rbx,0x1d8(%r15)
  40c96e:	41 bc 05 00 00 00    	mov    $0x5,%r12d
  40c974:	bb 05 00 00 00       	mov    $0x5,%ebx
  40c979:	e9 c8 df ff ff       	jmpq   40a946 <resume_solution+0x4c6>
    char *const new_data = meta_request_new_buffer(allocator->meta);
  40c97e:	48 8b 93 f8 00 00 00 	mov    0xf8(%rbx),%rdx
    char *const ret = meta_alloc->recycle_bin;
  40c985:	48 8b 02             	mov    (%rdx),%rax
    if (ret)
  40c988:	48 85 c0             	test   %rax,%rax
  40c98b:	0f 84 7e 03 00 00    	je     40cd0f <resume_solution+0x288f>
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  40c991:	48 8b 08             	mov    (%rax),%rcx
  40c994:	48 89 0a             	mov    %rcx,(%rdx)
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  40c997:	48 8b 93 d8 00 00 00 	mov    0xd8(%rbx),%rdx
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40c99e:	4c 8d 60 08          	lea    0x8(%rax),%r12
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  40c9a2:	48 89 10             	mov    %rdx,(%rax)
    allocator->old_list = new_data;
  40c9a5:	48 89 83 d8 00 00 00 	mov    %rax,0xd8(%rbx)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40c9ac:	48 05 80 fe 00 00    	add    $0xfe80,%rax
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40c9b2:	4c 89 a3 f0 00 00 00 	mov    %r12,0xf0(%rbx)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40c9b9:	48 89 83 e0 00 00 00 	mov    %rax,0xe0(%rbx)
  40c9c0:	e9 b4 f9 ff ff       	jmpq   40c379 <resume_solution+0x1ef9>
            BUMP_NUM_CHECKED_STATES();
  40c9c5:	48 8b 85 28 ff ff ff 	mov    -0xd8(%rbp),%rax
  40c9cc:	48 83 c1 01          	add    $0x1,%rcx
  40c9d0:	31 db                	xor    %ebx,%ebx
  40c9d2:	48 89 08             	mov    %rcx,(%rax)
  40c9d5:	e9 6c df ff ff       	jmpq   40a946 <resume_solution+0x4c6>
    char *const new_data = meta_request_new_buffer(allocator->meta);
  40c9da:	48 8b 93 f8 00 00 00 	mov    0xf8(%rbx),%rdx
    char *const ret = meta_alloc->recycle_bin;
  40c9e1:	48 8b 02             	mov    (%rdx),%rax
    if (ret)
  40c9e4:	48 85 c0             	test   %rax,%rax
  40c9e7:	0f 84 42 03 00 00    	je     40cd2f <resume_solution+0x28af>
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  40c9ed:	48 8b 08             	mov    (%rax),%rcx
  40c9f0:	48 89 0a             	mov    %rcx,(%rdx)
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  40c9f3:	48 8b 93 d8 00 00 00 	mov    0xd8(%rbx),%rdx
  40c9fa:	48 89 10             	mov    %rdx,(%rax)
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40c9fd:	48 8d 50 08          	lea    0x8(%rax),%rdx
    allocator->old_list = new_data;
  40ca01:	48 89 83 d8 00 00 00 	mov    %rax,0xd8(%rbx)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40ca08:	48 05 80 fe 00 00    	add    $0xfe80,%rax
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40ca0e:	48 89 93 f0 00 00 00 	mov    %rdx,0xf0(%rbx)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40ca15:	48 89 83 e0 00 00 00 	mov    %rax,0xe0(%rbx)
  40ca1c:	e9 7f f9 ff ff       	jmpq   40c3a0 <resume_solution+0x1f20>
  40ca21:	48 8b 80 40 05 00 00 	mov    0x540(%rax),%rax
            ret = FCS_STATE_IS_NOT_SOLVEABLE;
  40ca28:	48 83 f8 01          	cmp    $0x1,%rax
  40ca2c:	b8 01 00 00 00       	mov    $0x1,%eax
  40ca31:	0f 44 d8             	cmove  %eax,%ebx
            ret = user->ret_code = flare->ret_code = resume_instance(instance);
  40ca34:	48 8b 85 f0 fe ff ff 	mov    -0x110(%rbp),%rax
  40ca3b:	89 98 b8 05 00 00    	mov    %ebx,0x5b8(%rax)
  40ca41:	89 98 38 06 00 00    	mov    %ebx,0x638(%rax)
            flare->instance_is_ready = FALSE;
  40ca47:	c6 80 bc 05 00 00 00 	movb   $0x0,0x5bc(%rax)
  40ca4e:	89 d8                	mov    %ebx,%eax
  40ca50:	e9 da da ff ff       	jmpq   40a52f <resume_solution+0xaf>
        for (size_t group_idx = 0;
  40ca55:	31 d2                	xor    %edx,%edx
  40ca57:	e9 0c fa ff ff       	jmpq   40c468 <resume_solution+0x1fe8>
    memset(&(state->s), 0, sizeof(state->s));
  40ca5c:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
            if (!fc_solve_initial_user_state_to_c(user->state_string_copy,
  40ca60:	48 8d 90 48 0a 00 00 	lea    0xa48(%rax),%rdx
  40ca67:	48 89 c3             	mov    %rax,%rbx
  40ca6a:	c5 f8 11 83 d8 05 00 	vmovups %xmm0,0x5d8(%rbx)
  40ca71:	00 
  40ca72:	48 8d 80 d8 05 00 00 	lea    0x5d8(%rax),%rax
  40ca79:	c5 f8 11 83 e8 05 00 	vmovups %xmm0,0x5e8(%rbx)
  40ca80:	00 
  40ca81:	48 8d 8b 48 06 00 00 	lea    0x648(%rbx),%rcx
  40ca88:	c5 f8 11 83 f8 05 00 	vmovups %xmm0,0x5f8(%rbx)
  40ca8f:	00 
  40ca90:	c5 f8 11 83 08 06 00 	vmovups %xmm0,0x608(%rbx)
  40ca97:	00 
  40ca98:	48 c7 83 18 06 00 00 	movq   $0x0,0x618(%rbx)
  40ca9f:	00 00 00 00 
        memset(state->s.columns[i] = &indirect_stacks_buffer[i << 7], '\0',
  40caa3:	48 89 08             	mov    %rcx,(%rax)
  40caa6:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
  40caaa:	48 83 e9 80          	sub    $0xffffffffffffff80,%rcx
  40caae:	48 83 c0 08          	add    $0x8,%rax
  40cab2:	c5 f8 11 41 80       	vmovups %xmm0,-0x80(%rcx)
  40cab7:	c5 f8 11 41 90       	vmovups %xmm0,-0x70(%rcx)
  40cabc:	c5 f8 11 41 a0       	vmovups %xmm0,-0x60(%rcx)
  40cac1:	c7 41 b0 00 00 00 00 	movl   $0x0,-0x50(%rcx)
  40cac8:	c6 41 b4 00          	movb   $0x0,-0x4c(%rcx)
    for (i = 0; i < STACKS_NUM__VAL; ++i)
  40cacc:	48 39 ca             	cmp    %rcx,%rdx
  40cacf:	75 d2                	jne    40caa3 <resume_solution+0x2623>
    state->info.parent = NULL;
  40cad1:	4c 8b 95 f0 fe ff ff 	mov    -0x110(%rbp),%r10
    state->info.num_active_children = 0;
  40cad8:	31 f6                	xor    %esi,%esi
    state->info.stacks_copy_on_write_flags = 0;
  40cada:	45 31 c0             	xor    %r8d,%r8d
  40cadd:	41 b9 0d f0 40 00    	mov    $0x40f00d,%r9d
    state->info.parent = NULL;
  40cae3:	49 c7 82 20 06 00 00 	movq   $0x0,0x620(%r10)
  40caea:	00 00 00 00 
    state->info.depth = 0;
  40caee:	41 c7 82 28 06 00 00 	movl   $0x0,0x628(%r10)
  40caf5:	00 00 00 00 
    state->info.visited = 0;
  40caf9:	41 c6 82 2e 06 00 00 	movb   $0x0,0x62e(%r10)
  40cb00:	00 
    state->info.num_active_children = 0;
  40cb01:	66 41 89 b2 2c 06 00 	mov    %si,0x62c(%r10)
  40cb08:	00 
    memset(state->info.scan_visited, '\0', sizeof(state->info.scan_visited));
  40cb09:	41 c7 82 2f 06 00 00 	movl   $0x0,0x62f(%r10)
  40cb10:	00 00 00 00 
    state->info.stacks_copy_on_write_flags = 0;
  40cb14:	41 c7 82 34 06 00 00 	movl   $0x0,0x634(%r10)
  40cb1b:	00 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);
  40cb1f:	b9 0a 00 00 00       	mov    $0xa,%ecx
  40cb24:	48 89 d6             	mov    %rdx,%rsi
  40cb27:	4c 89 cf             	mov    %r9,%rdi
  40cb2a:	f3 a6                	repz cmpsb %es:(%rdi),%ds:(%rsi)
  40cb2c:	0f 85 2e 01 00 00    	jne    40cc60 <resume_solution+0x27e0>
        if (new_str)
  40cb32:	48 89 d0             	mov    %rdx,%rax
  40cb35:	48 83 c0 0a          	add    $0xa,%rax
  40cb39:	0f 84 21 01 00 00    	je     40cc60 <resume_solution+0x27e0>
                fcs_empty_freecell(out, c);
  40cb3f:	41 c7 82 18 06 00 00 	movl   $0x0,0x618(%r10)
  40cb46:	00 00 00 00 
            for (size_t c = 0; c < FREECELLS_NUM__VAL; ++c)
  40cb4a:	31 f6                	xor    %esi,%esi
                while ((*str == ' ') || (*str == '\t'))
  40cb4c:	0f b6 10             	movzbl (%rax),%edx
  40cb4f:	80 fa 09             	cmp    $0x9,%dl
  40cb52:	74 05                	je     40cb59 <resume_solution+0x26d9>
  40cb54:	80 fa 20             	cmp    $0x20,%dl
  40cb57:	75 11                	jne    40cb6a <resume_solution+0x26ea>
                    ++str;
  40cb59:	48 83 c0 01          	add    $0x1,%rax
                while ((*str == ' ') || (*str == '\t'))
  40cb5d:	0f b6 10             	movzbl (%rax),%edx
  40cb60:	80 fa 20             	cmp    $0x20,%dl
  40cb63:	74 f4                	je     40cb59 <resume_solution+0x26d9>
  40cb65:	80 fa 09             	cmp    $0x9,%dl
  40cb68:	74 ef                	je     40cb59 <resume_solution+0x26d9>
                if ((*str == '\r') || (*str == '\n'))
  40cb6a:	80 fa 0d             	cmp    $0xd,%dl
  40cb6d:	0f 84 ac 00 00 00    	je     40cc1f <resume_solution+0x279f>
  40cb73:	80 fa 0a             	cmp    $0xa,%dl
  40cb76:	0f 84 a3 00 00 00    	je     40cc1f <resume_solution+0x279f>
                fcs_put_card_in_freecell(out, c,
  40cb7c:	80 fa 2a             	cmp    $0x2a,%dl
  40cb7f:	0f 84 c5 01 00 00    	je     40cd4a <resume_solution+0x28ca>
  40cb85:	80 fa 2d             	cmp    $0x2d,%dl
  40cb88:	0f 84 bc 01 00 00    	je     40cd4a <resume_solution+0x28ca>
  40cb8e:	48 89 c1             	mov    %rax,%rcx
        switch (FC_SOLVE_MAP_CHAR(*string))
  40cb91:	0f b6 11             	movzbl (%rcx),%edx
  40cb94:	80 fa 35             	cmp    $0x35,%dl
  40cb97:	0f 84 7d 0d 00 00    	je     40d91a <resume_solution+0x349a>
  40cb9d:	0f 8e 8b 0d 00 00    	jle    40d92e <resume_solution+0x34ae>
  40cba3:	80 fa 41             	cmp    $0x41,%dl
  40cba6:	0f 84 78 0d 00 00    	je     40d924 <resume_solution+0x34a4>
  40cbac:	0f 8f c4 0d 00 00    	jg     40d976 <resume_solution+0x34f6>
  40cbb2:	80 fa 37             	cmp    $0x37,%dl
  40cbb5:	0f 84 b1 0d 00 00    	je     40d96c <resume_solution+0x34ec>
  40cbbb:	0f 8c a1 0d 00 00    	jl     40d962 <resume_solution+0x34e2>
  40cbc1:	80 fa 38             	cmp    $0x38,%dl
  40cbc4:	0f 84 8e 0d 00 00    	je     40d958 <resume_solution+0x34d8>
  40cbca:	80 fa 39             	cmp    $0x39,%dl
  40cbcd:	0f 85 db 0d 00 00    	jne    40d9ae <resume_solution+0x352e>
            return 9;
  40cbd3:	ba 09 00 00 00       	mov    $0x9,%edx
                fcs_put_card_in_freecell(out, c,
  40cbd8:	48 89 c7             	mov    %rax,%rdi
        switch (FC_SOLVE_MAP_CHAR(*suit))
  40cbdb:	0f b6 0f             	movzbl (%rdi),%ecx
  40cbde:	80 f9 43             	cmp    $0x43,%cl
  40cbe1:	0f 84 8a 0f 00 00    	je     40db71 <resume_solution+0x36f1>
  40cbe7:	0f 8e 70 0f 00 00    	jle    40db5d <resume_solution+0x36dd>
  40cbed:	80 f9 48             	cmp    $0x48,%cl
  40cbf0:	0f 84 74 0f 00 00    	je     40db6a <resume_solution+0x36ea>
  40cbf6:	80 f9 53             	cmp    $0x53,%cl
  40cbf9:	0f 84 f6 01 00 00    	je     40cdf5 <resume_solution+0x2975>
  40cbff:	80 f9 44             	cmp    $0x44,%cl
  40cc02:	0f 84 de 01 00 00    	je     40cde6 <resume_solution+0x2966>
            ++suit;
  40cc08:	48 83 c7 01          	add    $0x1,%rdi
  40cc0c:	eb cd                	jmp    40cbdb <resume_solution+0x275b>
  40cc0e:	66 90                	xchg   %ax,%ax
                HANDLE_EOS();
  40cc10:	84 d2                	test   %dl,%dl
  40cc12:	0f 84 b0 01 00 00    	je     40cdc8 <resume_solution+0x2948>
                ++str;
  40cc18:	48 83 c0 01          	add    $0x1,%rax
            while (*str != '\n')
  40cc1c:	0f b6 10             	movzbl (%rax),%edx
  40cc1f:	80 fa 0a             	cmp    $0xa,%dl
  40cc22:	75 ec                	jne    40cc10 <resume_solution+0x2790>
            s--;
  40cc24:	49 83 e8 01          	sub    $0x1,%r8
    for (size_t s = 0; s < STACKS_NUM__VAL; s++)
  40cc28:	49 83 c0 01          	add    $0x1,%r8
  40cc2c:	49 83 f8 07          	cmp    $0x7,%r8
  40cc30:	0f 87 c6 01 00 00    	ja     40cdfc <resume_solution+0x297c>
            while ((*str) != '\n')
  40cc36:	0f b6 10             	movzbl (%rax),%edx
  40cc39:	80 fa 0a             	cmp    $0xa,%dl
  40cc3c:	74 14                	je     40cc52 <resume_solution+0x27d2>
                HANDLE_EOS();
  40cc3e:	84 d2                	test   %dl,%dl
  40cc40:	0f 84 82 01 00 00    	je     40cdc8 <resume_solution+0x2948>
                ++str;
  40cc46:	48 83 c0 01          	add    $0x1,%rax
            while ((*str) != '\n')
  40cc4a:	0f b6 10             	movzbl (%rax),%edx
  40cc4d:	80 fa 0a             	cmp    $0xa,%dl
  40cc50:	75 ec                	jne    40cc3e <resume_solution+0x27be>
            ++str;
  40cc52:	48 8d 50 01          	lea    0x1(%rax),%rdx
  40cc56:	e9 c4 fe ff ff       	jmpq   40cb1f <resume_solution+0x269f>
  40cc5b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
  40cc60:	bf 18 f0 40 00       	mov    $0x40f018,%edi
  40cc65:	b9 0c 00 00 00       	mov    $0xc,%ecx
  40cc6a:	48 89 d6             	mov    %rdx,%rsi
  40cc6d:	f3 a6                	repz cmpsb %es:(%rdi),%ds:(%rsi)
  40cc6f:	0f 85 78 08 00 00    	jne    40d4ed <resume_solution+0x306d>
        if (new_str2)
  40cc75:	48 89 d0             	mov    %rdx,%rax
  40cc78:	48 83 c0 0c          	add    $0xc,%rax
  40cc7c:	0f 84 6b 08 00 00    	je     40d4ed <resume_solution+0x306d>
            size_t decks_index[4] = {0, 0, 0, 0};
  40cc82:	c5 f9 ef c0          	vpxor  %xmm0,%xmm0,%xmm0
                    decks_index[f_idx] = 0;
  40cc86:	45 31 db             	xor    %r11d,%r11d
            size_t decks_index[4] = {0, 0, 0, 0};
  40cc89:	c5 fd 7f 85 50 ff ff 	vmovdqa %ymm0,-0xb0(%rbp)
  40cc90:	ff 
                fcs_set_foundation(out, f_idx, 0);
  40cc91:	41 c7 82 1c 06 00 00 	movl   $0x0,0x61c(%r10)
  40cc98:	00 00 00 00 
                while ((*str == ' ') || (*str == '\t'))
  40cc9c:	0f b6 10             	movzbl (%rax),%edx
  40cc9f:	80 fa 20             	cmp    $0x20,%dl
  40cca2:	0f 84 96 00 00 00    	je     40cd3e <resume_solution+0x28be>
  40cca8:	80 fa 09             	cmp    $0x9,%dl
  40ccab:	0f 84 8d 00 00 00    	je     40cd3e <resume_solution+0x28be>
                if ((*str == '\n') || (*str == '\r'))
  40ccb1:	80 fa 0a             	cmp    $0xa,%dl
  40ccb4:	0f 84 6a ff ff ff    	je     40cc24 <resume_solution+0x27a4>
  40ccba:	80 fa 0d             	cmp    $0xd,%dl
  40ccbd:	0f 84 61 ff ff ff    	je     40cc24 <resume_solution+0x27a4>
  40ccc3:	48 89 c1             	mov    %rax,%rcx
        switch (FC_SOLVE_MAP_CHAR(*suit))
  40ccc6:	0f b6 11             	movzbl (%rcx),%edx
  40ccc9:	80 fa 43             	cmp    $0x43,%dl
  40cccc:	0f 84 b2 08 00 00    	je     40d584 <resume_solution+0x3104>
  40ccd2:	0f 8e 99 08 00 00    	jle    40d571 <resume_solution+0x30f1>
  40ccd8:	80 fa 48             	cmp    $0x48,%dl
  40ccdb:	0f 84 9d 08 00 00    	je     40d57e <resume_solution+0x30fe>
  40cce1:	80 fa 53             	cmp    $0x53,%dl
  40cce4:	0f 84 22 0a 00 00    	je     40d70c <resume_solution+0x328c>
  40ccea:	80 fa 44             	cmp    $0x44,%dl
  40cced:	0f 84 28 0a 00 00    	je     40d71b <resume_solution+0x329b>
            ++suit;
  40ccf3:	48 83 c1 01          	add    $0x1,%rcx
  40ccf7:	eb cd                	jmp    40ccc6 <resume_solution+0x2846>
  40ccf9:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
  40cd00:	48 8b bd f0 fe ff ff 	mov    -0x110(%rbp),%rdi
  40cd07:	48 8b 37             	mov    (%rdi),%rsi
  40cd0a:	e9 19 fd ff ff       	jmpq   40ca28 <resume_solution+0x25a8>
        return malloc(ALLOCED_SIZE);
  40cd0f:	bf 80 fe 00 00       	mov    $0xfe80,%edi
  40cd14:	e8 d7 43 ff ff       	callq  4010f0 <malloc@plt>
  40cd19:	e9 79 fc ff ff       	jmpq   40c997 <resume_solution+0x2517>
  40cd1e:	48 8b 80 40 05 00 00 	mov    0x540(%rax),%rax
                return FCS_STATE_IS_NOT_SOLVEABLE;
  40cd25:	bb 01 00 00 00       	mov    $0x1,%ebx
  40cd2a:	e9 f9 fc ff ff       	jmpq   40ca28 <resume_solution+0x25a8>
  40cd2f:	bf 80 fe 00 00       	mov    $0xfe80,%edi
  40cd34:	e8 b7 43 ff ff       	callq  4010f0 <malloc@plt>
  40cd39:	e9 b5 fc ff ff       	jmpq   40c9f3 <resume_solution+0x2573>
                    ++str;
  40cd3e:	48 8d 50 01          	lea    0x1(%rax),%rdx
            return 3;
  40cd42:	48 89 d0             	mov    %rdx,%rax
  40cd45:	e9 52 ff ff ff       	jmpq   40cc9c <resume_solution+0x281c>
                fcs_put_card_in_freecell(out, c,
  40cd4a:	31 d2                	xor    %edx,%edx
  40cd4c:	41 88 94 32 18 06 00 	mov    %dl,0x618(%r10,%rsi,1)
  40cd53:	00 
            for (size_t c = 0; c < FREECELLS_NUM__VAL; ++c)
  40cd54:	48 83 c6 01          	add    $0x1,%rsi
  40cd58:	48 83 fe 04          	cmp    $0x4,%rsi
  40cd5c:	75 31                	jne    40cd8f <resume_solution+0x290f>
  40cd5e:	e9 b9 fe ff ff       	jmpq   40cc1c <resume_solution+0x279c>
  40cd63:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40cd6a:	00 00 00 00 
  40cd6e:	66 90                	xchg   %ax,%ax
                    while (((*str) != ' ') && ((*str) != '\t') &&
  40cd70:	80 fa 09             	cmp    $0x9,%dl
  40cd73:	74 22                	je     40cd97 <resume_solution+0x2917>
                           ((*str) != '\n') && ((*str) != '\r'))
  40cd75:	80 fa 0d             	cmp    $0xd,%dl
  40cd78:	0f 84 a1 fe ff ff    	je     40cc1f <resume_solution+0x279f>
  40cd7e:	80 fa 0a             	cmp    $0xa,%dl
  40cd81:	0f 84 98 fe ff ff    	je     40cc1f <resume_solution+0x279f>
                        HANDLE_EOS();
  40cd87:	84 d2                	test   %dl,%dl
  40cd89:	74 3d                	je     40cdc8 <resume_solution+0x2948>
                        ++str;
  40cd8b:	48 83 c0 01          	add    $0x1,%rax
                    while (((*str) != ' ') && ((*str) != '\t') &&
  40cd8f:	0f b6 10             	movzbl (%rax),%edx
  40cd92:	80 fa 20             	cmp    $0x20,%dl
  40cd95:	75 d9                	jne    40cd70 <resume_solution+0x28f0>
                    if ((*str == '\n') || (*str == '\r'))
  40cd97:	80 fa 0a             	cmp    $0xa,%dl
  40cd9a:	0f 84 7c fe ff ff    	je     40cc1c <resume_solution+0x279c>
  40cda0:	80 fa 0d             	cmp    $0xd,%dl
  40cda3:	0f 84 73 fe ff ff    	je     40cc1c <resume_solution+0x279c>
                    ++str;
  40cda9:	48 83 c0 01          	add    $0x1,%rax
  40cdad:	e9 9a fd ff ff       	jmpq   40cb4c <resume_solution+0x26cc>
        switch (FC_SOLVE_MAP_CHAR(*string))
  40cdb2:	84 d2                	test   %dl,%dl
  40cdb4:	74 12                	je     40cdc8 <resume_solution+0x2948>
  40cdb6:	0f 88 f2 0b 00 00    	js     40d9ae <resume_solution+0x352e>
  40cdbc:	83 ea 09             	sub    $0x9,%edx
  40cdbf:	80 fa 01             	cmp    $0x1,%dl
  40cdc2:	0f 87 e6 0b 00 00    	ja     40d9ae <resume_solution+0x352e>
                return (user->ret_code = FCS_STATE_INVALID_STATE);
  40cdc8:	48 8b 85 f0 fe ff ff 	mov    -0x110(%rbp),%rax
  40cdcf:	bb 08 00 00 00       	mov    $0x8,%ebx
  40cdd4:	c7 80 38 06 00 00 08 	movl   $0x8,0x638(%rax)
  40cddb:	00 00 00 
  40cdde:	c5 f8 77             	vzeroupper 
  40cde1:	e9 9e d7 ff ff       	jmpq   40a584 <resume_solution+0x104>
            return 2;
  40cde6:	b9 02 00 00 00       	mov    $0x2,%ecx
    return (fcs_card)((((fcs_card)rank) << 2) | ((fcs_card)suit));
  40cdeb:	c1 e2 02             	shl    $0x2,%edx
  40cdee:	09 ca                	or     %ecx,%edx
  40cdf0:	e9 57 ff ff ff       	jmpq   40cd4c <resume_solution+0x28cc>
            return 3;
  40cdf5:	b9 03 00 00 00       	mov    $0x3,%ecx
  40cdfa:	eb ef                	jmp    40cdeb <resume_solution+0x296b>
  40cdfc:	48 8b 85 f0 fe ff ff 	mov    -0x110(%rbp),%rax
  40ce03:	bb 01 00 00 00       	mov    $0x1,%ebx
  40ce08:	4c 8d 60 08          	lea    0x8(%rax),%r12
            return 8;
  40ce0c:	4d 89 e1             	mov    %r12,%r9
  40ce0f:	49 89 dd             	mov    %rbx,%r13
        while ((c > 0) && ((STACK_COMPARE(GET_STACK(c), GET_STACK(c - 1))) < 0))
  40ce12:	49 8b b1 d0 05 00 00 	mov    0x5d0(%r9),%rsi
  40ce19:	49 83 ed 01          	sub    $0x1,%r13
  40ce1d:	49 8b b9 d8 05 00 00 	mov    0x5d8(%r9),%rdi
        const int min_len = min(s1[0], s2[0]);
  40ce24:	44 0f be 1e          	movsbl (%rsi),%r11d
  40ce28:	44 0f b6 17          	movzbl (%rdi),%r10d
  40ce2c:	45 38 d3             	cmp    %r10b,%r11b
  40ce2f:	41 0f be c2          	movsbl %r10b,%eax
  40ce33:	41 0f 4e c3          	cmovle %r11d,%eax
        for (int a = 1; a <= min_len; a++)
  40ce37:	84 c0                	test   %al,%al
  40ce39:	7e 3e                	jle    40ce79 <resume_solution+0x29f9>
            const int ret = fc_solve_card_compare(s1[a], s2[a]);
  40ce3b:	0f be 57 01          	movsbl 0x1(%rdi),%edx
  40ce3f:	0f be 4e 01          	movsbl 0x1(%rsi),%ecx
            if (ret != 0)
  40ce43:	29 ca                	sub    %ecx,%edx
  40ce45:	0f 85 fd 04 00 00    	jne    40d348 <resume_solution+0x2ec8>
  40ce4b:	44 8d 40 ff          	lea    -0x1(%rax),%r8d
  40ce4f:	b8 02 00 00 00       	mov    $0x2,%eax
  40ce54:	49 83 c0 02          	add    $0x2,%r8
  40ce58:	eb 1a                	jmp    40ce74 <resume_solution+0x29f4>
  40ce5a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
            const int ret = fc_solve_card_compare(s1[a], s2[a]);
  40ce60:	0f be 14 07          	movsbl (%rdi,%rax,1),%edx
  40ce64:	0f be 0c 06          	movsbl (%rsi,%rax,1),%ecx
  40ce68:	48 83 c0 01          	add    $0x1,%rax
            if (ret != 0)
  40ce6c:	29 ca                	sub    %ecx,%edx
  40ce6e:	0f 85 d4 04 00 00    	jne    40d348 <resume_solution+0x2ec8>
        for (int a = 1; a <= min_len; a++)
  40ce74:	49 39 c0             	cmp    %rax,%r8
  40ce77:	75 e7                	jne    40ce60 <resume_solution+0x29e0>
    if (s1[0] < s2[0])
  40ce79:	45 38 d3             	cmp    %r10b,%r11b
  40ce7c:	7e 1b                	jle    40ce99 <resume_solution+0x2a19>
                COPY_STACK(GET_STACK(c), GET_STACK(c - 1));
  40ce7e:	49 89 b1 d8 05 00 00 	mov    %rsi,0x5d8(%r9)
  40ce85:	49 83 e9 08          	sub    $0x8,%r9
                COPY_STACK(GET_STACK(c - 1), temp_stack);
  40ce89:	49 89 b9 d8 05 00 00 	mov    %rdi,0x5d8(%r9)
        while ((c > 0) && ((STACK_COMPARE(GET_STACK(c), GET_STACK(c - 1))) < 0))
  40ce90:	4d 85 ed             	test   %r13,%r13
  40ce93:	0f 85 79 ff ff ff    	jne    40ce12 <resume_solution+0x2992>
    for (size_t b = 1; b < STACKS_NUM__VAL; b++)
  40ce99:	48 83 c3 01          	add    $0x1,%rbx
  40ce9d:	49 83 c4 08          	add    $0x8,%r12
  40cea1:	48 83 fb 08          	cmp    $0x8,%rbx
  40cea5:	0f 85 61 ff ff ff    	jne    40ce0c <resume_solution+0x298c>
                               GET_FREECELL(c), GET_FREECELL(c - 1))) < 0))
  40ceab:	48 8b 9d f0 fe ff ff 	mov    -0x110(%rbp),%rbx
  40ceb2:	0f be b3 18 06 00 00 	movsbl 0x618(%rbx),%esi
  40ceb9:	44 0f be 83 19 06 00 	movsbl 0x619(%rbx),%r8d
  40cec0:	00 
  40cec1:	89 f0                	mov    %esi,%eax
  40cec3:	44 89 c1             	mov    %r8d,%ecx
        while ((c > 0) && ((fc_solve_card_compare(
  40cec6:	41 39 f0             	cmp    %esi,%r8d
  40cec9:	79 1a                	jns    40cee5 <resume_solution+0x2a65>
            GET_FREECELL(c - 1) = temp_freecell;
  40cecb:	44 89 c2             	mov    %r8d,%edx
            GET_FREECELL(c) = GET_FREECELL(c - 1);
  40cece:	40 88 b3 19 06 00 00 	mov    %sil,0x619(%rbx)
            GET_FREECELL(c - 1) = temp_freecell;
  40ced5:	44 88 83 18 06 00 00 	mov    %r8b,0x618(%rbx)
  40cedc:	41 89 f0             	mov    %esi,%r8d
  40cedf:	89 ce                	mov    %ecx,%esi
  40cee1:	89 c1                	mov    %eax,%ecx
  40cee3:	89 d0                	mov    %edx,%eax
                               GET_FREECELL(c), GET_FREECELL(c - 1))) < 0))
  40cee5:	0f be bb 1a 06 00 00 	movsbl 0x61a(%rbx),%edi
  40ceec:	89 fa                	mov    %edi,%edx
        while ((c > 0) && ((fc_solve_card_compare(
  40ceee:	44 39 c7             	cmp    %r8d,%edi
  40cef1:	0f 89 a0 04 00 00    	jns    40d397 <resume_solution+0x2f17>
            GET_FREECELL(c) = GET_FREECELL(c - 1);
  40cef7:	88 8b 1a 06 00 00    	mov    %cl,0x61a(%rbx)
        while ((c > 0) && ((fc_solve_card_compare(
  40cefd:	39 f7                	cmp    %esi,%edi
  40ceff:	0f 89 a8 04 00 00    	jns    40d3ad <resume_solution+0x2f2d>
            GET_FREECELL(c - 1) = temp_freecell;
  40cf05:	41 89 f9             	mov    %edi,%r9d
            GET_FREECELL(c) = GET_FREECELL(c - 1);
  40cf08:	88 83 19 06 00 00    	mov    %al,0x619(%rbx)
            GET_FREECELL(c - 1) = temp_freecell;
  40cf0e:	40 88 bb 18 06 00 00 	mov    %dil,0x618(%rbx)
  40cf15:	89 f7                	mov    %esi,%edi
  40cf17:	89 d6                	mov    %edx,%esi
  40cf19:	89 c2                	mov    %eax,%edx
  40cf1b:	44 89 c8             	mov    %r9d,%eax
                               GET_FREECELL(c), GET_FREECELL(c - 1))) < 0))
  40cf1e:	44 0f be 93 1b 06 00 	movsbl 0x61b(%rbx),%r10d
  40cf25:	00 
        while ((c > 0) && ((fc_solve_card_compare(
  40cf26:	45 39 c2             	cmp    %r8d,%r10d
  40cf29:	79 2b                	jns    40cf56 <resume_solution+0x2ad6>
            GET_FREECELL(c) = GET_FREECELL(c - 1);
  40cf2b:	88 8b 1b 06 00 00    	mov    %cl,0x61b(%rbx)
        while ((c > 0) && ((fc_solve_card_compare(
  40cf31:	41 39 fa             	cmp    %edi,%r10d
  40cf34:	0f 89 4e 04 00 00    	jns    40d388 <resume_solution+0x2f08>
            GET_FREECELL(c) = GET_FREECELL(c - 1);
  40cf3a:	88 93 1a 06 00 00    	mov    %dl,0x61a(%rbx)
        while ((c > 0) && ((fc_solve_card_compare(
  40cf40:	41 39 f2             	cmp    %esi,%r10d
  40cf43:	0f 89 30 04 00 00    	jns    40d379 <resume_solution+0x2ef9>
            GET_FREECELL(c) = GET_FREECELL(c - 1);
  40cf49:	88 83 19 06 00 00    	mov    %al,0x619(%rbx)
            GET_FREECELL(c - 1) = temp_freecell;
  40cf4f:	44 88 93 18 06 00 00 	mov    %r10b,0x618(%rbx)
        ST_LOOP_START() { soft_thread->hard_thread = instance; }
  40cf56:	48 8b 85 f0 fe ff ff 	mov    -0x110(%rbp),%rax
  40cf5d:	48 8b 88 20 05 00 00 	mov    0x520(%rax),%rcx
  40cf64:	4c 8b 88 c0 00 00 00 	mov    0xc0(%rax),%r9
  40cf6b:	48 89 c8             	mov    %rcx,%rax
  40cf6e:	48 c1 e0 06          	shl    $0x6,%rax
  40cf72:	48 29 c8             	sub    %rcx,%rax
  40cf75:	48 c1 e0 03          	shl    $0x3,%rax
  40cf79:	49 8d 34 01          	lea    (%r9,%rax,1),%rsi
  40cf7d:	49 39 f1             	cmp    %rsi,%r9
  40cf80:	73 19                	jae    40cf9b <resume_solution+0x2b1b>
  40cf82:	48 8b 9d f0 fe ff ff 	mov    -0x110(%rbp),%rbx
  40cf89:	4c 89 ca             	mov    %r9,%rdx
  40cf8c:	48 89 1a             	mov    %rbx,(%rdx)
  40cf8f:	48 81 c2 f8 01 00 00 	add    $0x1f8,%rdx
  40cf96:	48 39 d6             	cmp    %rdx,%rsi
  40cf99:	77 f1                	ja     40cf8c <resume_solution+0x2b0c>
    (*st_idx_ptr) = scan_idx;
  40cf9b:	48 8b 9d f0 fe ff ff 	mov    -0x110(%rbp),%rbx
        set_next_soft_thread(hard_thread, 0,
  40cfa2:	49 8b 91 e8 01 00 00 	mov    0x1e8(%r9),%rdx
    (*st_idx_ptr) = scan_idx;
  40cfa9:	48 c7 83 d0 00 00 00 	movq   $0x0,0xd0(%rbx)
  40cfb0:	00 00 00 00 
        NUM_CHECKED_STATES + quota;
  40cfb4:	4c 8b 1b             	mov    (%rbx),%r11
  40cfb7:	4c 01 da             	add    %r11,%rdx
  40cfba:	48 89 93 c8 00 00 00 	mov    %rdx,0xc8(%rbx)
        if (st_idx < num_soft_threads)
  40cfc1:	48 85 c9             	test   %rcx,%rcx
  40cfc4:	0f 8e df 00 00 00    	jle    40d0a9 <resume_solution+0x2c29>
  40cfca:	49 83 c1 18          	add    $0x18,%r9
    size_t total_move_funcs_bitmask = 0;
  40cfce:	31 ff                	xor    %edi,%edi
            *moves_order |= (1 << (test_ptr->idx));
  40cfd0:	41 b8 01 00 00 00    	mov    $0x1,%r8d
  40cfd6:	4d 8d 24 01          	lea    (%r9,%rax,1),%r12
        if (st_idx < num_soft_threads)
  40cfda:	4d 89 ca             	mov    %r9,%r10
            &(soft_thread->by_depth_moves_order.by_depth_moves[0].moves_order));
  40cfdd:	49 8b 02             	mov    (%r10),%rax
    const fcs_moves_group *const groups_end = group_ptr + st_tests_order->num;
  40cfe0:	4c 69 68 08 e8 00 00 	imul   $0xe8,0x8(%rax),%r13
  40cfe7:	00 
    const fcs_moves_group *group_ptr = st_tests_order->groups;
  40cfe8:	48 8b 58 10          	mov    0x10(%rax),%rbx
    const fcs_moves_group *const groups_end = group_ptr + st_tests_order->num;
  40cfec:	49 01 dd             	add    %rbx,%r13
    for (; group_ptr < groups_end; ++group_ptr)
  40cfef:	4c 39 eb             	cmp    %r13,%rbx
  40cff2:	73 3f                	jae    40d033 <resume_solution+0x2bb3>
        const fcs_move_func *test_ptr = group_ptr->move_funcs;
  40cff4:	48 8b 03             	mov    (%rbx),%rax
        const fcs_move_func *const tests_end = test_ptr + group_ptr->num;
  40cff7:	48 8b 53 08          	mov    0x8(%rbx),%rdx
  40cffb:	48 8d 34 d0          	lea    (%rax,%rdx,8),%rsi
        for (; test_ptr < tests_end; ++test_ptr)
  40cfff:	48 39 f0             	cmp    %rsi,%rax
  40d002:	73 23                	jae    40d027 <resume_solution+0x2ba7>
  40d004:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40d00b:	00 00 00 00 
  40d00f:	90                   	nop
            *moves_order |= (1 << (test_ptr->idx));
  40d010:	48 8b 08             	mov    (%rax),%rcx
  40d013:	44 89 c2             	mov    %r8d,%edx
        for (; test_ptr < tests_end; ++test_ptr)
  40d016:	48 83 c0 08          	add    $0x8,%rax
            *moves_order |= (1 << (test_ptr->idx));
  40d01a:	d3 e2                	shl    %cl,%edx
  40d01c:	48 63 d2             	movslq %edx,%rdx
  40d01f:	48 09 d7             	or     %rdx,%rdi
        for (; test_ptr < tests_end; ++test_ptr)
  40d022:	48 39 c6             	cmp    %rax,%rsi
  40d025:	77 e9                	ja     40d010 <resume_solution+0x2b90>
    for (; group_ptr < groups_end; ++group_ptr)
  40d027:	48 81 c3 e8 00 00 00 	add    $0xe8,%rbx
  40d02e:	49 39 dd             	cmp    %rbx,%r13
  40d031:	77 c1                	ja     40cff4 <resume_solution+0x2b74>
  40d033:	49 81 c2 f8 01 00 00 	add    $0x1f8,%r10
        if (st_idx < num_soft_threads)
  40d03a:	4d 39 d4             	cmp    %r10,%r12
  40d03d:	75 9e                	jne    40cfdd <resume_solution+0x2b5d>
            *moves_order |= (1 << (test_ptr->idx));
  40d03f:	bb 01 00 00 00       	mov    $0x1,%ebx
            &(soft_thread->by_depth_moves_order.by_depth_moves[0].moves_order));
  40d044:	49 8b 01             	mov    (%r9),%rax
        size_t moves_order = 0;
  40d047:	31 f6                	xor    %esi,%esi
    const fcs_moves_group *const groups_end = group_ptr + st_tests_order->num;
  40d049:	4c 69 68 08 e8 00 00 	imul   $0xe8,0x8(%rax),%r13
  40d050:	00 
    const fcs_moves_group *group_ptr = st_tests_order->groups;
  40d051:	4c 8b 60 10          	mov    0x10(%rax),%r12
    const fcs_moves_group *const groups_end = group_ptr + st_tests_order->num;
  40d055:	4d 01 e5             	add    %r12,%r13
    for (; group_ptr < groups_end; ++group_ptr)
  40d058:	4d 39 ec             	cmp    %r13,%r12
  40d05b:	73 35                	jae    40d092 <resume_solution+0x2c12>
        const fcs_move_func *test_ptr = group_ptr->move_funcs;
  40d05d:	49 8b 04 24          	mov    (%r12),%rax
        const fcs_move_func *const tests_end = test_ptr + group_ptr->num;
  40d061:	49 8b 54 24 08       	mov    0x8(%r12),%rdx
  40d066:	4c 8d 04 d0          	lea    (%rax,%rdx,8),%r8
        for (; test_ptr < tests_end; ++test_ptr)
  40d06a:	4c 39 c0             	cmp    %r8,%rax
  40d06d:	73 17                	jae    40d086 <resume_solution+0x2c06>
  40d06f:	90                   	nop
            *moves_order |= (1 << (test_ptr->idx));
  40d070:	48 8b 08             	mov    (%rax),%rcx
  40d073:	89 da                	mov    %ebx,%edx
        for (; test_ptr < tests_end; ++test_ptr)
  40d075:	48 83 c0 08          	add    $0x8,%rax
            *moves_order |= (1 << (test_ptr->idx));
  40d079:	d3 e2                	shl    %cl,%edx
  40d07b:	48 63 d2             	movslq %edx,%rdx
  40d07e:	48 09 d6             	or     %rdx,%rsi
        for (; test_ptr < tests_end; ++test_ptr)
  40d081:	49 39 c0             	cmp    %rax,%r8
  40d084:	77 ea                	ja     40d070 <resume_solution+0x2bf0>
    for (; group_ptr < groups_end; ++group_ptr)
  40d086:	49 81 c4 e8 00 00 00 	add    $0xe8,%r12
  40d08d:	4d 39 e5             	cmp    %r12,%r13
  40d090:	77 cb                	ja     40d05d <resume_solution+0x2bdd>
        STRUCT_SET_FLAG_TO(soft_thread, FCS_SOFT_THREAD_IS_A_COMPLETE_SCAN,
  40d092:	48 39 fe             	cmp    %rdi,%rsi
  40d095:	41 0f 94 81 ca 01 00 	sete   0x1ca(%r9)
  40d09c:	00 
  40d09d:	49 81 c1 f8 01 00 00 	add    $0x1f8,%r9
        if (st_idx < num_soft_threads)
  40d0a4:	4d 39 ca             	cmp    %r9,%r10
  40d0a7:	75 9b                	jne    40d044 <resume_solution+0x2bc4>
        user->init_num_checked_states.num_checked_states =
  40d0a9:	4c 8b bd f0 fe ff ff 	mov    -0x110(%rbp),%r15
        (hash_table_entry *)calloc(initial_hash_size, sizeof(hash->entries[0]));
  40d0b0:	be 08 00 00 00       	mov    $0x8,%esi
  40d0b5:	bf 00 08 00 00       	mov    $0x800,%edi
    hash->size = initial_hash_size;
  40d0ba:	48 b8 00 08 00 00 ff 	movabs $0x7ff00000800,%rax
  40d0c1:	07 00 00 
    fc_solve_hash_init(instance->meta_alloc, &(instance->hash),
  40d0c4:	49 8b 9f b0 05 00 00 	mov    0x5b0(%r15),%rbx
        user->init_num_checked_states.num_checked_states =
  40d0cb:	4d 89 9f d0 05 00 00 	mov    %r11,0x5d0(%r15)
  40d0d2:	49 89 47 1c          	mov    %rax,0x1c(%r15)
    hash->max_num_elems_before_resize = (new_size << 1);
  40d0d6:	49 c7 47 30 00 10 00 	movq   $0x1000,0x30(%r15)
  40d0dd:	00 
    hash->num_elems = 0;
  40d0de:	49 c7 47 28 00 00 00 	movq   $0x0,0x28(%r15)
  40d0e5:	00 
        (hash_table_entry *)calloc(initial_hash_size, sizeof(hash->entries[0]));
  40d0e6:	c5 f8 77             	vzeroupper 
  40d0e9:	e8 12 40 ff ff       	callq  401100 <calloc@plt>
    hash->hash_type = hash_type;
  40d0ee:	41 c7 47 18 01 00 00 	movl   $0x1,0x18(%r15)
  40d0f5:	00 
    hash->entries =
  40d0f6:	49 89 47 10          	mov    %rax,0x10(%r15)
    char *const ret = meta_alloc->recycle_bin;
  40d0fa:	48 8b 03             	mov    (%rbx),%rax
    allocator->meta = meta_alloc;
  40d0fd:	49 89 5f 58          	mov    %rbx,0x58(%r15)
    allocator->old_list = NULL;
  40d101:	49 c7 47 38 00 00 00 	movq   $0x0,0x38(%r15)
  40d108:	00 
    if (ret)
  40d109:	48 85 c0             	test   %rax,%rax
  40d10c:	0f 84 b6 02 00 00    	je     40d3c8 <resume_solution+0x2f48>
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  40d112:	48 8b 10             	mov    (%rax),%rdx
  40d115:	48 89 13             	mov    %rdx,(%rbx)
    allocator->old_list = new_data;
  40d118:	4c 8b bd f0 fe ff ff 	mov    -0x110(%rbp),%r15
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  40d11f:	48 c7 00 00 00 00 00 	movq   $0x0,(%rax)
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40d126:	48 8d 50 08          	lea    0x8(%rax),%rdx
        (hash_table_entry *)calloc(initial_hash_size, sizeof(hash->entries[0]));
  40d12a:	be 08 00 00 00       	mov    $0x8,%esi
  40d12f:	bf 00 08 00 00       	mov    $0x800,%edi
    allocator->old_list = new_data;
  40d134:	49 89 47 38          	mov    %rax,0x38(%r15)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40d138:	48 05 80 fe 00 00    	add    $0xfe80,%rax
  40d13e:	49 89 47 40          	mov    %rax,0x40(%r15)
    hash->size = initial_hash_size;
  40d142:	48 b8 00 08 00 00 ff 	movabs $0x7ff00000800,%rax
  40d149:	07 00 00 
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40d14c:	49 89 57 50          	mov    %rdx,0x50(%r15)
  40d150:	49 89 57 48          	mov    %rdx,0x48(%r15)
  40d154:	49 89 47 6c          	mov    %rax,0x6c(%r15)
    hash->max_num_elems_before_resize = (new_size << 1);
  40d158:	49 c7 87 80 00 00 00 	movq   $0x1000,0x80(%r15)
  40d15f:	00 10 00 00 
    hash->num_elems = 0;
  40d163:	49 c7 47 78 00 00 00 	movq   $0x0,0x78(%r15)
  40d16a:	00 
        (hash_table_entry *)calloc(initial_hash_size, sizeof(hash->entries[0]));
  40d16b:	e8 90 3f ff ff       	callq  401100 <calloc@plt>
    hash->hash_type = hash_type;
  40d170:	41 c7 47 68 00 00 00 	movl   $0x0,0x68(%r15)
  40d177:	00 
    hash->entries =
  40d178:	49 89 47 60          	mov    %rax,0x60(%r15)
    char *const ret = meta_alloc->recycle_bin;
  40d17c:	48 8b 03             	mov    (%rbx),%rax
    allocator->meta = meta_alloc;
  40d17f:	49 89 9f a8 00 00 00 	mov    %rbx,0xa8(%r15)
  40d186:	49 c7 87 88 00 00 00 	movq   $0x0,0x88(%r15)
  40d18d:	00 00 00 00 
    if (ret)
  40d191:	48 85 c0             	test   %rax,%rax
  40d194:	0f 84 1f 02 00 00    	je     40d3b9 <resume_solution+0x2f39>
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  40d19a:	48 8b 10             	mov    (%rax),%rdx
  40d19d:	48 89 13             	mov    %rdx,(%rbx)
    allocator->old_list = new_data;
  40d1a0:	48 8b 9d f0 fe ff ff 	mov    -0x110(%rbp),%rbx
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40d1a7:	48 8d 50 08          	lea    0x8(%rax),%rdx
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  40d1ab:	48 c7 00 00 00 00 00 	movq   $0x0,(%rax)
    instance->state_copy = (typeof(instance->state_copy)){.s = init_state->s,
  40d1b2:	b9 0c 00 00 00       	mov    $0xc,%ecx
  40d1b7:	4c 8b 8d 38 fe ff ff 	mov    -0x1c8(%rbp),%r9
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40d1be:	48 89 93 a0 00 00 00 	mov    %rdx,0xa0(%rbx)
  40d1c5:	c5 fa 6f 9b d8 05 00 	vmovdqu 0x5d8(%rbx),%xmm3
  40d1cc:	00 
  40d1cd:	48 8d bb 50 05 00 00 	lea    0x550(%rbx),%rdi
  40d1d4:	48 89 93 98 00 00 00 	mov    %rdx,0x98(%rbx)
  40d1db:	48 8b 93 18 06 00 00 	mov    0x618(%rbx),%rdx
  40d1e2:	4c 8d 93 90 05 00 00 	lea    0x590(%rbx),%r10
  40d1e9:	c5 fa 6f 93 e8 05 00 	vmovdqu 0x5e8(%rbx),%xmm2
  40d1f0:	00 
    allocator->old_list = new_data;
  40d1f1:	48 89 83 88 00 00 00 	mov    %rax,0x88(%rbx)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40d1f8:	48 05 80 fe 00 00    	add    $0xfe80,%rax
  40d1fe:	c5 fa 6f 8b f8 05 00 	vmovdqu 0x5f8(%rbx),%xmm1
  40d205:	00 
  40d206:	48 89 83 90 00 00 00 	mov    %rax,0x90(%rbx)
  40d20d:	31 c0                	xor    %eax,%eax
  40d20f:	c5 fa 6f 83 08 06 00 	vmovdqu 0x608(%rbx),%xmm0
  40d216:	00 
  40d217:	c5 f8 29 5d 80       	vmovaps %xmm3,-0x80(%rbp)
  40d21c:	f3 48 ab             	rep stos %rax,%es:(%rdi)
  40d21f:	c5 f8 29 55 90       	vmovaps %xmm2,-0x70(%rbp)
  40d224:	c5 f8 29 4d a0       	vmovaps %xmm1,-0x60(%rbp)
  40d229:	48 89 55 c0          	mov    %rdx,-0x40(%rbp)
  40d22d:	c5 f8 11 9b 50 05 00 	vmovups %xmm3,0x550(%rbx)
  40d234:	00 
  40d235:	c5 f8 11 93 60 05 00 	vmovups %xmm2,0x560(%rbx)
  40d23c:	00 
  40d23d:	c5 f8 11 8b 70 05 00 	vmovups %xmm1,0x570(%rbx)
  40d244:	00 
  40d245:	48 89 93 90 05 00 00 	mov    %rdx,0x590(%rbx)
  40d24c:	c7 83 ac 05 00 00 ff 	movl   $0xffffffff,0x5ac(%rbx)
  40d253:	ff ff ff 
  40d256:	c5 f8 29 45 b0       	vmovaps %xmm0,-0x50(%rbp)
  40d25b:	c5 f8 11 83 80 05 00 	vmovups %xmm0,0x580(%rbx)
  40d262:	00 
    fcs_seq_cards_power_type cards_under_sequences = 0;
  40d263:	c5 f9 57 c0          	vxorpd %xmm0,%xmm0,%xmm0
        const_AUTO(col, fcs_state_get_col(*s, a));
  40d267:	4d 8b 19             	mov    (%r9),%r11
        const_AUTO(col_len, fcs_col_len(col));
  40d26a:	41 0f be 0b          	movsbl (%r11),%ecx
        if (col_len <= 1)
  40d26e:	80 f9 01             	cmp    $0x1,%cl
  40d271:	7e 4e                	jle    40d2c1 <resume_solution+0x2e41>
        cards_under_sequences += FCS_SEQS_OVER_RENEGADE_POWER(
  40d273:	8d 41 ff             	lea    -0x1(%rcx),%eax
  40d276:	83 e9 02             	sub    $0x2,%ecx
    fcs_card this_card = fcs_col_get_card(col, d);
  40d279:	48 98                	cltq   
  40d27b:	4c 8d 40 ff          	lea    -0x1(%rax),%r8
  40d27f:	49 0f be 54 03 01    	movsbq 0x1(%r11,%rax,1),%rdx
  40d285:	49 29 c8             	sub    %rcx,%r8
  40d288:	eb 11                	jmp    40d29b <resume_solution+0x2e1b>
  40d28a:	48 83 e8 01          	sub    $0x1,%rax
         d--, this_card = prev_card)
  40d28e:	48 0f be d6          	movsbq %sil,%rdx
    for (; (d > 0) && ({
  40d292:	49 39 c0             	cmp    %rax,%r8
  40d295:	0f 84 d5 00 00 00    	je     40d370 <resume_solution+0x2ef0>
             prev_card = fcs_col_get_card(col, d - 1);
  40d29b:	49 0f be 0c 03       	movsbq (%r11,%rax,1),%rcx
  40d2a0:	48 63 f8             	movslq %eax,%rdi
  40d2a3:	48 89 ce             	mov    %rcx,%rsi
    return fc_solve_is_parent_buf[(size_t)parent][(size_t)child];
  40d2a6:	48 c1 e1 06          	shl    $0x6,%rcx
    for (; (d > 0) && ({
  40d2aa:	80 bc 0a c0 fe 40 00 	cmpb   $0x0,0x40fec0(%rdx,%rcx,1)
  40d2b1:	00 
  40d2b2:	75 d6                	jne    40d28a <resume_solution+0x2e0a>
  40d2b4:	c5 fb 10 14 fd a0 f6 	vmovsd 0x40f6a0(,%rdi,8),%xmm2
  40d2bb:	40 00 
  40d2bd:	c5 fb 58 c2          	vaddsd %xmm2,%xmm0,%xmm0
  40d2c1:	49 83 c1 08          	add    $0x8,%r9
    for (int a = 0; a < INSTANCE_STACKS_NUM; a++)
  40d2c5:	4d 39 ca             	cmp    %r9,%r10
  40d2c8:	75 9d                	jne    40d267 <resume_solution+0x2de7>
    instance->initial_cards_under_sequences_value = cards_under_sequences;
  40d2ca:	48 8b 9d f0 fe ff ff 	mov    -0x110(%rbp),%rbx
    fc_solve_check_and_add_state(
  40d2d1:	48 8d 95 40 ff ff ff 	lea    -0xc0(%rbp),%rdx
        pass_copy = FCS_STATE_keyval_pair_to_kv(&instance->state_copy);
  40d2d8:	c5 f9 6f b5 20 fe ff 	vmovdqa -0x1e0(%rbp),%xmm6
  40d2df:	ff 
    fc_solve_check_and_add_state(
  40d2e0:	48 8d b5 50 ff ff ff 	lea    -0xb0(%rbp),%rsi
        pass_copy = FCS_STATE_keyval_pair_to_kv(&instance->state_copy);
  40d2e7:	c5 f8 29 b5 50 ff ff 	vmovaps %xmm6,-0xb0(%rbp)
  40d2ee:	ff 
    instance->initial_cards_under_sequences_value = cards_under_sequences;
  40d2ef:	c5 fb 11 43 08       	vmovsd %xmm0,0x8(%rbx)
    fc_solve_check_and_add_state(
  40d2f4:	48 89 df             	mov    %rbx,%rdi
  40d2f7:	e8 54 47 ff ff       	callq  401a50 <fc_solve_check_and_add_state>
            if (HT_FIELD(hard_thread, prelude))
  40d2fc:	48 8b 93 10 05 00 00 	mov    0x510(%rbx),%rdx
            HT_FIELD(hard_thread, prelude_idx) = 0;
  40d303:	48 c7 83 08 05 00 00 	movq   $0x0,0x508(%rbx)
  40d30a:	00 00 00 00 
            if (HT_FIELD(hard_thread, prelude))
  40d30e:	48 85 d2             	test   %rdx,%rdx
  40d311:	74 23                	je     40d336 <resume_solution+0x2eb6>
        prelude[HT_FIELD(hard_thread, prelude_idx)++];
  40d313:	48 c7 83 08 05 00 00 	movq   $0x1,0x508(%rbx)
  40d31a:	01 00 00 00 
    set_next_soft_thread(
  40d31e:	48 8b 42 08          	mov    0x8(%rdx),%rax
    (*st_idx_ptr) = scan_idx;
  40d322:	48 8b 12             	mov    (%rdx),%rdx
        NUM_CHECKED_STATES + quota;
  40d325:	48 03 03             	add    (%rbx),%rax
    (*st_idx_ptr) = scan_idx;
  40d328:	48 89 93 d0 00 00 00 	mov    %rdx,0xd0(%rbx)
    HT_FIELD(hard_thread, ht__max_num_checked_states) =
  40d32f:	48 89 83 c8 00 00 00 	mov    %rax,0xc8(%rbx)
  40d336:	48 8b 85 f0 fe ff ff 	mov    -0x110(%rbp),%rax
  40d33d:	8b 98 b8 05 00 00    	mov    0x5b8(%rax),%ebx
  40d343:	e9 c0 d1 ff ff       	jmpq   40a508 <resume_solution+0x88>
        while ((c > 0) && ((STACK_COMPARE(GET_STACK(c), GET_STACK(c - 1))) < 0))
  40d348:	85 d2                	test   %edx,%edx
  40d34a:	0f 88 2e fb ff ff    	js     40ce7e <resume_solution+0x29fe>
    for (size_t b = 1; b < STACKS_NUM__VAL; b++)
  40d350:	48 83 c3 01          	add    $0x1,%rbx
  40d354:	49 83 c4 08          	add    $0x8,%r12
  40d358:	48 83 fb 08          	cmp    $0x8,%rbx
  40d35c:	0f 85 aa fa ff ff    	jne    40ce0c <resume_solution+0x298c>
  40d362:	e9 44 fb ff ff       	jmpq   40ceab <resume_solution+0x2a2b>
  40d367:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40d36e:	00 00 
  40d370:	c5 e9 57 d2          	vxorpd %xmm2,%xmm2,%xmm2
  40d374:	e9 44 ff ff ff       	jmpq   40d2bd <resume_solution+0x2e3d>
            GET_FREECELL(c - 1) = temp_freecell;
  40d379:	48 89 d8             	mov    %rbx,%rax
  40d37c:	44 88 90 19 06 00 00 	mov    %r10b,0x619(%rax)
  40d383:	e9 ce fb ff ff       	jmpq   40cf56 <resume_solution+0x2ad6>
  40d388:	48 89 d8             	mov    %rbx,%rax
  40d38b:	44 88 90 1a 06 00 00 	mov    %r10b,0x61a(%rax)
  40d392:	e9 bf fb ff ff       	jmpq   40cf56 <resume_solution+0x2ad6>
        while ((c > 0) && ((fc_solve_card_compare(
  40d397:	45 89 c1             	mov    %r8d,%r9d
  40d39a:	41 89 f8             	mov    %edi,%r8d
  40d39d:	44 89 cf             	mov    %r9d,%edi
  40d3a0:	41 89 c9             	mov    %ecx,%r9d
  40d3a3:	89 d1                	mov    %edx,%ecx
  40d3a5:	44 89 ca             	mov    %r9d,%edx
  40d3a8:	e9 71 fb ff ff       	jmpq   40cf1e <resume_solution+0x2a9e>
            GET_FREECELL(c - 1) = temp_freecell;
  40d3ad:	40 88 bb 19 06 00 00 	mov    %dil,0x619(%rbx)
  40d3b4:	e9 65 fb ff ff       	jmpq   40cf1e <resume_solution+0x2a9e>
        return malloc(ALLOCED_SIZE);
  40d3b9:	bf 80 fe 00 00       	mov    $0xfe80,%edi
  40d3be:	e8 2d 3d ff ff       	callq  4010f0 <malloc@plt>
  40d3c3:	e9 d8 fd ff ff       	jmpq   40d1a0 <resume_solution+0x2d20>
  40d3c8:	bf 80 fe 00 00       	mov    $0xfe80,%edi
  40d3cd:	e8 1e 3d ff ff       	callq  4010f0 <malloc@plt>
  40d3d2:	e9 41 fd ff ff       	jmpq   40d118 <resume_solution+0x2c98>
    fc_solve_finish_instance(instance);
  40d3d7:	4c 8b bd f0 fe ff ff 	mov    -0x110(%rbp),%r15
  40d3de:	4c 89 ff             	mov    %r15,%rdi
  40d3e1:	e8 3a 43 ff ff       	callq  401720 <fc_solve_finish_instance>
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40d3e6:	49 8b 87 d8 00 00 00 	mov    0xd8(%r15),%rax
    HT_FIELD(hard_thread, ht__max_num_checked_states) = FCS_INT_LIMIT_MAX;
  40d3ed:	48 bf ff ff ff ff ff 	movabs $0x7fffffffffffffff,%rdi
  40d3f4:	ff ff 7f 
    instance->i__num_checked_states = 0;
  40d3f7:	49 c7 07 00 00 00 00 	movq   $0x0,(%r15)
    meta_allocator *const meta = allocator->meta;
  40d3fe:	49 8b b7 f8 00 00 00 	mov    0xf8(%r15),%rsi
    instance->num_hard_threads_finished = 0;
  40d405:	49 c7 87 40 05 00 00 	movq   $0x0,0x540(%r15)
  40d40c:	00 00 00 00 
  40d410:	49 89 bf c8 00 00 00 	mov    %rdi,0xc8(%r15)
    HT_FIELD(hard_thread, num_soft_threads_finished) = 0;
  40d417:	41 c7 87 28 05 00 00 	movl   $0x0,0x528(%r15)
  40d41e:	00 00 00 00 
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40d422:	48 8b 10             	mov    (%rax),%rdx
    var_AUTO(bin, meta->recycle_bin);
  40d425:	48 8b 0e             	mov    (%rsi),%rcx
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40d428:	48 85 d2             	test   %rdx,%rdx
  40d42b:	75 06                	jne    40d433 <resume_solution+0x2fb3>
  40d42d:	eb 15                	jmp    40d444 <resume_solution+0x2fc4>
  40d42f:	90                   	nop
  40d430:	48 89 fa             	mov    %rdi,%rdx
        OLD_LIST_NEXT(iter) = bin;
  40d433:	48 89 08             	mov    %rcx,(%rax)
         iter = iter_next, iter_next = OLD_LIST_NEXT(iter))
  40d436:	48 8b 3a             	mov    (%rdx),%rdi
  40d439:	48 89 c1             	mov    %rax,%rcx
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40d43c:	48 89 d0             	mov    %rdx,%rax
  40d43f:	48 85 ff             	test   %rdi,%rdi
  40d442:	75 ec                	jne    40d430 <resume_solution+0x2fb0>
  40d444:	48 8b bd f0 fe ff ff 	mov    -0x110(%rbp),%rdi
    OLD_LIST_NEXT(iter) = bin;
  40d44b:	48 89 08             	mov    %rcx,(%rax)
    meta->recycle_bin = iter;
  40d44e:	48 89 06             	mov    %rax,(%rsi)
    ST_LOOP_START()
  40d451:	4c 69 af 20 05 00 00 	imul   $0x1f8,0x520(%rdi),%r13
  40d458:	f8 01 00 00 
  40d45c:	48 c7 87 d8 00 00 00 	movq   $0x0,0xd8(%rdi)
  40d463:	00 00 00 00 
  40d467:	4c 8b a7 c0 00 00 00 	mov    0xc0(%rdi),%r12
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  40d46e:	48 8b 10             	mov    (%rax),%rdx
  40d471:	4d 01 e5             	add    %r12,%r13
  40d474:	48 89 16             	mov    %rdx,(%rsi)
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40d477:	48 8d 50 08          	lea    0x8(%rax),%rdx
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  40d47b:	48 c7 00 00 00 00 00 	movq   $0x0,(%rax)
    allocator->old_list = new_data;
  40d482:	48 89 87 d8 00 00 00 	mov    %rax,0xd8(%rdi)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40d489:	48 05 80 fe 00 00    	add    $0xfe80,%rax
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40d48f:	48 89 97 f0 00 00 00 	mov    %rdx,0xf0(%rdi)
  40d496:	48 89 97 e8 00 00 00 	mov    %rdx,0xe8(%rdi)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40d49d:	48 89 87 e0 00 00 00 	mov    %rax,0xe0(%rdi)
  40d4a4:	4d 39 ec             	cmp    %r13,%r12
  40d4a7:	73 31                	jae    40d4da <resume_solution+0x305a>
    free(pq->elems);
  40d4a9:	49 8b bc 24 00 01 00 	mov    0x100(%r12),%rdi
  40d4b0:	00 
  40d4b1:	49 81 c4 f8 01 00 00 	add    $0x1f8,%r12
  40d4b8:	e8 93 3b ff ff       	callq  401050 <free@plt>
    STRUCT_CLEAR_FLAG(soft_thread, FCS_SOFT_THREAD_IS_FINISHED);
  40d4bd:	41 c6 44 24 e8 00    	movb   $0x0,-0x18(%r12)
    pq->elems = NULL;
  40d4c3:	49 c7 84 24 08 ff ff 	movq   $0x0,-0xf8(%r12)
  40d4ca:	ff 00 00 00 00 
    STRUCT_CLEAR_FLAG(soft_thread, FCS_SOFT_THREAD_INITIALIZED);
  40d4cf:	41 c6 44 24 e9 00    	movb   $0x0,-0x17(%r12)
  40d4d5:	4d 39 e5             	cmp    %r12,%r13
  40d4d8:	77 cf                	ja     40d4a9 <resume_solution+0x3029>
                flare->instance_is_ready = TRUE;
  40d4da:	48 8b 85 f0 fe ff ff 	mov    -0x110(%rbp),%rax
  40d4e1:	c6 80 bc 05 00 00 01 	movb   $0x1,0x5bc(%rax)
  40d4e8:	e9 8e d0 ff ff       	jmpq   40a57b <resume_solution+0xfb>
        if ((*str) == ':')
  40d4ed:	80 3a 3a             	cmpb   $0x3a,(%rdx)
  40d4f0:	75 04                	jne    40d4f6 <resume_solution+0x3076>
            ++str;
  40d4f2:	48 83 c2 01          	add    $0x1,%rdx
        var_AUTO(col, fcs_state_get_col(out, s));
  40d4f6:	4b 8b 8c c2 d8 05 00 	mov    0x5d8(%r10,%r8,8),%rcx
  40d4fd:	00 
  40d4fe:	48 89 d0             	mov    %rdx,%rax
        for (int c = 0; c < MAX_NUM_CARDS_IN_A_STACK; c++)
  40d501:	31 f6                	xor    %esi,%esi
            while ((*str == ' ') || (*str == '\t'))
  40d503:	0f b6 10             	movzbl (%rax),%edx
  40d506:	80 fa 09             	cmp    $0x9,%dl
  40d509:	74 05                	je     40d510 <resume_solution+0x3090>
  40d50b:	80 fa 20             	cmp    $0x20,%dl
  40d50e:	75 11                	jne    40d521 <resume_solution+0x30a1>
                ++str;
  40d510:	48 83 c0 01          	add    $0x1,%rax
            while ((*str == ' ') || (*str == '\t'))
  40d514:	0f b6 10             	movzbl (%rax),%edx
  40d517:	80 fa 20             	cmp    $0x20,%dl
  40d51a:	74 f4                	je     40d510 <resume_solution+0x3090>
  40d51c:	80 fa 09             	cmp    $0x9,%dl
  40d51f:	74 ef                	je     40d510 <resume_solution+0x3090>
            HANDLE_EOS();
  40d521:	84 d2                	test   %dl,%dl
  40d523:	0f 84 9f f8 ff ff    	je     40cdc8 <resume_solution+0x2948>
            if ((*str == '\n') || (*str == '\r'))
  40d529:	80 fa 0a             	cmp    $0xa,%dl
  40d52c:	0f 84 f6 f6 ff ff    	je     40cc28 <resume_solution+0x27a8>
  40d532:	80 fa 0d             	cmp    $0xd,%dl
  40d535:	0f 84 ed f6 ff ff    	je     40cc28 <resume_solution+0x27a8>
  40d53b:	48 89 c7             	mov    %rax,%rdi
        switch (FC_SOLVE_MAP_CHAR(*suit))
  40d53e:	0f b6 17             	movzbl (%rdi),%edx
  40d541:	80 fa 43             	cmp    $0x43,%dl
  40d544:	0f 84 c4 02 00 00    	je     40d80e <resume_solution+0x338e>
  40d54a:	0f 8e aa 02 00 00    	jle    40d7fa <resume_solution+0x337a>
  40d550:	80 fa 48             	cmp    $0x48,%dl
  40d553:	0f 84 ae 02 00 00    	je     40d807 <resume_solution+0x3387>
  40d559:	80 fa 53             	cmp    $0x53,%dl
  40d55c:	0f 84 8e 02 00 00    	je     40d7f0 <resume_solution+0x3370>
  40d562:	80 fa 44             	cmp    $0x44,%dl
  40d565:	0f 84 bf 01 00 00    	je     40d72a <resume_solution+0x32aa>
            ++suit;
  40d56b:	48 83 c7 01          	add    $0x1,%rdi
  40d56f:	eb cd                	jmp    40d53e <resume_solution+0x30be>
        switch (FC_SOLVE_MAP_CHAR(*suit))
  40d571:	84 d2                	test   %dl,%dl
  40d573:	74 09                	je     40d57e <resume_solution+0x30fe>
  40d575:	80 fa 20             	cmp    $0x20,%dl
  40d578:	0f 85 75 f7 ff ff    	jne    40ccf3 <resume_solution+0x2873>
            return 0;
  40d57e:	31 c9                	xor    %ecx,%ecx
        switch (FC_SOLVE_MAP_CHAR(*suit))
  40d580:	31 ff                	xor    %edi,%edi
  40d582:	eb 0a                	jmp    40d58e <resume_solution+0x310e>
  40d584:	bf 01 00 00 00       	mov    $0x1,%edi
            return 1;
  40d589:	b9 01 00 00 00       	mov    $0x1,%ecx
                while (*str == '-')
  40d58e:	0f b6 70 01          	movzbl 0x1(%rax),%esi
                ++str;
  40d592:	48 8d 50 01          	lea    0x1(%rax),%rdx
                while (*str == '-')
  40d596:	40 80 fe 2d          	cmp    $0x2d,%sil
  40d59a:	75 0d                	jne    40d5a9 <resume_solution+0x3129>
                    ++str;
  40d59c:	48 83 c2 01          	add    $0x1,%rdx
                while (*str == '-')
  40d5a0:	0f b6 32             	movzbl (%rdx),%esi
  40d5a3:	40 80 fe 2d          	cmp    $0x2d,%sil
  40d5a7:	74 f3                	je     40d59c <resume_solution+0x311c>
                const int c = ((str[0] == '0') ? 0 : fcs_str2rank(str));
  40d5a9:	40 80 fe 30          	cmp    $0x30,%sil
  40d5ad:	0f 84 c6 00 00 00    	je     40d679 <resume_solution+0x31f9>
  40d5b3:	48 89 d3             	mov    %rdx,%rbx
        switch (FC_SOLVE_MAP_CHAR(*string))
  40d5b6:	0f b6 03             	movzbl (%rbx),%eax
  40d5b9:	3c 35                	cmp    $0x35,%al
  40d5bb:	0f 84 ae 00 00 00    	je     40d66f <resume_solution+0x31ef>
  40d5c1:	0f 8e e2 00 00 00    	jle    40d6a9 <resume_solution+0x3229>
  40d5c7:	3c 41                	cmp    $0x41,%al
  40d5c9:	0f 84 d0 00 00 00    	je     40d69f <resume_solution+0x321f>
  40d5cf:	0f 8f b2 00 00 00    	jg     40d687 <resume_solution+0x3207>
  40d5d5:	3c 37                	cmp    $0x37,%al
  40d5d7:	0f 84 a0 00 00 00    	je     40d67d <resume_solution+0x31fd>
  40d5dd:	7c 6f                	jl     40d64e <resume_solution+0x31ce>
  40d5df:	3c 38                	cmp    $0x38,%al
  40d5e1:	74 64                	je     40d647 <resume_solution+0x31c7>
  40d5e3:	3c 39                	cmp    $0x39,%al
  40d5e5:	75 7f                	jne    40d666 <resume_solution+0x31e6>
        case '9':
  40d5e7:	b8 09 00 00 00       	mov    $0x9,%eax
                while ((*str != ' ') && (*str != '\t') && (*str != '\n') &&
  40d5ec:	40 80 fe 20          	cmp    $0x20,%sil
  40d5f0:	77 10                	ja     40d602 <resume_solution+0x3182>
  40d5f2:	48 bb 00 26 00 00 01 	movabs $0x100002600,%rbx
  40d5f9:	00 00 00 
  40d5fc:	48 0f a3 f3          	bt     %rsi,%rbx
  40d600:	72 26                	jb     40d628 <resume_solution+0x31a8>
                    HANDLE_EOS();
  40d602:	40 84 f6             	test   %sil,%sil
  40d605:	0f 84 bd f7 ff ff    	je     40cdc8 <resume_solution+0x2948>
                    ++str;
  40d60b:	48 83 c2 01          	add    $0x1,%rdx
                while ((*str != ' ') && (*str != '\t') && (*str != '\n') &&
  40d60f:	0f b6 32             	movzbl (%rdx),%esi
  40d612:	40 80 fe 20          	cmp    $0x20,%sil
  40d616:	77 ea                	ja     40d602 <resume_solution+0x3182>
  40d618:	48 bb 00 26 00 00 01 	movabs $0x100002600,%rbx
  40d61f:	00 00 00 
  40d622:	48 0f a3 f3          	bt     %rsi,%rbx
  40d626:	73 da                	jae    40d602 <resume_solution+0x3182>
                fcs_set_foundation(out, ((decks_index[f_idx] << 2) + f_idx), c);
  40d628:	48 8b b4 cd 50 ff ff 	mov    -0xb0(%rbp,%rcx,8),%rsi
  40d62f:	ff 
  40d630:	4c 01 d7             	add    %r10,%rdi
                    decks_index[f_idx] = 0;
  40d633:	4c 89 9c cd 50 ff ff 	mov    %r11,-0xb0(%rbp,%rcx,8)
  40d63a:	ff 
                fcs_set_foundation(out, ((decks_index[f_idx] << 2) + f_idx), c);
  40d63b:	88 84 b7 1c 06 00 00 	mov    %al,0x61c(%rdi,%rsi,4)
  40d642:	e9 fb f6 ff ff       	jmpq   40cd42 <resume_solution+0x28c2>
        case '8':
  40d647:	b8 08 00 00 00       	mov    $0x8,%eax
  40d64c:	eb 9e                	jmp    40d5ec <resume_solution+0x316c>
        case '6':
  40d64e:	b8 06 00 00 00       	mov    $0x6,%eax
  40d653:	eb 97                	jmp    40d5ec <resume_solution+0x316c>
        switch (FC_SOLVE_MAP_CHAR(*string))
  40d655:	84 c0                	test   %al,%al
  40d657:	0f 84 82 00 00 00    	je     40d6df <resume_solution+0x325f>
  40d65d:	78 07                	js     40d666 <resume_solution+0x31e6>
  40d65f:	83 e8 09             	sub    $0x9,%eax
  40d662:	3c 01                	cmp    $0x1,%al
  40d664:	76 79                	jbe    40d6df <resume_solution+0x325f>
            ++string;
  40d666:	48 83 c3 01          	add    $0x1,%rbx
  40d66a:	e9 47 ff ff ff       	jmpq   40d5b6 <resume_solution+0x3136>
        case '5':
  40d66f:	b8 05 00 00 00       	mov    $0x5,%eax
  40d674:	e9 73 ff ff ff       	jmpq   40d5ec <resume_solution+0x316c>
                const int c = ((str[0] == '0') ? 0 : fcs_str2rank(str));
  40d679:	31 c0                	xor    %eax,%eax
  40d67b:	eb 8e                	jmp    40d60b <resume_solution+0x318b>
        case '7':
  40d67d:	b8 07 00 00 00       	mov    $0x7,%eax
  40d682:	e9 65 ff ff ff       	jmpq   40d5ec <resume_solution+0x316c>
        switch (FC_SOLVE_MAP_CHAR(*string))
  40d687:	3c 4b                	cmp    $0x4b,%al
  40d689:	74 77                	je     40d702 <resume_solution+0x3282>
  40d68b:	7e 63                	jle    40d6f0 <resume_solution+0x3270>
  40d68d:	3c 51                	cmp    $0x51,%al
  40d68f:	74 36                	je     40d6c7 <resume_solution+0x3247>
  40d691:	3c 54                	cmp    $0x54,%al
  40d693:	75 d1                	jne    40d666 <resume_solution+0x31e6>
        case 'T':
  40d695:	b8 0a 00 00 00       	mov    $0xa,%eax
  40d69a:	e9 4d ff ff ff       	jmpq   40d5ec <resume_solution+0x316c>
        switch (FC_SOLVE_MAP_CHAR(*string))
  40d69f:	b8 01 00 00 00       	mov    $0x1,%eax
  40d6a4:	e9 43 ff ff ff       	jmpq   40d5ec <resume_solution+0x316c>
  40d6a9:	3c 0d                	cmp    $0xd,%al
  40d6ab:	74 32                	je     40d6df <resume_solution+0x325f>
  40d6ad:	7e a6                	jle    40d655 <resume_solution+0x31d5>
  40d6af:	3c 32                	cmp    $0x32,%al
  40d6b1:	74 33                	je     40d6e6 <resume_solution+0x3266>
  40d6b3:	7e 26                	jle    40d6db <resume_solution+0x325b>
  40d6b5:	3c 33                	cmp    $0x33,%al
  40d6b7:	74 18                	je     40d6d1 <resume_solution+0x3251>
  40d6b9:	3c 34                	cmp    $0x34,%al
  40d6bb:	75 a9                	jne    40d666 <resume_solution+0x31e6>
        case '4':
  40d6bd:	b8 04 00 00 00       	mov    $0x4,%eax
  40d6c2:	e9 25 ff ff ff       	jmpq   40d5ec <resume_solution+0x316c>
        case 'Q':
  40d6c7:	b8 0c 00 00 00       	mov    $0xc,%eax
  40d6cc:	e9 1b ff ff ff       	jmpq   40d5ec <resume_solution+0x316c>
        case '3':
  40d6d1:	b8 03 00 00 00       	mov    $0x3,%eax
  40d6d6:	e9 11 ff ff ff       	jmpq   40d5ec <resume_solution+0x316c>
        switch (FC_SOLVE_MAP_CHAR(*string))
  40d6db:	3c 20                	cmp    $0x20,%al
  40d6dd:	75 87                	jne    40d666 <resume_solution+0x31e6>
  40d6df:	31 c0                	xor    %eax,%eax
  40d6e1:	e9 06 ff ff ff       	jmpq   40d5ec <resume_solution+0x316c>
        case '2':
  40d6e6:	b8 02 00 00 00       	mov    $0x2,%eax
  40d6eb:	e9 fc fe ff ff       	jmpq   40d5ec <resume_solution+0x316c>
        switch (FC_SOLVE_MAP_CHAR(*string))
  40d6f0:	3c 4a                	cmp    $0x4a,%al
  40d6f2:	0f 85 6e ff ff ff    	jne    40d666 <resume_solution+0x31e6>
        case 'J':
  40d6f8:	b8 0b 00 00 00       	mov    $0xb,%eax
  40d6fd:	e9 ea fe ff ff       	jmpq   40d5ec <resume_solution+0x316c>
        case 'K':
  40d702:	b8 0d 00 00 00       	mov    $0xd,%eax
  40d707:	e9 e0 fe ff ff       	jmpq   40d5ec <resume_solution+0x316c>
        case 'S':
  40d70c:	bf 03 00 00 00       	mov    $0x3,%edi
            return 3;
  40d711:	b9 03 00 00 00       	mov    $0x3,%ecx
  40d716:	e9 73 fe ff ff       	jmpq   40d58e <resume_solution+0x310e>
        switch (FC_SOLVE_MAP_CHAR(*suit))
  40d71b:	bf 02 00 00 00       	mov    $0x2,%edi
            return 2;
  40d720:	b9 02 00 00 00       	mov    $0x2,%ecx
  40d725:	e9 64 fe ff ff       	jmpq   40d58e <resume_solution+0x310e>
  40d72a:	bf 02 00 00 00       	mov    $0x2,%edi
            return 3;
  40d72f:	49 89 c3             	mov    %rax,%r11
        switch (FC_SOLVE_MAP_CHAR(*string))
  40d732:	41 0f b6 13          	movzbl (%r11),%edx
  40d736:	80 fa 35             	cmp    $0x35,%dl
  40d739:	0f 84 a3 01 00 00    	je     40d8e2 <resume_solution+0x3462>
  40d73f:	0f 8e 6f 01 00 00    	jle    40d8b4 <resume_solution+0x3434>
  40d745:	80 fa 41             	cmp    $0x41,%dl
  40d748:	0f 84 39 01 00 00    	je     40d887 <resume_solution+0x3407>
  40d74e:	0f 8f 18 01 00 00    	jg     40d86c <resume_solution+0x33ec>
  40d754:	80 fa 37             	cmp    $0x37,%dl
  40d757:	0f 84 05 01 00 00    	je     40d862 <resume_solution+0x33e2>
  40d75d:	0f 8c f5 00 00 00    	jl     40d858 <resume_solution+0x33d8>
  40d763:	80 fa 38             	cmp    $0x38,%dl
  40d766:	0f 84 e2 00 00 00    	je     40d84e <resume_solution+0x33ce>
  40d76c:	80 fa 39             	cmp    $0x39,%dl
  40d76f:	0f 85 d0 00 00 00    	jne    40d845 <resume_solution+0x33c5>
            return 9;
  40d775:	ba 09 00 00 00       	mov    $0x9,%edx
    return (fcs_card)((((fcs_card)rank) << 2) | ((fcs_card)suit));
  40d77a:	c1 e2 02             	shl    $0x2,%edx
  40d77d:	09 fa                	or     %edi,%edx
            if (!fcs_card_rank(my_card))
  40d77f:	89 d3                	mov    %edx,%ebx
  40d781:	c0 eb 02             	shr    $0x2,%bl
  40d784:	0f 84 3e f6 ff ff    	je     40cdc8 <resume_solution+0x2948>
            fcs_col_push_card(col, my_card);
  40d78a:	48 0f be 39          	movsbq (%rcx),%rdi
        for (int c = 0; c < MAX_NUM_CARDS_IN_A_STACK; c++)
  40d78e:	83 c6 01             	add    $0x1,%esi
            fcs_col_push_card(col, my_card);
  40d791:	44 8d 5f 01          	lea    0x1(%rdi),%r11d
  40d795:	44 88 19             	mov    %r11b,(%rcx)
  40d798:	88 54 39 01          	mov    %dl,0x1(%rcx,%rdi,1)
        for (int c = 0; c < MAX_NUM_CARDS_IN_A_STACK; c++)
  40d79c:	83 fe 14             	cmp    $0x14,%esi
  40d79f:	0f 84 83 f4 ff ff    	je     40cc28 <resume_solution+0x27a8>
  40d7a5:	0f b6 10             	movzbl (%rax),%edx
                while (((*str) != ' ') && ((*str) != '\t') &&
  40d7a8:	80 fa 20             	cmp    $0x20,%dl
  40d7ab:	74 6b                	je     40d818 <resume_solution+0x3398>
  40d7ad:	80 fa 09             	cmp    $0x9,%dl
  40d7b0:	74 66                	je     40d818 <resume_solution+0x3398>
                       ((*str) != '\n') && ((*str) != '\r'))
  40d7b2:	80 fa 0a             	cmp    $0xa,%dl
  40d7b5:	0f 84 6d f4 ff ff    	je     40cc28 <resume_solution+0x27a8>
  40d7bb:	80 fa 0d             	cmp    $0xd,%dl
  40d7be:	0f 84 64 f4 ff ff    	je     40cc28 <resume_solution+0x27a8>
                    HANDLE_EOS();
  40d7c4:	84 d2                	test   %dl,%dl
  40d7c6:	0f 84 fc f5 ff ff    	je     40cdc8 <resume_solution+0x2948>
                    ++str;
  40d7cc:	48 83 c0 01          	add    $0x1,%rax
                while (((*str) != ' ') && ((*str) != '\t') &&
  40d7d0:	0f b6 10             	movzbl (%rax),%edx
  40d7d3:	80 fa 20             	cmp    $0x20,%dl
  40d7d6:	74 40                	je     40d818 <resume_solution+0x3398>
  40d7d8:	80 fa 09             	cmp    $0x9,%dl
  40d7db:	74 3b                	je     40d818 <resume_solution+0x3398>
                       ((*str) != '\n') && ((*str) != '\r'))
  40d7dd:	80 fa 0d             	cmp    $0xd,%dl
  40d7e0:	0f 84 42 f4 ff ff    	je     40cc28 <resume_solution+0x27a8>
  40d7e6:	80 fa 0a             	cmp    $0xa,%dl
  40d7e9:	75 d9                	jne    40d7c4 <resume_solution+0x3344>
  40d7eb:	e9 38 f4 ff ff       	jmpq   40cc28 <resume_solution+0x27a8>
            return 3;
  40d7f0:	bf 03 00 00 00       	mov    $0x3,%edi
  40d7f5:	e9 35 ff ff ff       	jmpq   40d72f <resume_solution+0x32af>
        switch (FC_SOLVE_MAP_CHAR(*suit))
  40d7fa:	84 d2                	test   %dl,%dl
  40d7fc:	74 09                	je     40d807 <resume_solution+0x3387>
  40d7fe:	80 fa 20             	cmp    $0x20,%dl
  40d801:	0f 85 64 fd ff ff    	jne    40d56b <resume_solution+0x30eb>
            return 0;
  40d807:	31 ff                	xor    %edi,%edi
  40d809:	e9 21 ff ff ff       	jmpq   40d72f <resume_solution+0x32af>
            return 1;
  40d80e:	bf 01 00 00 00       	mov    $0x1,%edi
  40d813:	e9 17 ff ff ff       	jmpq   40d72f <resume_solution+0x32af>
                if ((*str == '\n') || (*str == '\r'))
  40d818:	80 fa 0a             	cmp    $0xa,%dl
  40d81b:	0f 84 07 f4 ff ff    	je     40cc28 <resume_solution+0x27a8>
  40d821:	80 fa 0d             	cmp    $0xd,%dl
  40d824:	0f 85 d9 fc ff ff    	jne    40d503 <resume_solution+0x3083>
  40d82a:	e9 f9 f3 ff ff       	jmpq   40cc28 <resume_solution+0x27a8>
        switch (FC_SOLVE_MAP_CHAR(*string))
  40d82f:	84 d2                	test   %dl,%dl
  40d831:	0f 84 91 f5 ff ff    	je     40cdc8 <resume_solution+0x2948>
  40d837:	78 0c                	js     40d845 <resume_solution+0x33c5>
  40d839:	83 ea 09             	sub    $0x9,%edx
  40d83c:	80 fa 01             	cmp    $0x1,%dl
  40d83f:	0f 86 83 f5 ff ff    	jbe    40cdc8 <resume_solution+0x2948>
            ++string;
  40d845:	49 83 c3 01          	add    $0x1,%r11
  40d849:	e9 e4 fe ff ff       	jmpq   40d732 <resume_solution+0x32b2>
            return 8;
  40d84e:	ba 08 00 00 00       	mov    $0x8,%edx
  40d853:	e9 22 ff ff ff       	jmpq   40d77a <resume_solution+0x32fa>
            return 6;
  40d858:	ba 06 00 00 00       	mov    $0x6,%edx
  40d85d:	e9 18 ff ff ff       	jmpq   40d77a <resume_solution+0x32fa>
            return 7;
  40d862:	ba 07 00 00 00       	mov    $0x7,%edx
  40d867:	e9 0e ff ff ff       	jmpq   40d77a <resume_solution+0x32fa>
        switch (FC_SOLVE_MAP_CHAR(*string))
  40d86c:	80 fa 4b             	cmp    $0x4b,%dl
  40d86f:	74 39                	je     40d8aa <resume_solution+0x342a>
  40d871:	7e 28                	jle    40d89b <resume_solution+0x341b>
  40d873:	80 fa 51             	cmp    $0x51,%dl
  40d876:	74 19                	je     40d891 <resume_solution+0x3411>
  40d878:	80 fa 54             	cmp    $0x54,%dl
  40d87b:	75 c8                	jne    40d845 <resume_solution+0x33c5>
            return 10;
  40d87d:	ba 0a 00 00 00       	mov    $0xa,%edx
  40d882:	e9 f3 fe ff ff       	jmpq   40d77a <resume_solution+0x32fa>
            return 1;
  40d887:	ba 01 00 00 00       	mov    $0x1,%edx
  40d88c:	e9 e9 fe ff ff       	jmpq   40d77a <resume_solution+0x32fa>
            return 12;
  40d891:	ba 0c 00 00 00       	mov    $0xc,%edx
  40d896:	e9 df fe ff ff       	jmpq   40d77a <resume_solution+0x32fa>
        switch (FC_SOLVE_MAP_CHAR(*string))
  40d89b:	80 fa 4a             	cmp    $0x4a,%dl
  40d89e:	75 a5                	jne    40d845 <resume_solution+0x33c5>
            return 11;
  40d8a0:	ba 0b 00 00 00       	mov    $0xb,%edx
  40d8a5:	e9 d0 fe ff ff       	jmpq   40d77a <resume_solution+0x32fa>
            return 13;
  40d8aa:	ba 0d 00 00 00       	mov    $0xd,%edx
  40d8af:	e9 c6 fe ff ff       	jmpq   40d77a <resume_solution+0x32fa>
        switch (FC_SOLVE_MAP_CHAR(*string))
  40d8b4:	80 fa 0d             	cmp    $0xd,%dl
  40d8b7:	0f 84 0b f5 ff ff    	je     40cdc8 <resume_solution+0x2948>
  40d8bd:	0f 8e 6c ff ff ff    	jle    40d82f <resume_solution+0x33af>
  40d8c3:	80 fa 32             	cmp    $0x32,%dl
  40d8c6:	74 3c                	je     40d904 <resume_solution+0x3484>
  40d8c8:	7e 2c                	jle    40d8f6 <resume_solution+0x3476>
  40d8ca:	80 fa 33             	cmp    $0x33,%dl
  40d8cd:	74 1d                	je     40d8ec <resume_solution+0x346c>
  40d8cf:	80 fa 34             	cmp    $0x34,%dl
  40d8d2:	0f 85 6d ff ff ff    	jne    40d845 <resume_solution+0x33c5>
            return 4;
  40d8d8:	ba 04 00 00 00       	mov    $0x4,%edx
  40d8dd:	e9 98 fe ff ff       	jmpq   40d77a <resume_solution+0x32fa>
            return 5;
  40d8e2:	ba 05 00 00 00       	mov    $0x5,%edx
  40d8e7:	e9 8e fe ff ff       	jmpq   40d77a <resume_solution+0x32fa>
            return 3;
  40d8ec:	ba 03 00 00 00       	mov    $0x3,%edx
  40d8f1:	e9 84 fe ff ff       	jmpq   40d77a <resume_solution+0x32fa>
        switch (FC_SOLVE_MAP_CHAR(*string))
  40d8f6:	80 fa 20             	cmp    $0x20,%dl
  40d8f9:	0f 84 c9 f4 ff ff    	je     40cdc8 <resume_solution+0x2948>
  40d8ff:	e9 41 ff ff ff       	jmpq   40d845 <resume_solution+0x33c5>
            return 2;
  40d904:	ba 02 00 00 00       	mov    $0x2,%edx
  40d909:	e9 6c fe ff ff       	jmpq   40d77a <resume_solution+0x32fa>
        queue_last_item = my_brfs_queue_last_item;
  40d90e:	48 8b 85 18 ff ff ff 	mov    -0xe8(%rbp),%rax
  40d915:	e9 56 e1 ff ff       	jmpq   40ba70 <resume_solution+0x15f0>
            return 5;
  40d91a:	ba 05 00 00 00       	mov    $0x5,%edx
  40d91f:	e9 b4 f2 ff ff       	jmpq   40cbd8 <resume_solution+0x2758>
            return 1;
  40d924:	ba 01 00 00 00       	mov    $0x1,%edx
  40d929:	e9 aa f2 ff ff       	jmpq   40cbd8 <resume_solution+0x2758>
        switch (FC_SOLVE_MAP_CHAR(*string))
  40d92e:	80 fa 0d             	cmp    $0xd,%dl
  40d931:	0f 84 91 f4 ff ff    	je     40cdc8 <resume_solution+0x2948>
  40d937:	0f 8e 75 f4 ff ff    	jle    40cdb2 <resume_solution+0x2932>
  40d93d:	80 fa 32             	cmp    $0x32,%dl
  40d940:	74 59                	je     40d99b <resume_solution+0x351b>
  40d942:	7e 61                	jle    40d9a5 <resume_solution+0x3525>
  40d944:	80 fa 33             	cmp    $0x33,%dl
  40d947:	74 48                	je     40d991 <resume_solution+0x3511>
  40d949:	80 fa 34             	cmp    $0x34,%dl
  40d94c:	75 60                	jne    40d9ae <resume_solution+0x352e>
            return 4;
  40d94e:	ba 04 00 00 00       	mov    $0x4,%edx
  40d953:	e9 80 f2 ff ff       	jmpq   40cbd8 <resume_solution+0x2758>
            return 8;
  40d958:	ba 08 00 00 00       	mov    $0x8,%edx
  40d95d:	e9 76 f2 ff ff       	jmpq   40cbd8 <resume_solution+0x2758>
            return 6;
  40d962:	ba 06 00 00 00       	mov    $0x6,%edx
  40d967:	e9 6c f2 ff ff       	jmpq   40cbd8 <resume_solution+0x2758>
            return 7;
  40d96c:	ba 07 00 00 00       	mov    $0x7,%edx
  40d971:	e9 62 f2 ff ff       	jmpq   40cbd8 <resume_solution+0x2758>
        switch (FC_SOLVE_MAP_CHAR(*string))
  40d976:	80 fa 4b             	cmp    $0x4b,%dl
  40d979:	74 55                	je     40d9d0 <resume_solution+0x3550>
  40d97b:	7e 44                	jle    40d9c1 <resume_solution+0x3541>
  40d97d:	80 fa 51             	cmp    $0x51,%dl
  40d980:	74 35                	je     40d9b7 <resume_solution+0x3537>
  40d982:	80 fa 54             	cmp    $0x54,%dl
  40d985:	75 27                	jne    40d9ae <resume_solution+0x352e>
            return 10;
  40d987:	ba 0a 00 00 00       	mov    $0xa,%edx
  40d98c:	e9 47 f2 ff ff       	jmpq   40cbd8 <resume_solution+0x2758>
            return 3;
  40d991:	ba 03 00 00 00       	mov    $0x3,%edx
  40d996:	e9 3d f2 ff ff       	jmpq   40cbd8 <resume_solution+0x2758>
            return 2;
  40d99b:	ba 02 00 00 00       	mov    $0x2,%edx
  40d9a0:	e9 33 f2 ff ff       	jmpq   40cbd8 <resume_solution+0x2758>
        switch (FC_SOLVE_MAP_CHAR(*string))
  40d9a5:	80 fa 20             	cmp    $0x20,%dl
  40d9a8:	0f 84 1a f4 ff ff    	je     40cdc8 <resume_solution+0x2948>
            ++string;
  40d9ae:	48 83 c1 01          	add    $0x1,%rcx
  40d9b2:	e9 da f1 ff ff       	jmpq   40cb91 <resume_solution+0x2711>
            return 12;
  40d9b7:	ba 0c 00 00 00       	mov    $0xc,%edx
  40d9bc:	e9 17 f2 ff ff       	jmpq   40cbd8 <resume_solution+0x2758>
        switch (FC_SOLVE_MAP_CHAR(*string))
  40d9c1:	80 fa 4a             	cmp    $0x4a,%dl
  40d9c4:	75 e8                	jne    40d9ae <resume_solution+0x352e>
            return 11;
  40d9c6:	ba 0b 00 00 00       	mov    $0xb,%edx
  40d9cb:	e9 08 f2 ff ff       	jmpq   40cbd8 <resume_solution+0x2758>
            return 13;
  40d9d0:	ba 0d 00 00 00       	mov    $0xd,%edx
  40d9d5:	e9 fe f1 ff ff       	jmpq   40cbd8 <resume_solution+0x2758>
    if (!is_befs)
  40d9da:	48 8b 85 18 ff ff ff 	mov    -0xe8(%rbp),%rax
  40d9e1:	e9 95 e0 ff ff       	jmpq   40ba7b <resume_solution+0x15fb>
  40d9e6:	4c 89 e6             	mov    %r12,%rsi
  40d9e9:	48 c1 e6 04          	shl    $0x4,%rsi
  40d9ed:	e9 33 d5 ff ff       	jmpq   40af25 <resume_solution+0xaa5>
    if (!flare->instance_is_ready)
  40d9f2:	48 8b 85 f0 fe ff ff 	mov    -0x110(%rbp),%rax
  40d9f9:	80 b8 bc 05 00 00 00 	cmpb   $0x0,0x5bc(%rax)
  40da00:	74 4c                	je     40da4e <resume_solution+0x35ce>
        user->init_num_checked_states = initial_stats;
  40da02:	48 8b 85 f0 fe ff ff 	mov    -0x110(%rbp),%rax
  40da09:	48 c7 80 d0 05 00 00 	movq   $0x0,0x5d0(%rax)
  40da10:	00 00 00 00 
        flare->ret_code = FCS_STATE_NOT_BEGAN_YET;
  40da14:	c7 80 b8 05 00 00 09 	movl   $0x9,0x5b8(%rax)
  40da1b:	00 00 00 
    flare->obj_stats = initial_stats;
  40da1e:	48 c7 80 c0 05 00 00 	movq   $0x0,0x5c0(%rax)
  40da25:	00 00 00 00 
  40da29:	e9 56 cb ff ff       	jmpq   40a584 <resume_solution+0x104>
            user->init_num_checked_states = flare->obj_stats;
  40da2e:	48 89 c7             	mov    %rax,%rdi
  40da31:	48 8b 80 c0 05 00 00 	mov    0x5c0(%rax),%rax
            ret = user->ret_code = FCS_STATE_WAS_SOLVED;
  40da38:	c7 87 38 06 00 00 00 	movl   $0x0,0x638(%rdi)
  40da3f:	00 00 00 
            user->init_num_checked_states = flare->obj_stats;
  40da42:	48 89 87 d0 05 00 00 	mov    %rax,0x5d0(%rdi)
  40da49:	e9 36 cb ff ff       	jmpq   40a584 <resume_solution+0x104>
    fc_solve_finish_instance(instance);
  40da4e:	49 89 c7             	mov    %rax,%r15
  40da51:	48 89 c7             	mov    %rax,%rdi
  40da54:	e8 c7 3c ff ff       	callq  401720 <fc_solve_finish_instance>
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40da59:	49 8b 87 d8 00 00 00 	mov    0xd8(%r15),%rax
    HT_FIELD(hard_thread, ht__max_num_checked_states) = FCS_INT_LIMIT_MAX;
  40da60:	48 bf ff ff ff ff ff 	movabs $0x7fffffffffffffff,%rdi
  40da67:	ff ff 7f 
    instance->i__num_checked_states = 0;
  40da6a:	49 c7 07 00 00 00 00 	movq   $0x0,(%r15)
  40da71:	49 89 bf c8 00 00 00 	mov    %rdi,0xc8(%r15)
    meta_allocator *const meta = allocator->meta;
  40da78:	49 8b 97 f8 00 00 00 	mov    0xf8(%r15),%rdx
    instance->num_hard_threads_finished = 0;
  40da7f:	49 c7 87 40 05 00 00 	movq   $0x0,0x540(%r15)
  40da86:	00 00 00 00 
    HT_FIELD(hard_thread, num_soft_threads_finished) = 0;
  40da8a:	41 c7 87 28 05 00 00 	movl   $0x0,0x528(%r15)
  40da91:	00 00 00 00 
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40da95:	48 8b 38             	mov    (%rax),%rdi
    var_AUTO(bin, meta->recycle_bin);
  40da98:	48 8b 0a             	mov    (%rdx),%rcx
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40da9b:	48 85 ff             	test   %rdi,%rdi
  40da9e:	74 14                	je     40dab4 <resume_solution+0x3634>
  40daa0:	48 89 c6             	mov    %rax,%rsi
  40daa3:	48 89 f8             	mov    %rdi,%rax
        OLD_LIST_NEXT(iter) = bin;
  40daa6:	48 89 0e             	mov    %rcx,(%rsi)
         iter = iter_next, iter_next = OLD_LIST_NEXT(iter))
  40daa9:	48 8b 3f             	mov    (%rdi),%rdi
  40daac:	48 89 f1             	mov    %rsi,%rcx
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40daaf:	48 85 ff             	test   %rdi,%rdi
  40dab2:	75 ec                	jne    40daa0 <resume_solution+0x3620>
  40dab4:	48 8b bd f0 fe ff ff 	mov    -0x110(%rbp),%rdi
    OLD_LIST_NEXT(iter) = bin;
  40dabb:	48 89 08             	mov    %rcx,(%rax)
    meta->recycle_bin = iter;
  40dabe:	48 89 02             	mov    %rax,(%rdx)
    ST_LOOP_START()
  40dac1:	4c 69 af 20 05 00 00 	imul   $0x1f8,0x520(%rdi),%r13
  40dac8:	f8 01 00 00 
  40dacc:	48 c7 87 d8 00 00 00 	movq   $0x0,0xd8(%rdi)
  40dad3:	00 00 00 00 
  40dad7:	4c 8b a7 c0 00 00 00 	mov    0xc0(%rdi),%r12
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  40dade:	48 8b 08             	mov    (%rax),%rcx
  40dae1:	4d 01 e5             	add    %r12,%r13
  40dae4:	48 89 0a             	mov    %rcx,(%rdx)
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40dae7:	48 8d 50 08          	lea    0x8(%rax),%rdx
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  40daeb:	48 c7 00 00 00 00 00 	movq   $0x0,(%rax)
    allocator->old_list = new_data;
  40daf2:	48 89 87 d8 00 00 00 	mov    %rax,0xd8(%rdi)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40daf9:	48 05 80 fe 00 00    	add    $0xfe80,%rax
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40daff:	48 89 97 f0 00 00 00 	mov    %rdx,0xf0(%rdi)
  40db06:	48 89 97 e8 00 00 00 	mov    %rdx,0xe8(%rdi)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40db0d:	48 89 87 e0 00 00 00 	mov    %rax,0xe0(%rdi)
  40db14:	4d 39 ec             	cmp    %r13,%r12
  40db17:	73 31                	jae    40db4a <resume_solution+0x36ca>
    free(pq->elems);
  40db19:	49 8b bc 24 00 01 00 	mov    0x100(%r12),%rdi
  40db20:	00 
  40db21:	49 81 c4 f8 01 00 00 	add    $0x1f8,%r12
  40db28:	e8 23 35 ff ff       	callq  401050 <free@plt>
    STRUCT_CLEAR_FLAG(soft_thread, FCS_SOFT_THREAD_IS_FINISHED);
  40db2d:	41 c6 44 24 e8 00    	movb   $0x0,-0x18(%r12)
    pq->elems = NULL;
  40db33:	49 c7 84 24 08 ff ff 	movq   $0x0,-0xf8(%r12)
  40db3a:	ff 00 00 00 00 
    STRUCT_CLEAR_FLAG(soft_thread, FCS_SOFT_THREAD_INITIALIZED);
  40db3f:	41 c6 44 24 e9 00    	movb   $0x0,-0x17(%r12)
  40db45:	4d 39 e5             	cmp    %r12,%r13
  40db48:	77 cf                	ja     40db19 <resume_solution+0x3699>
        flare->instance_is_ready = TRUE;
  40db4a:	48 8b 85 f0 fe ff ff 	mov    -0x110(%rbp),%rax
  40db51:	c6 80 bc 05 00 00 01 	movb   $0x1,0x5bc(%rax)
  40db58:	e9 a5 fe ff ff       	jmpq   40da02 <resume_solution+0x3582>
        switch (FC_SOLVE_MAP_CHAR(*suit))
  40db5d:	84 c9                	test   %cl,%cl
  40db5f:	74 09                	je     40db6a <resume_solution+0x36ea>
  40db61:	80 f9 20             	cmp    $0x20,%cl
  40db64:	0f 85 9e f0 ff ff    	jne    40cc08 <resume_solution+0x2788>
            return 0;
  40db6a:	31 c9                	xor    %ecx,%ecx
  40db6c:	e9 7a f2 ff ff       	jmpq   40cdeb <resume_solution+0x296b>
            return 1;
  40db71:	b9 01 00 00 00       	mov    $0x1,%ecx
  40db76:	e9 70 f2 ff ff       	jmpq   40cdeb <resume_solution+0x296b>
  40db7b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)

000000000040db80 <worker_thread>:
{
  40db80:	55                   	push   %rbp
    fcs_user *const ret = (fcs_user *)SMALLOC1(ret);
  40db81:	bf 50 12 00 00       	mov    $0x1250,%edi
  40db86:	48 89 e5             	mov    %rsp,%rbp
  40db89:	41 57                	push   %r15
  40db8b:	41 56                	push   %r14
  40db8d:	41 55                	push   %r13
  40db8f:	41 54                	push   %r12
  40db91:	41 52                	push   %r10
  40db93:	53                   	push   %rbx
  40db94:	48 81 ec 80 02 00 00 	sub    $0x280,%rsp
  40db9b:	e8 50 35 ff ff       	callq  4010f0 <malloc@plt>
    *(instance) = (fcs_instance){
  40dba0:	ba b8 05 00 00       	mov    $0x5b8,%edx
  40dba5:	31 f6                	xor    %esi,%esi
    fcs_user *const ret = (fcs_user *)SMALLOC1(ret);
  40dba7:	49 89 c7             	mov    %rax,%r15
    *(instance) = (fcs_instance){
  40dbaa:	48 89 c7             	mov    %rax,%rdi
    meta->recycle_bin = NULL;
  40dbad:	48 c7 80 48 12 00 00 	movq   $0x0,0x1248(%rax)
  40dbb4:	00 00 00 00 
    user->iterations_board_started_at = initial_stats;
  40dbb8:	48 c7 80 c8 05 00 00 	movq   $0x0,0x5c8(%rax)
  40dbbf:	00 00 00 00 
    *(instance) = (fcs_instance){
  40dbc3:	e8 d8 34 ff ff       	callq  4010a0 <memset@plt>
    alloc_instance(instance, &(user->meta_alloc));
  40dbc8:	49 8d 87 48 12 00 00 	lea    0x1248(%r15),%rax
    fc_solve_apply_moves_order(&(instance->instance_moves_order),
  40dbcf:	be 25 f0 40 00       	mov    $0x40f025,%esi
    *(instance) = (fcs_instance){
  40dbd4:	41 c6 87 b8 00 00 00 	movb   $0x1,0xb8(%r15)
  40dbdb:	01 
    fc_solve_apply_moves_order(&(instance->instance_moves_order),
  40dbdc:	49 8d bf 30 05 00 00 	lea    0x530(%r15),%rdi
    alloc_instance(instance, &(user->meta_alloc));
  40dbe3:	49 89 87 b0 05 00 00 	mov    %rax,0x5b0(%r15)
    fc_solve_apply_moves_order(&(instance->instance_moves_order),
  40dbea:	e8 01 c1 ff ff       	callq  409cf0 <fc_solve_apply_moves_order>
    fc_solve_new_soft_thread(hard_thread);
  40dbef:	4c 89 ff             	mov    %r15,%rdi
    HT_FIELD(hard_thread, num_soft_threads) = 0;
  40dbf2:	49 c7 87 20 05 00 00 	movq   $0x0,0x520(%r15)
  40dbf9:	00 00 00 00 
    HT_FIELD(hard_thread, soft_threads) = NULL;
  40dbfd:	49 c7 87 c0 00 00 00 	movq   $0x0,0xc0(%r15)
  40dc04:	00 00 00 00 
    fc_solve_new_soft_thread(hard_thread);
  40dc08:	e8 13 39 ff ff       	callq  401520 <fc_solve_new_soft_thread>
    fc_solve_compact_allocator_init(&(HT_FIELD(hard_thread, allocator)),
  40dc0d:	49 8b 97 b0 05 00 00 	mov    0x5b0(%r15),%rdx
    HT_FIELD(hard_thread, ht__max_num_checked_states) = FCS_INT_LIMIT_MAX;
  40dc14:	48 b8 ff ff ff ff ff 	movabs $0x7fffffffffffffff,%rax
  40dc1b:	ff ff 7f 
    HT_FIELD(hard_thread, prelude) = NULL;
  40dc1e:	49 c7 87 10 05 00 00 	movq   $0x0,0x510(%r15)
  40dc25:	00 00 00 00 
  40dc29:	49 89 87 c8 00 00 00 	mov    %rax,0xc8(%r15)
    HT_FIELD(hard_thread, prelude_num_items) = 0;
  40dc30:	49 c7 87 00 05 00 00 	movq   $0x0,0x500(%r15)
  40dc37:	00 00 00 00 
    HT_FIELD(hard_thread, num_soft_threads_finished) = 0;
  40dc3b:	41 c7 87 28 05 00 00 	movl   $0x0,0x528(%r15)
  40dc42:	00 00 00 00 
    char *const ret = meta_alloc->recycle_bin;
  40dc46:	48 8b 02             	mov    (%rdx),%rax
    allocator->meta = meta_alloc;
  40dc49:	49 89 97 f8 00 00 00 	mov    %rdx,0xf8(%r15)
    allocator->old_list = NULL;
  40dc50:	49 c7 87 d8 00 00 00 	movq   $0x0,0xd8(%r15)
  40dc57:	00 00 00 00 
    if (ret)
  40dc5b:	48 85 c0             	test   %rax,%rax
  40dc5e:	0f 84 d7 11 00 00    	je     40ee3b <worker_thread+0x12bb>
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  40dc64:	48 8b 08             	mov    (%rax),%rcx
  40dc67:	48 89 0a             	mov    %rcx,(%rdx)
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  40dc6a:	48 c7 00 00 00 00 00 	movq   $0x0,(%rax)
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40dc71:	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));
  40dc75:	31 f6                	xor    %esi,%esi
  40dc77:	4c 89 ff             	mov    %r15,%rdi
    allocator->old_list = new_data;
  40dc7a:	49 89 87 d8 00 00 00 	mov    %rax,0xd8(%r15)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40dc81:	48 05 80 fe 00 00    	add    $0xfe80,%rax
  40dc87:	49 89 87 e0 00 00 00 	mov    %rax,0xe0(%r15)
    user->soft_thread = &(INST_HT0(instance).soft_threads[0]);
  40dc8e:	49 8b 87 c0 00 00 00 	mov    0xc0(%r15),%rax
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40dc95:	49 89 97 f0 00 00 00 	mov    %rdx,0xf0(%r15)
  40dc9c:	49 89 97 e8 00 00 00 	mov    %rdx,0xe8(%r15)
  40dca3:	ba 34 f0 40 00       	mov    $0x40f034,%edx
    user->ret_code = flare->ret_code = FCS_STATE_NOT_BEGAN_YET;
  40dca8:	41 c7 87 b8 05 00 00 	movl   $0x9,0x5b8(%r15)
  40dcaf:	09 00 00 00 
    user->soft_thread = &(INST_HT0(instance).soft_threads[0]);
  40dcb3:	49 89 87 40 06 00 00 	mov    %rax,0x640(%r15)
    user->ret_code = flare->ret_code = FCS_STATE_NOT_BEGAN_YET;
  40dcba:	41 c7 87 38 06 00 00 	movl   $0x9,0x638(%r15)
  40dcc1:	09 00 00 00 
    flare->instance_is_ready = TRUE;
  40dcc5:	41 c6 87 bc 05 00 00 	movb   $0x1,0x5bc(%r15)
  40dccc:	01 
    flare->obj_stats = initial_stats;
  40dccd:	49 c7 87 c0 05 00 00 	movq   $0x0,0x5c0(%r15)
  40dcd4:	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 =
  40dcd8:	c6 80 f1 01 00 00 01 	movb   $0x1,0x1f1(%rax)
    }
    break;
#endif
    }

    soft_thread->super_method_type = super_method_type;
  40dcdf:	c7 40 20 00 00 00 00 	movl   $0x0,0x20(%rax)
  40dce6:	e8 15 c5 ff ff       	callq  40a200 <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));
  40dceb:	4c 89 ff             	mov    %r15,%rdi
  40dcee:	ba 3b f0 40 00       	mov    $0x40f03b,%edx
  40dcf3:	be 21 00 00 00       	mov    $0x21,%esi
  40dcf8:	e8 03 c5 ff ff       	callq  40a200 <freecell_solver_user_set_depth_tests_order>
    return ((fcs_user *const)api_instance)->soft_thread;
  40dcfd:	49 8b 87 40 06 00 00 	mov    0x640(%r15),%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(
  40dd04:	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;
  40dd07:	c6 80 f0 01 00 00 01 	movb   $0x1,0x1f0(%rax)
    api_soft_thread(api_instance)->checked_states_step = checked_states_step;
  40dd0e:	48 c7 80 e8 01 00 00 	movq   $0x1f4,0x1e8(%rax)
  40dd15:	f4 01 00 00 
    const_AUTO(
  40dd19:	e8 02 38 ff ff       	callq  401520 <fc_solve_new_soft_thread>
    if (soft_thread == NULL)
  40dd1e:	48 85 c0             	test   %rax,%rax
  40dd21:	0f 84 a8 10 00 00    	je     40edcf <worker_thread+0x124f>
    user->soft_thread = soft_thread;
  40dd27:	49 89 87 40 06 00 00 	mov    %rax,0x640(%r15)
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));
  40dd2e:	31 f6                	xor    %esi,%esi
  40dd30:	ba 4c f0 40 00       	mov    $0x40f04c,%edx
  40dd35:	4c 89 ff             	mov    %r15,%rdi
        soft_thread->master_to_randomize =
  40dd38:	c6 80 f1 01 00 00 01 	movb   $0x1,0x1f1(%rax)
    soft_thread->super_method_type = super_method_type;
  40dd3f:	c7 40 20 00 00 00 00 	movl   $0x0,0x20(%rax)
  40dd46:	e8 b5 c4 ff ff       	callq  40a200 <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));
  40dd4b:	4c 89 ff             	mov    %r15,%rdi
  40dd4e:	ba 3b f0 40 00       	mov    $0x40f03b,%edx
  40dd53:	be 37 00 00 00       	mov    $0x37,%esi
  40dd58:	e8 a3 c4 ff ff       	callq  40a200 <freecell_solver_user_set_depth_tests_order>
    return ((fcs_user *const)api_instance)->soft_thread;
  40dd5d:	49 8b 87 40 06 00 00 	mov    0x640(%r15),%rax
    const_AUTO(
  40dd64:	48 8b 38             	mov    (%rax),%rdi
        soft_thread->enable_pruning = TRUE;
  40dd67:	c6 80 f0 01 00 00 01 	movb   $0x1,0x1f0(%rax)
    api_soft_thread(api_instance)->checked_states_step = checked_states_step;
  40dd6e:	48 c7 80 e8 01 00 00 	movq   $0x1f4,0x1e8(%rax)
  40dd75:	f4 01 00 00 
    const_AUTO(
  40dd79:	e8 a2 37 ff ff       	callq  401520 <fc_solve_new_soft_thread>
    if (soft_thread == NULL)
  40dd7e:	48 85 c0             	test   %rax,%rax
  40dd81:	0f 84 3c 10 00 00    	je     40edc3 <worker_thread+0x1243>
    user->soft_thread = soft_thread;
  40dd87:	49 89 87 40 06 00 00 	mov    %rax,0x640(%r15)
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));
  40dd8e:	31 f6                	xor    %esi,%esi
  40dd90:	4c 89 ff             	mov    %r15,%rdi
        soft_thread->master_to_randomize =
  40dd93:	c6 80 f1 01 00 00 01 	movb   $0x1,0x1f1(%rax)
  40dd9a:	ba 66 f0 40 00       	mov    $0x40f066,%edx
    soft_thread->super_method_type = super_method_type;
  40dd9f:	c7 40 20 00 00 00 00 	movl   $0x0,0x20(%rax)
    DFS_VAR(api_soft_thread(api_instance), rand_seed) = seed;
  40dda6:	c7 40 48 06 00 00 00 	movl   $0x6,0x48(%rax)
  40ddad:	e8 4e c4 ff ff       	callq  40a200 <freecell_solver_user_set_depth_tests_order>
    return ((fcs_user *const)api_instance)->soft_thread;
  40ddb2:	49 8b 87 40 06 00 00 	mov    0x640(%r15),%rax
    const_AUTO(
  40ddb9:	48 8b 38             	mov    (%rax),%rdi
        soft_thread->enable_pruning = TRUE;
  40ddbc:	c6 80 f0 01 00 00 01 	movb   $0x1,0x1f0(%rax)
    api_soft_thread(api_instance)->checked_states_step = checked_states_step;
  40ddc3:	48 c7 80 e8 01 00 00 	movq   $0x1f4,0x1e8(%rax)
  40ddca:	f4 01 00 00 
    const_AUTO(
  40ddce:	e8 4d 37 ff ff       	callq  401520 <fc_solve_new_soft_thread>
    if (soft_thread == NULL)
  40ddd3:	48 85 c0             	test   %rax,%rax
  40ddd6:	0f 84 db 0f 00 00    	je     40edb7 <worker_thread+0x1237>
    user->soft_thread = soft_thread;
  40dddc:	49 89 87 40 06 00 00 	mov    %rax,0x640(%r15)
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));
  40dde3:	31 f6                	xor    %esi,%esi
  40dde5:	ba 6f f0 40 00       	mov    $0x40f06f,%edx
  40ddea:	4c 89 ff             	mov    %r15,%rdi
        soft_thread->master_to_randomize =
  40dded:	c6 80 f1 01 00 00 01 	movb   $0x1,0x1f1(%rax)
    soft_thread->super_method_type = super_method_type;
  40ddf4:	c7 40 20 00 00 00 00 	movl   $0x0,0x20(%rax)
  40ddfb:	e8 00 c4 ff ff       	callq  40a200 <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));
  40de00:	ba 78 f0 40 00       	mov    $0x40f078,%edx
  40de05:	be 09 00 00 00       	mov    $0x9,%esi
  40de0a:	4c 89 ff             	mov    %r15,%rdi
  40de0d:	e8 ee c3 ff ff       	callq  40a200 <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));
  40de12:	4c 89 ff             	mov    %r15,%rdi
  40de15:	ba 84 f0 40 00       	mov    $0x40f084,%edx
  40de1a:	be 0f 00 00 00       	mov    $0xf,%esi
  40de1f:	e8 dc c3 ff ff       	callq  40a200 <freecell_solver_user_set_depth_tests_order>
    return ((fcs_user *const)api_instance)->soft_thread;
  40de24:	49 8b 87 40 06 00 00 	mov    0x640(%r15),%rax
    const_AUTO(
  40de2b:	48 8b 38             	mov    (%rax),%rdi
    DFS_VAR(api_soft_thread(api_instance), rand_seed) = seed;
  40de2e:	c7 40 48 e4 28 00 00 	movl   $0x28e4,0x48(%rax)
    api_soft_thread(api_instance)->checked_states_step = checked_states_step;
  40de35:	48 c7 80 e8 01 00 00 	movq   $0x1f4,0x1e8(%rax)
  40de3c:	f4 01 00 00 
        soft_thread->enable_pruning = TRUE;
  40de40:	c6 80 f0 01 00 00 01 	movb   $0x1,0x1f0(%rax)
    const_AUTO(
  40de47:	e8 d4 36 ff ff       	callq  401520 <fc_solve_new_soft_thread>
    if (soft_thread == NULL)
  40de4c:	48 85 c0             	test   %rax,%rax
  40de4f:	0f 84 56 0f 00 00    	je     40edab <worker_thread+0x122b>
    user->soft_thread = soft_thread;
  40de55:	49 89 87 40 06 00 00 	mov    %rax,0x640(%r15)
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));
  40de5c:	31 f6                	xor    %esi,%esi
  40de5e:	ba 96 f0 40 00       	mov    $0x40f096,%edx
  40de63:	4c 89 ff             	mov    %r15,%rdi
        soft_thread->master_to_randomize =
  40de66:	c6 80 f1 01 00 00 01 	movb   $0x1,0x1f1(%rax)
    soft_thread->super_method_type = super_method_type;
  40de6d:	c7 40 20 00 00 00 00 	movl   $0x0,0x20(%rax)
  40de74:	e8 87 c3 ff ff       	callq  40a200 <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));
  40de79:	4c 89 ff             	mov    %r15,%rdi
  40de7c:	ba a0 f0 40 00       	mov    $0x40f0a0,%edx
  40de81:	be 09 00 00 00       	mov    $0x9,%esi
  40de86:	e8 75 c3 ff ff       	callq  40a200 <freecell_solver_user_set_depth_tests_order>
    return ((fcs_user *const)api_instance)->soft_thread;
  40de8b:	49 8b 87 40 06 00 00 	mov    0x640(%r15),%rax
    const_AUTO(
  40de92:	48 8b 38             	mov    (%rax),%rdi
    DFS_VAR(api_soft_thread(api_instance), rand_seed) = seed;
  40de95:	c7 40 48 da ac 00 00 	movl   $0xacda,0x48(%rax)
    api_soft_thread(api_instance)->checked_states_step = checked_states_step;
  40de9c:	48 c7 80 e8 01 00 00 	movq   $0x1f4,0x1e8(%rax)
  40dea3:	f4 01 00 00 
        soft_thread->enable_pruning = TRUE;
  40dea7:	c6 80 f0 01 00 00 01 	movb   $0x1,0x1f0(%rax)
    const_AUTO(
  40deae:	e8 6d 36 ff ff       	callq  401520 <fc_solve_new_soft_thread>
    if (soft_thread == NULL)
  40deb3:	48 85 c0             	test   %rax,%rax
  40deb6:	0f 84 73 0f 00 00    	je     40ee2f <worker_thread+0x12af>
    user->soft_thread = soft_thread;
  40debc:	49 89 87 40 06 00 00 	mov    %rax,0x640(%r15)
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));
  40dec3:	31 f6                	xor    %esi,%esi
  40dec5:	ba aa f0 40 00       	mov    $0x40f0aa,%edx
  40deca:	4c 89 ff             	mov    %r15,%rdi
        soft_thread->master_to_randomize =
  40decd:	c6 80 f1 01 00 00 01 	movb   $0x1,0x1f1(%rax)
    soft_thread->super_method_type = super_method_type;
  40ded4:	c7 40 20 00 00 00 00 	movl   $0x0,0x20(%rax)
  40dedb:	e8 20 c3 ff ff       	callq  40a200 <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));
  40dee0:	ba b6 f0 40 00       	mov    $0x40f0b6,%edx
  40dee5:	be 05 00 00 00       	mov    $0x5,%esi
  40deea:	4c 89 ff             	mov    %r15,%rdi
  40deed:	e8 0e c3 ff ff       	callq  40a200 <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));
  40def2:	4c 89 ff             	mov    %r15,%rdi
  40def5:	ba c3 f0 40 00       	mov    $0x40f0c3,%edx
  40defa:	be 0d 00 00 00       	mov    $0xd,%esi
  40deff:	e8 fc c2 ff ff       	callq  40a200 <freecell_solver_user_set_depth_tests_order>
    return ((fcs_user *const)api_instance)->soft_thread;
  40df04:	49 8b 87 40 06 00 00 	mov    0x640(%r15),%rax
    const_AUTO(
  40df0b:	48 8b 38             	mov    (%rax),%rdi
    DFS_VAR(api_soft_thread(api_instance), rand_seed) = seed;
  40df0e:	c7 40 48 78 47 00 00 	movl   $0x4778,0x48(%rax)
    api_soft_thread(api_instance)->checked_states_step = checked_states_step;
  40df15:	48 c7 80 e8 01 00 00 	movq   $0x1f4,0x1e8(%rax)
  40df1c:	f4 01 00 00 
        soft_thread->enable_pruning = TRUE;
  40df20:	c6 80 f0 01 00 00 01 	movb   $0x1,0x1f0(%rax)
    const_AUTO(
  40df27:	e8 f4 35 ff ff       	callq  401520 <fc_solve_new_soft_thread>
    if (soft_thread == NULL)
  40df2c:	48 85 c0             	test   %rax,%rax
  40df2f:	0f 84 ee 0e 00 00    	je     40ee23 <worker_thread+0x12a3>
    user->soft_thread = soft_thread;
  40df35:	49 89 87 40 06 00 00 	mov    %rax,0x640(%r15)
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));
  40df3c:	31 f6                	xor    %esi,%esi
  40df3e:	ba aa f0 40 00       	mov    $0x40f0aa,%edx
  40df43:	4c 89 ff             	mov    %r15,%rdi
        soft_thread->master_to_randomize =
  40df46:	c6 80 f1 01 00 00 01 	movb   $0x1,0x1f1(%rax)
    soft_thread->super_method_type = super_method_type;
  40df4d:	c7 40 20 00 00 00 00 	movl   $0x0,0x20(%rax)
  40df54:	e8 a7 c2 ff ff       	callq  40a200 <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));
  40df59:	ba b6 f0 40 00       	mov    $0x40f0b6,%edx
  40df5e:	be 05 00 00 00       	mov    $0x5,%esi
  40df63:	4c 89 ff             	mov    %r15,%rdi
  40df66:	e8 95 c2 ff ff       	callq  40a200 <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));
  40df6b:	4c 89 ff             	mov    %r15,%rdi
  40df6e:	ba c3 f0 40 00       	mov    $0x40f0c3,%edx
  40df73:	be 0d 00 00 00       	mov    $0xd,%esi
  40df78:	e8 83 c2 ff ff       	callq  40a200 <freecell_solver_user_set_depth_tests_order>
    return ((fcs_user *const)api_instance)->soft_thread;
  40df7d:	49 8b 87 40 06 00 00 	mov    0x640(%r15),%rax
    const_AUTO(
  40df84:	48 8b 38             	mov    (%rax),%rdi
    DFS_VAR(api_soft_thread(api_instance), rand_seed) = seed;
  40df87:	c7 40 48 5b 83 00 00 	movl   $0x835b,0x48(%rax)
    api_soft_thread(api_instance)->checked_states_step = checked_states_step;
  40df8e:	48 c7 80 e8 01 00 00 	movq   $0x1f4,0x1e8(%rax)
  40df95:	f4 01 00 00 
        soft_thread->enable_pruning = TRUE;
  40df99:	c6 80 f0 01 00 00 01 	movb   $0x1,0x1f0(%rax)
    const_AUTO(
  40dfa0:	e8 7b 35 ff ff       	callq  401520 <fc_solve_new_soft_thread>
    if (soft_thread == NULL)
  40dfa5:	48 85 c0             	test   %rax,%rax
  40dfa8:	0f 84 69 0e 00 00    	je     40ee17 <worker_thread+0x1297>
    user->soft_thread = soft_thread;
  40dfae:	49 89 87 40 06 00 00 	mov    %rax,0x640(%r15)
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));
  40dfb5:	31 f6                	xor    %esi,%esi
  40dfb7:	ba d5 f0 40 00       	mov    $0x40f0d5,%edx
  40dfbc:	4c 89 ff             	mov    %r15,%rdi
        soft_thread->master_to_randomize =
  40dfbf:	c6 80 f1 01 00 00 01 	movb   $0x1,0x1f1(%rax)
    soft_thread->super_method_type = super_method_type;
  40dfc6:	c7 40 20 00 00 00 00 	movl   $0x0,0x20(%rax)
  40dfcd:	e8 2e c2 ff ff       	callq  40a200 <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));
  40dfd2:	ba de f0 40 00       	mov    $0x40f0de,%edx
  40dfd7:	be 0d 00 00 00       	mov    $0xd,%esi
  40dfdc:	4c 89 ff             	mov    %r15,%rdi
  40dfdf:	e8 1c c2 ff ff       	callq  40a200 <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));
  40dfe4:	4c 89 ff             	mov    %r15,%rdi
  40dfe7:	ba ef f0 40 00       	mov    $0x40f0ef,%edx
  40dfec:	be 1a 00 00 00       	mov    $0x1a,%esi
  40dff1:	e8 0a c2 ff ff       	callq  40a200 <freecell_solver_user_set_depth_tests_order>
    return ((fcs_user *const)api_instance)->soft_thread;
  40dff6:	49 8b 87 40 06 00 00 	mov    0x640(%r15),%rax
    const_AUTO(
  40dffd:	48 8b 38             	mov    (%rax),%rdi
        soft_thread->enable_pruning = TRUE;
  40e000:	c6 80 f0 01 00 00 01 	movb   $0x1,0x1f0(%rax)
    api_soft_thread(api_instance)->checked_states_step = checked_states_step;
  40e007:	48 c7 80 e8 01 00 00 	movq   $0x1f4,0x1e8(%rax)
  40e00e:	f4 01 00 00 
    const_AUTO(
  40e012:	e8 09 35 ff ff       	callq  401520 <fc_solve_new_soft_thread>
    if (soft_thread == NULL)
  40e017:	48 85 c0             	test   %rax,%rax
  40e01a:	0f 84 eb 0d 00 00    	je     40ee0b <worker_thread+0x128b>
    user->soft_thread = soft_thread;
  40e020:	49 89 87 40 06 00 00 	mov    %rax,0x640(%r15)
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));
  40e027:	31 f6                	xor    %esi,%esi
  40e029:	4c 89 ff             	mov    %r15,%rdi
        soft_thread->master_to_randomize =
  40e02c:	c6 80 f1 01 00 00 01 	movb   $0x1,0x1f1(%rax)
  40e033:	ba 02 f1 40 00       	mov    $0x40f102,%edx
    soft_thread->super_method_type = super_method_type;
  40e038:	c7 40 20 00 00 00 00 	movl   $0x0,0x20(%rax)
  40e03f:	e8 bc c1 ff ff       	callq  40a200 <freecell_solver_user_set_depth_tests_order>
    return ((fcs_user *const)api_instance)->soft_thread;
  40e044:	49 8b 87 40 06 00 00 	mov    0x640(%r15),%rax
    const_AUTO(
  40e04b:	48 8b 38             	mov    (%rax),%rdi
        soft_thread->enable_pruning = TRUE;
  40e04e:	c6 80 f0 01 00 00 01 	movb   $0x1,0x1f0(%rax)
    api_soft_thread(api_instance)->checked_states_step = checked_states_step;
  40e055:	48 c7 80 e8 01 00 00 	movq   $0x1f4,0x1e8(%rax)
  40e05c:	f4 01 00 00 
    const_AUTO(
  40e060:	e8 bb 34 ff ff       	callq  401520 <fc_solve_new_soft_thread>
    if (soft_thread == NULL)
  40e065:	48 85 c0             	test   %rax,%rax
  40e068:	0f 84 91 0d 00 00    	je     40edff <worker_thread+0x127f>
    user->soft_thread = soft_thread;
  40e06e:	49 89 87 40 06 00 00 	mov    %rax,0x640(%r15)
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));
  40e075:	31 f6                	xor    %esi,%esi
  40e077:	ba 1f f1 40 00       	mov    $0x40f11f,%edx
  40e07c:	4c 89 ff             	mov    %r15,%rdi
        soft_thread->master_to_randomize =
  40e07f:	c6 80 f1 01 00 00 01 	movb   $0x1,0x1f1(%rax)
    soft_thread->super_method_type = super_method_type;
  40e086:	c7 40 20 00 00 00 00 	movl   $0x0,0x20(%rax)
  40e08d:	e8 6e c1 ff ff       	callq  40a200 <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));
  40e092:	ba 24 f1 40 00       	mov    $0x40f124,%edx
  40e097:	be 06 00 00 00       	mov    $0x6,%esi
  40e09c:	4c 89 ff             	mov    %r15,%rdi
  40e09f:	e8 5c c1 ff ff       	callq  40a200 <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));
  40e0a4:	4c 89 ff             	mov    %r15,%rdi
  40e0a7:	ba c3 f0 40 00       	mov    $0x40f0c3,%edx
  40e0ac:	be 0d 00 00 00       	mov    $0xd,%esi
  40e0b1:	e8 4a c1 ff ff       	callq  40a200 <freecell_solver_user_set_depth_tests_order>
    return ((fcs_user *const)api_instance)->soft_thread;
  40e0b6:	49 8b 87 40 06 00 00 	mov    0x640(%r15),%rax
    const_AUTO(
  40e0bd:	48 8b 38             	mov    (%rax),%rdi
        soft_thread->enable_pruning = TRUE;
  40e0c0:	c6 80 f0 01 00 00 01 	movb   $0x1,0x1f0(%rax)
    api_soft_thread(api_instance)->checked_states_step = checked_states_step;
  40e0c7:	48 c7 80 e8 01 00 00 	movq   $0x1f4,0x1e8(%rax)
  40e0ce:	f4 01 00 00 
    const_AUTO(
  40e0d2:	e8 49 34 ff ff       	callq  401520 <fc_solve_new_soft_thread>
    if (soft_thread == NULL)
  40e0d7:	48 85 c0             	test   %rax,%rax
  40e0da:	0f 84 13 0d 00 00    	je     40edf3 <worker_thread+0x1273>
    user->soft_thread = soft_thread;
  40e0e0:	49 89 87 40 06 00 00 	mov    %rax,0x640(%r15)
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));
  40e0e7:	31 f6                	xor    %esi,%esi
  40e0e9:	ba aa f0 40 00       	mov    $0x40f0aa,%edx
  40e0ee:	4c 89 ff             	mov    %r15,%rdi
        soft_thread->master_to_randomize =
  40e0f1:	c6 80 f1 01 00 00 01 	movb   $0x1,0x1f1(%rax)
    soft_thread->super_method_type = super_method_type;
  40e0f8:	c7 40 20 00 00 00 00 	movl   $0x0,0x20(%rax)
  40e0ff:	e8 fc c0 ff ff       	callq  40a200 <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));
  40e104:	4c 89 ff             	mov    %r15,%rdi
  40e107:	ba b6 f0 40 00       	mov    $0x40f0b6,%edx
  40e10c:	be 07 00 00 00       	mov    $0x7,%esi
  40e111:	e8 ea c0 ff ff       	callq  40a200 <freecell_solver_user_set_depth_tests_order>
    return ((fcs_user *const)api_instance)->soft_thread;
  40e116:	49 8b 87 40 06 00 00 	mov    0x640(%r15),%rax
    const_AUTO(
  40e11d:	48 8b 38             	mov    (%rax),%rdi
    DFS_VAR(api_soft_thread(api_instance), rand_seed) = seed;
  40e120:	c7 40 48 39 80 01 00 	movl   $0x18039,0x48(%rax)
    api_soft_thread(api_instance)->checked_states_step = checked_states_step;
  40e127:	48 c7 80 e8 01 00 00 	movq   $0x1f4,0x1e8(%rax)
  40e12e:	f4 01 00 00 
        soft_thread->enable_pruning = TRUE;
  40e132:	c6 80 f0 01 00 00 01 	movb   $0x1,0x1f0(%rax)
    const_AUTO(
  40e139:	e8 e2 33 ff ff       	callq  401520 <fc_solve_new_soft_thread>
    if (soft_thread == NULL)
  40e13e:	48 85 c0             	test   %rax,%rax
  40e141:	0f 84 a0 0c 00 00    	je     40ede7 <worker_thread+0x1267>
    user->soft_thread = soft_thread;
  40e147:	49 89 87 40 06 00 00 	mov    %rax,0x640(%r15)
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));
  40e14e:	31 f6                	xor    %esi,%esi
  40e150:	4c 89 ff             	mov    %r15,%rdi
        soft_thread->master_to_randomize =
  40e153:	c6 80 f1 01 00 00 01 	movb   $0x1,0x1f1(%rax)
  40e15a:	ba 3e f1 40 00       	mov    $0x40f13e,%edx
    soft_thread->super_method_type = super_method_type;
  40e15f:	c7 40 20 00 00 00 00 	movl   $0x0,0x20(%rax)
  40e166:	e8 95 c0 ff ff       	callq  40a200 <freecell_solver_user_set_depth_tests_order>
    return ((fcs_user *const)api_instance)->soft_thread;
  40e16b:	49 8b 87 40 06 00 00 	mov    0x640(%r15),%rax
    const_AUTO(
  40e172:	48 8b 38             	mov    (%rax),%rdi
    DFS_VAR(api_soft_thread(api_instance), rand_seed) = seed;
  40e175:	c7 40 48 08 00 00 00 	movl   $0x8,0x48(%rax)
    api_soft_thread(api_instance)->checked_states_step = checked_states_step;
  40e17c:	48 c7 80 e8 01 00 00 	movq   $0x1f4,0x1e8(%rax)
  40e183:	f4 01 00 00 
        soft_thread->enable_pruning = TRUE;
  40e187:	c6 80 f0 01 00 00 01 	movb   $0x1,0x1f0(%rax)
    const_AUTO(
  40e18e:	e8 8d 33 ff ff       	callq  401520 <fc_solve_new_soft_thread>
    if (soft_thread == NULL)
  40e193:	48 85 c0             	test   %rax,%rax
  40e196:	0f 84 3f 0c 00 00    	je     40eddb <worker_thread+0x125b>
    user->soft_thread = soft_thread;
  40e19c:	49 89 87 40 06 00 00 	mov    %rax,0x640(%r15)
    const_AUTO(
  40e1a3:	48 8b 38             	mov    (%rax),%rdi
        soft_thread->is_befs = TRUE;
  40e1a6:	c6 80 f2 01 00 00 01 	movb   $0x1,0x1f2(%rax)
    BEFS_VAR(soft_thread, weighting).befs_weights.weights[my_index] = weight;
  40e1ad:	c5 fd 28 05 eb 2b 00 	vmovapd 0x2beb(%rip),%ymm0        # 410da0 <fc_solve_is_parent_buf+0xee0>
  40e1b4:	00 
    soft_thread->super_method_type = super_method_type;
  40e1b5:	c7 40 20 01 00 00 00 	movl   $0x1,0x20(%rax)
    BEFS_VAR(soft_thread, weighting).befs_weights.weights[my_index] = weight;
  40e1bc:	48 c7 80 c8 01 00 00 	movq   $0x0,0x1c8(%rax)
  40e1c3:	00 00 00 00 
  40e1c7:	c5 f8 11 80 a8 01 00 	vmovups %xmm0,0x1a8(%rax)
  40e1ce:	00 
  40e1cf:	c4 e3 7d 19 80 b8 01 	vextractf128 $0x1,%ymm0,0x1b8(%rax)
  40e1d6:	00 00 01 
    api_soft_thread(api_instance)->checked_states_step = checked_states_step;
  40e1d9:	48 c7 80 e8 01 00 00 	movq   $0x1f4,0x1e8(%rax)
  40e1e0:	f4 01 00 00 
        soft_thread->enable_pruning = TRUE;
  40e1e4:	c6 80 f0 01 00 00 01 	movb   $0x1,0x1f0(%rax)
    const_AUTO(
  40e1eb:	c5 f8 77             	vzeroupper 
  40e1ee:	e8 2d 33 ff ff       	callq  401520 <fc_solve_new_soft_thread>
    if (soft_thread == NULL)
  40e1f3:	48 85 c0             	test   %rax,%rax
  40e1f6:	0f 84 97 0b 00 00    	je     40ed93 <worker_thread+0x1213>
    user->soft_thread = soft_thread;
  40e1fc:	49 89 87 40 06 00 00 	mov    %rax,0x640(%r15)
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));
  40e203:	4c 89 ff             	mov    %r15,%rdi
  40e206:	ba 4d f1 40 00       	mov    $0x40f14d,%edx
  40e20b:	31 f6                	xor    %esi,%esi
        soft_thread->is_befs = TRUE;
  40e20d:	c6 80 f2 01 00 00 01 	movb   $0x1,0x1f2(%rax)
    soft_thread->super_method_type = super_method_type;
  40e214:	c7 40 20 01 00 00 00 	movl   $0x1,0x20(%rax)
  40e21b:	e8 e0 bf ff ff       	callq  40a200 <freecell_solver_user_set_depth_tests_order>
    return ((fcs_user *const)api_instance)->soft_thread;
  40e220:	49 8b 87 40 06 00 00 	mov    0x640(%r15),%rax
    BEFS_VAR(soft_thread, weighting).befs_weights.weights[my_index] = weight;
  40e227:	c5 fd 28 05 91 2b 00 	vmovapd 0x2b91(%rip),%ymm0        # 410dc0 <fc_solve_is_parent_buf+0xf00>
  40e22e:	00 
    const_AUTO(
  40e22f:	48 8b 38             	mov    (%rax),%rdi
    BEFS_VAR(soft_thread, weighting).befs_weights.weights[my_index] = weight;
  40e232:	c5 f8 11 80 a8 01 00 	vmovups %xmm0,0x1a8(%rax)
  40e239:	00 
  40e23a:	c4 e3 7d 19 80 b8 01 	vextractf128 $0x1,%ymm0,0x1b8(%rax)
  40e241:	00 00 01 
  40e244:	48 c7 80 c8 01 00 00 	movq   $0x0,0x1c8(%rax)
  40e24b:	00 00 00 00 
    api_soft_thread(api_instance)->checked_states_step = checked_states_step;
  40e24f:	48 c7 80 e8 01 00 00 	movq   $0x1f4,0x1e8(%rax)
  40e256:	f4 01 00 00 
        soft_thread->enable_pruning = TRUE;
  40e25a:	c6 80 f0 01 00 00 01 	movb   $0x1,0x1f0(%rax)
    const_AUTO(
  40e261:	c5 f8 77             	vzeroupper 
  40e264:	e8 b7 32 ff ff       	callq  401520 <fc_solve_new_soft_thread>
    if (soft_thread == NULL)
  40e269:	48 85 c0             	test   %rax,%rax
  40e26c:	0f 84 15 0b 00 00    	je     40ed87 <worker_thread+0x1207>
    user->soft_thread = soft_thread;
  40e272:	49 89 87 40 06 00 00 	mov    %rax,0x640(%r15)
    const_AUTO(
  40e279:	48 8b 38             	mov    (%rax),%rdi
        soft_thread->master_to_randomize =
  40e27c:	c6 80 f1 01 00 00 01 	movb   $0x1,0x1f1(%rax)
    soft_thread->super_method_type = super_method_type;
  40e283:	c7 40 20 00 00 00 00 	movl   $0x0,0x20(%rax)
    DFS_VAR(api_soft_thread(api_instance), rand_seed) = seed;
  40e28a:	c7 40 48 69 00 00 00 	movl   $0x69,0x48(%rax)
    api_soft_thread(api_instance)->checked_states_step = checked_states_step;
  40e291:	48 c7 80 e8 01 00 00 	movq   $0x1f4,0x1e8(%rax)
  40e298:	f4 01 00 00 
        soft_thread->enable_pruning = TRUE;
  40e29c:	c6 80 f0 01 00 00 01 	movb   $0x1,0x1f0(%rax)
    const_AUTO(
  40e2a3:	e8 78 32 ff ff       	callq  401520 <fc_solve_new_soft_thread>
    if (soft_thread == NULL)
  40e2a8:	48 85 c0             	test   %rax,%rax
  40e2ab:	0f 84 ee 0a 00 00    	je     40ed9f <worker_thread+0x121f>
    user->soft_thread = soft_thread;
  40e2b1:	49 89 87 40 06 00 00 	mov    %rax,0x640(%r15)
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));
  40e2b8:	31 f6                	xor    %esi,%esi
  40e2ba:	4c 89 ff             	mov    %r15,%rdi
        soft_thread->master_to_randomize =
  40e2bd:	c6 80 f1 01 00 00 01 	movb   $0x1,0x1f1(%rax)
    typeof(total_num_iters) total_num_iters_temp = 0;
  40e2c4:	45 31 f6             	xor    %r14d,%r14d
  40e2c7:	ba aa f0 40 00       	mov    $0x40f0aa,%edx
    soft_thread->super_method_type = super_method_type;
  40e2cc:	c7 40 20 00 00 00 00 	movl   $0x0,0x20(%rax)
  40e2d3:	e8 28 bf ff ff       	callq  40a200 <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));
  40e2d8:	ba b6 f0 40 00       	mov    $0x40f0b6,%edx
  40e2dd:	be 08 00 00 00       	mov    $0x8,%esi
  40e2e2:	4c 89 ff             	mov    %r15,%rdi
  40e2e5:	e8 16 bf ff ff       	callq  40a200 <freecell_solver_user_set_depth_tests_order>
    return ((fcs_user *const)api_instance)->soft_thread;
  40e2ea:	49 8b 87 40 06 00 00 	mov    0x640(%r15),%rax
  40e2f1:	c5 f9 6f 0d 27 2a 00 	vmovdqa 0x2a27(%rip),%xmm1        # 410d20 <fc_solve_is_parent_buf+0xe60>
  40e2f8:	00 
    DFS_VAR(api_soft_thread(api_instance), rand_seed) = seed;
  40e2f9:	c7 40 48 25 97 00 00 	movl   $0x9725,0x48(%rax)
    api_soft_thread(api_instance)->checked_states_step = checked_states_step;
  40e300:	48 c7 80 e8 01 00 00 	movq   $0x1f4,0x1e8(%rax)
  40e307:	f4 01 00 00 
        soft_thread->enable_pruning = TRUE;
  40e30b:	c6 80 f0 01 00 00 01 	movb   $0x1,0x1f0(%rax)
    fcs_hard_thread *const hard_thread = user->soft_thread->hard_thread;
  40e312:	48 8b 00             	mov    (%rax),%rax
    HT_FIELD(hard_thread, prelude_num_items) = num;
  40e315:	48 c7 80 00 05 00 00 	movq   $0x14,0x500(%rax)
  40e31c:	14 00 00 00 
    HT_FIELD(hard_thread, prelude) = prelude;
  40e320:	48 c7 80 10 05 00 00 	movq   $0x40f2e0,0x510(%rax)
  40e327:	e0 f2 40 00 
        pthread_mutex_lock(&next_board_num_lock);
  40e32b:	bf 60 31 41 00       	mov    $0x413160,%edi
  40e330:	c5 f8 29 8d 70 fd ff 	vmovaps %xmm1,-0x290(%rbp)
  40e337:	ff 
  40e338:	e8 13 2e ff ff       	callq  401150 <pthread_mutex_lock@plt>
        board_num = next_board_num;
  40e33d:	48 8b 1d 0c 4e 00 00 	mov    0x4e0c(%rip),%rbx        # 413150 <next_board_num>
        pthread_mutex_unlock(&next_board_num_lock);
  40e344:	bf 60 31 41 00       	mov    $0x413160,%edi
        const long long proposed_quota_end = (next_board_num += board_num_step);
  40e349:	4c 8b 25 80 4d 00 00 	mov    0x4d80(%rip),%r12        # 4130d0 <board_num_step>
  40e350:	49 01 dc             	add    %rbx,%r12
  40e353:	4c 89 25 f6 4d 00 00 	mov    %r12,0x4df6(%rip)        # 413150 <next_board_num>
        pthread_mutex_unlock(&next_board_num_lock);
  40e35a:	e8 61 2d ff ff       	callq  4010c0 <pthread_mutex_unlock@plt>
        const long long quota_end = min(proposed_quota_end, past_end_board);
  40e35f:	48 8b 05 e2 4d 00 00 	mov    0x4de2(%rip),%rax        # 413148 <past_end_board>
        for (; board_num < quota_end; board_num++)
  40e366:	c5 f9 6f 8d 70 fd ff 	vmovdqa -0x290(%rbp),%xmm1
  40e36d:	ff 
        const long long quota_end = min(proposed_quota_end, past_end_board);
  40e36e:	49 39 c4             	cmp    %rax,%r12
  40e371:	4c 0f 4f e0          	cmovg  %rax,%r12
        for (; board_num < quota_end; board_num++)
  40e375:	4c 39 e3             	cmp    %r12,%rbx
        const long long quota_end = min(proposed_quota_end, past_end_board);
  40e378:	4c 89 a5 68 fd ff ff 	mov    %r12,-0x298(%rbp)
        for (; board_num < quota_end; board_num++)
  40e37f:	0f 8d 98 02 00 00    	jge    40e61d <worker_thread+0xa9d>
  40e385:	49 8d 87 48 0a 00 00 	lea    0xa48(%r15),%rax
  40e38c:	48 89 85 60 fd ff ff 	mov    %rax,-0x2a0(%rbp)
  40e393:	4c 8d a5 80 fd ff ff 	lea    -0x280(%rbp),%r12
  40e39a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
#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"
  40e3a0:	c5 f9 6f 05 88 29 00 	vmovdqa 0x2988(%rip),%xmm0        # 410d30 <fc_solve_is_parent_buf+0xe70>
  40e3a7:	00 
  40e3a8:	89 d9                	mov    %ebx,%ecx
  40e3aa:	48 b8 20 58 58 20 58 	movabs $0x5820585820585820,%rax
  40e3b1:	58 20 58 
  40e3b4:	48 ba 58 0a 58 58 20 	movabs $0x2058582058580a58,%rdx
  40e3bb:	58 58 20 
  40e3be:	49 89 44 24 20       	mov    %rax,0x20(%r12)
  40e3c3:	c4 c1 78 29 04 24    	vmovaps %xmm0,(%r12)
  40e3c9:	c5 f9 6f 05 6f 29 00 	vmovdqa 0x296f(%rip),%xmm0        # 410d40 <fc_solve_is_parent_buf+0xe80>
  40e3d0:	00 
  40e3d1:	49 89 84 24 80 00 00 	mov    %rax,0x80(%r12)
  40e3d8:	00 
  40e3d9:	48 b8 58 58 20 58 58 	movabs $0x5858205858205858,%rax
  40e3e0:	20 58 58 
  40e3e3:	c4 c1 78 29 44 24 10 	vmovaps %xmm0,0x10(%r12)
  40e3ea:	c5 f9 6f 05 5e 29 00 	vmovdqa 0x295e(%rip),%xmm0        # 410d50 <fc_solve_is_parent_buf+0xe90>
  40e3f1:	00 
  40e3f2:	49 89 54 24 28       	mov    %rdx,0x28(%r12)
  40e3f7:	c4 c1 78 29 44 24 30 	vmovaps %xmm0,0x30(%r12)
  40e3fe:	c5 f9 6f 05 5a 29 00 	vmovdqa 0x295a(%rip),%xmm0        # 410d60 <fc_solve_is_parent_buf+0xea0>
  40e405:	00 
  40e406:	49 89 94 24 88 00 00 	mov    %rdx,0x88(%r12)
  40e40d:	00 
  40e40e:	48 8d 55 d0          	lea    -0x30(%rbp),%rdx
  40e412:	c4 c1 78 29 44 24 40 	vmovaps %xmm0,0x40(%r12)
  40e419:	c5 f9 6f 05 4f 29 00 	vmovdqa 0x294f(%rip),%xmm0        # 410d70 <fc_solve_is_parent_buf+0xeb0>
  40e420:	00 
  40e421:	49 89 84 24 90 00 00 	mov    %rax,0x90(%r12)
  40e428:	00 
  40e429:	48 8d 85 30 fe ff ff 	lea    -0x1d0(%rbp),%rax
  40e430:	c4 c1 78 29 44 24 50 	vmovaps %xmm0,0x50(%r12)
  40e437:	c5 f9 6f 05 41 29 00 	vmovdqa 0x2941(%rip),%xmm0        # 410d80 <fc_solve_is_parent_buf+0xec0>
  40e43e:	00 
  40e43f:	41 c7 84 24 98 00 00 	movl   $0xa585820,0x98(%r12)
  40e446:	00 20 58 58 0a 
  40e44b:	c4 c1 78 29 44 24 60 	vmovaps %xmm0,0x60(%r12)
  40e452:	c5 f9 6f 05 36 29 00 	vmovdqa 0x2936(%rip),%xmm0        # 410d90 <fc_solve_is_parent_buf+0xed0>
  40e459:	00 
  40e45a:	41 c6 84 24 9c 00 00 	movb   $0x0,0x9c(%r12)
  40e461:	00 00 
  40e463:	c4 c1 78 29 44 24 70 	vmovaps %xmm0,0x70(%r12)
  40e46a:	c5 f9 6f 05 9e 28 00 	vmovdqa 0x289e(%rip),%xmm0        # 410d10 <fc_solve_is_parent_buf+0xe50>
  40e471:	00 
  40e472:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40e479:	00 00 00 00 
  40e47d:	0f 1f 00             	nopl   (%rax)

    /* shuffle cards */

    for (size_t i = 0; i < 52; ++i) /* put unique card in each deck loc. */
    {
        deck[i] = i;
  40e480:	c5 f8 29 00          	vmovaps %xmm0,(%rax)
  40e484:	48 83 c0 10          	add    $0x10,%rax
  40e488:	c5 f9 d4 c1          	vpaddq %xmm1,%xmm0,%xmm0
  40e48c:	48 39 c2             	cmp    %rax,%rdx
  40e48f:	75 ef                	jne    40e480 <worker_thread+0x900>
  40e491:	b8 ff ff ff ff       	mov    $0xffffffff,%eax
  40e496:	bf 20 f4 40 00       	mov    $0x40f420,%edi
    }

    microsoft_rand_uint num_cards_left = 52;
  40e49b:	be 34 00 00 00       	mov    $0x34,%esi
  40e4a0:	48 39 c3             	cmp    %rax,%rbx
  40e4a3:	0f 8f a7 04 00 00    	jg     40e950 <worker_thread+0xdd0>
  40e4a9:	48 81 fb ff ff ff 7f 	cmp    $0x7fffffff,%rbx
  40e4b0:	0f 8f 0a 05 00 00    	jg     40e9c0 <worker_thread+0xe40>
  40e4b6:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  40e4bd:	00 00 00 
  40e4c0:	48 69 c9 fd 43 03 00 	imul   $0x343fd,%rcx,%rcx
    for (size_t i = 0; i < 52; ++i)
    {
        const microsoft_rand_uint j =
  40e4c7:	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]);
  40e4c9:	4c 8b 07             	mov    (%rdi),%r8
  40e4cc:	48 83 c7 08          	add    $0x8,%rdi
  40e4d0:	4d 01 e0             	add    %r12,%r8
  40e4d3:	48 81 c1 c3 9e 26 00 	add    $0x269ec3,%rcx

static inline microsoft_rand_uint microsoft_rand_rand(
    microsoft_rand *const my_rand)
{
    *my_rand = ((*my_rand) * 214013 + 2531011);
    return ((*my_rand) >> 16) & 0x7fff;
  40e4da:	48 89 c8             	mov    %rcx,%rax
  40e4dd:	48 c1 f8 10          	sar    $0x10,%rax
  40e4e1:	25 ff 7f 00 00       	and    $0x7fff,%eax
        const microsoft_rand_uint j =
  40e4e6:	f7 f6                	div    %esi
        card_to_string(&ret[offset_by_i[i]], deck[j]);
  40e4e8:	89 d2                	mov    %edx,%edx
  40e4ea:	48 8b 84 d5 30 fe ff 	mov    -0x1d0(%rbp,%rdx,8),%rax
  40e4f1:	ff 
    s[0] = card_to_string_values[VALUE(card)];
  40e4f2:	49 89 c1             	mov    %rax,%r9
    s[1] = card_to_string_suits[SUIT(card)];
  40e4f5:	83 e0 03             	and    $0x3,%eax
  40e4f8:	0f b6 80 63 f1 40 00 	movzbl 0x40f163(%rax),%eax
    s[0] = card_to_string_values[VALUE(card)];
  40e4ff:	49 c1 e9 02          	shr    $0x2,%r9
  40e503:	45 0f b6 89 55 f1 40 	movzbl 0x40f155(%r9),%r9d
  40e50a:	00 
    s[1] = card_to_string_suits[SUIT(card)];
  40e50b:	41 88 40 01          	mov    %al,0x1(%r8)
        deck[j] = deck[--num_cards_left];
  40e50f:	8d 46 ff             	lea    -0x1(%rsi),%eax
  40e512:	48 89 c6             	mov    %rax,%rsi
  40e515:	48 8b 84 c5 30 fe ff 	mov    -0x1d0(%rbp,%rax,8),%rax
  40e51c:	ff 
    s[0] = card_to_string_values[VALUE(card)];
  40e51d:	45 88 08             	mov    %r9b,(%r8)
        deck[j] = deck[--num_cards_left];
  40e520:	48 89 84 d5 30 fe ff 	mov    %rax,-0x1d0(%rbp,%rdx,8)
  40e527:	ff 
    for (size_t i = 0; i < 52; ++i)
  40e528:	85 f6                	test   %esi,%esi
  40e52a:	75 94                	jne    40e4c0 <worker_thread+0x940>
    const size_t len = strlen(orig_str);
  40e52c:	4d 89 e5             	mov    %r12,%r13
  40e52f:	41 8b 55 00          	mov    0x0(%r13),%edx
  40e533:	49 83 c5 04          	add    $0x4,%r13
  40e537:	8d 82 ff fe fe fe    	lea    -0x1010101(%rdx),%eax
  40e53d:	f7 d2                	not    %edx
  40e53f:	21 d0                	and    %edx,%eax
  40e541:	25 80 80 80 80       	and    $0x80808080,%eax
  40e546:	74 e7                	je     40e52f <worker_thread+0x9af>
  40e548:	89 c2                	mov    %eax,%edx
  40e54a:	c1 ea 10             	shr    $0x10,%edx
  40e54d:	a9 80 80 00 00       	test   $0x8080,%eax
  40e552:	0f 44 c2             	cmove  %edx,%eax
  40e555:	49 8d 55 02          	lea    0x2(%r13),%rdx
  40e559:	89 c7                	mov    %eax,%edi
  40e55b:	4c 0f 44 ea          	cmove  %rdx,%r13
  40e55f:	40 00 c7             	add    %al,%dil
  40e562:	49 83 dd 03          	sbb    $0x3,%r13
    if (len)
  40e566:	4d 29 e5             	sub    %r12,%r13
  40e569:	0f 84 c5 04 00 00    	je     40ea34 <worker_thread+0xeb4>
        if (len >= MAX_STATE_STRING_COPY_LEN - MY_MARGIN)
  40e56f:	49 81 fd fc 07 00 00 	cmp    $0x7fc,%r13
  40e576:	0f 86 09 06 00 00    	jbe    40eb85 <worker_thread+0x1005>
    return user->iterations_board_started_at.num_checked_states +
  40e57c:	49 8b 07             	mov    (%r15),%rax
  40e57f:	49 39 87 c0 05 00 00 	cmp    %rax,0x5c0(%r15)
  40e586:	49 0f 4d 87 c0 05 00 	cmovge 0x5c0(%r15),%rax
  40e58d:	00 
  40e58e:	49 03 87 c8 05 00 00 	add    0x5c8(%r15),%rax
               user_obj(user)->i__num_checked_states) -
  40e595:	49 2b 87 d0 05 00 00 	sub    0x5d0(%r15),%rax
    *total_num_iters_temp += freecell_solver_user_get_num_times_long(instance);
  40e59c:	49 01 c6             	add    %rax,%r14
            if (total_num_iters_temp >= UPDATE_TOTAL_NUM_ITERS_THRESHOLD)
  40e59f:	49 81 fe 3f 42 0f 00 	cmp    $0xf423f,%r14
  40e5a6:	0f 8f 14 05 00 00    	jg     40eac0 <worker_thread+0xf40>
            if (unlikely(board_num % stop_at == 0))
  40e5ac:	48 89 d8             	mov    %rbx,%rax
  40e5af:	48 99                	cqto   
  40e5b1:	48 f7 3d 48 4b 00 00 	idivq  0x4b48(%rip)        # 413100 <stop_at>
  40e5b8:	48 85 d2             	test   %rdx,%rdx
  40e5bb:	0f 84 4e 07 00 00    	je     40ed0f <worker_thread+0x118f>
    if (flare->ret_code != FCS_STATE_NOT_BEGAN_YET)
  40e5c1:	41 83 bf b8 05 00 00 	cmpl   $0x9,0x5b8(%r15)
  40e5c8:	09 
  40e5c9:	74 24                	je     40e5ef <worker_thread+0xa6f>
    if (!flare->instance_is_ready)
  40e5cb:	41 80 bf bc 05 00 00 	cmpb   $0x0,0x5bc(%r15)
  40e5d2:	00 
  40e5d3:	0f 84 f2 05 00 00    	je     40ebcb <worker_thread+0x104b>
        user->init_num_checked_states = initial_stats;
  40e5d9:	49 c7 87 d0 05 00 00 	movq   $0x0,0x5d0(%r15)
  40e5e0:	00 00 00 00 
        flare->ret_code = FCS_STATE_NOT_BEGAN_YET;
  40e5e4:	41 c7 87 b8 05 00 00 	movl   $0x9,0x5b8(%r15)
  40e5eb:	09 00 00 00 
    flare->obj_stats = initial_stats;
  40e5ef:	49 c7 87 c0 05 00 00 	movq   $0x0,0x5c0(%r15)
  40e5f6:	00 00 00 00 
        for (; board_num < quota_end; board_num++)
  40e5fa:	48 83 c3 01          	add    $0x1,%rbx
    user->iterations_board_started_at = initial_stats;
  40e5fe:	49 c7 87 c8 05 00 00 	movq   $0x0,0x5c8(%r15)
  40e605:	00 00 00 00 
  40e609:	48 39 9d 68 fd ff ff 	cmp    %rbx,-0x298(%rbp)
  40e610:	0f 85 8a fd ff ff    	jne    40e3a0 <worker_thread+0x820>
  40e616:	48 8b 05 2b 4b 00 00 	mov    0x4b2b(%rip),%rax        # 413148 <past_end_board>
    } while (board_num < past_end_board);
  40e61d:	48 39 c3             	cmp    %rax,%rbx
  40e620:	0f 8c 05 fd ff ff    	jl     40e32b <worker_thread+0x7ab>
    pthread_mutex_lock(&total_num_iters_lock);
  40e626:	bf 20 31 41 00       	mov    $0x413120,%edi
  40e62b:	e8 20 2b ff ff       	callq  401150 <pthread_mutex_lock@plt>
    pthread_mutex_unlock(&total_num_iters_lock);
  40e630:	bf 20 31 41 00       	mov    $0x413120,%edi
    total_num_iters += total_num_iters_temp;
  40e635:	4c 01 35 cc 4a 00 00 	add    %r14,0x4acc(%rip)        # 413108 <total_num_iters>
    pthread_mutex_unlock(&total_num_iters_lock);
  40e63c:	e8 7f 2a ff ff       	callq  4010c0 <pthread_mutex_unlock@plt>
        if ((ret_code != FCS_STATE_NOT_BEGAN_YET) &&
  40e641:	41 8b 87 b8 05 00 00 	mov    0x5b8(%r15),%eax
  40e648:	83 e8 08             	sub    $0x8,%eax
  40e64b:	83 f8 01             	cmp    $0x1,%eax
  40e64e:	0f 87 ca 04 00 00    	ja     40eb1e <worker_thread+0xf9e>
    const int_fast32_t num_soft_threads =
  40e654:	49 8b 87 20 05 00 00 	mov    0x520(%r15),%rax
  40e65b:	48 89 85 50 fd ff ff 	mov    %rax,-0x2b0(%rbp)
        if (st_idx < num_soft_threads)
  40e662:	48 85 c0             	test   %rax,%rax
  40e665:	0f 8e df 01 00 00    	jle    40e84a <worker_thread+0xcca>
    for (int_fast32_t st_idx = 0; st_idx <= num_soft_threads; ++st_idx)
  40e66b:	48 c7 85 60 fd ff ff 	movq   $0x0,-0x2a0(%rbp)
  40e672:	00 00 00 00 
  40e676:	4c 89 bd 58 fd ff ff 	mov    %r15,-0x2a8(%rbp)
  40e67d:	0f 1f 00             	nopl   (%rax)
            soft_thread = &(instance->hard_thread.soft_threads[st_idx]);
  40e680:	48 8b 9d 60 fd ff ff 	mov    -0x2a0(%rbp),%rbx
  40e687:	48 89 d8             	mov    %rbx,%rax
  40e68a:	48 c1 e0 06          	shl    $0x6,%rax
  40e68e:	48 29 d8             	sub    %rbx,%rax
  40e691:	48 8b 9d 58 fd ff ff 	mov    -0x2a8(%rbp),%rbx
  40e698:	48 8b 93 c0 00 00 00 	mov    0xc0(%rbx),%rdx
  40e69f:	4c 8d 3c c2          	lea    (%rdx,%rax,8),%r15
    free(pq->elems);
  40e6a3:	49 8b bf 00 01 00 00 	mov    0x100(%r15),%rdi
  40e6aa:	e8 a1 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));
  40e6af:	49 8b bf c8 00 00 00 	mov    0xc8(%r15),%rdi
    pq->elems = NULL;
  40e6b6:	49 c7 87 00 01 00 00 	movq   $0x0,0x100(%r15)
  40e6bd:	00 00 00 00 
  40e6c1:	e8 8a 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);
  40e6c6:	49 8b 47 50          	mov    0x50(%r15),%rax
    BEFS_M_VAR(soft_thread, moves_list) = NULL;
  40e6ca:	49 c7 87 c8 00 00 00 	movq   $0x0,0xc8(%r15)
  40e6d1:	00 00 00 00 
  40e6d5:	49 8b 7f 58          	mov    0x58(%r15),%rdi
    const_SLOT(num_units, arr);
  40e6d9:	48 89 85 68 fd ff ff 	mov    %rax,-0x298(%rbp)
    for (size_t unit_idx = 0; unit_idx < num_units; unit_idx++)
  40e6e0:	48 85 c0             	test   %rax,%rax
  40e6e3:	0f 84 84 00 00 00    	je     40e76d <worker_thread+0xbed>
  40e6e9:	48 c7 85 70 fd ff ff 	movq   $0x0,-0x290(%rbp)
  40e6f0:	00 00 00 00 
  40e6f4:	45 31 f6             	xor    %r14d,%r14d
  40e6f7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40e6fe:	00 00 
    {
        if (arr->by_depth_units[unit_idx].move_funcs.groups)
  40e700:	4a 8d 04 37          	lea    (%rdi,%r14,1),%rax
  40e704:	4c 8b 60 10          	mov    0x10(%rax),%r12
  40e708:	4d 85 e4             	test   %r12,%r12
  40e70b:	74 44                	je     40e751 <worker_thread+0xbd1>
        {
            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);
  40e70d:	48 8b 58 08          	mov    0x8(%rax),%rbx

            for (typeof(arr->by_depth_units[unit_idx].move_funcs.num) i = 0;
  40e711:	48 85 db             	test   %rbx,%rbx
  40e714:	74 2f                	je     40e745 <worker_thread+0xbc5>
  40e716:	48 69 db e8 00 00 00 	imul   $0xe8,%rbx,%rbx
  40e71d:	4d 89 e5             	mov    %r12,%r13
  40e720:	4c 01 e3             	add    %r12,%rbx
  40e723:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40e72a:	00 00 00 00 
  40e72e:	66 90                	xchg   %ax,%ax
                 i < num; i++)
            {
                free(groups[i].move_funcs);
  40e730:	49 8b 7d 00          	mov    0x0(%r13),%rdi
  40e734:	49 81 c5 e8 00 00 00 	add    $0xe8,%r13
  40e73b:	e8 10 29 ff ff       	callq  401050 <free@plt>
            for (typeof(arr->by_depth_units[unit_idx].move_funcs.num) i = 0;
  40e740:	4c 39 eb             	cmp    %r13,%rbx
  40e743:	75 eb                	jne    40e730 <worker_thread+0xbb0>
            }
            free(groups);
  40e745:	4c 89 e7             	mov    %r12,%rdi
  40e748:	e8 03 29 ff ff       	callq  401050 <free@plt>
  40e74d:	49 8b 7f 58          	mov    0x58(%r15),%rdi
    for (size_t unit_idx = 0; unit_idx < num_units; unit_idx++)
  40e751:	48 83 85 70 fd ff ff 	addq   $0x1,-0x290(%rbp)
  40e758:	01 
  40e759:	49 83 c6 18          	add    $0x18,%r14
  40e75d:	48 8b 85 70 fd ff ff 	mov    -0x290(%rbp),%rax
  40e764:	48 39 85 68 fd ff ff 	cmp    %rax,-0x298(%rbp)
  40e76b:	75 93                	jne    40e700 <worker_thread+0xb80>
        }
    }
    free(arr->by_depth_units);
  40e76d:	e8 de 28 ff ff       	callq  401050 <free@plt>
    const_AUTO(
  40e772:	49 8b 5f 18          	mov    0x18(%r15),%rbx
    arr->by_depth_units = NULL;
  40e776:	49 c7 47 58 00 00 00 	movq   $0x0,0x58(%r15)
  40e77d:	00 
    const_AUTO(num, soft_thread->by_depth_moves_order.num);
  40e77e:	49 8b 47 10          	mov    0x10(%r15),%rax
    const_AUTO(
  40e782:	48 89 9d 68 fd ff ff 	mov    %rbx,-0x298(%rbp)
    for (size_t i = 0; i < num; ++i)
  40e789:	48 85 c0             	test   %rax,%rax
  40e78c:	74 7d                	je     40e80b <worker_thread+0xc8b>
  40e78e:	48 8d 04 40          	lea    (%rax,%rax,2),%rax
  40e792:	48 8d 44 c3 08       	lea    0x8(%rbx,%rax,8),%rax
  40e797:	4c 8d 63 08          	lea    0x8(%rbx),%r12
  40e79b:	48 89 85 70 fd ff ff 	mov    %rax,-0x290(%rbp)
  40e7a2:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40e7a9:	00 00 00 00 
  40e7ad:	0f 1f 00             	nopl   (%rax)
    const_SLOT(num, moves_order);
  40e7b0:	49 8b 1c 24          	mov    (%r12),%rbx
    const_SLOT(groups, moves_order);
  40e7b4:	4d 8b 6c 24 08       	mov    0x8(%r12),%r13
    for (size_t group_idx = 0; group_idx < num; ++group_idx)
  40e7b9:	48 85 db             	test   %rbx,%rbx
  40e7bc:	74 26                	je     40e7e4 <worker_thread+0xc64>
  40e7be:	48 69 db e8 00 00 00 	imul   $0xe8,%rbx,%rbx
  40e7c5:	4d 89 ee             	mov    %r13,%r14
  40e7c8:	4c 01 eb             	add    %r13,%rbx
  40e7cb:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
        free(groups[group_idx].move_funcs);
  40e7d0:	49 8b 3e             	mov    (%r14),%rdi
  40e7d3:	49 81 c6 e8 00 00 00 	add    $0xe8,%r14
  40e7da:	e8 71 28 ff ff       	callq  401050 <free@plt>
    for (size_t group_idx = 0; group_idx < num; ++group_idx)
  40e7df:	4c 39 f3             	cmp    %r14,%rbx
  40e7e2:	75 ec                	jne    40e7d0 <worker_thread+0xc50>
    free(groups);
  40e7e4:	4c 89 ef             	mov    %r13,%rdi
  40e7e7:	49 83 c4 18          	add    $0x18,%r12
  40e7eb:	e8 60 28 ff ff       	callq  401050 <free@plt>
    moves_order->groups = NULL;
  40e7f0:	49 c7 44 24 f0 00 00 	movq   $0x0,-0x10(%r12)
  40e7f7:	00 00 
    moves_order->num = 0;
  40e7f9:	49 c7 44 24 e8 00 00 	movq   $0x0,-0x18(%r12)
  40e800:	00 00 
  40e802:	4c 39 a5 70 fd ff ff 	cmp    %r12,-0x290(%rbp)
  40e809:	75 a5                	jne    40e7b0 <worker_thread+0xc30>
    free(by_depth_moves);
  40e80b:	48 8b bd 68 fd ff ff 	mov    -0x298(%rbp),%rdi
    soft_thread->by_depth_moves_order.num = 0;
  40e812:	49 c7 47 10 00 00 00 	movq   $0x0,0x10(%r15)
  40e819:	00 
    free(by_depth_moves);
  40e81a:	e8 31 28 ff ff       	callq  401050 <free@plt>
    soft_thread->by_depth_moves_order.by_depth_moves = NULL;
  40e81f:	49 c7 47 18 00 00 00 	movq   $0x0,0x18(%r15)
  40e826:	00 
    for (int_fast32_t st_idx = 0; st_idx <= num_soft_threads; ++st_idx)
  40e827:	48 83 85 60 fd ff ff 	addq   $0x1,-0x2a0(%rbp)
  40e82e:	01 
  40e82f:	48 8b 85 60 fd ff ff 	mov    -0x2a0(%rbp),%rax
        if (st_idx < num_soft_threads)
  40e836:	48 39 85 50 fd ff ff 	cmp    %rax,-0x2b0(%rbp)
  40e83d:	0f 85 3d fe ff ff    	jne    40e680 <worker_thread+0xb00>
  40e843:	4c 8b bd 58 fd ff ff 	mov    -0x2a8(%rbp),%r15
    free(HT_FIELD(hard_thread, soft_threads));
  40e84a:	49 8b bf c0 00 00 00 	mov    0xc0(%r15),%rdi
  40e851:	e8 fa 27 ff ff       	callq  401050 <free@plt>
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40e856:	49 8b 87 d8 00 00 00 	mov    0xd8(%r15),%rax
    meta_allocator *const meta = allocator->meta;
  40e85d:	49 8b bf f8 00 00 00 	mov    0xf8(%r15),%rdi
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40e864:	48 8b 10             	mov    (%rax),%rdx
    var_AUTO(bin, meta->recycle_bin);
  40e867:	48 8b 37             	mov    (%rdi),%rsi
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40e86a:	48 85 d2             	test   %rdx,%rdx
  40e86d:	75 17                	jne    40e886 <worker_thread+0xd06>
  40e86f:	e9 d6 05 00 00       	jmpq   40ee4a <worker_thread+0x12ca>
  40e874:	66 66 2e 0f 1f 84 00 	data16 nopw %cs:0x0(%rax,%rax,1)
  40e87b:	00 00 00 00 
  40e87f:	90                   	nop
  40e880:	48 89 d0             	mov    %rdx,%rax
  40e883:	48 89 ca             	mov    %rcx,%rdx
        OLD_LIST_NEXT(iter) = bin;
  40e886:	48 89 30             	mov    %rsi,(%rax)
         iter = iter_next, iter_next = OLD_LIST_NEXT(iter))
  40e889:	48 8b 0a             	mov    (%rdx),%rcx
  40e88c:	48 89 c6             	mov    %rax,%rsi
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40e88f:	48 85 c9             	test   %rcx,%rcx
  40e892:	75 ec                	jne    40e880 <worker_thread+0xd00>
    OLD_LIST_NEXT(iter) = bin;
  40e894:	48 89 02             	mov    %rax,(%rdx)
    const_SLOT(num, moves_order);
  40e897:	49 8b 87 30 05 00 00 	mov    0x530(%r15),%rax
    meta->recycle_bin = iter;
  40e89e:	48 89 17             	mov    %rdx,(%rdi)
    const_SLOT(groups, moves_order);
  40e8a1:	4d 8b af 38 05 00 00 	mov    0x538(%r15),%r13
    for (size_t group_idx = 0; group_idx < num; ++group_idx)
  40e8a8:	48 85 c0             	test   %rax,%rax
  40e8ab:	74 27                	je     40e8d4 <worker_thread+0xd54>
  40e8ad:	48 69 c0 e8 00 00 00 	imul   $0xe8,%rax,%rax
  40e8b4:	4c 89 eb             	mov    %r13,%rbx
  40e8b7:	4e 8d 24 28          	lea    (%rax,%r13,1),%r12
  40e8bb:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
        free(groups[group_idx].move_funcs);
  40e8c0:	48 8b 3b             	mov    (%rbx),%rdi
  40e8c3:	48 81 c3 e8 00 00 00 	add    $0xe8,%rbx
  40e8ca:	e8 81 27 ff ff       	callq  401050 <free@plt>
    for (size_t group_idx = 0; group_idx < num; ++group_idx)
  40e8cf:	49 39 dc             	cmp    %rbx,%r12
  40e8d2:	75 ec                	jne    40e8c0 <worker_thread+0xd40>
    free(groups);
  40e8d4:	4c 89 ef             	mov    %r13,%rdi
        iter_next = iter ? OLD_LIST_NEXT(iter) : NULL;
  40e8d7:	31 db                	xor    %ebx,%ebx
  40e8d9:	e8 72 27 ff ff       	callq  401050 <free@plt>
    for (iter = meta_alloc->recycle_bin,
  40e8de:	49 8b bf 48 12 00 00 	mov    0x1248(%r15),%rdi
    moves_order->groups = NULL;
  40e8e5:	49 c7 87 38 05 00 00 	movq   $0x0,0x538(%r15)
  40e8ec:	00 00 00 00 
    moves_order->num = 0;
  40e8f0:	49 c7 87 30 05 00 00 	movq   $0x0,0x530(%r15)
  40e8f7:	00 00 00 00 
        iter_next = iter ? OLD_LIST_NEXT(iter) : NULL;
  40e8fb:	48 85 ff             	test   %rdi,%rdi
  40e8fe:	74 23                	je     40e923 <worker_thread+0xda3>
  40e900:	48 8b 1f             	mov    (%rdi),%rbx
    for (iter = meta_alloc->recycle_bin,
  40e903:	48 85 db             	test   %rbx,%rbx
  40e906:	75 0b                	jne    40e913 <worker_thread+0xd93>
  40e908:	e9 48 05 00 00       	jmpq   40ee55 <worker_thread+0x12d5>
  40e90d:	0f 1f 00             	nopl   (%rax)
  40e910:	48 89 c3             	mov    %rax,%rbx
        free(iter);
  40e913:	e8 38 27 ff ff       	callq  401050 <free@plt>
         iter_next; iter = iter_next, iter_next = OLD_LIST_NEXT(iter))
  40e918:	48 8b 03             	mov    (%rbx),%rax
  40e91b:	48 89 df             	mov    %rbx,%rdi
    for (iter = meta_alloc->recycle_bin,
  40e91e:	48 85 c0             	test   %rax,%rax
  40e921:	75 ed                	jne    40e910 <worker_thread+0xd90>
    free(iter);
  40e923:	48 89 df             	mov    %rbx,%rdi
  40e926:	e8 25 27 ff ff       	callq  401050 <free@plt>
    free(user);
  40e92b:	4c 89 ff             	mov    %r15,%rdi
  40e92e:	e8 1d 27 ff ff       	callq  401050 <free@plt>
}
  40e933:	48 81 c4 80 02 00 00 	add    $0x280,%rsp
  40e93a:	31 c0                	xor    %eax,%eax
  40e93c:	5b                   	pop    %rbx
  40e93d:	41 5a                	pop    %r10
  40e93f:	41 5c                	pop    %r12
  40e941:	41 5d                	pop    %r13
  40e943:	41 5e                	pop    %r14
  40e945:	41 5f                	pop    %r15
  40e947:	5d                   	pop    %rbp
  40e948:	c3                   	retq   
  40e949:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
  40e950:	48 69 c9 fd 43 03 00 	imul   $0x343fd,%rcx,%rcx
        const microsoft_rand_uint j =
  40e957:	31 d2                	xor    %edx,%edx
        card_to_string(&ret[offset_by_i[i]], deck[j]);
  40e959:	4c 8b 07             	mov    (%rdi),%r8
  40e95c:	48 83 c7 08          	add    $0x8,%rdi
  40e960:	4d 01 e0             	add    %r12,%r8
  40e963:	48 81 c1 c3 9e 26 00 	add    $0x269ec3,%rcx

static inline microsoft_rand_uint microsoft_rand_randp(
    microsoft_rand *const my_rand)
{
    *my_rand = ((*my_rand) * 214013 + 2531011);
    return ((*my_rand) >> 16) & 0xffff;
  40e96a:	89 c8                	mov    %ecx,%eax
  40e96c:	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;
  40e96f:	83 c0 01             	add    $0x1,%eax
        const microsoft_rand_uint j =
  40e972:	f7 f6                	div    %esi
        card_to_string(&ret[offset_by_i[i]], deck[j]);
  40e974:	89 d2                	mov    %edx,%edx
  40e976:	48 8b 84 d5 30 fe ff 	mov    -0x1d0(%rbp,%rdx,8),%rax
  40e97d:	ff 
    s[0] = card_to_string_values[VALUE(card)];
  40e97e:	49 89 c1             	mov    %rax,%r9
    s[1] = card_to_string_suits[SUIT(card)];
  40e981:	83 e0 03             	and    $0x3,%eax
  40e984:	0f b6 80 63 f1 40 00 	movzbl 0x40f163(%rax),%eax
    s[0] = card_to_string_values[VALUE(card)];
  40e98b:	49 c1 e9 02          	shr    $0x2,%r9
  40e98f:	45 0f b6 89 55 f1 40 	movzbl 0x40f155(%r9),%r9d
  40e996:	00 
    s[1] = card_to_string_suits[SUIT(card)];
  40e997:	41 88 40 01          	mov    %al,0x1(%r8)
        deck[j] = deck[--num_cards_left];
  40e99b:	8d 46 ff             	lea    -0x1(%rsi),%eax
  40e99e:	48 89 c6             	mov    %rax,%rsi
  40e9a1:	48 8b 84 c5 30 fe ff 	mov    -0x1d0(%rbp,%rax,8),%rax
  40e9a8:	ff 
    s[0] = card_to_string_values[VALUE(card)];
  40e9a9:	45 88 08             	mov    %r9b,(%r8)
        deck[j] = deck[--num_cards_left];
  40e9ac:	48 89 84 d5 30 fe ff 	mov    %rax,-0x1d0(%rbp,%rdx,8)
  40e9b3:	ff 
    for (size_t i = 0; i < 52; ++i)
  40e9b4:	85 f6                	test   %esi,%esi
  40e9b6:	75 98                	jne    40e950 <worker_thread+0xdd0>
  40e9b8:	e9 6f fb ff ff       	jmpq   40e52c <worker_thread+0x9ac>
  40e9bd:	0f 1f 00             	nopl   (%rax)
  40e9c0:	48 69 c9 fd 43 03 00 	imul   $0x343fd,%rcx,%rcx
        const microsoft_rand_uint j =
  40e9c7:	31 d2                	xor    %edx,%edx
        card_to_string(&ret[offset_by_i[i]], deck[j]);
  40e9c9:	4c 8b 07             	mov    (%rdi),%r8
  40e9cc:	48 83 c7 08          	add    $0x8,%rdi
  40e9d0:	4d 01 e0             	add    %r12,%r8
  40e9d3:	48 81 c1 c3 9e 26 00 	add    $0x269ec3,%rcx
    return ((*my_rand) >> 16) & 0x7fff;
  40e9da:	48 89 c8             	mov    %rcx,%rax
  40e9dd:	48 c1 f8 10          	sar    $0x10,%rax
  40e9e1:	25 ff 7f 00 00       	and    $0x7fff,%eax
        return ((gnGameNumber < 0x80000000) ? ret : (ret | 0x8000));
  40e9e6:	80 cc 80             	or     $0x80,%ah
        const microsoft_rand_uint j =
  40e9e9:	f7 f6                	div    %esi
        card_to_string(&ret[offset_by_i[i]], deck[j]);
  40e9eb:	89 d2                	mov    %edx,%edx
  40e9ed:	48 8b 84 d5 30 fe ff 	mov    -0x1d0(%rbp,%rdx,8),%rax
  40e9f4:	ff 
    s[0] = card_to_string_values[VALUE(card)];
  40e9f5:	49 89 c1             	mov    %rax,%r9
    s[1] = card_to_string_suits[SUIT(card)];
  40e9f8:	83 e0 03             	and    $0x3,%eax
  40e9fb:	0f b6 80 63 f1 40 00 	movzbl 0x40f163(%rax),%eax
    s[0] = card_to_string_values[VALUE(card)];
  40ea02:	49 c1 e9 02          	shr    $0x2,%r9
  40ea06:	45 0f b6 89 55 f1 40 	movzbl 0x40f155(%r9),%r9d
  40ea0d:	00 
    s[1] = card_to_string_suits[SUIT(card)];
  40ea0e:	41 88 40 01          	mov    %al,0x1(%r8)
        deck[j] = deck[--num_cards_left];
  40ea12:	8d 46 ff             	lea    -0x1(%rsi),%eax
  40ea15:	48 89 c6             	mov    %rax,%rsi
  40ea18:	48 8b 84 c5 30 fe ff 	mov    -0x1d0(%rbp,%rax,8),%rax
  40ea1f:	ff 
    s[0] = card_to_string_values[VALUE(card)];
  40ea20:	45 88 08             	mov    %r9b,(%r8)
        deck[j] = deck[--num_cards_left];
  40ea23:	48 89 84 d5 30 fe ff 	mov    %rax,-0x1d0(%rbp,%rdx,8)
  40ea2a:	ff 
    for (size_t i = 0; i < 52; ++i)
  40ea2b:	85 f6                	test   %esi,%esi
  40ea2d:	75 91                	jne    40e9c0 <worker_thread+0xe40>
  40ea2f:	e9 f8 fa ff ff       	jmpq   40e52c <worker_thread+0x9ac>
        s[0] = '\n';
  40ea34:	b8 0a 00 00 00       	mov    $0xa,%eax
  40ea39:	66 41 89 87 48 0a 00 	mov    %ax,0xa48(%r15)
  40ea40:	00 
    return resume_solution(user);
  40ea41:	4c 89 ff             	mov    %r15,%rdi
  40ea44:	c5 f8 29 8d 70 fd ff 	vmovaps %xmm1,-0x290(%rbp)
  40ea4b:	ff 
  40ea4c:	e8 2f ba ff ff       	callq  40a480 <resume_solution>
    switch (freecell_solver_user_solve_board(instance, state_string))
  40ea51:	c5 f9 6f 8d 70 fd ff 	vmovdqa -0x290(%rbp),%xmm1
  40ea58:	ff 
  40ea59:	83 f8 05             	cmp    $0x5,%eax
  40ea5c:	0f 84 de 00 00 00    	je     40eb40 <worker_thread+0xfc0>
  40ea62:	83 f8 0c             	cmp    $0xc,%eax
  40ea65:	0f 84 88 00 00 00    	je     40eaf3 <worker_thread+0xf73>
  40ea6b:	83 f8 01             	cmp    $0x1,%eax
  40ea6e:	0f 85 08 fb ff ff    	jne    40e57c <worker_thread+0x9fc>
    FCS_GET_TIME(ret);
  40ea74:	48 8d 85 30 fe ff ff 	lea    -0x1d0(%rbp),%rax
  40ea7b:	c5 f8 29 8d 70 fd ff 	vmovaps %xmm1,-0x290(%rbp)
  40ea82:	ff 
  40ea83:	48 8d 70 10          	lea    0x10(%rax),%rsi
  40ea87:	48 89 c7             	mov    %rax,%rdi
  40ea8a:	e8 d1 26 ff ff       	callq  401160 <gettimeofday@plt>
    printf("Unsolved " FCS_B_AT_FMT "\n", board_num, FCS_TIME_GET_SEC(mytime),
  40ea8f:	48 89 de             	mov    %rbx,%rsi
  40ea92:	bf 00 f2 40 00       	mov    $0x40f200,%edi
  40ea97:	31 c0                	xor    %eax,%eax
  40ea99:	48 8b 8d 38 fe ff ff 	mov    -0x1c8(%rbp),%rcx
  40eaa0:	48 8b 95 30 fe ff ff 	mov    -0x1d0(%rbp),%rdx
  40eaa7:	e8 84 25 ff ff       	callq  401030 <printf@plt>
  40eaac:	c5 f9 6f 8d 70 fd ff 	vmovdqa -0x290(%rbp),%xmm1
  40eab3:	ff 
  40eab4:	e9 c3 fa ff ff       	jmpq   40e57c <worker_thread+0x9fc>
  40eab9:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
                pthread_mutex_lock(&total_num_iters_lock);
  40eac0:	bf 20 31 41 00       	mov    $0x413120,%edi
  40eac5:	c5 f8 29 8d 70 fd ff 	vmovaps %xmm1,-0x290(%rbp)
  40eacc:	ff 
  40eacd:	e8 7e 26 ff ff       	callq  401150 <pthread_mutex_lock@plt>
                pthread_mutex_unlock(&total_num_iters_lock);
  40ead2:	bf 20 31 41 00       	mov    $0x413120,%edi
                total_num_iters += total_num_iters_temp;
  40ead7:	4c 01 35 2a 46 00 00 	add    %r14,0x462a(%rip)        # 413108 <total_num_iters>
                total_num_iters_temp = 0;
  40eade:	45 31 f6             	xor    %r14d,%r14d
                pthread_mutex_unlock(&total_num_iters_lock);
  40eae1:	e8 da 25 ff ff       	callq  4010c0 <pthread_mutex_unlock@plt>
                total_num_iters_temp = 0;
  40eae6:	c5 f9 6f 8d 70 fd ff 	vmovdqa -0x290(%rbp),%xmm1
  40eaed:	ff 
  40eaee:	e9 b9 fa ff ff       	jmpq   40e5ac <worker_thread+0xa2c>
{
#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");
  40eaf3:	48 8b 3d e6 45 00 00 	mov    0x45e6(%rip),%rdi        # 4130e0 <stderr@@GLIBC_2.2.5>
  40eafa:	ba 68 f1 40 00       	mov    $0x40f168,%edx
  40eaff:	be 7a f1 40 00       	mov    $0x40f17a,%esi
  40eb04:	31 c0                	xor    %eax,%eax
  40eb06:	e8 35 26 ff ff       	callq  401140 <fprintf@plt>
        if ((ret_code != FCS_STATE_NOT_BEGAN_YET) &&
  40eb0b:	41 8b 87 b8 05 00 00 	mov    0x5b8(%r15),%eax
  40eb12:	83 e8 08             	sub    $0x8,%eax
  40eb15:	83 f8 01             	cmp    $0x1,%eax
  40eb18:	0f 86 36 fb ff ff    	jbe    40e654 <worker_thread+0xad4>
            (ret_code != FCS_STATE_INVALID_STATE) &&
  40eb1e:	41 80 bf bc 05 00 00 	cmpb   $0x0,0x5bc(%r15)
  40eb25:	00 
  40eb26:	0f 85 28 fb ff ff    	jne    40e654 <worker_thread+0xad4>
            fc_solve_finish_instance(instance);
  40eb2c:	4c 89 ff             	mov    %r15,%rdi
  40eb2f:	e8 ec 2b ff ff       	callq  401720 <fc_solve_finish_instance>
  40eb34:	e9 1b fb ff ff       	jmpq   40e654 <worker_thread+0xad4>
  40eb39:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
    FCS_GET_TIME(ret);
  40eb40:	48 8d 85 30 fe ff ff 	lea    -0x1d0(%rbp),%rax
  40eb47:	c5 f8 29 8d 70 fd ff 	vmovaps %xmm1,-0x290(%rbp)
  40eb4e:	ff 
  40eb4f:	48 8d 70 10          	lea    0x10(%rax),%rsi
  40eb53:	48 89 c7             	mov    %rax,%rdi
  40eb56:	e8 05 26 ff ff       	callq  401160 <gettimeofday@plt>
    printf("Intractable " FCS_B_AT_FMT "\n", board_num,
  40eb5b:	48 89 de             	mov    %rbx,%rsi
  40eb5e:	bf d0 f1 40 00       	mov    $0x40f1d0,%edi
  40eb63:	31 c0                	xor    %eax,%eax
  40eb65:	48 8b 8d 38 fe ff ff 	mov    -0x1c8(%rbp),%rcx
  40eb6c:	48 8b 95 30 fe ff ff 	mov    -0x1d0(%rbp),%rdx
  40eb73:	e8 b8 24 ff ff       	callq  401030 <printf@plt>
  40eb78:	c5 f9 6f 8d 70 fd ff 	vmovdqa -0x290(%rbp),%xmm1
  40eb7f:	ff 
  40eb80:	e9 f7 f9 ff ff       	jmpq   40e57c <worker_thread+0x9fc>
        strcpy(s, orig_str);
  40eb85:	48 8b bd 60 fd ff ff 	mov    -0x2a0(%rbp),%rdi
  40eb8c:	49 8d 55 01          	lea    0x1(%r13),%rdx
  40eb90:	4c 89 e6             	mov    %r12,%rsi
  40eb93:	c5 f8 29 8d 70 fd ff 	vmovaps %xmm1,-0x290(%rbp)
  40eb9a:	ff 
  40eb9b:	e8 40 25 ff ff       	callq  4010e0 <memcpy@plt>
        char *s_end = s + len - 1;
  40eba0:	48 8b 85 60 fd ff ff 	mov    -0x2a0(%rbp),%rax
        if ((*s_end) != TRAILING_CHAR)
  40eba7:	c5 f9 6f 8d 70 fd ff 	vmovdqa -0x290(%rbp),%xmm1
  40ebae:	ff 
        char *s_end = s + len - 1;
  40ebaf:	4a 8d 44 28 ff       	lea    -0x1(%rax,%r13,1),%rax
        if ((*s_end) != TRAILING_CHAR)
  40ebb4:	80 38 0a             	cmpb   $0xa,(%rax)
  40ebb7:	0f 84 84 fe ff ff    	je     40ea41 <worker_thread+0xec1>
            *(++s_end) = TRAILING_CHAR;
  40ebbd:	ba 0a 00 00 00       	mov    $0xa,%edx
  40ebc2:	66 89 50 01          	mov    %dx,0x1(%rax)
  40ebc6:	e9 76 fe ff ff       	jmpq   40ea41 <worker_thread+0xec1>
    fc_solve_finish_instance(instance);
  40ebcb:	4c 89 ff             	mov    %r15,%rdi
  40ebce:	c5 f8 29 8d 70 fd ff 	vmovaps %xmm1,-0x290(%rbp)
  40ebd5:	ff 
  40ebd6:	e8 45 2b ff ff       	callq  401720 <fc_solve_finish_instance>
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40ebdb:	49 8b 97 d8 00 00 00 	mov    0xd8(%r15),%rdx
    HT_FIELD(hard_thread, ht__max_num_checked_states) = FCS_INT_LIMIT_MAX;
  40ebe2:	48 b8 ff ff ff ff ff 	movabs $0x7fffffffffffffff,%rax
  40ebe9:	ff ff 7f 
    instance->i__num_checked_states = 0;
  40ebec:	49 c7 07 00 00 00 00 	movq   $0x0,(%r15)
  40ebf3:	49 89 87 c8 00 00 00 	mov    %rax,0xc8(%r15)
    meta_allocator *const meta = allocator->meta;
  40ebfa:	49 8b bf f8 00 00 00 	mov    0xf8(%r15),%rdi
    instance->num_hard_threads_finished = 0;
  40ec01:	49 c7 87 40 05 00 00 	movq   $0x0,0x540(%r15)
  40ec08:	00 00 00 00 
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40ec0c:	c5 f9 6f 8d 70 fd ff 	vmovdqa -0x290(%rbp),%xmm1
  40ec13:	ff 
    HT_FIELD(hard_thread, num_soft_threads_finished) = 0;
  40ec14:	41 c7 87 28 05 00 00 	movl   $0x0,0x528(%r15)
  40ec1b:	00 00 00 00 
  40ec1f:	48 8b 02             	mov    (%rdx),%rax
    var_AUTO(bin, meta->recycle_bin);
  40ec22:	48 8b 37             	mov    (%rdi),%rsi
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40ec25:	48 85 c0             	test   %rax,%rax
  40ec28:	75 0c                	jne    40ec36 <worker_thread+0x10b6>
  40ec2a:	e9 4d 01 00 00       	jmpq   40ed7c <worker_thread+0x11fc>
  40ec2f:	90                   	nop
  40ec30:	48 89 c2             	mov    %rax,%rdx
  40ec33:	48 89 c8             	mov    %rcx,%rax
        OLD_LIST_NEXT(iter) = bin;
  40ec36:	48 89 32             	mov    %rsi,(%rdx)
         iter = iter_next, iter_next = OLD_LIST_NEXT(iter))
  40ec39:	48 8b 08             	mov    (%rax),%rcx
  40ec3c:	48 89 d6             	mov    %rdx,%rsi
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40ec3f:	48 85 c9             	test   %rcx,%rcx
  40ec42:	75 ec                	jne    40ec30 <worker_thread+0x10b0>
    OLD_LIST_NEXT(iter) = bin;
  40ec44:	48 89 10             	mov    %rdx,(%rax)
    ST_LOOP_START()
  40ec47:	49 8b 8f 20 05 00 00 	mov    0x520(%r15),%rcx
    meta->recycle_bin = iter;
  40ec4e:	48 89 07             	mov    %rax,(%rdi)
  40ec51:	4d 8b af c0 00 00 00 	mov    0xc0(%r15),%r13
  40ec58:	49 c7 87 d8 00 00 00 	movq   $0x0,0xd8(%r15)
  40ec5f:	00 00 00 00 
        meta_alloc->recycle_bin = OLD_LIST_NEXT(ret);
  40ec63:	48 8b 10             	mov    (%rax),%rdx
  40ec66:	48 89 17             	mov    %rdx,(%rdi)
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40ec69:	48 8d 50 08          	lea    0x8(%rax),%rdx
    OLD_LIST_NEXT(new_data) = allocator->old_list;
  40ec6d:	48 c7 00 00 00 00 00 	movq   $0x0,(%rax)
    allocator->ptr = allocator->rollback_ptr = OLD_LIST_DATA(new_data);
  40ec74:	49 89 97 f0 00 00 00 	mov    %rdx,0xf0(%r15)
  40ec7b:	49 89 97 e8 00 00 00 	mov    %rdx,0xe8(%r15)
  40ec82:	48 89 ca             	mov    %rcx,%rdx
  40ec85:	48 c1 e2 06          	shl    $0x6,%rdx
    allocator->old_list = new_data;
  40ec89:	49 89 87 d8 00 00 00 	mov    %rax,0xd8(%r15)
    allocator->max_ptr = new_data + ALLOCED_SIZE;
  40ec90:	48 05 80 fe 00 00    	add    $0xfe80,%rax
  40ec96:	48 29 ca             	sub    %rcx,%rdx
  40ec99:	49 89 87 e0 00 00 00 	mov    %rax,0xe0(%r15)
  40eca0:	49 8d 44 d5 00       	lea    0x0(%r13,%rdx,8),%rax
  40eca5:	49 39 c5             	cmp    %rax,%r13
  40eca8:	73 58                	jae    40ed02 <worker_thread+0x1182>
  40ecaa:	48 89 9d 58 fd ff ff 	mov    %rbx,-0x2a8(%rbp)
  40ecb1:	4c 89 eb             	mov    %r13,%rbx
  40ecb4:	49 89 c5             	mov    %rax,%r13
  40ecb7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
  40ecbe:	00 00 
    free(pq->elems);
  40ecc0:	48 8b bb 00 01 00 00 	mov    0x100(%rbx),%rdi
  40ecc7:	c5 f8 29 8d 70 fd ff 	vmovaps %xmm1,-0x290(%rbp)
  40ecce:	ff 
  40eccf:	48 81 c3 f8 01 00 00 	add    $0x1f8,%rbx
  40ecd6:	e8 75 23 ff ff       	callq  401050 <free@plt>
    STRUCT_CLEAR_FLAG(soft_thread, FCS_SOFT_THREAD_IS_FINISHED);
  40ecdb:	c6 43 e8 00          	movb   $0x0,-0x18(%rbx)
  40ecdf:	c5 f9 6f 8d 70 fd ff 	vmovdqa -0x290(%rbp),%xmm1
  40ece6:	ff 
    pq->elems = NULL;
  40ece7:	48 c7 83 08 ff ff ff 	movq   $0x0,-0xf8(%rbx)
  40ecee:	00 00 00 00 
    STRUCT_CLEAR_FLAG(soft_thread, FCS_SOFT_THREAD_INITIALIZED);
  40ecf2:	c6 43 e9 00          	movb   $0x0,-0x17(%rbx)
  40ecf6:	49 39 dd             	cmp    %rbx,%r13
  40ecf9:	77 c5                	ja     40ecc0 <worker_thread+0x1140>
  40ecfb:	48 8b 9d 58 fd ff ff 	mov    -0x2a8(%rbp),%rbx
        flare->instance_is_ready = TRUE;
  40ed02:	41 c6 87 bc 05 00 00 	movb   $0x1,0x5bc(%r15)
  40ed09:	01 
  40ed0a:	e9 ca f8 ff ff       	jmpq   40e5d9 <worker_thread+0xa59>
                pthread_mutex_lock(&total_num_iters_lock);
  40ed0f:	bf 20 31 41 00       	mov    $0x413120,%edi
  40ed14:	c5 f8 29 8d 70 fd ff 	vmovaps %xmm1,-0x290(%rbp)
  40ed1b:	ff 
  40ed1c:	e8 2f 24 ff ff       	callq  401150 <pthread_mutex_lock@plt>
                    (total_num_iters += total_num_iters_temp);
  40ed21:	4c 03 35 e0 43 00 00 	add    0x43e0(%rip),%r14        # 413108 <total_num_iters>
                pthread_mutex_unlock(&total_num_iters_lock);
  40ed28:	bf 20 31 41 00       	mov    $0x413120,%edi
                    (total_num_iters += total_num_iters_temp);
  40ed2d:	4c 89 35 d4 43 00 00 	mov    %r14,0x43d4(%rip)        # 413108 <total_num_iters>
                pthread_mutex_unlock(&total_num_iters_lock);
  40ed34:	e8 87 23 ff ff       	callq  4010c0 <pthread_mutex_unlock@plt>
    FCS_GET_TIME(ret);
  40ed39:	48 8d 85 30 fe ff ff 	lea    -0x1d0(%rbp),%rax
  40ed40:	48 8d 70 10          	lea    0x10(%rax),%rsi
  40ed44:	48 89 c7             	mov    %rax,%rdi
  40ed47:	e8 14 24 ff ff       	callq  401160 <gettimeofday@plt>
    printf("Reached " FCS_B_AT_FMT " (total_num_iters=" FCS_LL_FMT ")\n",
  40ed4c:	4d 89 f0             	mov    %r14,%r8
  40ed4f:	48 89 de             	mov    %rbx,%rsi
  40ed52:	bf 28 f2 40 00       	mov    $0x40f228,%edi
  40ed57:	48 8b 8d 38 fe ff ff 	mov    -0x1c8(%rbp),%rcx
  40ed5e:	31 c0                	xor    %eax,%eax
                total_num_iters_temp = 0;
  40ed60:	45 31 f6             	xor    %r14d,%r14d
  40ed63:	48 8b 95 30 fe ff ff 	mov    -0x1d0(%rbp),%rdx
  40ed6a:	e8 c1 22 ff ff       	callq  401030 <printf@plt>
  40ed6f:	c5 f9 6f 8d 70 fd ff 	vmovdqa -0x290(%rbp),%xmm1
  40ed76:	ff 
  40ed77:	e9 45 f8 ff ff       	jmpq   40e5c1 <worker_thread+0xa41>
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40ed7c:	48 89 d0             	mov    %rdx,%rax
    var_AUTO(bin, meta->recycle_bin);
  40ed7f:	48 89 f2             	mov    %rsi,%rdx
  40ed82:	e9 bd fe ff ff       	jmpq   40ec44 <worker_thread+0x10c4>
  40ed87:	49 8b 87 40 06 00 00 	mov    0x640(%r15),%rax
  40ed8e:	e9 e6 f4 ff ff       	jmpq   40e279 <worker_thread+0x6f9>
  40ed93:	49 8b 87 40 06 00 00 	mov    0x640(%r15),%rax
  40ed9a:	e9 64 f4 ff ff       	jmpq   40e203 <worker_thread+0x683>
  40ed9f:	49 8b 87 40 06 00 00 	mov    0x640(%r15),%rax
  40eda6:	e9 0d f5 ff ff       	jmpq   40e2b8 <worker_thread+0x738>
  40edab:	49 8b 87 40 06 00 00 	mov    0x640(%r15),%rax
  40edb2:	e9 a5 f0 ff ff       	jmpq   40de5c <worker_thread+0x2dc>
  40edb7:	49 8b 87 40 06 00 00 	mov    0x640(%r15),%rax
  40edbe:	e9 20 f0 ff ff       	jmpq   40dde3 <worker_thread+0x263>
  40edc3:	49 8b 87 40 06 00 00 	mov    0x640(%r15),%rax
  40edca:	e9 bf ef ff ff       	jmpq   40dd8e <worker_thread+0x20e>
  40edcf:	49 8b 87 40 06 00 00 	mov    0x640(%r15),%rax
  40edd6:	e9 53 ef ff ff       	jmpq   40dd2e <worker_thread+0x1ae>
  40eddb:	49 8b 87 40 06 00 00 	mov    0x640(%r15),%rax
  40ede2:	e9 bc f3 ff ff       	jmpq   40e1a3 <worker_thread+0x623>
  40ede7:	49 8b 87 40 06 00 00 	mov    0x640(%r15),%rax
  40edee:	e9 5b f3 ff ff       	jmpq   40e14e <worker_thread+0x5ce>
  40edf3:	49 8b 87 40 06 00 00 	mov    0x640(%r15),%rax
  40edfa:	e9 e8 f2 ff ff       	jmpq   40e0e7 <worker_thread+0x567>
  40edff:	49 8b 87 40 06 00 00 	mov    0x640(%r15),%rax
  40ee06:	e9 6a f2 ff ff       	jmpq   40e075 <worker_thread+0x4f5>
  40ee0b:	49 8b 87 40 06 00 00 	mov    0x640(%r15),%rax
  40ee12:	e9 10 f2 ff ff       	jmpq   40e027 <worker_thread+0x4a7>
  40ee17:	49 8b 87 40 06 00 00 	mov    0x640(%r15),%rax
  40ee1e:	e9 92 f1 ff ff       	jmpq   40dfb5 <worker_thread+0x435>
  40ee23:	49 8b 87 40 06 00 00 	mov    0x640(%r15),%rax
  40ee2a:	e9 0d f1 ff ff       	jmpq   40df3c <worker_thread+0x3bc>
  40ee2f:	49 8b 87 40 06 00 00 	mov    0x640(%r15),%rax
  40ee36:	e9 88 f0 ff ff       	jmpq   40dec3 <worker_thread+0x343>
        return malloc(ALLOCED_SIZE);
  40ee3b:	bf 80 fe 00 00       	mov    $0xfe80,%edi
  40ee40:	e8 ab 22 ff ff       	callq  4010f0 <malloc@plt>
  40ee45:	e9 20 ee ff ff       	jmpq   40dc6a <worker_thread+0xea>
    for (iter = allocator->old_list, iter_next = OLD_LIST_NEXT(iter); iter_next;
  40ee4a:	48 89 c2             	mov    %rax,%rdx
    var_AUTO(bin, meta->recycle_bin);
  40ee4d:	48 89 f0             	mov    %rsi,%rax
  40ee50:	e9 3f fa ff ff       	jmpq   40e894 <worker_thread+0xd14>
    for (iter = meta_alloc->recycle_bin,
  40ee55:	48 89 fb             	mov    %rdi,%rbx
  40ee58:	e9 c6 fa ff ff       	jmpq   40e923 <worker_thread+0xda3>
  40ee5d:	0f 1f 00             	nopl   (%rax)

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

static inline __attribute__((noreturn))
__attribute__((format(printf, 1, 2))) void
fc_solve_err(const char *msg, ...)
{
  40ee60:	48 81 ec d8 00 00 00 	sub    $0xd8,%rsp
  40ee67:	48 89 74 24 28       	mov    %rsi,0x28(%rsp)
  40ee6c:	48 89 54 24 30       	mov    %rdx,0x30(%rsp)
  40ee71:	48 89 4c 24 38       	mov    %rcx,0x38(%rsp)
  40ee76:	4c 89 44 24 40       	mov    %r8,0x40(%rsp)
  40ee7b:	4c 89 4c 24 48       	mov    %r9,0x48(%rsp)
  40ee80:	84 c0                	test   %al,%al
  40ee82:	74 3f                	je     40eec3 <fc_solve_err+0x63>
  40ee84:	c5 f8 29 44 24 50    	vmovaps %xmm0,0x50(%rsp)
  40ee8a:	c5 f8 29 4c 24 60    	vmovaps %xmm1,0x60(%rsp)
  40ee90:	c5 f8 29 54 24 70    	vmovaps %xmm2,0x70(%rsp)
  40ee96:	c5 f8 29 9c 24 80 00 	vmovaps %xmm3,0x80(%rsp)
  40ee9d:	00 00 
  40ee9f:	c5 f8 29 a4 24 90 00 	vmovaps %xmm4,0x90(%rsp)
  40eea6:	00 00 
  40eea8:	c5 f8 29 ac 24 a0 00 	vmovaps %xmm5,0xa0(%rsp)
  40eeaf:	00 00 
  40eeb1:	c5 f8 29 b4 24 b0 00 	vmovaps %xmm6,0xb0(%rsp)
  40eeb8:	00 00 
  40eeba:	c5 f8 29 bc 24 c0 00 	vmovaps %xmm7,0xc0(%rsp)
  40eec1:	00 00 
    va_list ap;

    va_start(ap, msg);
    vfprintf(stderr, msg, ap);
  40eec3:	48 89 fe             	mov    %rdi,%rsi
  40eec6:	48 8b 3d 13 42 00 00 	mov    0x4213(%rip),%rdi        # 4130e0 <stderr@@GLIBC_2.2.5>
  40eecd:	48 89 e2             	mov    %rsp,%rdx
    va_start(ap, msg);
  40eed0:	c7 04 24 08 00 00 00 	movl   $0x8,(%rsp)
  40eed7:	48 8d 84 24 e0 00 00 	lea    0xe0(%rsp),%rax
  40eede:	00 
  40eedf:	c7 44 24 04 30 00 00 	movl   $0x30,0x4(%rsp)
  40eee6:	00 
  40eee7:	48 89 44 24 08       	mov    %rax,0x8(%rsp)
  40eeec:	48 8d 44 24 20       	lea    0x20(%rsp),%rax
  40eef1:	48 89 44 24 10       	mov    %rax,0x10(%rsp)
    vfprintf(stderr, msg, ap);
  40eef6:	e8 25 22 ff ff       	callq  401120 <vfprintf@plt>
    va_end(ap);
    exit(-1);
  40eefb:	bf ff ff ff ff       	mov    $0xffffffff,%edi
  40ef00:	e8 0b 22 ff ff       	callq  401110 <exit@plt>
  40ef05:	66 2e 0f 1f 84 00 00 	nopw   %cs:0x0(%rax,%rax,1)
  40ef0c:	00 00 00 
  40ef0f:	90                   	nop

000000000040ef10 <__libc_csu_init>:
  40ef10:	41 57                	push   %r15
  40ef12:	49 89 d7             	mov    %rdx,%r15
  40ef15:	41 56                	push   %r14
  40ef17:	49 89 f6             	mov    %rsi,%r14
  40ef1a:	41 55                	push   %r13
  40ef1c:	41 89 fd             	mov    %edi,%r13d
  40ef1f:	41 54                	push   %r12
  40ef21:	4c 8d 25 98 3e 00 00 	lea    0x3e98(%rip),%r12        # 412dc0 <__frame_dummy_init_array_entry>
  40ef28:	55                   	push   %rbp
  40ef29:	48 8d 2d 98 3e 00 00 	lea    0x3e98(%rip),%rbp        # 412dc8 <__init_array_end>
  40ef30:	53                   	push   %rbx
  40ef31:	4c 29 e5             	sub    %r12,%rbp
  40ef34:	48 83 ec 08          	sub    $0x8,%rsp
  40ef38:	e8 c3 20 ff ff       	callq  401000 <_init>
  40ef3d:	48 c1 fd 03          	sar    $0x3,%rbp
  40ef41:	74 1b                	je     40ef5e <__libc_csu_init+0x4e>
  40ef43:	31 db                	xor    %ebx,%ebx
  40ef45:	0f 1f 00             	nopl   (%rax)
  40ef48:	4c 89 fa             	mov    %r15,%rdx
  40ef4b:	4c 89 f6             	mov    %r14,%rsi
  40ef4e:	44 89 ef             	mov    %r13d,%edi
  40ef51:	41 ff 14 dc          	callq  *(%r12,%rbx,8)
  40ef55:	48 83 c3 01          	add    $0x1,%rbx
  40ef59:	48 39 dd             	cmp    %rbx,%rbp
  40ef5c:	75 ea                	jne    40ef48 <__libc_csu_init+0x38>
  40ef5e:	48 83 c4 08          	add    $0x8,%rsp
  40ef62:	5b                   	pop    %rbx
  40ef63:	5d                   	pop    %rbp
  40ef64:	41 5c                	pop    %r12
  40ef66:	41 5d                	pop    %r13
  40ef68:	41 5e                	pop    %r14
  40ef6a:	41 5f                	pop    %r15
  40ef6c:	c3                   	retq   
  40ef6d:	0f 1f 00             	nopl   (%rax)

000000000040ef70 <__libc_csu_fini>:
  40ef70:	c3                   	retq   

Disassembly of section .fini:

000000000040ef74 <_fini>:
  40ef74:	48 83 ec 08          	sub    $0x8,%rsp
  40ef78:	48 83 c4 08          	add    $0x8,%rsp
  40ef7c:	c3                   	retq   
