#include <stdio.h>
#include <inttypes.h>
#include <limits.h>
 
__asm__ (
/* support both environments that does and doesn't add underscore before function name */
"loop_asm:\n"
"_loop_asm:\n"
"push %ebp\n"
"mov %esp, %ebp\n"
"push %esi\n"
"push %edi\n"
"push %ebx\n"
 
"# x at %ebp+8, n at %ebp+12\n"
"movl 8(%ebp), %esi\n"
"movl 12(%ebp), %ebx\n"
"movl $-1, %edi\n"
"movl $1, %edx\n"
".L2_test:\n" /* rename .L2 to .L2_test to avoid collision */
"movl %edx, %eax\n"
"andl %esi, %eax\n"
"xorl %eax, %edi\n"
"movl %ebx, %ecx\n"
"sall %cl, %edx\n"
"testl %edx, %edx\n"
"jne .L2_test\n"
"movl %edi, %eax\n"
 
"pop %ebx\n"
"pop %edi\n"
"pop %esi\n"
"leave\n"
"ret\n"
);
 
uint32_t loop_asm(uint32_t, uint32_t);
 
uint32_t loop_convert(uint32_t x, uint32_t n) {
    uint32_t result = -1;
    uint32_t mask;
    for (mask = 1; mask != 0; mask <<= n & 31) {
        result ^= mask & x;
    }
    return result;
}
 
int mask;
    int loop(int x, int n){
 
    int result = -1;
 
    for (mask = 1; mask >= result; mask = x&1) {
 
    result ^= n;
 
    }
return result;
}
 
int main(void) {
    int x, n;
    uint32_t raw, test, conv;
    int miss_count = 0;
    /* search for mismatch in some range */
    for (n = 1; n < 32; n++) {
        uint32_t x_test;
        for (x_test = 0; x_test < UINT32_C(100000); x_test++) {
            if (loop_asm(x, n) != loop_convert(x, n)) {
                printf("mismatch at x=%"PRIu32
", n=%d\n", x_test
, n
);                 if (miss_count < INT_MAX) miss_count++;
            }
        }
    }
    printf("%d mismatch(es) found.\n", miss_count
);     /* print some examples */
    x = 100;
    n = 5;
    raw = loop_asm(x, n);
    conv = loop_convert(x, n);
    printf("loop_asm(%d, %d) = %"PRIu32
"\n", x
, n
, raw
);     printf("loop_convert(%d, %d) = %"PRIu32
"\n", x
, n
, conv
);     test = loop(x, n);
    printf("loop(%d, %d) = %"PRIu32
"\n", x
, n
, test
);     return 0;
}
 
				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