// File: /workspace/github_c_makefile_star2_O1/mishun[P]plantri/plantri.c
// Function: find_extensions_min5
static void
find_extensions_min5(int nbtot, int nbop, EDGE *extA1[], EDGE *extA2[],
   int *nextA, EDGE *extB[], int extBmirror[], int *nextB,
   EDGE *extC[], int *nextC, EDGE *lastA)

/* Determine the inequivalent places to make extensions, for the
   ordinary triangulations of minimum degree 5.  The results are
   put in the arrays extD1[0..*nextD-1], etc..
   nbtot and nbop are the usual group parameters.
   If lastA != NULL, this graph was made with an A-operation and lastA
   is its central edge.  If lastA == NULL, it wasn't made with A.
*/
{
    register int i,k;
    register EDGE *e,*e1,*e2,*elast,*elast1,*elast2;
    EDGE **nb,**nb0,**nblim,**nboplim,**nb1,**nb2;
    int v1,v2,d1,d2,xd1,xd2,oldcola,oldcolb,alpha,cola,colb;


    RESETMARKS_V;
    if (lastA)
    {
        v1 = lastA->start;
	v2 = lastA->end;
	d1 = degree[v1];
	d2 = degree[v2];
        MARK_V(v1);
        MARK_V(v2);
        MARK_V(lastA->prev->end);
        MARK_V(lastA->next->end);
    }

    if (nbtot == 1)
    {
      /* A-extensions, trivial group */

	k = 0;
	for (i = 0; i < nv; ++i)
	if (degree[i] >= 6)
	{
	    cola = degree[i] + 4;

	    if (ISMARKED_V(i) || !lastA || cola >= d1+d2+2)
	    {
	        e1 = elast1 = firstedge[i];
                do
                {
		    e2 = e1->next->next->next;
		    elast2 = e1->prev->prev;
		    do
		    {
		        if (e2 > e1)
		        {
			    extA1[k] = e1;
			    extA2[k] = e2;
			    ++k;
		        }
		        e2 = e2->next;
		    } while (e2 != elast2);
		    e1 = e1->next;
	        } while (e1 != elast1);
	    }
	    else if (cola < d1+d2)
		continue;
	    else
            {
                e1 = elast1 = firstedge[i];
                do
                {
                    e2 = e1->next->next->next;
                    elast2 = e1->prev->prev;
                    alpha = 2;
                    do
                    {
                        if (e2 > e1)
                        {
			    if (e1->end == v1 || e2->end == v1) xd1 = d1+1;
			    else                                xd1 = d1;
			    if (e1->end == v2 || e2->end == v2) xd2 = d2+1;
			    else                                xd2 = d2;

			    oldcola = xd1 + xd2;
			    if (cola > oldcola)
			    {
                                extA1[k] = e1;
                                extA2[k] = e2;
                                ++k;
			    }
			    else if (cola == oldcola)
			    {
			        oldcolb = MIN(xd1,xd2);
				colb = 3 + MIN(alpha,degree[i]-alpha-2);
			   	if (colb >= oldcolb)
			        {
                                    extA1[k] = e1;
                                    extA2[k] = e2;
                                    ++k;
			        }
			    }
                        }
                        ++alpha;
                        e2 = e2->next;
                    } while (e2 != elast2);
                    e1 = e1->next;
                } while (e1 != elast1);
            }
	}

	*nextA = k;

      /* B-extensions, trivial group */

	if (lastA || nv >= maxnv-1)
	    *nextB = 0;
	else
	{
            k = 0;

	    for (i = 0; i < nv; ++i)
	    if (degree[i] == 5)
	    {
		e = elast = firstedge[i];
		do
		{
		    if (degree[e->end] == 5 && e == e->min)
		    {
			extB[k] = extB[k+1] = e;
			extBmirror[k] = FALSE;
			extBmirror[k+1] = TRUE;
			k += 2;
		    }
		    e = e->next;
		} while (e != elast);
	    }
	    *nextB = k;
	}

      /* C-extensions, trivial group */

	if (nv >= maxnv-4)
	    *nextC = 0;
	else
	{
	    k = 0;
	    for (i = 0; i < nv; ++i)
		if (degree[i] == 5) extC[k++] = firstedge[i];
	    *nextC = k;
	}
    }
    else    
    {
        nb0 = (EDGE**)numbering[0];
        nboplim = (EDGE**)numbering[nbop==0?nbtot:nbop];
        nblim = (EDGE**)numbering[nbtot];

	for (i = 0; i < ne; ++i) nb0[i]->index = i;

      /* A-extensions, non-trivial group */
    
	k = 0;

	for (i = 0; i < nv; ++i)
	if (degree[i] >= 6)
	{
            if (!ISMARKED_V(i) && lastA && degree[i]+4 < d1+d2) continue;

	    e1 = elast1 = firstedge[i];
            do
            {
		e2 = e1->next->next->next;
		elast2 = e1->prev->prev;
		do
		{
		    if (e1 < e2)
		    {
			nb1 = &nb0[e1->index + MAXE];
			nb2 = &nb0[e2->index + MAXE];
			for ( ; nb1 < nblim; nb1 += MAXE, nb2 += MAXE)
			    if (*nb1 < *nb2)
			    {
				if (*nb1 < e1 || (*nb1 == e1 && *nb2 < e2))
				    break;	
			    }
			    else
			    {
				if (*nb2 < e1 || (*nb2 == e1 && *nb1 < e2))
				    break;	
			    }

			if (nb1 >= nblim)
			{
			    extA1[k] = e1;
			    extA2[k] = e2;
			    ++k;
			}
		    }
		    e2 = e2->next;
		} while (e2 != elast2);
		e1 = e1->next;
	    } while (e1 != elast1);
	}

	*nextA = k;

      /* B-extensions, non-trivial group */

        if (lastA || nv >= maxnv-1)
            *nextB = 0;
        else
        {
            k = 0;
            RESETMARKS;

	    for (i = 0; i < ne; ++i)
		if (!ISMARKEDLO(nb0[i]) && degree[nb0[i]->start] == 5
					 && degree[nb0[i]->end] == 5)
		{
		    extB[k] = nb0[i]->min;
		    if (nb0[i] == nb0[i]->min)
		    {
			extBmirror[k] = TRUE;

		        for (nb = &nb0[i]; nb < nboplim; nb += MAXE)
			    MARKLO((*nb)->min);
		        for ( ; nb < nblim; nb += MAXE)
			    MARKLO((*nb)->min->invers);
		    }
		    else
                    {
                        extBmirror[k] = FALSE;

                        for (nb = &nb0[i]; nb < nboplim; nb += MAXE)
                            MARKLO((*nb)->min->invers);
                        for ( ; nb < nblim; nb += MAXE)
                            MARKLO((*nb)->min);
                    }
		    ++k;
		}

	    *nextB = k;
	}

      /* C-extensions, non-trivial group */

        if (nv >= maxnv-4)
            *nextC = 0;
        else
        {
            k = 0;

	    RESETMARKS_V;
	    for (i = 0; i < nv; ++i)
	        if (!ISMARKED_V(i) && degree[i] == 5)
		{
		    extC[k++] = firstedge[i];
		    for (nb = nb0+firstedge[i]->index; nb < nblim; nb += MAXE)
			MARK_V((*nb)->start);
		}
	    *nextC = k;
	}		
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, 0x48(%rsp)
movq %r8, 0x50(%rsp)
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebx
movl %edi, %r13d
movl 0x13948(%rip), %eax     # 0x26098
leal 0x1(%rax), %ecx
movl %ecx, 0x1393f(%rip)     # 0x26098
cmpl $0x7530, %eax           # imm = 0x7530
jl 0x1277d
movl $0x1, 0x1392e(%rip)     # 0x26098
leaq 0x2784bf(%rip), %rdi    # 0x28ac30
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0x1030
movq 0xb0(%rsp), %rax
testq %rax, %rax
je 0x127da
movslq (%rax), %r9
movslq 0x4(%rax), %r10
movq %rax, %rsi
leaq 0x15455(%rip), %rax     # 0x27bf0
movl (%rax,%r9,4), %ecx
movq %rcx, 0x30(%rsp)
movl (%rax,%r10,4), %eax
movq %rax, 0x18(%rsp)
movl 0x138e5(%rip), %eax     # 0x26098
leaq 0x278476(%rip), %rcx    # 0x28ac30
movl %eax, (%rcx,%r9,4)
movl %eax, (%rcx,%r10,4)
movq 0x10(%rsi), %rdx
movslq 0x4(%rdx), %rdx
movl %eax, (%rcx,%rdx,4)
movq 0x18(%rsi), %rdx
movslq 0x4(%rdx), %rdx
movl %eax, (%rcx,%rdx,4)
jmp 0x127e4
movq %rax, 0x30(%rsp)
movq %rax, 0x18(%rsp)
cmpl $0x1, %r13d
jne 0x129d9
movslq 0x231e1b(%rip), %rbp    # 0x244610
movl $0x0, %r13d
testq %rbp, %rbp
jle 0x129a2
movl 0x1388e(%rip), %eax     # 0x26098
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
leal (%rax,%rcx), %edx
movl %edx, 0x20(%rsp)
incl %ecx
movl %ecx, 0x40(%rsp)
incl %eax
xorl %edx, %edx
xorl %r13d, %r13d
movq %rbp, 0x10(%rsp)
leaq 0x153b8(%rip), %rcx     # 0x27bf0
movl (%rcx,%rdx,4), %r8d
cmpl $0x6, %r8d
movq %rdx, 0x28(%rsp)
jl 0x1298c
cmpq $0x0, 0xb0(%rsp)
je 0x12945
movl 0xc(%rsp), %ecx
leaq 0x2783cb(%rip), %rsi    # 0x28ac30
cmpl %ecx, (%rsi,%rdx,4)
je 0x12945
leal 0x2(%r8), %ecx
cmpl 0x20(%rsp), %ecx
jge 0x12945
leal 0x4(%r8), %ebx
cmpl 0x20(%rsp), %ebx
jl 0x1298c
leaq 0x1515f(%rip), %rcx     # 0x279f0
movq (%rcx,%rdx,8), %rbp
addl $-0x4, %r8d
movq %rbp, 0x38(%rsp)
movq %r8, (%rsp)
movq 0x10(%rbp), %rcx
movq 0x18(%rbp), %rdx
movq 0x18(%rdx), %rdx
movq 0x18(%rdx), %rdi
movq 0x10(%rcx), %rsi
movl $0x2, %ecx
movl %r8d, %r11d
cmpq %rbp, %rdi
jbe 0x12922
movl 0x4(%rbp), %edx
cmpl %r9d, %edx
je 0x128d6
movq 0x30(%rsp), %r8
cmpl %r9d, 0x4(%rdi)
jne 0x128db
movl 0x40(%rsp), %r8d
cmpl %r10d, %edx
je 0x128eb
movq 0x18(%rsp), %rdx
cmpl %r10d, 0x4(%rdi)
jne 0x128ed
movl %eax, %edx
leal (%rdx,%r8), %r14d
cmpl %r14d, %ebx
jle 0x12906
movslq %r13d, %r13
movq %rbp, (%r12,%r13,8)
movq %rdi, (%r15,%r13,8)
incl %r13d
jmp 0x12922
jne 0x12922
cmpl %edx, %r8d
cmovll %r8d, %edx
cmpl %r11d, %ecx
movl %r11d, %r8d
cmovll %ecx, %r8d
addl $0x3, %r8d
cmpl %edx, %r8d
jge 0x128f6
incl %ecx
movq 0x18(%rdi), %rdi
decl %r11d
cmpq %rsi, %rdi
jne 0x128be
movq 0x18(%rbp), %rbp
cmpq 0x38(%rsp), %rbp
movq (%rsp), %r8
jne 0x128a2
jmp 0x1298c
leaq 0x150a4(%rip), %rcx     # 0x279f0
movq (%rcx,%rdx,8), %rcx
movq %rcx, %rsi
movq 0x10(%rsi), %rdx
movq 0x18(%rsi), %rdi
movq 0x18(%rdi), %rdi
movq 0x18(%rdi), %rdi
movq 0x10(%rdx), %r8
cmpq %rsi, %rdi
jbe 0x1297a
movslq %r13d, %r13
movq %rsi, (%r12,%r13,8)
movq %rdi, (%r15,%r13,8)
incl %r13d
movq 0x18(%rdi), %rdi
cmpq %r8, %rdi
jne 0x12967
movq 0x18(%rsi), %rsi
cmpq %rcx, %rsi
jne 0x12953
movq 0x28(%rsp), %rdx
incq %rdx
movq 0x10(%rsp), %rbp
cmpq %rbp, %rdx
jne 0x12831
movq 0x50(%rsp), %rax
movl %r13d, (%rax)
cmpq $0x0, 0xb0(%rsp)
je 0x12ba6
movq 0xa8(%rsp), %r14
movq 0xa0(%rsp), %r9
movq 0x98(%rsp), %r11
xorl %r15d, %r15d
jmp 0x12c4a
testl %ebx, %ebx
cmovel %r13d, %ebx
movl %ebx, 0xc(%rsp)
leaq 0x15306(%rip), %rbp     # 0x27cf0
movslq %r13d, %rax
imulq $0xba0, %rax, %rax      # imm = 0xBA0
movq %rax, 0x20(%rsp)
movslq 0x231c14(%rip), %rsi    # 0x244614
testq %rsi, %rsi
jle 0x12a1c
xorl %eax, %eax
movq %rbp, %rcx
movq (%rcx), %rdx
movl %eax, 0x34(%rdx)
incq %rax
addq $0x8, %rcx
cmpq %rax, %rsi
jne 0x12a0a
movq %rsi, 0x28(%rsp)
movq 0x20(%rsp), %rax
leaq (%rax,%rbp), %r13
movslq 0x231bdf(%rip), %rdx    # 0x244610
movl $0x0, 0x10(%rsp)
movl $0x0, %ecx
movq %rdx, (%rsp)
testq %rdx, %rdx
jle 0x12b73
movl 0x13647(%rip), %eax     # 0x26098
movl %eax, 0x38(%rsp)
movq 0x18(%rsp), %rax
addl 0x30(%rsp), %eax
movq %rax, 0x18(%rsp)
xorl %esi, %esi
movl $0xba0, %edi            # imm = 0xBA0
xorl %ecx, %ecx
leaq 0x1517d(%rip), %rax     # 0x27bf0
movl (%rax,%rsi,4), %eax
cmpl $0x6, %eax
movq %rsi, 0x40(%rsp)
jl 0x12b61
cmpq $0x0, 0xb0(%rsp)
je 0x12aad
movl 0x38(%rsp), %edx
leaq 0x278196(%rip), %r8     # 0x28ac30
cmpl %edx, (%r8,%rsi,4)
je 0x12aad
addl $0x4, %eax
cmpl 0x18(%rsp), %eax
jl 0x12b61
leaq 0x14f3c(%rip), %rax     # 0x279f0
movq (%rax,%rsi,8), %r11
movq %r11, %rbx
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rdx
movq 0x18(%rdx), %rdx
movq 0x18(%rdx), %r10
movq 0x10(%rax), %rax
cmpq %r10, %rbx
jae 0x12b47
movslq 0x34(%rbx), %rdx
leaq 0xba0(,%rdx,8), %r9
addq %rbp, %r9
cmpq %r13, %r9
setb %sil
jae 0x12b3a
movslq 0x34(%r10), %rdx
leaq 0xba0(,%rdx,8), %r14
addq %rbp, %r14
movq (%r9), %r8
movq (%r14), %rdx
cmpq %rdx, %r8
jae 0x12b14
cmpq %rbx, %r8
jb 0x12b34
jne 0x12b23
cmpq %r10, %rdx
jae 0x12b23
jmp 0x12b34
cmpq %rbx, %rdx
jb 0x12b34
cmpq %r10, %r8
jae 0x12b23
cmpq %rbx, %rdx
je 0x12b34
addq %rdi, %r14
addq %rdi, %r9
cmpq %r13, %r9
setb %sil
jb 0x12afb
jmp 0x12b3a
testb $0x1, %sil
jne 0x12b47
movslq %ecx, %rcx
movq %rbx, (%r12,%rcx,8)
movq %r10, (%r15,%rcx,8)
incl %ecx
movq 0x18(%r10), %r10
cmpq %rax, %r10
jne 0x12acf
movq 0x18(%rbx), %rbx
cmpq %r11, %rbx
jne 0x12abb
movq 0x40(%rsp), %rsi
incq %rsi
cmpq (%rsp), %rsi
jne 0x12a6c
movq 0x50(%rsp), %rax
movl %ecx, (%rax)
cmpq $0x0, 0xb0(%rsp)
je 0x12ca4
movq 0xa8(%rsp), %r14
movq 0xa0(%rsp), %r15
movq 0x98(%rsp), %r12
jmp 0x12e3b
movl 0x136c4(%rip), %eax     # 0x26270
decl %eax
cmpl %eax, %ebp
setge %al
testl %ebp, %ebp
setle %cl
orb %al, %cl
movq 0xa8(%rsp), %r14
movq 0xa0(%rsp), %r9
movq 0x48(%rsp), %r10
movq 0x98(%rsp), %r11
movq 0x90(%rsp), %rbx
movl $0x0, %r15d
jne 0x12c4a
xorl %eax, %eax
leaq 0x15000(%rip), %rcx     # 0x27bf0
leaq 0x14df9(%rip), %rdx     # 0x279f0
xorl %r15d, %r15d
cmpl $0x5, (%rcx,%rax,4)
jne 0x12c42
movq (%rdx,%rax,8), %rsi
movq %rsi, %rdi
movslq 0x4(%rdi), %r8
cmpl $0x5, (%rcx,%r8,4)
jne 0x12c39
cmpq 0x28(%rdi), %rdi
jne 0x12c39
movslq %r15d, %r15
movq %rdi, 0x8(%r10,%r15,8)
movq %rdi, (%r10,%r15,8)
movl $0x0, (%rbx,%r15,4)
movl $0x1, 0x4(%rbx,%r15,4)
addl $0x2, %r15d
movq 0x18(%rdi), %rdi
cmpq %rsi, %rdi
jne 0x12c07
incq %rax
cmpq %rbp, %rax
jne 0x12bfa
movl %r15d, (%r11)
movl 0x1361d(%rip), %eax     # 0x26270
addl $-0x4, %eax
cmpl %eax, %ebp
setge %al
testl %ebp, %ebp
setle %cl
xorl %ebx, %ebx
orb %al, %cl
jne 0x12eff
shlq $0x2, %rbp
xorl %eax, %eax
leaq 0x14d79(%rip), %rcx     # 0x279f0
leaq 0x14f72(%rip), %rdx     # 0x27bf0
xorl %ebx, %ebx
cmpl $0x5, (%rax,%rdx)
jne 0x12c92
movq (%rcx), %rsi
movslq %ebx, %rdi
incl %ebx
movq %rsi, (%r9,%rdi,8)
addq $0x8, %rcx
addq $0x4, %rax
cmpq %rax, %rbp
jne 0x12c80
jmp 0x12eff
movl 0x135c6(%rip), %eax     # 0x26270
decl %eax
cmpl %eax, (%rsp)
movq 0xa8(%rsp), %r14
movq 0xa0(%rsp), %r15
movq 0x98(%rsp), %r12
jge 0x12e3b
movl 0x133c1(%rip), %eax     # 0x26094
leal 0x2(%rax), %ecx
movl %ecx, 0x133b8(%rip)     # 0x26094
cmpl $0x752f, %eax           # imm = 0x752F
jl 0x12d0c
movl $0x2, 0x133a7(%rip)     # 0x26094
movl $0x30, %eax
leaq 0x231927(%rip), %rcx    # 0x244620
movl $0x0, (%rax,%rcx)
addq $0x40, %rax
cmpq $0x46630, %rax          # imm = 0x46630
jne 0x12cf9
cmpl $0x0, 0x28(%rsp)
movq 0x48(%rsp), %rbx
jle 0x12e3b
movslq 0xc(%rsp), %rax
imulq $0xba0, %rax, %rax      # imm = 0xBA0
leaq (%rax,%rbp), %rcx
movl 0x13362(%rip), %edx     # 0x26094
xorl %edi, %edi
leaq 0x14eb5(%rip), %r8      # 0x27bf0
movl $0x0, 0x10(%rsp)
movq (%rbp,%rdi,8), %r10
cmpl %edx, 0x30(%r10)
je 0x12e2d
movslq (%r10), %rsi
cmpl $0x5, (%r8,%rsi,4)
jne 0x12e2d
movslq 0x4(%r10), %rsi
cmpl $0x5, (%r8,%rsi,4)
jne 0x12e2d
leaq (,%rdi,8), %rsi
leaq (,%rdi,8), %r9
addq %rbp, %r9
movq 0x28(%r10), %r11
movslq 0x10(%rsp), %r10
movq %r11, (%rbx,%r10,8)
movq (%rsi,%rbp), %r11
cmpq 0x28(%r11), %r11
je 0x12de2
movq 0x90(%rsp), %r11
movl $0x0, (%r11,%r10,4)
cmpq %rax, %rsi
jge 0x12ddb
movq (%r9), %rsi
movq 0x28(%rsi), %rsi
movq 0x20(%rsi), %rsi
movl %edx, 0x30(%rsi)
addq $0xba0, %r9             # imm = 0xBA0
cmpq %rcx, %r9
jb 0x12dae
jmp 0x12ddb
movq (%r9), %rsi
movq 0x28(%rsi), %rsi
movl %edx, 0x30(%rsi)
addq $0xba0, %r9             # imm = 0xBA0
cmpq %r13, %r9
jb 0x12dca
jmp 0x12e29
movq 0x90(%rsp), %r11
movl $0x1, (%r11,%r10,4)
cmpq %rax, %rsi
jge 0x12e24
movq (%r9), %rsi
movq 0x28(%rsi), %rsi
movl %edx, 0x30(%rsi)
addq $0xba0, %r9             # imm = 0xBA0
cmpq %rcx, %r9
jb 0x12df7
jmp 0x12e24
movq (%r9), %rsi
movq 0x28(%rsi), %rsi
movq 0x20(%rsi), %rsi
movl %edx, 0x30(%rsi)
addq $0xba0, %r9             # imm = 0xBA0
cmpq %r13, %r9
jb 0x12e0f
incl 0x10(%rsp)
incq %rdi
cmpq 0x28(%rsp), %rdi
jne 0x12d43
movl 0x10(%rsp), %eax
movl %eax, (%r12)
movl 0x13427(%rip), %eax     # 0x26270
addl $-0x4, %eax
xorl %ebx, %ebx
cmpl %eax, (%rsp)
jge 0x12eff
movl 0x1323b(%rip), %eax     # 0x26098
leal 0x1(%rax), %ecx
movl %ecx, 0x13232(%rip)     # 0x26098
cmpl $0x7530, %eax           # imm = 0x7530
jl 0x12e8a
movl $0x1, 0x13221(%rip)     # 0x26098
leaq 0x277db2(%rip), %rdi    # 0x28ac30
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0x1030
cmpl $0x0, (%rsp)
movq 0x20(%rsp), %r10
jle 0x12eff
movl 0x131fd(%rip), %eax     # 0x26098
xorl %ecx, %ecx
leaq 0x277d8c(%rip), %rdx    # 0x28ac30
leaq 0x14d45(%rip), %rsi     # 0x27bf0
leaq 0x14b3e(%rip), %rdi     # 0x279f0
xorl %ebx, %ebx
cmpl %eax, (%rdx,%rcx,4)
je 0x12ef6
cmpl $0x5, (%rsi,%rcx,4)
jne 0x12ef6
movq (%rdi,%rcx,8), %r8
movslq %ebx, %r9
incl %ebx
movq %r8, (%r15,%r9,8)
movq (%rdi,%rcx,8), %r8
movslq 0x34(%r8), %r8
shlq $0x3, %r8
cmpq %r10, %r8
jge 0x12ef6
addq %rbp, %r8
movq (%r8), %r9
movslq (%r9), %r9
movl %eax, (%rdx,%r9,4)
addq $0xba0, %r8             # imm = 0xBA0
cmpq %r13, %r8
jb 0x12ee0
incq %rcx
cmpq (%rsp), %rcx
jne 0x12eb4
movl %ebx, (%r14)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq