; generated by Component: ARM Compiler 5.05 update 2 (build 169) Tool: ArmCC [4d0f38]
; commandline ArmCC [--c99 --list --split_sections --debug -c --asm --interleave -o..\..\..\..\build\bootloader\mico-fire_f429\obj_rvmdk\retarget.o --asm_dir=..\..\..\..\Build\Bootloader\MICO-Fire_F429\list_RVMDK\ --list_dir=..\..\..\..\Build\Bootloader\MICO-Fire_F429\list_RVMDK\ --depend=..\..\..\..\build\bootloader\mico-fire_f429\obj_rvmdk\retarget.d --cpu=Cortex-M4.fp --apcs=interwork --diag_suppress=9931,1,1293 -I..\..\..\..\Bootloader -I..\..\..\..\Board\fire_F429 -I..\..\..\..\include -I..\..\..\..\libraries\utilities -I..\..\..\..\libraries\utilities\json_c -I..\..\..\..\MICO\core -I..\..\..\..\MICO\security -I..\..\..\..\MICO\system -I..\..\..\..\MICO\system\command_console -I..\..\..\..\Platform\include -I..\..\..\..\Platform\Cortex-M4 -I..\..\..\..\Platform\Cortex-M4\CMSIS -I..\..\..\..\Platform\MCU\STM32F4xx\peripherals -I..\..\..\..\Platform\MCU\STM32F4xx\peripherals\Libraries\STM32F4xx_StdPeriph_Driver\inc -I..\..\..\..\Platform\MCU\STM32F4xx\peripherals\Libraries -I..\..\..\..\Platform\MCU\STM32F4xx\wlan_bus_driver -I..\..\..\..\Platform\Drivers\spi_flash -I..\..\..\..\Platform\Drivers -IG:\GIT_OSC\F429_OV2640_MICO_SDRAM\Projects\STM32F429\bootloader\RVMDK\RTE -ID:\work\keil5\ARM\PACK\Keil\STM32F4xx_DFP\2.5.0\Drivers\CMSIS\Device\ST\STM32F4xx\Include -ID:\work\keil5\ARM\CMSIS\Include -ID:\work\keil5\ARM\PACK\Keil\STM32F4xx_DFP\2.5.0 -D__MICROLIB -D__UVISION_VERSION=516 -DSTM32F429xx -DUSE_STDPERIPH_DRIVER -DBOOTLOADER -DNO_MICO_RTOS -DHSE_VALUE=25000000 --omf_browse=..\..\..\..\build\bootloader\mico-fire_f429\obj_rvmdk\retarget.crf ..\..\..\..\Platform\RVMDK\Retarget.c]
                          THUMB

                          AREA ||i.__data_GetMemChunk||, CODE, READONLY, ALIGN=1

                  __data_GetMemChunk PROC
;;;408    
;;;409    int __data_GetMemChunk(void)
000000  2000              MOVS     r0,#0
;;;410    {
;;;411    	return 0;
;;;412    }
000002  4770              BX       lr
;;;413    
                          ENDP


                          AREA ||i.__iar_Memchr||, CODE, READONLY, ALIGN=1

                  __iar_Memchr PROC
