// File: /workspace/github_cpp_makefile_star2_O3/myudelson[P]hmm-scalable/InputUtil.cpp
// Function: InputUtil::readTxt(char const*, param*)
bool InputUtil::readTxt(const char *fn, struct param * param) {
	FILE *fid = fopen(fn,"r");
    if( fid == NULL) {
        fprintf(stderr,"Could not read input file (%s).\n",fn);
        return false;
    }
    
	int number_columns = 0;
	max_line_length = 1024;
	char *col;
    
	// count lines and check for number of columns
	line = (char *)malloc((size_t)max_line_length);// Malloc(char,max_line_length);
	
	// grab memory and read all data
	StripedArray<NPAR> *striped_dat_obs = new StripedArray<NPAR>();
	StripedArray<NCAT> *striped_dat_group = new StripedArray<NCAT>();
    StripedArray<NCAT> *striped_dat_skill = NULL;
    StripedArray<NCAT> *striped_dat_skill_stacked = NULL;
    StripedArray<NCAT> *striped_dat_skill_rcount  = NULL;
    StripedArray<NCAT> *striped_dat_skill_rix     = NULL;
    NDAT current_stacked = 0;
    if(param->multiskill==0)
        striped_dat_skill = new StripedArray<NCAT>();
    else {
//        param->dat_multiskill = new StripedArray< NCAT* >(true);
        striped_dat_skill_stacked = new StripedArray<NCAT>();
        striped_dat_skill_rcount  = new StripedArray<NCAT>();
        striped_dat_skill_rix     = new StripedArray<NCAT>();
    }
	StripedArray<NCAT> * striped_dat_item = new StripedArray<NCAT>();
    StripedArray<NPAR> *striped_dat_slice = NULL;
    if(param->sliced)
        striped_dat_slice = new StripedArray<NPAR>();
    param->map_group_fwd = new map<string,NCAT>();
    param->map_group_bwd = new map<NCAT,string>();
    param->map_skill_fwd = new map<string,NCAT>();
    param->map_skill_bwd = new map<NCAT,string>();
    param->map_step_fwd = new map<string,NCAT>();
    param->map_step_bwd = new map<NCAT,string>();
	string s_group, s_step, s_skill;
    NPAR slice = 0;
	map<string,NCAT>::iterator it;
	map<string,NCAT>::iterator it2;
	bool wrong_no_columns = false;
    param->N = 0;
    param->Nstacked = 0;
    NDAT Nstacked_alt = 0;
    param->N_null = 0;
	while( readline(fid)!=NULL && !wrong_no_columns) {
        //    while( NULL!=fgets(line,max_line_length,fid) && !wrong_no_columns) {
		number_columns = 0;
		// Observation
		col = strtok(line,"\t\n\r");
		if(col == NULL) {
			wrong_no_columns = true;
			break;
		}
		number_columns++;
		NPAR obs = (NPAR)(atoi( col )-1);
		if(obs==NPAR_MAX) {
			fprintf(stderr,"Number of observtions exceeds allowed maximum of %d.\n",NPAR_MAX);
			return false;
		}
		striped_dat_obs->add(obs); // dat_obs[t] = (NPAR)obs;
		if( (obs >= 0) && ((param->nO-1) < obs) )
			param->nO = (NPAR)(obs + 1); // obs[t] + 1;

		// Group
		col = strtok(NULL,"\t\n\r");
		if(col == NULL) {
			wrong_no_columns = true;
			break;
		}
		number_columns++;
		s_group = string( col );
		it = param->map_group_fwd->find(s_group);
		if( it==param->map_group_fwd->end() ) { // not found
			if(param->map_group_fwd->size()==NCAT_MAX) {
				fprintf(stderr,"Number of unique groups exceeds allowed maximum of %d.\n",NCAT_MAX);
				return false;
			}
			NCAT newg = (NCAT)param->map_group_fwd->size();
			striped_dat_group->add(newg); //[t] = param->map_group_fwd.size();
			param->map_group_fwd->insert(pair<string,NCAT>(s_group, newg));
			param->map_group_bwd->insert(pair<NCAT,string>(newg, s_group));
		}
		else
			striped_dat_group->add(it->second); // [t] = it->second;
		
		
		// Step
		col = strtok(NULL,"\t\n\r");
		if(col == NULL) {
			wrong_no_columns = true;
			break;
		}
		number_columns++;
		s_step = string( col );
		it2 = param->map_step_fwd->find(s_step);
		if( it2==param->map_step_fwd->end() ) { // not found
			if(param->map_step_fwd->size()==NCAT_MAX) {
				fprintf(stderr,"Number of unique steps exceeds allowed maximum of %d.\n",NCAT_MAX);
				return false;
			}
            NCAT news = (NCAT)param->map_step_fwd->size();
			striped_dat_item->add(news); //[t] = param->map_group_fwd.size();
			param->map_step_fwd->insert(pair<string,NCAT>(s_step, news));
			param->map_step_bwd->insert(pair<NCAT,string>(news, s_step));
		}
		else
            striped_dat_item->add(it2->second);
		
        
		// Skill
		col = strtok(NULL,"\t\n\r");
		if(col == NULL) {
			wrong_no_columns = true;
			break;
		}
		number_columns++;
		s_skill = string( col );
        // process skills later
        
        // Slice
        if(param->sliced) {
            col = strtok(NULL,"\t\n\r");
            if(col == NULL) {
                wrong_no_columns = true;
                break;
            }
            number_columns++;
            slice = (NPAR) atoi( col );
            if( slice<0 ) {
                fprintf(stderr,"Slice cannot be negative (line %d).\n",param->N+1);
				return false;
            }
            if( (slice >= 0) && ((param->nZ-1) < slice) ) // update slice count
                param->nZ = (NPAR)(slice + 1);
            striped_dat_slice->add(slice);
        } // time
        
        // back to skill processing
		if( (s_skill.empty() || ( s_skill.size()==1 && (s_skill[0]=='.' || s_skill[0]==' ') ) ) ) { // null skill
            param->N_null++;
            param->Nstacked++;	// increase stackd count too
            if(param->multiskill == 0) {
                striped_dat_skill->add(-1); // [t] = -1;
            }
            else {
                NCAT* a_skills = Malloc(NCAT, 2);
                a_skills[0] = 1; // count
                a_skills[1] = -1; // value
//                param->dat_multiskill->add(a_skills);
                // add whole multi-skill row
                striped_dat_skill_rcount->add(1);
                striped_dat_skill_rix->add(current_stacked++); // first add pointer, then increase
                striped_dat_skill_stacked->add(-1);
            }
		} // empty skill
		else { // non-empty skill
            // multiskill
            if(param->multiskill != 0) {
                list<NCAT> a_skills;//
                char* a_kc;
                col = &s_skill[0];//. c_str();
                a_kc  = strtok(col, "~\n\r");
                string s_kc;
                // stacked
                NDAT skill_count = 0;
                striped_dat_skill_rix->add(current_stacked); // add stacked pointer once (but increase it with every next skill
                while(a_kc != NULL) {
                    s_kc = string(a_kc);
                    // stacked
                    skill_count++;
                    current_stacked++;
                    param->Nstacked++;	// increase line count
                    // adding vvvv
                    it = param->map_skill_fwd->find(s_kc);
                    if( it==param->map_skill_fwd->end() ) { // not found
                        if(param->map_skill_fwd->size()==NCAT_MAX) {
                            fprintf(stderr,"Number of unique skills exceeds allowed maximum of %d.\n",NCAT_MAX);
                            return false;
                        }
                        a_skills.insert(a_skills.end(), (NCAT)param->map_skill_fwd->size()); //dat_skill->add(param->map_skill_fwd->size());
                        param->map_skill_fwd->insert(pair<string,NCAT>(s_kc, (NCAT)param->map_skill_fwd->size()));
                        param->map_skill_bwd->insert(pair<NCAT,string>((NCAT)param->map_skill_bwd->size(),s_kc));
                        // add stacked skill
                        striped_dat_skill_stacked->add((NCAT)param->map_skill_fwd->size()-1); // -1 because after adding
                    }
                    else {
                        a_skills.insert(a_skills.end(), it->second); //dat_skill->add(it->second); //[t] = it->second;
                        // add stacked skill
                        striped_dat_skill_stacked->add(it->second);
                    }
                    // adding ^^^^
                    a_kc  = strtok(NULL,"~\n\r");
                }
//                NCAT *b_skills = Malloc(NCAT, a_skills.size()+1);
//                b_skills[0] = (NCAT)a_skills.size();
//                int count = 0;
//                for(list<NCAT>::iterator it=a_skills.begin(); it!=a_skills.end(); it++)
//                    b_skills[++count] = *it;
//                param->dat_multiskill->add(b_skills);
                // add stacked count
                striped_dat_skill_rcount->add(skill_count);
                Nstacked_alt+=skill_count;
                // multi skill
            } else {
                // single skill
                it = param->map_skill_fwd->find(s_skill);
                if( it==param->map_skill_fwd->end() ) { // not found
                    if(param->map_skill_fwd->size()==NCAT_MAX) {
                        fprintf(stderr,"Number of unique skills exceeds allowed maximum of %d.\n",NCAT_MAX);
                        return false;
                    }
                    striped_dat_skill->add((NCAT)param->map_skill_fwd->size()); //[t] = param->map_skill_fwd.size();
                    param->map_skill_fwd->insert(pair<string,NCAT>(s_skill, (NCAT)param->map_skill_fwd->size()));
                    param->map_skill_bwd->insert(pair<NCAT,string>((NCAT)param->map_skill_bwd->size(),s_skill));
                }
                else
                    striped_dat_skill->add(it->second); //[t] = it->second;
            } // single skill
		} // non empty skill
        
		// count lines
		param->N++;	// increase line count
	}// reading loop
	if(wrong_no_columns) {
		fprintf(stderr,"Wrong number of columns in line %u. Expected %d, found %d\n",param->N+1,COLUMNS+param->sliced, number_columns);
		free(line);
		fclose(fid);
        return false;
	}
	param->nG = (NCAT)param->map_group_fwd->size();
	param->nK = (NCAT)param->map_skill_fwd->size();
	param->nI = (NCAT)param->map_step_fwd->size();
    
    // copy striped to lined
    param->dat_obs = striped_dat_obs->toArray();
  
    delete striped_dat_obs;
    param->dat_group = striped_dat_group->toArray();
    delete striped_dat_group;
    if(param->multiskill==0) {
        param->dat_skill = striped_dat_skill->toArray();
        delete striped_dat_skill;
    } else {
        param->dat_skill_stacked = striped_dat_skill_stacked->toArray();
        param->dat_skill_rcount  = striped_dat_skill_rcount->toArray();
        param->dat_skill_rix     = striped_dat_skill_rix->toArray();
        delete striped_dat_skill_stacked;
        delete striped_dat_skill_rcount;
        delete striped_dat_skill_rix;
    }
    param->dat_item = striped_dat_item->toArray();
    delete striped_dat_item;
    if(param->sliced) {
        param->dat_slice = striped_dat_slice->toArray();
        delete striped_dat_slice;
    }

	fclose(fid);
	free(line);
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rsi, %r14
movq %rdi, %r15
leaq 0x25400(%rip), %rsi     # 0x33044
callq 0x4290
testq %rax, %rax
je 0xe9d3
movq %rax, %r12
movl $0x400, 0x320e5(%rip)   # imm = 0x400
movl $0x400, %edi            # imm = 0x400
callq 0x4300
movq %rax, 0x320d8(%rip)     # 0x3fd48
movl $0x18, %edi
callq 0x4210
movabsq $0x4e2000000000, %rbx   # imm = 0x4E2000000000
movq %rbx, (%rax)
xorps %xmm0, %xmm0
movq %rax, 0x110(%rsp)
movups %xmm0, 0x8(%rax)
movl $0x18, %edi
callq 0x4210
movq %rbx, (%rax)
movq %rax, 0x80(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movb 0x918(%r14), %bpl
movl $0x18, %edi
callq 0x4210
xorps %xmm0, %xmm0
movq %rax, %r15
movq %rbx, (%rax)
movups %xmm0, 0x8(%rax)
testb %bpl, %bpl
je 0xdd11
movl $0x18, %edi
callq 0x4210
movq %rbx, (%rax)
movq %rax, 0x48(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movl $0x18, %edi
callq 0x4210
movq %rbx, (%rax)
movq %rax, 0x50(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %r15, 0x58(%rsp)
xorl %r15d, %r15d
jmp 0xdd2c
movq $0x0, 0x50(%rsp)
movq $0x0, 0x48(%rsp)
movq $0x0, 0x58(%rsp)
movl $0x18, %edi
callq 0x4210
movq %rbx, (%rax)
movq %rax, 0x78(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
cmpb $0x0, 0x33(%r14)
movq %r15, 0x60(%rsp)
je 0xdd6c
movl $0x18, %edi
callq 0x4210
movq %rbx, (%rax)
xorps %xmm0, %xmm0
movq %rax, 0x68(%rsp)
movups %xmm0, 0x8(%rax)
jmp 0xdd75
movq $0x0, 0x68(%rsp)
movl $0x30, %edi
callq 0x4210
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
xorl %ebx, %ebx
movq %rbx, 0x28(%rax)
movq %rax, 0x920(%r14)
movl $0x30, %edi
callq 0x4210
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %rbx, 0x28(%rax)
movq %rax, 0x928(%r14)
movl $0x30, %edi
callq 0x4210
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %rbx, 0x28(%rax)
movq %rax, 0x940(%r14)
movl $0x30, %edi
callq 0x4210
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %rbx, 0x28(%rax)
movq %rax, 0x948(%r14)
movl $0x30, %edi
callq 0x4210
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %rbx, 0x28(%rax)
movq %rax, 0x930(%r14)
movl $0x30, %edi
callq 0x4210
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %rbx, 0x28(%rax)
movq %rax, 0x938(%r14)
leaq 0xf8(%rsp), %rax
movq %rax, -0x10(%rax)
movq %rbx, -0x8(%rax)
movb %bl, (%rax)
leaq 0xd8(%rsp), %rax
movq %rax, -0x10(%rax)
movq %rbx, -0x8(%rax)
movb %bl, (%rax)
leaq 0xb8(%rsp), %rax
movq %rax, -0x10(%rax)
movq %rbx, -0x8(%rax)
movb %bl, (%rax)
movq %rbx, 0x8b0(%r14)
movl $0x0, 0x8cc(%r14)
movq 0x31e80(%rip), %rdi     # 0x3fd48
movl 0x31e76(%rip), %esi     # 0x3fd44
movq %r12, %rdx
callq 0x43c0
testq %rax, %rax
je 0xe7bb
leaq 0x33(%r14), %rax
movq %rax, 0x108(%rsp)
leaq 0x8b0(%r14), %rax
movq %rax, 0x70(%rsp)
movq %rsp, %r13
movl $0x0, 0x2c(%rsp)
movq 0x31e3f(%rip), %rbx     # 0x3fd48
movq %rbx, %rdi
movl $0xa, %esi
callq 0x4250
testq %rax, %rax
jne 0xdf7d
movq %rbx, %rdi
movl $0xd, %esi
callq 0x4250
testq %rax, %rax
jne 0xdf7d
movslq 0x31e10(%rip), %r15     # 0x3fd44
addq %r15, %r15
movl %r15d, 0x31e06(%rip)    # 0x3fd44
movq %rbx, %rdi
movq %r15, %rsi
callq 0x43f0
movq %rax, %rbx
movq %rax, 0x31df5(%rip)     # 0x3fd48
movq %rax, %rdi
callq 0x4100
cltq
addq %rax, %rbx
subl %eax, %r15d
movq %rbx, %rdi
movl %r15d, %esi
movq %r12, %rdx
callq 0x43c0
testq %rax, %rax
jne 0xdf02
movq 0x31dcb(%rip), %rbx     # 0x3fd48
testq %rbx, %rbx
je 0xe7bb
movq %rbx, %rdi
leaq 0x25261(%rip), %rsi     # 0x331f1
callq 0x43b0
testq %rax, %rax
je 0xe9f2
movq %rax, %rdi
callq 0x43a0
movl %eax, %ebx
leal -0x1(%rbx), %r15d
cmpb $0x7f, %r15b
je 0xe9f6
movsbl %r15b, %esi
movq 0x110(%rsp), %rdi
callq 0xfb86
testb %r15b, %r15b
js 0xdfdc
cmpb %r15b, 0x8b9(%r14)
jg 0xdfdc
movb %bl, 0x8b9(%r14)
xorl %edi, %edi
leaq 0x2520c(%rip), %rsi     # 0x331f1
callq 0x43b0
testq %rax, %rax
je 0xe9fd
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, (%rsp)
movq %rax, %rdi
callq 0x4100
movq %rbx, %rdx
addq %rax, %rdx
movq %r13, %rdi
movq %rbx, %rsi
callq 0xa7c0
leaq 0xe8(%rsp), %rdi
movq %r13, %rsi
callq 0x42c0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xe03e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4220
movq 0x920(%r14), %rdi
leaq 0xe8(%rsp), %rsi
callq 0xffc8
movq 0x920(%r14), %rcx
leaq 0x8(%rcx), %rdx
cmpq %rdx, %rax
je 0xe077
movl 0x40(%rax), %esi
movq 0x80(%rsp), %rdi
callq 0xfbdc
jmp 0xe147
movq 0x28(%rcx), %r15
cmpq $0x7fffffff, %r15       # imm = 0x7FFFFFFF
je 0xea3f
movq 0x80(%rsp), %rdi
movl %r15d, %esi
callq 0xfbdc
movq 0x920(%r14), %rbx
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0xe8(%rsp), %rsi
movq 0xf0(%rsp), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0xa6be
movl %r15d, 0x20(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x100c0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xe0ee
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4220
movq 0x928(%r14), %rbx
movl %r15d, (%rsp)
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0xe8(%rsp), %rsi
movq 0xf0(%rsp), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0xa6be
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1028a
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xe147
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4220
xorl %edi, %edi
leaq 0x250a1(%rip), %rsi     # 0x331f1
callq 0x43b0
testq %rax, %rax
je 0xea04
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, (%rsp)
movq %rax, %rdi
callq 0x4100
movq %rbx, %rdx
addq %rax, %rdx
movq %r13, %rdi
movq %rbx, %rsi
callq 0xa7c0
leaq 0xc8(%rsp), %rdi
movq %r13, %rsi
callq 0x42c0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xe1a9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4220
movq 0x930(%r14), %rdi
leaq 0xc8(%rsp), %rsi
callq 0xffc8
movq 0x930(%r14), %rcx
leaq 0x8(%rcx), %rdx
cmpq %rdx, %rax
je 0xe1df
movl 0x40(%rax), %esi
movq 0x78(%rsp), %rdi
callq 0xfbdc
jmp 0xe2ac
movq 0x28(%rcx), %r15
cmpq $0x7fffffff, %r15       # imm = 0x7FFFFFFF
je 0xea46
movq 0x78(%rsp), %rdi
movl %r15d, %esi
callq 0xfbdc
movq 0x930(%r14), %rbx
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0xc8(%rsp), %rsi
movq 0xd0(%rsp), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0xa6be
movl %r15d, 0x20(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x100c0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xe253
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4220
movq 0x938(%r14), %rbx
movl %r15d, (%rsp)
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0xc8(%rsp), %rsi
movq 0xd0(%rsp), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0xa6be
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1028a
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xe2ac
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4220
xorl %edi, %edi
leaq 0x24f3c(%rip), %rsi     # 0x331f1
callq 0x43b0
testq %rax, %rax
je 0xea0b
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, (%rsp)
movq %rax, %rdi
callq 0x4100
movq %rbx, %rdx
addq %rax, %rdx
movq %r13, %rdi
movq %rbx, %rsi
callq 0xa7c0
leaq 0xa8(%rsp), %rdi
movq %r13, %rsi
callq 0x42c0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xe30e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4220
movq 0x108(%rsp), %rax
cmpb $0x0, (%rax)
je 0xe364
xorl %edi, %edi
leaq 0x24ecd(%rip), %rsi     # 0x331f1
callq 0x43b0
testq %rax, %rax
je 0xea12
movq %rax, %rdi
callq 0x43a0
movsbl %al, %esi
testl %esi, %esi
js 0xea33
movsbl 0x8c8(%r14), %ecx
cmpl %ecx, %esi
jl 0xe35a
incb %al
movb %al, 0x8c8(%r14)
movq 0x68(%rsp), %rdi
callq 0xfb86
movq 0xb0(%rsp), %rax
testq %rax, %rax
je 0xe38c
cmpq $0x1, %rax
jne 0xe3dd
movq 0xa8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x2e, %eax
je 0xe38c
cmpl $0x20, %eax
jne 0xe3dd
incl 0x8cc(%r14)
incl 0x8b4(%r14)
cmpb $0x0, 0x918(%r14)
je 0xe674
movq 0x48(%rsp), %rdi
movl $0x1, %esi
callq 0xfbdc
movq 0x50(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0xfbdc
movq 0x58(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xfbdc
incl 0x2c(%rsp)
jmp 0xe6ac
cmpb $0x0, 0x918(%r14)
je 0xe67b
leaq 0x30(%rsp), %rax
movq %rax, 0x38(%rsp)
movq %rax, 0x30(%rsp)
xorl %r15d, %r15d
movq %r15, 0x40(%rsp)
movq 0xa8(%rsp), %rdi
leaq 0x25c62(%rip), %rsi     # 0x34073
callq 0x43b0
movq %rax, %rbx
leaq 0x98(%rsp), %rax
movq %rax, 0x88(%rsp)
movq %r15, 0x90(%rsp)
movb $0x0, 0x98(%rsp)
movq 0x50(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0xfbdc
xorl %r15d, %r15d
testq %rbx, %rbx
je 0xe613
leaq 0x10(%rsp), %rbp
movq %rbp, (%rsp)
movq %rbx, %rdi
callq 0x4100
leaq (%rax,%rbx), %rdx
movq %r13, %rdi
movq %rbx, %rsi
callq 0xa7c0
leaq 0x88(%rsp), %rdi
movq %r13, %rsi
callq 0x42c0
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0xe499
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4220
incl 0x8b4(%r14)
movq 0x940(%r14), %rdi
leaq 0x88(%rsp), %rsi
callq 0xffc8
movq %rax, %rbx
incl 0x2c(%rsp)
movq 0x940(%r14), %rax
leaq 0x8(%rax), %rcx
cmpq %rcx, %rbx
je 0xe4f5
movl $0x18, %edi
callq 0x4210
movl 0x40(%rbx), %ecx
movl %ecx, 0x10(%rax)
movq %rax, %rdi
leaq 0x30(%rsp), %rsi
callq 0x4070
incq 0x40(%rsp)
movl 0x40(%rbx), %esi
jmp 0xe5ec
movq 0x28(%rax), %rbx
cmpq $0x7fffffff, %rbx       # imm = 0x7FFFFFFF
je 0xe7af
movq %r12, %rbp
movl $0x18, %edi
callq 0x4210
movl %ebx, 0x10(%rax)
movq %rax, %rdi
leaq 0x30(%rsp), %rsi
callq 0x4070
incq 0x40(%rsp)
movq 0x940(%r14), %rbx
movq 0x28(%rbx), %r12
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x88(%rsp), %rsi
movq 0x90(%rsp), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0xa6be
movl %r12d, 0x20(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x100c0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
movq %rbp, %r12
je 0xe585
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4220
movq 0x948(%r14), %rbx
movl 0x28(%rbx), %eax
movl %eax, (%rsp)
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x88(%rsp), %rsi
movq 0x90(%rsp), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0xa6be
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1028a
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xe5e0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4220
movq 0x940(%r14), %rax
movl 0x28(%rax), %esi
decl %esi
movq 0x58(%rsp), %rdi
callq 0xfbdc
xorl %edi, %edi
leaq 0x25a74(%rip), %rsi     # 0x34073
callq 0x43b0
movq %rax, %rbx
incl %r15d
testq %rax, %rax
jne 0xe453
movb $0x1, %bl
movq 0x48(%rsp), %rdi
movl %r15d, %esi
callq 0xfbdc
movq 0x88(%rsp), %rdi
leaq 0x98(%rsp), %rax
cmpq %rax, %rdi
je 0xe647
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x4220
movq 0x30(%rsp), %rdi
leaq 0x30(%rsp), %rbp
cmpq %rbp, %rdi
je 0xe66b
movq (%rdi), %r15
movl $0x18, %esi
callq 0x4220
movq %r15, %rdi
cmpq %rbp, %r15
jne 0xe656
testb %bl, %bl
jne 0xe6ac
jmp 0xea2c
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
jmp 0xe6a2
movq 0x940(%r14), %rdi
leaq 0xa8(%rsp), %rsi
callq 0xffc8
movq 0x940(%r14), %rcx
leaq 0x8(%rcx), %rdx
cmpq %rdx, %rax
je 0xe6d6
movl 0x40(%rax), %esi
movq 0x60(%rsp), %rdi
callq 0xfbdc
movq 0x70(%rsp), %rax
incl (%rax)
movq 0x3168e(%rip), %rdi     # 0x3fd48
movl 0x31684(%rip), %esi     # 0x3fd44
movq %r12, %rdx
callq 0x43c0
testq %rax, %rax
jne 0xdf02
jmp 0xe7bb
movq 0x28(%rcx), %rsi
cmpq $0x7fffffff, %rsi       # imm = 0x7FFFFFFF
je 0xea4d
movq 0x60(%rsp), %rdi
callq 0xfbdc
movq 0x940(%r14), %rbx
movq 0x28(%rbx), %r15
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0xa8(%rsp), %rsi
movq 0xb0(%rsp), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0xa6be
movl %r15d, 0x20(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x100c0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xe74b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4220
movq 0x948(%r14), %rbx
movl 0x28(%rbx), %eax
movl %eax, (%rsp)
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0xa8(%rsp), %rsi
movq 0xb0(%rsp), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0xa6be
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1028a
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xe6ac
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4220
jmp 0xe6ac
callq 0x4898
xorl %ebx, %ebx
jmp 0xe622
movq 0x920(%r14), %rax
movq 0x930(%r14), %rcx
movl 0x28(%rax), %eax
movl %eax, 0x8bc(%r14)
movq 0x940(%r14), %rax
movl 0x28(%rax), %eax
movl %eax, 0x8c0(%r14)
movl 0x28(%rcx), %eax
movl %eax, 0x8c4(%r14)
movq 0x110(%rsp), %rbx
movq %rbx, %rdi
callq 0xfc30
movq %rax, 0x870(%r14)
movq %rbx, %rdi
callq 0xfcb2
movl $0x18, %esi
movq %rbx, %rdi
callq 0x4220
movq 0x80(%rsp), %rbx
movq %rbx, %rdi
callq 0xfcec
movq %rax, 0x878(%r14)
movq %rbx, %rdi
callq 0xfd80
movl $0x18, %esi
movq %rbx, %rdi
callq 0x4220
cmpb $0x0, 0x918(%r14)
je 0xe8b8
movq 0x58(%rsp), %r13
movq %r13, %rdi
callq 0xfcec
movq %rax, 0x888(%r14)
movq 0x48(%rsp), %rbx
movq %rbx, %rdi
callq 0xfcec
movq %rax, 0x890(%r14)
movq 0x50(%rsp), %r15
movq %r15, %rdi
callq 0xfcec
movq %rax, 0x898(%r14)
movq %r13, %rdi
callq 0xfd80
movl $0x18, %esi
movq %r13, %rdi
callq 0x4220
movq %rbx, %rdi
callq 0xfd80
movl $0x18, %esi
movq %rbx, %rdi
callq 0x4220
jmp 0xe8cc
movq 0x60(%rsp), %r15
movq %r15, %rdi
callq 0xfcec
movq %rax, 0x880(%r14)
movq %r15, %rdi
callq 0xfd80
movl $0x18, %esi
movq %r15, %rdi
callq 0x4220
movq 0x78(%rsp), %rbx
movq %rbx, %rdi
callq 0xfcec
movq %rax, 0x8a0(%r14)
movq %rbx, %rdi
callq 0xfd80
movl $0x18, %esi
movq %rbx, %rdi
callq 0x4220
cmpb $0x0, 0x33(%r14)
je 0xe93a
movq 0x68(%rsp), %rbx
movq %rbx, %rdi
callq 0xfc30
movq %rax, 0x8a8(%r14)
movq %rbx, %rdi
callq 0xfcb2
movl $0x18, %esi
movq %rbx, %rdi
callq 0x4220
movq %r12, %rdi
callq 0x4200
movq 0x313ff(%rip), %rdi     # 0x3fd48
callq 0x42a0
movb $0x1, %bl
movq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
cmpq %rax, %rdi
je 0xe975
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x4220
movq 0xc8(%rsp), %rdi
leaq 0xd8(%rsp), %rax
cmpq %rax, %rdi
je 0xe99a
movq 0xd8(%rsp), %rsi
incq %rsi
callq 0x4220
movq 0xe8(%rsp), %rdi
leaq 0xf8(%rsp), %rax
cmpq %rax, %rdi
je 0xe9bf
movq 0xf8(%rsp), %rsi
incq %rsi
callq 0x4220
movl %ebx, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x305fe(%rip), %rax     # 0x3efd8
movq (%rax), %rdi
leaq 0x255a4(%rip), %rsi     # 0x33f88
xorl %ebx, %ebx
movq %r15, %rdx
xorl %eax, %eax
callq 0x4330
jmp 0xe9bf
xorl %edx, %edx
jmp 0xea17
callq 0x4924
jmp 0xea2c
movl $0x1, %edx
jmp 0xea17
movl $0x2, %edx
jmp 0xea17
movl $0x3, %edx
jmp 0xea17
movl $0x4, %edx
movq 0x70(%rsp), %rdi
movq 0x108(%rsp), %rsi
movq %r12, %rcx
callq 0x4945
xorl %ebx, %ebx
jmp 0xe950
movq 0x70(%rsp), %rdi
callq 0x4873
jmp 0xea2c
callq 0x4901
jmp 0xea2c
callq 0x48de
jmp 0xea2c
callq 0x48bb
jmp 0xea2c
jmp 0xea7a
jmp 0xeb11
jmp 0xea99
jmp 0xeb11
jmp 0xeb11
jmp 0xea7a
jmp 0xeb11
jmp 0xea99
jmp 0xeb11
jmp 0xeb11
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xeb68
movq 0x18(%rsp), %rsi
jmp 0xeab3
jmp 0xeb11
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xeb68
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x4220
jmp 0xeb68
jmp 0xeb11
jmp 0xeb11
jmp 0xeb1c
jmp 0xeb11
jmp 0xeb11
jmp 0xeb11
jmp 0xeb11
jmp 0xeb11
jmp 0xeb11
jmp 0xeb1c
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xeb1f
movq 0x10(%rsp), %rsi
jmp 0xeb05
jmp 0xeb1c
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xeb1f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4220
jmp 0xeb1f
jmp 0xeb1c
movq %rax, %rbx
jmp 0xeb68
jmp 0xeb1c
jmp 0xeb1c
jmp 0xeb1c
movq %rax, %rbx
leaq 0x30(%rsp), %r15
movq 0x88(%rsp), %rdi
leaq 0x98(%rsp), %rax
cmpq %rax, %rdi
je 0xeb49
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x4220
movq 0x30(%rsp), %rdi
cmpq %r15, %rdi
je 0xeb68
movq (%rdi), %r14
movl $0x18, %esi
callq 0x4220
movq %r14, %rdi
cmpq %r15, %r14
jne 0xeb53
movq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
cmpq %rax, %rdi
je 0xeb8d
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x4220
movq 0xc8(%rsp), %rdi
leaq 0xd8(%rsp), %rax
cmpq %rax, %rdi
je 0xebb2
movq 0xd8(%rsp), %rsi
incq %rsi
callq 0x4220
movq 0xe8(%rsp), %rdi
leaq 0xf8(%rsp), %rax
cmpq %rax, %rdi
je 0xebd7
movq 0xf8(%rsp), %rsi
incq %rsi
callq 0x4220
movq %rbx, %rdi
callq 0x4430
nop