#include <avr/io.h>

volatile uint8_t value8=0xaa; 
volatile uint16_t value16= 0xbbcc;
int main()
{
  // coloca em value8 o byte lido da PORTA D
  asm volatile("in %0, %1" : "=r" (value8) : "I" (_SFR_IO_ADDR(PORTD)));
  value8++;

// agora vamos trocar os nibbles de value
  asm volatile("swap %0" : "=r" (value8) : "0" (value8));

// agora vamos trocar os bytes da variavel de 16 bits value16
asm volatile("mov __tmp_reg__, %A0" "\n\t"
             "mov %A0, %B0"         "\n\t"
             "mov %B0, __tmp_reg__" "\n\t"
             : "=r" (value16)
             : "0" (value16)
            );
}
#include <avr/io.h>

#define loop_until_mybit_is_clear(port,bit)  \
        __asm__ __volatile__ (             \
        "L_%=: " "sbic %0, %1" "\n\t"      \
                 "rjmp L_%="               \
                 :  /* no outputs */       \
				 : "I" (_SFR_IO_ADDR(port)), "I" (bit)  \
        )

int main(){
    uint8_t bit=7;
	loop_until_mybit_is_clear(PORTD,bit);
	loop_until_mybit_is_clear(PORTB,bit);
}
#include <avr/io.h>
volatile char table[8];
volatile char * ptable = table;

int main(){
asm volatile(
    "ld __tmp_reg__, %a0"       "\n\t"
    "inc __tmp_reg__"           "\n\t"
    "st %a0+, __tmp_reg__"       "\n\t"                       "\n\t"
    :
    : "e" (ptable)
);
}
// swap macro exchanges operand values using exclusive or operator
#include <avr/io.h>
#define swap(a,b)({a^=b; b^=a; a^=b;})
volatile uint8_t m ;
volatile uint8_t n ;
/*
volatile char table[12];
volatile char * ptable = table;
*/
uint8_t foo(uint8_t bar){
	return(bar/2);
}
int main(){
    m=0x02;
   	n=0x07;
	swap(m,n);

}
#include <avr/io.h>
volatile uint8_t pdata;
int main(){
	asm volatile("in %0, %1" : "=r" (pdata):"I" (_SFR_IO_ADDR(PORTD)));
	pdata &= 0x0f;
}