;;;272    void *
;;;273    MEMCHR (void const *s, int c_in, size_t n)
000000  b570              PUSH     {r4-r6,lr}
;;;274    {
;;;275      /* On 32-bit hardware, choosing longword to be a 32-bit unsigned
;;;276         long instead of a 64-bit uintmax_t tends to give better
;;;277         performance.  On 64-bit hardware, unsigned long is generally 64
;;;278         bits already.  Change this typedef to experiment with
;;;279         performance.  */
;;;280      typedef unsigned long int longword;
;;;281    
;;;282      const unsigned char *char_ptr;
;;;283      const longword *longword_ptr;
;;;284      longword repeated_one;
;;;285      longword repeated_c;
;;;286      unsigned char c;
;;;287    
;;;288      c = (unsigned char) c_in;
000002  b2c9              UXTB     r1,r1
000004  e004              B        |L2.16|
                  |L2.6|
;;;289    
;;;290      /* Handle the first few bytes by reading one byte at a time.
;;;291         Do this until CHAR_PTR is aligned on a longword boundary.  */
;;;292      for (char_ptr = (const unsigned char *) s;
;;;293           n > 0 && (size_t) char_ptr % sizeof (longword) != 0;
;;;294           --n, ++char_ptr)
;;;295        if (*char_ptr == c)
000006  7803              LDRB     r3,[r0,#0]
000008  428b              CMP      r3,r1
00000a  d01f              BEQ      |L2.76|
00000c  1c40              ADDS     r0,r0,#1
00000e  1e52              SUBS     r2,r2,#1
                  |L2.16|
000010  b10a              CBZ      r2,|L2.22|
000012  0783              LSLS     r3,r0,#30             ;293
000014  d1f7              BNE      |L2.6|
                  |L2.22|
;;;296          return (void *) char_ptr;
;;;297    
;;;298      longword_ptr = (const longword *) char_ptr;
;;;299    
;;;300      /* All these elucidatory comments refer to 4-byte longwords,
;;;301         but the theory applies equally well to any size longwords.  */
;;;302    
;;;303      /* Compute auxiliary longword values:
;;;304         repeated_one is a value which has a 1 in every byte.
;;;305         repeated_c has c in every byte.  */
;;;306      repeated_one = 0x01010101;
;;;307      repeated_c = c | (c << 8);
000016  ea412301          ORR      r3,r1,r1,LSL #8
00001a  f04f3401          MOV      r4,#0x1010101         ;306
;;;308      repeated_c |= repeated_c << 16;
00001e  ea434503          ORR      r5,r3,r3,LSL #16
;;;309      if (0xffffffffU < (longword) -1)
;;;310        {
;;;311          repeated_one |= repeated_one << 31 << 1;
;;;312          repeated_c |= repeated_c << 31 << 1;
;;;313          if (8 < sizeof (longword))
;;;314    	{
;;;315    	  size_t i;
;;;316    
;;;317    	  for (i = 64; i < sizeof (longword) * 8; i *= 2)
;;;318    	    {
;;;319    	      repeated_one |= repeated_one << i;
;;;320    	      repeated_c |= repeated_c << i;
;;;321    	    }
;;;322    	}
;;;323        }
;;;324    
;;;325      /* Instead of the traditional loop which tests each byte, we will test a
;;;326         longword at a time.  The tricky part is testing if *any of the four*
;;;327         bytes in the longword in question are equal to c.  We first use an xor
;;;328         with repeated_c.  This reduces the task to testing whether *any of the
;;;329         four* bytes in longword1 is zero.
;;;330    
;;;331         We compute tmp =
;;;332           ((longword1 - repeated_one) & ~longword1) & (repeated_one << 7).
;;;333         That is, we perform the following operations:
;;;334           1. Subtract repeated_one.
;;;335           2. & ~longword1.
;;;336           3. & a mask consisting of 0x80 in every byte.
;;;337         Consider what happens in each byte:
;;;338           - If a byte of longword1 is zero, step 1 and 2 transform it into 0xff,
;;;339    	 and step 3 transforms it into 0x80.  A carry can also be propagated
;;;340    	 to more significant bytes.
;;;341           - If a byte of longword1 is nonzero, let its lowest 1 bit be at
;;;342    	 position k (0 <= k <= 7); so the lowest k bits are 0.  After step 1,
;;;343    	 the byte ends in a single bit of value 0 and k bits of value 1.
;;;344    	 After step 2, the result is just k bits of value 1: 2^k - 1.  After
;;;345    	 step 3, the result is 0.  And no carry is produced.
;;;346         So, if longword1 has only non-zero bytes, tmp is zero.
;;;347         Whereas if longword1 has a zero byte, call j the position of the least
;;;348         significant zero byte.  Then the result has a zero at positions 0, ...,
;;;349         j-1 and a 0x80 at position j.  We cannot predict the result at the more
;;;350         significant bytes (positions j+1..3), but it does not matter since we
;;;351         already have a non-zero bit at position 8*j+7.
;;;352    
;;;353         So, the test whether any byte in longword1 is zero is equivalent to
;;;354         testing whether tmp is nonzero.  */
;;;355    
;;;356      while (n >= sizeof (longword))
000022  e008              B        |L2.54|
                  |L2.36|
;;;357        {
;;;358          longword longword1 = *longword_ptr ^ repeated_c;
000024  6803              LDR      r3,[r0,#0]
000026  406b              EORS     r3,r3,r5
;;;359    
;;;360          if ((((longword1 - repeated_one) & ~longword1)
000028  1b1e              SUBS     r6,r3,r4
00002a  439e              BICS     r6,r6,r3
00002c  ea161fc4          TST      r6,r4,LSL #7
000030  d109              BNE      |L2.70|
000032  1d00              ADDS     r0,r0,#4
000034  1f12              SUBS     r2,r2,#4
                  |L2.54|
000036  2a04              CMP      r2,#4                 ;356
000038  d2f4              BCS      |L2.36|
00003a  e004              B        |L2.70|
                  |L2.60|
;;;361    	   & (repeated_one << 7)) != 0)
;;;362    	break;
;;;363          longword_ptr++;
;;;364          n -= sizeof (longword);
;;;365        }
;;;366    
;;;367      char_ptr = (const unsigned char *) longword_ptr;
;;;368    
;;;369      /* At this point, we know that either n < sizeof (longword), or one of the
;;;370         sizeof (longword) bytes starting at char_ptr is == c.  On little-endian
;;;371         machines, we could determine the first such byte without any further
;;;372         memory accesses, just by looking at the tmp result from the last loop
;;;373         iteration.  But this does not work on big-endian machines.  Choose code
;;;374         that works in both cases.  */
;;;375    
;;;376      for (; n > 0; --n, ++char_ptr)
;;;377        {
;;;378          if (*char_ptr == c)
00003c  7803              LDRB     r3,[r0,#0]
00003e  428b              CMP      r3,r1
000040  d004              BEQ      |L2.76|
000042  1c40              ADDS     r0,r0,#1
000044  1e52              SUBS     r2,r2,#1
                  |L2.70|
000046  2a00              CMP      r2,#0                 ;376
000048  d1f8              BNE      |L2.60|
;;;379    	return (void *) char_ptr;
;;;380        }
;;;381    
;;;382      return NULL;
00004a  2000              MOVS     r0,#0
                  |L2.76|
;;;383    }
00004c  bd70              POP      {r4-r6,pc}
;;;384    //mxchipWNET.o
                          ENDP


                          AREA ||i.__iar_Strchr||, CODE, READONLY, ALIGN=2

                  __iar_Strchr PROC
;;;121    char *
;;;122    STRCHR (const char *s, int c_in)
000000  b570              PUSH     {r4-r6,lr}
;;;123    {
;;;124      const unsigned char *char_ptr;
;;;125      const unsigned long int *longword_ptr;
;;;126      unsigned long int longword, magic_bits, charmask;
;;;127      unsigned char c;
;;;128    
;;;129      c = (unsigned char) c_in;
000002  b2c9              UXTB     r1,r1
000004  e004              B        |L3.16|
                  |L3.6|
;;;130    
;;;131      /* Handle the first few characters by reading one character at a time.
;;;132         Do this until CHAR_PTR is aligned on a longword boundary.  */
;;;133      for (char_ptr = (const unsigned char *) s;
;;;134           ((unsigned long int) char_ptr & (sizeof (longword) - 1)) != 0;
;;;135           ++char_ptr)
;;;136        if (*char_ptr == c)
000006  7802              LDRB     r2,[r0,#0]
000008  428a              CMP      r2,r1
00000a  d02b              BEQ      |L3.100|
;;;137          return (void *) char_ptr;
;;;138        else if (*char_ptr == '\0')
00000c  b34a              CBZ      r2,|L3.98|
00000e  1c40              ADDS     r0,r0,#1
                  |L3.16|
000010  0782              LSLS     r2,r0,#30             ;134
000012  d1f8              BNE      |L3.6|
;;;139          return NULL;
;;;140    
;;;141      /* All these elucidatory comments refer to 4-byte longwords,
;;;142         but the theory applies equally well to 8-byte longwords.  */
;;;143    
;;;144      longword_ptr = (unsigned long int *) char_ptr;
000014  4602              MOV      r2,r0
;;;145    
;;;146      /* Bits 31, 24, 16, and 8 of this number are zero.  Call these bits
;;;147         the "holes."  Note that there is a hole just to the left of
;;;148         each byte, with an extra at the end:
;;;149    
;;;150         bits:  01111110 11111110 11111110 11111111
;;;151         bytes: AAAAAAAA BBBBBBBB CCCCCCCC DDDDDDDD
;;;152    
;;;153         The 1-bits make sure that carries propagate to the next 0-bit.
;;;154         The 0-bits provide holes for carries to fall into.  */
;;;155      switch (sizeof (longword))
;;;156        {
;;;157        case 4: magic_bits = 0x7efefeffL; break;
000016  4b14              LDR      r3,|L3.104|
;;;158        default:
;;;159          abort ();
;;;160        }
;;;161    
;;;162      /* Set up a longword, each of whose bytes is C.  */
;;;163      charmask = c | (c << 8);
000018  ea412001          ORR      r0,r1,r1,LSL #8
;;;164      charmask |= charmask << 16;
00001c  ea404400          ORR      r4,r0,r0,LSL #16
                  |L3.32|
;;;165      if (sizeof (longword) > 4)
;;;166        /* Do the shift in two steps to avoid a warning if long has 32 bits.  */
;;;167        charmask |= (charmask << 16) << 16;
;;;168      if (sizeof (longword) > 8)
;;;169        abort ();
;;;170    
;;;171      /* Instead of the traditional loop which tests each character,
;;;172         we will test a longword at a time.  The tricky part is testing
;;;173         if *any of the four* bytes in the longword in question are zero.  */
;;;174      for (;;)
;;;175        {
;;;176          /* We tentatively exit the loop if adding MAGIC_BITS to
;;;177    	 LONGWORD fails to change any of the hole bits of LONGWORD.
;;;178    
;;;179    	 1) Is this safe?  Will it catch all the zero bytes?
;;;180    	 Suppose there is a byte with all zeros.  Any carry bits
;;;181    	 propagating from its left will fall into the hole at its
;;;182    	 least significant bit and stop.  Since there will be no
;;;183    	 carry from its most significant bit, the LSB of the
;;;184    	 byte to the left will be unchanged, and the zero will be
;;;185    	 detected.
;;;186    
;;;187    	 2) Is this worthwhile?  Will it ignore everything except
;;;188    	 zero bytes?  Suppose every byte of LONGWORD has a bit set
;;;189    	 somewhere.  There will be a carry into bit 8.  If bit 8
;;;190    	 is set, this will carry into bit 16.  If bit 8 is clear,
;;;191    	 one of bits 9-15 must be set, so there will be a carry
;;;192    	 into bit 16.  Similarly, there will be a carry into bit
;;;193    	 24.  If one of bits 24-30 is set, there will be a carry
;;;194    	 into bit 31, so all of the hole bits will be changed.
;;;195    
;;;196    	 The one misfire occurs when bits 24-30 are clear and bit
;;;197    	 31 is set; in this case, the hole at bit 31 is not
;;;198    	 changed.  If we had access to the processor carry flag,
;;;199    	 we could close this loophole by putting the fourth hole
;;;200    	 at bit 32!
;;;201    
;;;202    	 So it ignores everything except 128's, when they're aligned
;;;203    	 properly.
;;;204    
;;;205    	 3) But wait!  Aren't we looking for C as well as zero?
;;;206    	 Good point.  So what we do is XOR LONGWORD with a longword,
;;;207    	 each of whose bytes is C.  This turns each byte that is C
;;;208    	 into a zero.  */
;;;209    
;;;210          longword = *longword_ptr++;
000020  ca01              LDM      r2!,{r0}
;;;211    
;;;212          /* Add MAGIC_BITS to LONGWORD.  */
;;;213          if ((((longword + magic_bits)
000022  18c5              ADDS     r5,r0,r3
000024  43c6              MVNS     r6,r0
000026  4075              EORS     r5,r5,r6
000028  439d              BICS     r5,r5,r3
00002a  d105              BNE      |L3.56|
;;;214    
;;;215    	    /* Set those bits that were unchanged by the addition.  */
;;;216    	    ^ ~longword)
;;;217    
;;;218    	   /* Look at only the hole bits.  If any of the hole bits
;;;219    	      are unchanged, most likely one of the bytes was a
;;;220    	      zero.  */
;;;221    	   & ~magic_bits) != 0 ||
;;;222    
;;;223    	  /* That caught zeroes.  Now test for C.  */
;;;224    	  ((((longword ^ charmask) + magic_bits) ^ ~(longword ^ charmask))
00002c  4060              EORS     r0,r0,r4
00002e  18c5              ADDS     r5,r0,r3
000030  43c0              MVNS     r0,r0
000032  4045              EORS     r5,r5,r0
000034  439d              BICS     r5,r5,r3
000036  d0f3              BEQ      |L3.32|
                  |L3.56|
;;;225    	   & ~magic_bits) != 0)
;;;226    	{
;;;227    	  /* Which of the bytes was C or zero?
;;;228    	     If none of them were, it was a misfire; continue the search.  */
;;;229    
;;;230    	  const unsigned char *cp = (const unsigned char *) (longword_ptr - 1);
000038  1f10              SUBS     r0,r2,#4
;;;231    
;;;232    	  if (*cp == c)
00003a  7805              LDRB     r5,[r0,#0]
00003c  428d              CMP      r5,r1
00003e  d011              BEQ      |L3.100|
;;;233    	    return (char *) cp;
;;;234    	  else if (*cp == '\0')
000040  b17d              CBZ      r5,|L3.98|
;;;235    	    return NULL;
;;;236    	  if (*++cp == c)
000042  f8105f01          LDRB     r5,[r0,#1]!
000046  428d              CMP      r5,r1
000048  d00c              BEQ      |L3.100|
;;;237    	    return (char *) cp;
;;;238    	  else if (*cp == '\0')
00004a  b155              CBZ      r5,|L3.98|
;;;239    	    return NULL;
;;;240    	  if (*++cp == c)
00004c  f8105f01          LDRB     r5,[r0,#1]!
000050  428d              CMP      r5,r1
000052  d007              BEQ      |L3.100|
;;;241    	    return (char *) cp;
;;;242    	  else if (*cp == '\0')
000054  b12d              CBZ      r5,|L3.98|
;;;243    	    return NULL;
;;;244    	  if (*++cp == c)
000056  f8105f01          LDRB     r5,[r0,#1]!
00005a  428d              CMP      r5,r1
00005c  d002              BEQ      |L3.100|
;;;245    	    return (char *) cp;
;;;246    	  else if (*cp == '\0')
00005e  2d00              CMP      r5,#0
000060  d1de              BNE      |L3.32|
                  |L3.98|
;;;247    	    return NULL;
000062  2000              MOVS     r0,#0
                  |L3.100|
;;;248    	  if (sizeof (longword) > 4)
;;;249    	    {
;;;250    	      if (*++cp == c)
;;;251    		return (char *) cp;
;;;252    	      else if (*cp == '\0')
;;;253    		return NULL;
;;;254    	      if (*++cp == c)
;;;255    		return (char *) cp;
;;;256    	      else if (*cp == '\0')
;;;257    		return NULL;
;;;258    	      if (*++cp == c)
;;;259    		return (char *) cp;
;;;260    	      else if (*cp == '\0')
;;;261    		return NULL;
;;;262    	      if (*++cp == c)
;;;263    		return (char *) cp;
;;;264    	      else if (*cp == '\0')
;;;265    		return NULL;
;;;266    	    }
;;;267    	}
;;;268      }
;;;269    }
000064  bd70              POP      {r4-r6,pc}
;;;270    
                          ENDP

000066  0000              DCW      0x0000
                  |L3.104|
                          DCD      0x7efefeff

                          AREA ||i.__iar_Strrchr||, CODE, READONLY, ALIGN=1

                  __iar_Strrchr PROC
;;;99     char *
;;;100    STRRCHR (const char *s, int c)
000000  b570              PUSH     {r4-r6,lr}
;;;101    {
;;;102      const char *found, *p;
;;;103    
;;;104      c = (unsigned char) c;
000002  f01105ff          ANDS     r5,r1,#0xff
000006  d001              BEQ      |L4.12|
;;;105    
;;;106      /* Since strchr is fast, we use it rather than the obvious loop.  */
;;;107    
;;;108      if (c == '\0')
;;;109        return strchr (s, '\0');
;;;110    
;;;111      found = NULL;
000008  2400              MOVS     r4,#0
;;;112      while ((p = strchr (s, c)) != NULL)
00000a  e006              B        |L4.26|
                  |L4.12|
00000c  e8bd4070          POP      {r4-r6,lr}            ;109
000010  2100              MOVS     r1,#0                 ;109
000012  f7ffbffe          B.W      strchr
                  |L4.22|
;;;113        {
;;;114          found = p;
000016  4604              MOV      r4,r0
;;;115          s = p + 1;
000018  1c40              ADDS     r0,r0,#1
                  |L4.26|
00001a  4629              MOV      r1,r5                 ;112
00001c  f7fffffe          BL       strchr
000020  2800              CMP      r0,#0                 ;112
000022  d1f8              BNE      |L4.22|
;;;116        }
;;;117    
;;;118      return (char *) found;
000024  4620              MOV      r0,r4
;;;119    }
000026  bd70              POP      {r4-r6,pc}
;;;120    
                          ENDP


                          AREA ||i.__iar_Strstr||, CODE, READONLY, ALIGN=1

                  __iar_Strstr PROC
;;;69     // logging.o
;;;70     char* __iar_Strstr(char* s1, char* s2)
000000  b510              PUSH     {r4,lr}
;;;71     {  
;;;72         int n;  
;;;73         if (*s2)  
000002  780a              LDRB     r2,[r1,#0]
000004  b962              CBNZ     r2,|L5.32|
                  |L5.6|
;;;74         {  
;;;75             while (*s1)  
;;;76             {  
;;;77                 for (n=0; *(s1 + n) == *(s2 + n); n++)  
;;;78                 {  
;;;79                     if (!*(s2 + n + 1))  
;;;80                         return (char *)s1;  
;;;81                 }  
;;;82                 s1++;  
;;;83             }  
;;;84             return NULL;  
;;;85         }  
;;;86         else  
;;;87             return (char *)s1;  
;;;88     }  
000006  bd10              POP      {r4,pc}
                  |L5.8|
000008  2200              MOVS     r2,#0                 ;77
00000a  e004              B        |L5.22|
                  |L5.12|
00000c  188b              ADDS     r3,r1,r2              ;79
00000e  785b              LDRB     r3,[r3,#1]            ;79
000010  2b00              CMP      r3,#0                 ;79
000012  d0f8              BEQ      |L5.6|
000014  1c52              ADDS     r2,r2,#1              ;79
                  |L5.22|
000016  5c83              LDRB     r3,[r0,r2]            ;77
000018  5c8c              LDRB     r4,[r1,r2]            ;77
00001a  42a3              CMP      r3,r4                 ;77
00001c  d0f6              BEQ      |L5.12|
00001e  1c40              ADDS     r0,r0,#1              ;77
                  |L5.32|
000020  7802              LDRB     r2,[r0,#0]            ;75
000022  2a00              CMP      r2,#0                 ;75
000024  d1f0              BNE      |L5.8|
000026  2000              MOVS     r0,#0                 ;84
000028  bd10              POP      {r4,pc}
;;;89     
                          ENDP


                          AREA ||i.__iar_dlmallinfo||, CODE, READONLY, ALIGN=1

                  __iar_dlmallinfo PROC
;;;388    
;;;389    __weak void *__iar_dlmallinfo(void)
000000  2000              MOVS     r0,#0
;;;390    {
;;;391        return NULL;
;;;392    }
000002  4770              BX       lr
;;;393    
                          ENDP


                          AREA ||i._sys_command_string||, CODE, READONLY, ALIGN=1

                  _sys_command_string PROC
;;;61     
;;;62     char *_sys_command_string(char * cmd, int len) 
000000  2000              MOVS     r0,#0
;;;63     {
;;;64         cmd = cmd;
;;;65         len = len;
;;;66         return 0;
;;;67     }
000002  4770              BX       lr
;;;68     
                          ENDP


                          AREA ||i._sys_exit||, CODE, READONLY, ALIGN=1

                  _sys_exit PROC
                  |L8.0|
;;;51     
;;;52     void _sys_exit(int return_code) {
000000  e7fe              B        |L8.0|
;;;53     label:  goto label;  /* endless loop */
;;;54     }
;;;55     
                          ENDP


                          AREA ||i._ttywrch||, CODE, READONLY, ALIGN=1

                  _ttywrch PROC
;;;46     
;;;47     void _ttywrch(int ch) {
000000  4770              BX       lr
;;;48       return;
;;;49     }
;;;50     
                          ENDP


                          AREA ||i.aes_decrypt||, CODE, READONLY, ALIGN=1

                  aes_decrypt PROC
;;;393    
;;;394    __weak int aes_decrypt(void)
000000  2000              MOVS     r0,#0
;;;395    {
;;;396        return 0;
;;;397    }
000002  4770              BX       lr
;;;398    
                          ENDP


                          AREA ||i.ferror||, CODE, READONLY, ALIGN=1

                  ferror PROC
;;;40     
;;;41     int ferror(FILE *f) {
000000  f04f30ff          MOV      r0,#0xffffffff
;;;42       /* Your implementation of ferror */
;;;43       return EOF;
;;;44     }
000004  4770              BX       lr
;;;45     
                          ENDP


                          AREA ||i.fgetc||, CODE, READONLY, ALIGN=1

                  fgetc PROC
;;;35     
;;;36     int fgetc(FILE *f) {
000000  2030              MOVS     r0,#0x30
;;;37       return 0x30;
;;;38     }
000002  4770              BX       lr
;;;39     
                          ENDP


                          AREA ||i.fputc||, CODE, READONLY, ALIGN=1

                  fputc PROC
;;;55     
;;;56     int fputc(int ch, FILE *f) {
000000  b513              PUSH     {r0,r1,r4,lr}
;;;57       MicoUartSend( STDIO_UART, &ch, 1 );
000002  2201              MOVS     r2,#1
000004  4669              MOV      r1,sp
000006  2000              MOVS     r0,#0
000008  f7fffffe          BL       MicoUartSend
;;;58       return ch;
00000c  9800              LDR      r0,[sp,#0]
;;;59     }
00000e  bd1c              POP      {r2-r4,pc}
;;;60     
                          ENDP


                          AREA ||i.is_nfc_up||, CODE, READONLY, ALIGN=1

                  is_nfc_up PROC
;;;384    //mxchipWNET.o
;;;385    int is_nfc_up(void){
000000  2000              MOVS     r0,#0
;;;386        return 0;
;;;387    }
000002  4770              BX       lr
;;;388    
                          ENDP


                          AREA ||i.mico_platform_get_rtc_time||, CODE, READONLY, ALIGN=1

                  mico_platform_get_rtc_time PROC
;;;433    
;;;434    int mico_platform_get_rtc_time (){
000000  2001              MOVS     r0,#1
;;;435        return 1;
;;;436    }
000002  4770              BX       lr
;;;437    int mico_platform_set_rtc_time (){
                          ENDP


                          AREA ||i.mico_platform_set_rtc_time||, CODE, READONLY, ALIGN=1

                  mico_platform_set_rtc_time PROC
;;;436    }
;;;437    int mico_platform_set_rtc_time (){
000000  2000              MOVS     r0,#0
;;;438        return 0;
;;;439    }
000002  4770              BX       lr
;;;440    
                          ENDP


                          AREA ||i.nfc_config_stop||, CODE, READONLY, ALIGN=1

                  nfc_config_stop PROC
;;;398    
;;;399    int nfc_config_stop(void)
000000  2000              MOVS     r0,#0
;;;400    {
;;;401        return 0;
;;;402    }
000002  4770              BX       lr
;;;403    
                          ENDP


                          AREA ||i.strdup||, CODE, READONLY, ALIGN=1

                  strdup PROC
;;;414    
;;;415    char *strdup(const char *src)
000000  b570              PUSH     {r4-r6,lr}
;;;416    {
000002  0004              MOVS     r4,r0
000004  d011              BEQ      |L18.42|
;;;417      int len;
;;;418      char *dst;
;;;419      
;;;420      if (src == NULL)
;;;421        return NULL;
;;;422      
;;;423      if (src[0] == 0)
000006  7820              LDRB     r0,[r4,#0]
000008  2800              CMP      r0,#0
00000a  d00d              BEQ      |L18.40|
;;;424        return NULL;
;;;425      
;;;426      len = strlen(src) + 1;
00000c  4620              MOV      r0,r4
00000e  f7fffffe          BL       strlen
000012  1c40              ADDS     r0,r0,#1
000014  4606              MOV      r6,r0
;;;427      dst = (char*)malloc(len);
000016  f7fffffe          BL       malloc
00001a  0005              MOVS     r5,r0
;;;428      if (dst) 
00001c  d003              BEQ      |L18.38|
;;;429        memcpy(dst, src, len);
00001e  4632              MOV      r2,r6
000020  4621              MOV      r1,r4
000022  f7fffffe          BL       __aeabi_memcpy
                  |L18.38|
;;;430      return dst;
000026  4628              MOV      r0,r5
                  |L18.40|
;;;431    }
000028  bd70              POP      {r4-r6,pc}
                  |L18.42|
00002a  2000              MOVS     r0,#0                 ;421
00002c  bd70              POP      {r4-r6,pc}
;;;432    
                          ENDP


                          AREA ||i.uart_init||, CODE, READONLY, ALIGN=1

                  uart_init PROC
;;;403    
;;;404    int uart_init(void)
000000  2000              MOVS     r0,#0
;;;405    {
;;;406        return 0;
;;;407    }
000002  4770              BX       lr
;;;408    
                          ENDP


                          AREA ||.data||, DATA, ALIGN=2

                  __stdout
                          DCD      0x00000000

                          AREA ||area_number.23||, DATA, ALIGN=2

                          EXPORTAS ||area_number.23||, ||.data||
                  __stdin
                          DCD      0x00000000

                          AREA ||area_number.24||, DATA, ALIGN=2

                          EXPORTAS ||area_number.24||, ||.data||
                  __stderr
                          DCD      0x00000000

;*** Start embedded assembler ***

#line 1 "..\\..\\..\\..\\Platform\\RVMDK\\Retarget.c"
	AREA ||.rev16_text||, CODE
	THUMB
	EXPORT |__asm___10_Retarget_c_fgetc____REV16|
#line 114 "..\\..\\..\\..\\Platform\\Cortex-M4\\CMSIS\\core_cmInstr.h"
|__asm___10_Retarget_c_fgetc____REV16| PROC
#line 115

 rev16 r0, r0
 bx lr
	ENDP
	AREA ||.revsh_text||, CODE
	THUMB
	EXPORT |__asm___10_Retarget_c_fgetc____REVSH|
#line 128
|__asm___10_Retarget_c_fgetc____REVSH| PROC
#line 129

 revsh r0, r0
 bx lr
	ENDP

;*** End   embedded assembler ***
