; generated by ARM C/C++ Compiler, 4.1 [Build 894]
; commandline ArmCC [--list --split_sections --debug -c --asm --interleave -o.\STM324xG_EVAL\stm32f4xx_flash.o --asm_dir=.\STM324xG_EVAL\ --list_dir=.\STM324xG_EVAL\ --depend=.\STM324xG_EVAL\stm32f4xx_flash.d --cpu=Cortex-M4.fp --apcs=interwork -O0 -Otime -I..\ -I..\..\..\Libraries\CMSIS\Device\ST\STM32F4xx\Include -I..\..\..\Libraries\STM32F4xx_StdPeriph_Driver\inc -I..\..\..\Utilities\STM32_EVAL\Common -I..\..\..\Utilities\STM32_EVAL\STM3240_41_G_EVAL -IC:\Keil\ARM\RV31\Inc -IC:\Keil\ARM\CMSIS\Include -IC:\Keil\ARM\Inc\ST\STM32F4xx -D__MICROLIB -DUSE_STM324xG_EVAL -DSTM32F4XX -DUSE_STDPERIPH_DRIVER --omf_browse=.\STM324xG_EVAL\stm32f4xx_flash.crf ..\..\..\Libraries\STM32F4xx_StdPeriph_Driver\src\stm32f4xx_flash.c]
                          THUMB

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

                  FLASH_ClearFlag PROC
;;;963      */
;;;964    void FLASH_ClearFlag(uint32_t FLASH_FLAG)
000000  4901              LDR      r1,|L1.8|
;;;965    {
;;;966      /* Check the parameters */
;;;967      assert_param(IS_FLASH_CLEAR_FLAG(FLASH_FLAG));
;;;968      
;;;969      /* Clear the flags */
;;;970      FLASH->SR = FLASH_FLAG;
000002  6008              STR      r0,[r1,#0]
;;;971    }
000004  4770              BX       lr
;;;972    
                          ENDP

000006  0000              DCW      0x0000
                  |L1.8|
                          DCD      0x40023c0c

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

                  FLASH_DataCacheCmd PROC
;;;223      */
;;;224    void FLASH_DataCacheCmd(FunctionalState NewState)
000000  b130              CBZ      r0,|L2.16|
;;;225    {
;;;226      /* Check the parameters */
;;;227      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;228      
;;;229      if(NewState != DISABLE)
;;;230      {
;;;231        FLASH->ACR |= FLASH_ACR_DCEN;
000002  4907              LDR      r1,|L2.32|
000004  6809              LDR      r1,[r1,#0]
000006  f4416180          ORR      r1,r1,#0x400
00000a  4a05              LDR      r2,|L2.32|
00000c  6011              STR      r1,[r2,#0]
00000e  e005              B        |L2.28|
                  |L2.16|
;;;232      }
;;;233      else
;;;234      {
;;;235        FLASH->ACR &= (~FLASH_ACR_DCEN);
000010  4903              LDR      r1,|L2.32|
000012  6809              LDR      r1,[r1,#0]
000014  f4216180          BIC      r1,r1,#0x400
000018  4a01              LDR      r2,|L2.32|
00001a  6011              STR      r1,[r2,#0]
                  |L2.28|
;;;236      }
;;;237    }
00001c  4770              BX       lr
;;;238    
                          ENDP

00001e  0000              DCW      0x0000
                  |L2.32|
                          DCD      0x40023c00

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

                  FLASH_DataCacheReset PROC
;;;255      */
;;;256    void FLASH_DataCacheReset(void)
000000  4803              LDR      r0,|L3.16|
;;;257    {
;;;258      FLASH->ACR |= FLASH_ACR_DCRST;
000002  6800              LDR      r0,[r0,#0]
000004  f4405080          ORR      r0,r0,#0x1000
000008  4901              LDR      r1,|L3.16|
00000a  6008              STR      r0,[r1,#0]
;;;259    }
00000c  4770              BX       lr
;;;260    
                          ENDP

00000e  0000              DCW      0x0000
                  |L3.16|
                          DCD      0x40023c00

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

                  FLASH_EraseAllSectors PROC
;;;405      */
;;;406    FLASH_Status FLASH_EraseAllSectors(uint8_t VoltageRange)
000000  b530              PUSH     {r4,r5,lr}
;;;407    {
000002  4603              MOV      r3,r0
;;;408      uint32_t tmp_psize = 0x0;
000004  2500              MOVS     r5,#0
;;;409      FLASH_Status status = FLASH_COMPLETE;
000006  2408              MOVS     r4,#8
;;;410      
;;;411      /* Wait for last operation to be completed */
;;;412      status = FLASH_WaitForLastOperation();
000008  f7fffffe          BL       FLASH_WaitForLastOperation
00000c  4604              MOV      r4,r0
;;;413      assert_param(IS_VOLTAGERANGE(VoltageRange));
;;;414      
;;;415      if(VoltageRange == VoltageRange_1)
00000e  b903              CBNZ     r3,|L4.18|
;;;416      {
;;;417         tmp_psize = FLASH_PSIZE_BYTE;
000010  e009              B        |L4.38|
                  |L4.18|
;;;418      }
;;;419      else if(VoltageRange == VoltageRange_2)
000012  2b01              CMP      r3,#1
000014  d101              BNE      |L4.26|
;;;420      {
;;;421        tmp_psize = FLASH_PSIZE_HALF_WORD;
000016  021d              LSLS     r5,r3,#8
000018  e005              B        |L4.38|
                  |L4.26|
;;;422      }
;;;423      else if(VoltageRange == VoltageRange_3)
00001a  2b02              CMP      r3,#2
00001c  d101              BNE      |L4.34|
;;;424      {
;;;425        tmp_psize = FLASH_PSIZE_WORD;
00001e  021d              LSLS     r5,r3,#8
000020  e001              B        |L4.38|
                  |L4.34|
;;;426      }
;;;427      else
;;;428      {
;;;429        tmp_psize = FLASH_PSIZE_DOUBLE_WORD;
000022  f44f7540          MOV      r5,#0x300
                  |L4.38|
;;;430      }  
;;;431      if(status == FLASH_COMPLETE)
000026  2c08              CMP      r4,#8
000028  d11c              BNE      |L4.100|
;;;432      {
;;;433        /* if the previous operation is completed, proceed to erase all sectors */
;;;434         FLASH->CR &= CR_PSIZE_MASK;
00002a  480f              LDR      r0,|L4.104|
00002c  6800              LDR      r0,[r0,#0]
00002e  f4207040          BIC      r0,r0,#0x300
000032  490d              LDR      r1,|L4.104|
000034  6008              STR      r0,[r1,#0]
;;;435         FLASH->CR |= tmp_psize;
000036  4608              MOV      r0,r1
000038  6800              LDR      r0,[r0,#0]
00003a  4328              ORRS     r0,r0,r5
00003c  6008              STR      r0,[r1,#0]
;;;436         FLASH->CR |= FLASH_CR_MER;
00003e  4608              MOV      r0,r1
000040  6800              LDR      r0,[r0,#0]
000042  f0400004          ORR      r0,r0,#4
000046  6008              STR      r0,[r1,#0]
;;;437         FLASH->CR |= FLASH_CR_STRT;
000048  4608              MOV      r0,r1
00004a  6800              LDR      r0,[r0,#0]
00004c  f4403080          ORR      r0,r0,#0x10000
000050  6008              STR      r0,[r1,#0]
;;;438        
;;;439        /* Wait for last operation to be completed */
;;;440        status = FLASH_WaitForLastOperation();
000052  f7fffffe          BL       FLASH_WaitForLastOperation
000056  4604              MOV      r4,r0
;;;441    
;;;442        /* if the erase operation is completed, disable the MER Bit */
;;;443        FLASH->CR &= (~FLASH_CR_MER);
000058  4803              LDR      r0,|L4.104|
00005a  6800              LDR      r0,[r0,#0]
00005c  f0200004          BIC      r0,r0,#4
000060  4901              LDR      r1,|L4.104|
000062  6008              STR      r0,[r1,#0]
                  |L4.100|
;;;444    
;;;445      }   
;;;446      /* Return the Erase Status */
;;;447      return status;
000064  4620              MOV      r0,r4
;;;448    }
000066  bd30              POP      {r4,r5,pc}
;;;449    
                          ENDP

                  |L4.104|
                          DCD      0x40023c10

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

                  FLASH_EraseSector PROC
;;;340      */
;;;341    FLASH_Status FLASH_EraseSector(uint32_t FLASH_Sector, uint8_t VoltageRange)
000000  b570              PUSH     {r4-r6,lr}
;;;342    {
000002  4604              MOV      r4,r0
000004  460b              MOV      r3,r1
;;;343      uint32_t tmp_psize = 0x0;
000006  2600              MOVS     r6,#0
;;;344      FLASH_Status status = FLASH_COMPLETE;
000008  2508              MOVS     r5,#8
;;;345    
;;;346      /* Check the parameters */
;;;347      assert_param(IS_FLASH_SECTOR(FLASH_Sector));
;;;348      assert_param(IS_VOLTAGERANGE(VoltageRange));
;;;349      
;;;350      if(VoltageRange == VoltageRange_1)
00000a  b903              CBNZ     r3,|L5.14|
;;;351      {
;;;352         tmp_psize = FLASH_PSIZE_BYTE;
00000c  e009              B        |L5.34|
                  |L5.14|
;;;353      }
;;;354      else if(VoltageRange == VoltageRange_2)
00000e  2b01              CMP      r3,#1
000010  d101              BNE      |L5.22|
;;;355      {
;;;356        tmp_psize = FLASH_PSIZE_HALF_WORD;
000012  021e              LSLS     r6,r3,#8
000014  e005              B        |L5.34|
                  |L5.22|
;;;357      }
;;;358      else if(VoltageRange == VoltageRange_3)
000016  2b02              CMP      r3,#2
000018  d101              BNE      |L5.30|
;;;359      {
;;;360        tmp_psize = FLASH_PSIZE_WORD;
00001a  021e              LSLS     r6,r3,#8
00001c  e001              B        |L5.34|
                  |L5.30|
;;;361      }
;;;362      else
;;;363      {
;;;364        tmp_psize = FLASH_PSIZE_DOUBLE_WORD;
00001e  f44f7640          MOV      r6,#0x300
                  |L5.34|
;;;365      }
;;;366      /* Wait for last operation to be completed */
;;;367      status = FLASH_WaitForLastOperation();
000022  f7fffffe          BL       FLASH_WaitForLastOperation
000026  4605              MOV      r5,r0
;;;368      
;;;369      if(status == FLASH_COMPLETE)
000028  2d08              CMP      r5,#8
00002a  d128              BNE      |L5.126|
;;;370      { 
;;;371        /* if the previous operation is completed, proceed to erase the sector */
;;;372        FLASH->CR &= CR_PSIZE_MASK;
00002c  4815              LDR      r0,|L5.132|
00002e  6800              LDR      r0,[r0,#0]
000030  f4207040          BIC      r0,r0,#0x300
000034  4913              LDR      r1,|L5.132|
000036  6008              STR      r0,[r1,#0]
;;;373        FLASH->CR |= tmp_psize;
000038  4608              MOV      r0,r1
00003a  6800              LDR      r0,[r0,#0]
00003c  4330              ORRS     r0,r0,r6
00003e  6008              STR      r0,[r1,#0]
;;;374        FLASH->CR &= SECTOR_MASK;
000040  4608              MOV      r0,r1
000042  6800              LDR      r0,[r0,#0]
000044  f02000f8          BIC      r0,r0,#0xf8
000048  6008              STR      r0,[r1,#0]
;;;375        FLASH->CR |= FLASH_CR_SER | FLASH_Sector;
00004a  4608              MOV      r0,r1
00004c  6800              LDR      r0,[r0,#0]
00004e  f0440102          ORR      r1,r4,#2
000052  4308              ORRS     r0,r0,r1
000054  490b              LDR      r1,|L5.132|
000056  6008              STR      r0,[r1,#0]
;;;376        FLASH->CR |= FLASH_CR_STRT;
000058  4608              MOV      r0,r1
00005a  6800              LDR      r0,[r0,#0]
00005c  f4403080          ORR      r0,r0,#0x10000
000060  6008              STR      r0,[r1,#0]
;;;377        
;;;378        /* Wait for last operation to be completed */
;;;379        status = FLASH_WaitForLastOperation();
000062  f7fffffe          BL       FLASH_WaitForLastOperation
000066  4605              MOV      r5,r0
;;;380        
;;;381        /* if the erase operation is completed, disable the SER Bit */
;;;382        FLASH->CR &= (~FLASH_CR_SER);
000068  4806              LDR      r0,|L5.132|
00006a  6800              LDR      r0,[r0,#0]
00006c  f0200002          BIC      r0,r0,#2
000070  4904              LDR      r1,|L5.132|
000072  6008              STR      r0,[r1,#0]
;;;383        FLASH->CR &= SECTOR_MASK; 
000074  4608              MOV      r0,r1
000076  6800              LDR      r0,[r0,#0]
000078  f02000f8          BIC      r0,r0,#0xf8
00007c  6008              STR      r0,[r1,#0]
                  |L5.126|
;;;384      }
;;;385      /* Return the Erase Status */
;;;386      return status;
00007e  4628              MOV      r0,r5
;;;387    }
000080  bd70              POP      {r4-r6,pc}
;;;388    
                          ENDP

000082  0000              DCW      0x0000
                  |L5.132|
                          DCD      0x40023c10

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

                  FLASH_GetFlagStatus PROC
;;;933      */
;;;934    FlagStatus FLASH_GetFlagStatus(uint32_t FLASH_FLAG)
000000  4601              MOV      r1,r0
;;;935    {
;;;936      FlagStatus bitstatus = RESET;
000002  2000              MOVS     r0,#0
;;;937      /* Check the parameters */
;;;938      assert_param(IS_FLASH_GET_FLAG(FLASH_FLAG));
;;;939    
;;;940      if((FLASH->SR & FLASH_FLAG) != (uint32_t)RESET)
000004  4a03              LDR      r2,|L6.20|
000006  6812              LDR      r2,[r2,#0]
000008  420a              TST      r2,r1
00000a  d001              BEQ      |L6.16|
;;;941      {
;;;942        bitstatus = SET;
00000c  2001              MOVS     r0,#1
00000e  e000              B        |L6.18|
                  |L6.16|
;;;943      }
;;;944      else
;;;945      {
;;;946        bitstatus = RESET;
000010  2000              MOVS     r0,#0
                  |L6.18|
;;;947      }
;;;948      /* Return the new state of FLASH_FLAG (SET or RESET) */
;;;949      return bitstatus; 
;;;950    }
000012  4770              BX       lr
;;;951    
                          ENDP

                  |L6.20|
                          DCD      0x40023c0c

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

                  FLASH_GetStatus PROC
;;;978      */
;;;979    FLASH_Status FLASH_GetStatus(void)
000000  2008              MOVS     r0,#8
;;;980    {
;;;981      FLASH_Status flashstatus = FLASH_COMPLETE;
;;;982      
;;;983      if((FLASH->SR & FLASH_FLAG_BSY) == FLASH_FLAG_BSY) 
000002  4910              LDR      r1,|L7.68|
000004  6809              LDR      r1,[r1,#0]
000006  f4013180          AND      r1,r1,#0x10000
00000a  f5b13f80          CMP      r1,#0x10000
00000e  d101              BNE      |L7.20|
;;;984      {
;;;985        flashstatus = FLASH_BUSY;
000010  2001              MOVS     r0,#1
000012  e015              B        |L7.64|
                  |L7.20|
;;;986      }
;;;987      else 
;;;988      {  
;;;989        if((FLASH->SR & FLASH_FLAG_WRPERR) != (uint32_t)0x00)
000014  490b              LDR      r1,|L7.68|
000016  6809              LDR      r1,[r1,#0]
000018  f0110f10          TST      r1,#0x10
00001c  d001              BEQ      |L7.34|
;;;990        { 
;;;991          flashstatus = FLASH_ERROR_WRP;
00001e  2005              MOVS     r0,#5
000020  e00e              B        |L7.64|
                  |L7.34|
;;;992        }
;;;993        else 
;;;994        {
;;;995          if((FLASH->SR & (uint32_t)0xEF) != (uint32_t)0x00)
000022  4908              LDR      r1,|L7.68|
000024  6809              LDR      r1,[r1,#0]
000026  f0110fef          TST      r1,#0xef
00002a  d001              BEQ      |L7.48|
;;;996          {
;;;997            flashstatus = FLASH_ERROR_PROGRAM; 
00002c  2006              MOVS     r0,#6
00002e  e007              B        |L7.64|
                  |L7.48|
;;;998          }
;;;999          else
;;;1000         {
;;;1001           if((FLASH->SR & FLASH_FLAG_OPERR) != (uint32_t)0x00)
000030  4904              LDR      r1,|L7.68|
000032  6809              LDR      r1,[r1,#0]
000034  f0110f02          TST      r1,#2
000038  d001              BEQ      |L7.62|
;;;1002           {
;;;1003             flashstatus = FLASH_ERROR_OPERATION;
00003a  2007              MOVS     r0,#7
00003c  e000              B        |L7.64|
                  |L7.62|
;;;1004           }
;;;1005           else
;;;1006           {
;;;1007             flashstatus = FLASH_COMPLETE;
00003e  2008              MOVS     r0,#8
                  |L7.64|
;;;1008           }
;;;1009         }
;;;1010       }
;;;1011     }
;;;1012     /* Return the FLASH Status */
;;;1013     return flashstatus;
;;;1014   }
000040  4770              BX       lr
;;;1015   
                          ENDP

000042  0000              DCW      0x0000
                  |L7.68|
                          DCD      0x40023c0c

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

                  FLASH_ITConfig PROC
;;;902      */
;;;903    void FLASH_ITConfig(uint32_t FLASH_IT, FunctionalState NewState)
000000  b129              CBZ      r1,|L8.14|
;;;904    {
;;;905      /* Check the parameters */
;;;906      assert_param(IS_FLASH_IT(FLASH_IT)); 
;;;907      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;908    
;;;909      if(NewState != DISABLE)
;;;910      {
;;;911        /* Enable the interrupt sources */
;;;912        FLASH->CR |= FLASH_IT;
000002  4a06              LDR      r2,|L8.28|
000004  6812              LDR      r2,[r2,#0]
000006  4302              ORRS     r2,r2,r0
000008  4b04              LDR      r3,|L8.28|
00000a  601a              STR      r2,[r3,#0]
00000c  e004              B        |L8.24|
                  |L8.14|
;;;913      }
;;;914      else
;;;915      {
;;;916        /* Disable the interrupt sources */
;;;917        FLASH->CR &= ~(uint32_t)FLASH_IT;
00000e  4a03              LDR      r2,|L8.28|
000010  6812              LDR      r2,[r2,#0]
000012  4382              BICS     r2,r2,r0
000014  4b01              LDR      r3,|L8.28|
000016  601a              STR      r2,[r3,#0]
                  |L8.24|
;;;918      }
;;;919    }
000018  4770              BX       lr
;;;920    
                          ENDP

00001a  0000              DCW      0x0000
                  |L8.28|
                          DCD      0x40023c10

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

                  FLASH_InstructionCacheCmd PROC
;;;202      */
;;;203    void FLASH_InstructionCacheCmd(FunctionalState NewState)
000000  b130              CBZ      r0,|L9.16|
;;;204    {
;;;205      /* Check the parameters */
;;;206      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;207      
;;;208      if(NewState != DISABLE)
;;;209      {
;;;210        FLASH->ACR |= FLASH_ACR_ICEN;
000002  4907              LDR      r1,|L9.32|
000004  6809              LDR      r1,[r1,#0]
000006  f4417100          ORR      r1,r1,#0x200
00000a  4a05              LDR      r2,|L9.32|
00000c  6011              STR      r1,[r2,#0]
00000e  e005              B        |L9.28|
                  |L9.16|
;;;211      }
;;;212      else
;;;213      {
;;;214        FLASH->ACR &= (~FLASH_ACR_ICEN);
000010  4903              LDR      r1,|L9.32|
000012  6809              LDR      r1,[r1,#0]
000014  f4217100          BIC      r1,r1,#0x200
000018  4a01              LDR      r2,|L9.32|
00001a  6011              STR      r1,[r2,#0]
                  |L9.28|
;;;215      }
;;;216    }
00001c  4770              BX       lr
;;;217    
                          ENDP

00001e  0000              DCW      0x0000
                  |L9.32|
                          DCD      0x40023c00

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

                  FLASH_InstructionCacheReset PROC
;;;244      */
;;;245    void FLASH_InstructionCacheReset(void)
000000  4803              LDR      r0,|L10.16|
;;;246    {
;;;247      FLASH->ACR |= FLASH_ACR_ICRST;
000002  6800              LDR      r0,[r0,#0]
000004  f4406000          ORR      r0,r0,#0x800
000008  4901              LDR      r1,|L10.16|
00000a  6008              STR      r0,[r1,#0]
;;;248    }
00000c  4770              BX       lr
;;;249    
                          ENDP

00000e  0000              DCW      0x0000
                  |L10.16|
                          DCD      0x40023c00

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

                  FLASH_Lock PROC
;;;314      */
;;;315    void FLASH_Lock(void)
000000  4803              LDR      r0,|L11.16|
;;;316    {
;;;317      /* Set the LOCK Bit to lock the FLASH Registers access */
;;;318      FLASH->CR |= FLASH_CR_LOCK;
000002  6800              LDR      r0,[r0,#0]
000004  f0404000          ORR      r0,r0,#0x80000000
000008  4901              LDR      r1,|L11.16|
00000a  6008              STR      r0,[r1,#0]
;;;319    }
00000c  4770              BX       lr
;;;320    
                          ENDP

00000e  0000              DCW      0x0000
                  |L11.16|
                          DCD      0x40023c10

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

                  FLASH_OB_BORConfig PROC
;;;788      */
;;;789    void FLASH_OB_BORConfig(uint8_t OB_BOR)
000000  4905              LDR      r1,|L12.24|
;;;790    {
;;;791      /* Check the parameters */
;;;792      assert_param(IS_OB_BOR(OB_BOR));
;;;793    
;;;794      /* Set the BOR Level */
;;;795      *(__IO uint8_t *)OPTCR_BYTE0_ADDRESS &= (~FLASH_OPTCR_BOR_LEV);
000002  7809              LDRB     r1,[r1,#0]
000004  f021010c          BIC      r1,r1,#0xc
000008  4a03              LDR      r2,|L12.24|
00000a  7011              STRB     r1,[r2,#0]
;;;796      *(__IO uint8_t *)OPTCR_BYTE0_ADDRESS |= OB_BOR;
00000c  4611              MOV      r1,r2
00000e  7809              LDRB     r1,[r1,#0]
000010  4301              ORRS     r1,r1,r0
000012  7011              STRB     r1,[r2,#0]
;;;797    
;;;798    }
000014  4770              BX       lr
;;;799    
                          ENDP

000016  0000              DCW      0x0000
                  |L12.24|
                          DCD      0x40023c14

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

                  FLASH_OB_GetBOR PROC
;;;872      */
;;;873    uint8_t FLASH_OB_GetBOR(void)
000000  4802              LDR      r0,|L13.12|
;;;874    {
;;;875      /* Return the FLASH BOR level */
;;;876      return (uint8_t)(*(__IO uint8_t *)(OPTCR_BYTE0_ADDRESS) & (uint8_t)0x0C);
000002  7800              LDRB     r0,[r0,#0]
000004  f000000c          AND      r0,r0,#0xc
;;;877    }
000008  4770              BX       lr
;;;878    
                          ENDP

00000a  0000              DCW      0x0000
                  |L13.12|
                          DCD      0x40023c14

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

                  FLASH_OB_GetRDP PROC
;;;848      */
;;;849    FlagStatus FLASH_OB_GetRDP(void)
000000  2000              MOVS     r0,#0
;;;850    {
;;;851      FlagStatus readstatus = RESET;
;;;852    
;;;853      if ((*(__IO uint8_t*)(OPTCR_BYTE1_ADDRESS) != (uint8_t)OB_RDP_Level_0))
000002  4904              LDR      r1,|L14.20|
000004  7809              LDRB     r1,[r1,#0]
000006  29aa              CMP      r1,#0xaa
000008  d001              BEQ      |L14.14|
;;;854      {
;;;855        readstatus = SET;
00000a  2001              MOVS     r0,#1
00000c  e000              B        |L14.16|
                  |L14.14|
;;;856      }
;;;857      else
;;;858      {
;;;859        readstatus = RESET;
00000e  2000              MOVS     r0,#0
                  |L14.16|
;;;860      }
;;;861      return readstatus;
;;;862    }
000010  4770              BX       lr
;;;863    
                          ENDP

000012  0000              DCW      0x0000
                  |L14.20|
                          DCD      0x40023c15

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

                  FLASH_OB_GetUser PROC
;;;824      */
;;;825    uint8_t FLASH_OB_GetUser(void)
000000  4802              LDR      r0,|L15.12|
;;;826    {
;;;827      /* Return the User Option Byte */
;;;828      return (uint8_t)(FLASH->OPTCR >> 5);
000002  6800              LDR      r0,[r0,#0]
000004  f3c01047          UBFX     r0,r0,#5,#8
;;;829    }
000008  4770              BX       lr
;;;830    
                          ENDP

00000a  0000              DCW      0x0000
                  |L15.12|
                          DCD      0x40023c14

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

                  FLASH_OB_GetWRP PROC
;;;835      */
;;;836    uint16_t FLASH_OB_GetWRP(void)
000000  4801              LDR      r0,|L16.8|
;;;837    {
;;;838      /* Return the FLASH write protection Register value */
;;;839      return (*(__IO uint16_t *)(OPTCR_BYTE2_ADDRESS));
000002  8800              LDRH     r0,[r0,#0]
;;;840    }
000004  4770              BX       lr
;;;841    
                          ENDP

000006  0000              DCW      0x0000
                  |L16.8|
                          DCD      0x40023c16

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

                  FLASH_OB_Launch PROC
;;;805      */
;;;806    FLASH_Status FLASH_OB_Launch(void)
000000  b500              PUSH     {lr}
;;;807    {
;;;808      FLASH_Status status = FLASH_COMPLETE;
000002  2308              MOVS     r3,#8
;;;809    
;;;810      /* Set the OPTSTRT bit in OPTCR register */
;;;811      *(__IO uint8_t *)OPTCR_BYTE0_ADDRESS |= FLASH_OPTCR_OPTSTRT;
000004  4805              LDR      r0,|L17.28|
000006  7800              LDRB     r0,[r0,#0]
000008  f0400002          ORR      r0,r0,#2
00000c  4903              LDR      r1,|L17.28|
00000e  7008              STRB     r0,[r1,#0]
;;;812    
;;;813      /* Wait for last operation to be completed */
;;;814      status = FLASH_WaitForLastOperation();
000010  f7fffffe          BL       FLASH_WaitForLastOperation
000014  4603              MOV      r3,r0
;;;815    
;;;816      return status;
000016  4618              MOV      r0,r3
;;;817    }
000018  bd00              POP      {pc}
;;;818    
                          ENDP

00001a  0000              DCW      0x0000
                  |L17.28|
                          DCD      0x40023c14

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

                  FLASH_OB_Lock PROC
;;;672      */
;;;673    void FLASH_OB_Lock(void)
000000  4803              LDR      r0,|L18.16|
;;;674    {
;;;675      /* Set the OPTLOCK Bit to lock the FLASH Option Byte Registers access */
;;;676      FLASH->OPTCR |= FLASH_OPTCR_OPTLOCK;
000002  6800              LDR      r0,[r0,#0]
000004  f0400001          ORR      r0,r0,#1
000008  4901              LDR      r1,|L18.16|
00000a  6008              STR      r0,[r1,#0]
;;;677    }
00000c  4770              BX       lr
;;;678    
                          ENDP

00000e  0000              DCW      0x0000
                  |L18.16|
                          DCD      0x40023c14

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

                  FLASH_OB_RDPConfig PROC
;;;723      */
;;;724    void FLASH_OB_RDPConfig(uint8_t OB_RDP)
000000  b510              PUSH     {r4,lr}
;;;725    {
000002  4603              MOV      r3,r0
;;;726      FLASH_Status status = FLASH_COMPLETE;
000004  2408              MOVS     r4,#8
;;;727    
;;;728      /* Check the parameters */
;;;729      assert_param(IS_OB_RDP(OB_RDP));
;;;730    
;;;731      status = FLASH_WaitForLastOperation();
000006  f7fffffe          BL       FLASH_WaitForLastOperation
00000a  4604              MOV      r4,r0
;;;732    
;;;733      if(status == FLASH_COMPLETE)
00000c  2c08              CMP      r4,#8
00000e  d101              BNE      |L19.20|
;;;734      {
;;;735        *(__IO uint8_t*)OPTCR_BYTE1_ADDRESS = OB_RDP;
000010  4801              LDR      r0,|L19.24|
000012  7003              STRB     r3,[r0,#0]
                  |L19.20|
;;;736    
;;;737      }
;;;738    }
000014  bd10              POP      {r4,pc}
;;;739    
                          ENDP

000016  0000              DCW      0x0000
                  |L19.24|
                          DCD      0x40023c15

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

                  FLASH_OB_Unlock PROC
;;;657      */
;;;658    void FLASH_OB_Unlock(void)
000000  4805              LDR      r0,|L20.24|
;;;659    {
;;;660      if((FLASH->OPTCR & FLASH_OPTCR_OPTLOCK) != RESET)
000002  6800              LDR      r0,[r0,#0]
000004  f0100f01          TST      r0,#1
000008  d005              BEQ      |L20.22|
;;;661      {
;;;662        /* Authorizes the Option Byte register programming */
;;;663        FLASH->OPTKEYR = FLASH_OPT_KEY1;
00000a  4804              LDR      r0,|L20.28|
00000c  4902              LDR      r1,|L20.24|
00000e  390c              SUBS     r1,r1,#0xc
000010  6008              STR      r0,[r1,#0]
;;;664        FLASH->OPTKEYR = FLASH_OPT_KEY2;
000012  4803              LDR      r0,|L20.32|
000014  6008              STR      r0,[r1,#0]
                  |L20.22|
;;;665      }  
;;;666    }
000016  4770              BX       lr
;;;667    
                          ENDP

                  |L20.24|
                          DCD      0x40023c14
                  |L20.28|
                          DCD      0x08192a3b
                  |L20.32|
                          DCD      0x4c5d6e7f

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

                  FLASH_OB_UserConfig PROC
;;;755      */
;;;756    void FLASH_OB_UserConfig(uint8_t OB_IWDG, uint8_t OB_STOP, uint8_t OB_STDBY)
000000  b5f0              PUSH     {r4-r7,lr}
;;;757    {
000002  4603              MOV      r3,r0
000004  460c              MOV      r4,r1
000006  4615              MOV      r5,r2
;;;758      uint8_t optiontmp = 0xFF;
000008  26ff              MOVS     r6,#0xff
;;;759      FLASH_Status status = FLASH_COMPLETE; 
00000a  2708              MOVS     r7,#8
;;;760    
;;;761      /* Check the parameters */
;;;762      assert_param(IS_OB_IWDG_SOURCE(OB_IWDG));
;;;763      assert_param(IS_OB_STOP_SOURCE(OB_STOP));
;;;764      assert_param(IS_OB_STDBY_SOURCE(OB_STDBY));
;;;765    
;;;766      /* Wait for last operation to be completed */
;;;767      status = FLASH_WaitForLastOperation();
00000c  f7fffffe          BL       FLASH_WaitForLastOperation
000010  4607              MOV      r7,r0
;;;768      
;;;769      if(status == FLASH_COMPLETE)
000012  2f08              CMP      r7,#8
000014  d109              BNE      |L21.42|
;;;770      { 
;;;771        /* Mask OPTLOCK, OPTSTRT and BOR_LEV bits */
;;;772        optiontmp =  (uint8_t)((*(__IO uint8_t *)OPTCR_BYTE0_ADDRESS) & (uint8_t)0x0F); 
000016  4805              LDR      r0,|L21.44|
000018  7800              LDRB     r0,[r0,#0]
00001a  f000060f          AND      r6,r0,#0xf
;;;773    
;;;774        /* Update User Option Byte */
;;;775        *(__IO uint8_t *)OPTCR_BYTE0_ADDRESS = OB_IWDG | (uint8_t)(OB_STDBY | (uint8_t)(OB_STOP | ((uint8_t)optiontmp))); 
00001e  ea440006          ORR      r0,r4,r6
000022  4328              ORRS     r0,r0,r5
000024  4318              ORRS     r0,r0,r3
000026  4901              LDR      r1,|L21.44|
000028  7008              STRB     r0,[r1,#0]
                  |L21.42|
;;;776      }  
;;;777    }
00002a  bdf0              POP      {r4-r7,pc}
;;;778    
                          ENDP

                  |L21.44|
                          DCD      0x40023c14

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

                  FLASH_OB_WRPConfig PROC
;;;688      */
;;;689    void FLASH_OB_WRPConfig(uint32_t OB_WRP, FunctionalState NewState)
000000  b530              PUSH     {r4,r5,lr}
;;;690    { 
000002  4603              MOV      r3,r0
000004  460c              MOV      r4,r1
;;;691      FLASH_Status status = FLASH_COMPLETE;
000006  2508              MOVS     r5,#8
;;;692      
;;;693      /* Check the parameters */
;;;694      assert_param(IS_OB_WRP(OB_WRP));
;;;695      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;696        
;;;697      status = FLASH_WaitForLastOperation();
000008  f7fffffe          BL       FLASH_WaitForLastOperation
00000c  4605              MOV      r5,r0
;;;698    
;;;699      if(status == FLASH_COMPLETE)
00000e  2d08              CMP      r5,#8
000010  d10c              BNE      |L22.44|
;;;700      { 
;;;701        if(NewState != DISABLE)
000012  b12c              CBZ      r4,|L22.32|
;;;702        {
;;;703          *(__IO uint16_t*)OPTCR_BYTE2_ADDRESS &= (~OB_WRP);
000014  4806              LDR      r0,|L22.48|
000016  8800              LDRH     r0,[r0,#0]
000018  4398              BICS     r0,r0,r3
00001a  4905              LDR      r1,|L22.48|
00001c  8008              STRH     r0,[r1,#0]
00001e  e005              B        |L22.44|
                  |L22.32|
;;;704        }
;;;705        else
;;;706        {
;;;707          *(__IO uint16_t*)OPTCR_BYTE2_ADDRESS |= (uint16_t)OB_WRP;
000020  4803              LDR      r0,|L22.48|
000022  8800              LDRH     r0,[r0,#0]
000024  b299              UXTH     r1,r3
000026  4308              ORRS     r0,r0,r1
000028  4901              LDR      r1,|L22.48|
00002a  8008              STRH     r0,[r1,#0]
                  |L22.44|
;;;708        }
;;;709      }
;;;710    }
00002c  bd30              POP      {r4,r5,pc}
;;;711    
                          ENDP

00002e  0000              DCW      0x0000
                  |L22.48|
                          DCD      0x40023c16

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

                  FLASH_PrefetchBufferCmd PROC
;;;180      */
;;;181    void FLASH_PrefetchBufferCmd(FunctionalState NewState)
000000  b130              CBZ      r0,|L23.16|
;;;182    {
;;;183      /* Check the parameters */
;;;184      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;185      
;;;186      /* Enable or disable the Prefetch Buffer */
;;;187      if(NewState != DISABLE)
;;;188      {
;;;189        FLASH->ACR |= FLASH_ACR_PRFTEN;
000002  4907              LDR      r1,|L23.32|
000004  6809              LDR      r1,[r1,#0]
000006  f4417180          ORR      r1,r1,#0x100
00000a  4a05              LDR      r2,|L23.32|
00000c  6011              STR      r1,[r2,#0]
00000e  e005              B        |L23.28|
                  |L23.16|
;;;190      }
;;;191      else
;;;192      {
;;;193        FLASH->ACR &= (~FLASH_ACR_PRFTEN);
000010  4903              LDR      r1,|L23.32|
000012  6809              LDR      r1,[r1,#0]
000014  f4217180          BIC      r1,r1,#0x100
000018  4a01              LDR      r2,|L23.32|
00001a  6011              STR      r1,[r2,#0]
                  |L23.28|
;;;194      }
;;;195    }
00001c  4770              BX       lr
;;;196    
                          ENDP

00001e  0000              DCW      0x0000
                  |L23.32|
                          DCD      0x40023c00

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

                  FLASH_ProgramByte PROC
;;;572      */
;;;573    FLASH_Status FLASH_ProgramByte(uint32_t Address, uint8_t Data)
000000  b530              PUSH     {r4,r5,lr}
;;;574    {
000002  4603              MOV      r3,r0
000004  460c              MOV      r4,r1
;;;575      FLASH_Status status = FLASH_COMPLETE;
000006  2508              MOVS     r5,#8
;;;576    
;;;577      /* Check the parameters */
;;;578      assert_param(IS_FLASH_ADDRESS(Address));
;;;579    
;;;580      /* Wait for last operation to be completed */
;;;581      status = FLASH_WaitForLastOperation();
000008  f7fffffe          BL       FLASH_WaitForLastOperation
00000c  4605              MOV      r5,r0
;;;582      
;;;583      if(status == FLASH_COMPLETE)
00000e  2d08              CMP      r5,#8
000010  d117              BNE      |L24.66|
;;;584      {
;;;585        /* if the previous operation is completed, proceed to program the new data */
;;;586        FLASH->CR &= CR_PSIZE_MASK;
000012  480d              LDR      r0,|L24.72|
000014  6800              LDR      r0,[r0,#0]
000016  f4207040          BIC      r0,r0,#0x300
00001a  490b              LDR      r1,|L24.72|
00001c  6008              STR      r0,[r1,#0]
;;;587        FLASH->CR |= FLASH_PSIZE_BYTE;
00001e  4608              MOV      r0,r1
000020  6800              LDR      r0,[r0,#0]
000022  6008              STR      r0,[r1,#0]
;;;588        FLASH->CR |= FLASH_CR_PG;
000024  4608              MOV      r0,r1
000026  6800              LDR      r0,[r0,#0]
000028  f0400001          ORR      r0,r0,#1
00002c  6008              STR      r0,[r1,#0]
;;;589      
;;;590        *(__IO uint8_t*)Address = Data;
00002e  701c              STRB     r4,[r3,#0]
;;;591            
;;;592        /* Wait for last operation to be completed */
;;;593        status = FLASH_WaitForLastOperation();
000030  f7fffffe          BL       FLASH_WaitForLastOperation
000034  4605              MOV      r5,r0
;;;594    
;;;595        /* if the program operation is completed, disable the PG Bit */
;;;596        FLASH->CR &= (~FLASH_CR_PG);
000036  4804              LDR      r0,|L24.72|
000038  6800              LDR      r0,[r0,#0]
00003a  f0200001          BIC      r0,r0,#1
00003e  4902              LDR      r1,|L24.72|
000040  6008              STR      r0,[r1,#0]
                  |L24.66|
;;;597      } 
;;;598    
;;;599      /* Return the Program Status */
;;;600      return status;
000042  4628              MOV      r0,r5
;;;601    }
000044  bd30              POP      {r4,r5,pc}
;;;602    
                          ENDP

000046  0000              DCW      0x0000
                  |L24.72|
                          DCD      0x40023c10

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

                  FLASH_ProgramDoubleWord PROC
;;;458      */
;;;459    FLASH_Status FLASH_ProgramDoubleWord(uint32_t Address, uint64_t Data)
000000  b570              PUSH     {r4-r6,lr}
;;;460    {
000002  4606              MOV      r6,r0
000004  4614              MOV      r4,r2
000006  461d              MOV      r5,r3
;;;461      FLASH_Status status = FLASH_COMPLETE;
000008  f04f0308          MOV      r3,#8
;;;462    
;;;463      /* Check the parameters */
;;;464      assert_param(IS_FLASH_ADDRESS(Address));
;;;465    
;;;466      /* Wait for last operation to be completed */
;;;467      status = FLASH_WaitForLastOperation();
00000c  f7fffffe          BL       FLASH_WaitForLastOperation
000010  4603              MOV      r3,r0
;;;468      
;;;469      if(status == FLASH_COMPLETE)
000012  2b08              CMP      r3,#8
000014  d11a              BNE      |L25.76|
;;;470      {
;;;471        /* if the previous operation is completed, proceed to program the new data */
;;;472        FLASH->CR &= CR_PSIZE_MASK;
000016  480e              LDR      r0,|L25.80|
000018  6800              LDR      r0,[r0,#0]
00001a  f4207040          BIC      r0,r0,#0x300
00001e  490c              LDR      r1,|L25.80|
000020  6008              STR      r0,[r1,#0]
;;;473        FLASH->CR |= FLASH_PSIZE_DOUBLE_WORD;
000022  4608              MOV      r0,r1
000024  6800              LDR      r0,[r0,#0]
000026  f4407040          ORR      r0,r0,#0x300
00002a  6008              STR      r0,[r1,#0]
;;;474        FLASH->CR |= FLASH_CR_PG;
00002c  4608              MOV      r0,r1
00002e  6800              LDR      r0,[r0,#0]
000030  f0400001          ORR      r0,r0,#1
000034  6008              STR      r0,[r1,#0]
;;;475      
;;;476        *(__IO uint64_t*)Address = Data;
000036  6034              STR      r4,[r6,#0]
000038  6075              STR      r5,[r6,#4]
;;;477            
;;;478        /* Wait for last operation to be completed */
;;;479        status = FLASH_WaitForLastOperation();
00003a  f7fffffe          BL       FLASH_WaitForLastOperation
00003e  4603              MOV      r3,r0
;;;480    
;;;481        /* if the program operation is completed, disable the PG Bit */
;;;482        FLASH->CR &= (~FLASH_CR_PG);
000040  4803              LDR      r0,|L25.80|
000042  6800              LDR      r0,[r0,#0]
000044  f0200001          BIC      r0,r0,#1
000048  4901              LDR      r1,|L25.80|
00004a  6008              STR      r0,[r1,#0]
                  |L25.76|
;;;483      } 
;;;484      /* Return the Program Status */
;;;485      return status;
00004c  4618              MOV      r0,r3
;;;486    }
00004e  bd70              POP      {r4-r6,pc}
;;;487    
                          ENDP

                  |L25.80|
                          DCD      0x40023c10

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

                  FLASH_ProgramHalfWord PROC
;;;534      */
;;;535    FLASH_Status FLASH_ProgramHalfWord(uint32_t Address, uint16_t Data)
000000  b530              PUSH     {r4,r5,lr}
;;;536    {
000002  4603              MOV      r3,r0
000004  460c              MOV      r4,r1
;;;537      FLASH_Status status = FLASH_COMPLETE;
000006  2508              MOVS     r5,#8
;;;538    
;;;539      /* Check the parameters */
;;;540      assert_param(IS_FLASH_ADDRESS(Address));
;;;541    
;;;542      /* Wait for last operation to be completed */
;;;543      status = FLASH_WaitForLastOperation();
000008  f7fffffe          BL       FLASH_WaitForLastOperation
00000c  4605              MOV      r5,r0
;;;544      
;;;545      if(status == FLASH_COMPLETE)
00000e  2d08              CMP      r5,#8
000010  d119              BNE      |L26.70|
;;;546      {
;;;547        /* if the previous operation is completed, proceed to program the new data */
;;;548        FLASH->CR &= CR_PSIZE_MASK;
000012  480e              LDR      r0,|L26.76|
000014  6800              LDR      r0,[r0,#0]
000016  f4207040          BIC      r0,r0,#0x300
00001a  490c              LDR      r1,|L26.76|
00001c  6008              STR      r0,[r1,#0]
;;;549        FLASH->CR |= FLASH_PSIZE_HALF_WORD;
00001e  4608              MOV      r0,r1
000020  6800              LDR      r0,[r0,#0]
000022  f4407080          ORR      r0,r0,#0x100
000026  6008              STR      r0,[r1,#0]
;;;550        FLASH->CR |= FLASH_CR_PG;
000028  4608              MOV      r0,r1
00002a  6800              LDR      r0,[r0,#0]
00002c  f0400001          ORR      r0,r0,#1
000030  6008              STR      r0,[r1,#0]
;;;551      
;;;552        *(__IO uint16_t*)Address = Data;
000032  801c              STRH     r4,[r3,#0]
;;;553            
;;;554        /* Wait for last operation to be completed */
;;;555        status = FLASH_WaitForLastOperation();
000034  f7fffffe          BL       FLASH_WaitForLastOperation
000038  4605              MOV      r5,r0
;;;556    
;;;557        /* if the program operation is completed, disable the PG Bit */
;;;558        FLASH->CR &= (~FLASH_CR_PG);
00003a  4804              LDR      r0,|L26.76|
00003c  6800              LDR      r0,[r0,#0]
00003e  f0200001          BIC      r0,r0,#1
000042  4902              LDR      r1,|L26.76|
000044  6008              STR      r0,[r1,#0]
                  |L26.70|
;;;559      } 
;;;560      /* Return the Program Status */
;;;561      return status;
000046  4628              MOV      r0,r5
;;;562    }
000048  bd30              POP      {r4,r5,pc}
;;;563    
                          ENDP

00004a  0000              DCW      0x0000
                  |L26.76|
                          DCD      0x40023c10

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

                  FLASH_ProgramWord PROC
;;;496      */
;;;497    FLASH_Status FLASH_ProgramWord(uint32_t Address, uint32_t Data)
000000  b530              PUSH     {r4,r5,lr}
;;;498    {
000002  4603              MOV      r3,r0
000004  460c              MOV      r4,r1
;;;499      FLASH_Status status = FLASH_COMPLETE;
000006  2508              MOVS     r5,#8
;;;500    
;;;501      /* Check the parameters */
;;;502      assert_param(IS_FLASH_ADDRESS(Address));
;;;503    
;;;504      /* Wait for last operation to be completed */
;;;505      status = FLASH_WaitForLastOperation();
000008  f7fffffe          BL       FLASH_WaitForLastOperation
00000c  4605              MOV      r5,r0
;;;506      
;;;507      if(status == FLASH_COMPLETE)
00000e  2d08              CMP      r5,#8
000010  d119              BNE      |L27.70|
;;;508      {
;;;509        /* if the previous operation is completed, proceed to program the new data */
;;;510        FLASH->CR &= CR_PSIZE_MASK;
000012  480e              LDR      r0,|L27.76|
000014  6800              LDR      r0,[r0,#0]
000016  f4207040          BIC      r0,r0,#0x300
00001a  490c              LDR      r1,|L27.76|
00001c  6008              STR      r0,[r1,#0]
;;;511        FLASH->CR |= FLASH_PSIZE_WORD;
00001e  4608              MOV      r0,r1
000020  6800              LDR      r0,[r0,#0]
000022  f4407000          ORR      r0,r0,#0x200
000026  6008              STR      r0,[r1,#0]
;;;512        FLASH->CR |= FLASH_CR_PG;
000028  4608              MOV      r0,r1
00002a  6800              LDR      r0,[r0,#0]
00002c  f0400001          ORR      r0,r0,#1
000030  6008              STR      r0,[r1,#0]
;;;513      
;;;514        *(__IO uint32_t*)Address = Data;
000032  601c              STR      r4,[r3,#0]
;;;515            
;;;516        /* Wait for last operation to be completed */
;;;517        status = FLASH_WaitForLastOperation();
000034  f7fffffe          BL       FLASH_WaitForLastOperation
000038  4605              MOV      r5,r0
;;;518    
;;;519        /* if the program operation is completed, disable the PG Bit */
;;;520        FLASH->CR &= (~FLASH_CR_PG);
00003a  4804              LDR      r0,|L27.76|
00003c  6800              LDR      r0,[r0,#0]
00003e  f0200001          BIC      r0,r0,#1
000042  4902              LDR      r1,|L27.76|
000044  6008              STR      r0,[r1,#0]
                  |L27.70|
;;;521      } 
;;;522      /* Return the Program Status */
;;;523      return status;
000046  4628              MOV      r0,r5
;;;524    }
000048  bd30              POP      {r4,r5,pc}
;;;525    
                          ENDP

00004a  0000              DCW      0x0000
                  |L27.76|
                          DCD      0x40023c10

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

                  FLASH_SetLatency PROC
;;;165      */
;;;166    void FLASH_SetLatency(uint32_t FLASH_Latency)
000000  4a01              LDR      r2,|L28.8|
;;;167    {
;;;168      /* Check the parameters */
;;;169      assert_param(IS_FLASH_LATENCY(FLASH_Latency));
;;;170      
;;;171      /* Perform Byte access to FLASH_ACR[8:0] to set the Latency value */
;;;172      *(__IO uint8_t *)ACR_BYTE0_ADDRESS = (uint8_t)FLASH_Latency;
000002  7010              STRB     r0,[r2,#0]
;;;173    }
000004  4770              BX       lr
;;;174    
                          ENDP

000006  0000              DCW      0x0000
                  |L28.8|
                          DCD      0x40023c00

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

                  FLASH_Unlock PROC
;;;299      */
;;;300    void FLASH_Unlock(void)
000000  4805              LDR      r0,|L29.24|
;;;301    {
;;;302      if((FLASH->CR & FLASH_CR_LOCK) != RESET)
000002  6800              LDR      r0,[r0,#0]
000004  f0104f00          TST      r0,#0x80000000
000008  d005              BEQ      |L29.22|
;;;303      {
;;;304        /* Authorize the FLASH Registers access */
;;;305        FLASH->KEYR = FLASH_KEY1;
00000a  4804              LDR      r0,|L29.28|
00000c  4902              LDR      r1,|L29.24|
00000e  390c              SUBS     r1,r1,#0xc
000010  6008              STR      r0,[r1,#0]
;;;306        FLASH->KEYR = FLASH_KEY2;
000012  4803              LDR      r0,|L29.32|
000014  6008              STR      r0,[r1,#0]
                  |L29.22|
;;;307      }  
;;;308    }
000016  4770              BX       lr
;;;309    
                          ENDP

                  |L29.24|
                          DCD      0x40023c10
                  |L29.28|
                          DCD      0x45670123
                  |L29.32|
                          DCD      0xcdef89ab

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

                  FLASH_WaitForLastOperation PROC
;;;1021     */
;;;1022   FLASH_Status FLASH_WaitForLastOperation(void)
000000  b500              PUSH     {lr}
;;;1023   { 
;;;1024     __IO FLASH_Status status = FLASH_COMPLETE;
000002  2208              MOVS     r2,#8
;;;1025      
;;;1026     /* Check for the FLASH Status */
;;;1027     status = FLASH_GetStatus();
000004  f7fffffe          BL       FLASH_GetStatus
000008  4602              MOV      r2,r0
;;;1028   
;;;1029     /* Wait for the FLASH operation to complete by polling on BUSY flag to be reset.
;;;1030        Even if the FLASH operation fails, the BUSY flag will be reset and an error
;;;1031        flag will be set */
;;;1032     while(status == FLASH_BUSY)
00000a  e002              B        |L30.18|
                  |L30.12|
;;;1033     {
;;;1034       status = FLASH_GetStatus();
00000c  f7fffffe          BL       FLASH_GetStatus
000010  4602              MOV      r2,r0
                  |L30.18|
000012  2a01              CMP      r2,#1                 ;1032
000014  d0fa              BEQ      |L30.12|
;;;1035     }
;;;1036     /* Return the operation status */
;;;1037     return status;
000016  4610              MOV      r0,r2
;;;1038   }
000018  bd00              POP      {pc}
;;;1039   
                          ENDP


;*** Start embedded assembler ***

#line 1 "..\\..\\..\\Libraries\\STM32F4xx_StdPeriph_Driver\\src\\stm32f4xx_flash.c"
	AREA ||.rev16_text||, CODE, READONLY
	THUMB
	EXPORT |__asm___17_stm32f4xx_flash_c_a2a150d6____REV16|
#line 114 "C:\\Keil\\ARM\\CMSIS\\Include\\core_cmInstr.h"
|__asm___17_stm32f4xx_flash_c_a2a150d6____REV16| PROC
#line 115

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

 revsh r0, r0
 bx lr
	ENDP

;*** End   embedded assembler ***
