; generated by ARM C/C++ Compiler, 4.1 [Build 894]
; commandline ArmCC [--list --split_sections --debug -c --asm --interleave -o.\STM324xG_EVAL\stm32f4xx_hash.o --asm_dir=.\STM324xG_EVAL\ --list_dir=.\STM324xG_EVAL\ --depend=.\STM324xG_EVAL\stm32f4xx_hash.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_hash.crf ..\..\..\Libraries\STM32F4xx_StdPeriph_Driver\src\stm32f4xx_hash.c]
                          THUMB

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

                  HASH_ClearFlag PROC
;;;624      */
;;;625    void HASH_ClearFlag(uint16_t HASH_FLAG)
000000  43c1              MVNS     r1,r0
;;;626    {
;;;627      /* Check the parameters */
;;;628      assert_param(IS_HASH_CLEAR_FLAG(HASH_FLAG));
;;;629      
;;;630      /* Clear the selected HASH flags */
;;;631      HASH->SR = ~(uint32_t)HASH_FLAG;
000002  4a01              LDR      r2,|L1.8|
000004  6011              STR      r1,[r2,#0]
;;;632    }
000006  4770              BX       lr
;;;633    /**
                          ENDP

                  |L1.8|
                          DCD      0x50060424

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

                  HASH_ClearITPendingBit PROC
;;;674      */
;;;675    void HASH_ClearITPendingBit(uint8_t HASH_IT)
000000  43c1              MVNS     r1,r0
;;;676    {
;;;677      /* Check the parameters */
;;;678      assert_param(IS_HASH_IT(HASH_IT));
;;;679    
;;;680      /* Clear the selected HASH interrupt pending bit */
;;;681      HASH->SR = (uint8_t)~HASH_IT;
000002  b2c9              UXTB     r1,r1
000004  4a01              LDR      r2,|L2.12|
000006  6011              STR      r1,[r2,#0]
;;;682    }
000008  4770              BX       lr
;;;683    
                          ENDP

00000a  0000              DCW      0x0000
                  |L2.12|
                          DCD      0x50060424

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

                  HASH_DMACmd PROC
;;;459      */
;;;460    void HASH_DMACmd(FunctionalState NewState)
000000  b130              CBZ      r0,|L3.16|
;;;461    {
;;;462      /* Check the parameters */
;;;463      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;464    
;;;465      if (NewState != DISABLE)
;;;466      {
;;;467        /* Enable the HASH DMA request */
;;;468        HASH->CR |= HASH_CR_DMAE;
000002  4907              LDR      r1,|L3.32|
000004  6809              LDR      r1,[r1,#0]
000006  f0410108          ORR      r1,r1,#8
00000a  4a05              LDR      r2,|L3.32|
00000c  6011              STR      r1,[r2,#0]
00000e  e005              B        |L3.28|
                  |L3.16|
;;;469      }
;;;470      else
;;;471      {
;;;472        /* Disable the HASH DMA request */
;;;473        HASH->CR &= ~HASH_CR_DMAE;
000010  4903              LDR      r1,|L3.32|
000012  6809              LDR      r1,[r1,#0]
000014  f0210108          BIC      r1,r1,#8
000018  4a01              LDR      r2,|L3.32|
00001a  6011              STR      r1,[r2,#0]
                  |L3.28|
;;;474      }
;;;475    }
00001c  4770              BX       lr
;;;476    /**
                          ENDP

00001e  0000              DCW      0x0000
                  |L3.32|
                          DCD      0x50060400

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

                  HASH_DataIn PROC
;;;305      */
;;;306    void HASH_DataIn(uint32_t Data)
000000  4901              LDR      r1,|L4.8|
;;;307    {
;;;308      /* Write in the DIN register a new data */
;;;309      HASH->DIN = Data;
000002  6008              STR      r0,[r1,#0]
;;;310    }
000004  4770              BX       lr
;;;311    
                          ENDP

000006  0000              DCW      0x0000
                  |L4.8|
                          DCD      0x50060404

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

                  HASH_DeInit PROC
;;;170      */
;;;171    void HASH_DeInit(void)
000000  b510              PUSH     {r4,lr}
;;;172    {
;;;173      /* Enable HASH reset state */
;;;174      RCC_AHB2PeriphResetCmd(RCC_AHB2Periph_HASH, ENABLE);
000002  2101              MOVS     r1,#1
000004  2020              MOVS     r0,#0x20
000006  f7fffffe          BL       RCC_AHB2PeriphResetCmd
;;;175      /* Release HASH from reset state */
;;;176      RCC_AHB2PeriphResetCmd(RCC_AHB2Periph_HASH, DISABLE);
00000a  2100              MOVS     r1,#0
00000c  2020              MOVS     r0,#0x20
00000e  f7fffffe          BL       RCC_AHB2PeriphResetCmd
;;;177    }
000012  bd10              POP      {r4,pc}
;;;178    
                          ENDP


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

                  HASH_GetDigest PROC
;;;330      */
;;;331    void HASH_GetDigest(HASH_MsgDigest* HASH_MessageDigest)
000000  4909              LDR      r1,|L6.40|
;;;332    {
;;;333      /* Get the data field */
;;;334      HASH_MessageDigest->Data[0] = HASH->HR[0];
000002  6809              LDR      r1,[r1,#0]
000004  6001              STR      r1,[r0,#0]
;;;335      HASH_MessageDigest->Data[1] = HASH->HR[1];
000006  4908              LDR      r1,|L6.40|
000008  390c              SUBS     r1,r1,#0xc
00000a  6909              LDR      r1,[r1,#0x10]
00000c  6041              STR      r1,[r0,#4]
;;;336      HASH_MessageDigest->Data[2] = HASH->HR[2];
00000e  4906              LDR      r1,|L6.40|
000010  390c              SUBS     r1,r1,#0xc
000012  6949              LDR      r1,[r1,#0x14]
000014  6081              STR      r1,[r0,#8]
;;;337      HASH_MessageDigest->Data[3] = HASH->HR[3];
000016  4904              LDR      r1,|L6.40|
000018  390c              SUBS     r1,r1,#0xc
00001a  6989              LDR      r1,[r1,#0x18]
00001c  60c1              STR      r1,[r0,#0xc]
;;;338      HASH_MessageDigest->Data[4] = HASH->HR[4];
00001e  4902              LDR      r1,|L6.40|
000020  390c              SUBS     r1,r1,#0xc
000022  69c9              LDR      r1,[r1,#0x1c]
000024  6101              STR      r1,[r0,#0x10]
;;;339    }
000026  4770              BX       lr
;;;340    
                          ENDP

                  |L6.40|
                          DCD      0x5006040c

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

                  HASH_GetFlagStatus PROC
;;;583      */
;;;584    FlagStatus HASH_GetFlagStatus(uint16_t HASH_FLAG)
000000  4601              MOV      r1,r0
;;;585    {
;;;586      FlagStatus bitstatus = RESET;
000002  2000              MOVS     r0,#0
;;;587      uint32_t tempreg = 0;
000004  2200              MOVS     r2,#0
;;;588    
;;;589      /* Check the parameters */
;;;590      assert_param(IS_HASH_GET_FLAG(HASH_FLAG));
;;;591    
;;;592      /* check if the FLAG is in CR register */
;;;593      if ((HASH_FLAG & HASH_FLAG_DINNE) != (uint16_t)RESET ) 
000006  f4115f80          TST      r1,#0x1000
00000a  d002              BEQ      |L7.18|
;;;594      {
;;;595        tempreg = HASH->CR;
00000c  4b05              LDR      r3,|L7.36|
00000e  681a              LDR      r2,[r3,#0]
000010  e002              B        |L7.24|
                  |L7.18|
;;;596      }
;;;597      else /* The FLAG is in SR register */
;;;598      {
;;;599        tempreg = HASH->SR;
000012  4b04              LDR      r3,|L7.36|
000014  3324              ADDS     r3,r3,#0x24
000016  681a              LDR      r2,[r3,#0]
                  |L7.24|
;;;600      }
;;;601    
;;;602      /* Check the status of the specified HASH flag */
;;;603      if ((tempreg & HASH_FLAG) != (uint16_t)RESET)
000018  420a              TST      r2,r1
00001a  d001              BEQ      |L7.32|
;;;604      {
;;;605        /* HASH is set */
;;;606        bitstatus = SET;
00001c  2001              MOVS     r0,#1
00001e  e000              B        |L7.34|
                  |L7.32|
;;;607      }
;;;608      else
;;;609      {
;;;610        /* HASH_FLAG is reset */
;;;611        bitstatus = RESET;
000020  2000              MOVS     r0,#0
                  |L7.34|
;;;612      }
;;;613    
;;;614      /* Return the HASH_FLAG status */
;;;615      return  bitstatus;
;;;616    }
000022  4770              BX       lr
;;;617    /**
                          ENDP

                  |L7.36|
                          DCD      0x50060400

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

                  HASH_GetITStatus PROC
;;;640      */
;;;641    ITStatus HASH_GetITStatus(uint8_t HASH_IT)
000000  4601              MOV      r1,r0
;;;642    {
;;;643      ITStatus bitstatus = RESET;
000002  2000              MOVS     r0,#0
;;;644      uint32_t tmpreg = 0;
000004  2200              MOVS     r2,#0
;;;645    
;;;646      /* Check the parameters */
;;;647      assert_param(IS_HASH_GET_IT(HASH_IT));  
;;;648    
;;;649    
;;;650      /* Check the status of the specified HASH interrupt */
;;;651      tmpreg =  HASH->SR;
000006  4b05              LDR      r3,|L8.28|
000008  681a              LDR      r2,[r3,#0]
;;;652    
;;;653      if (((HASH->IMR & tmpreg) & HASH_IT) != RESET)
00000a  1f1b              SUBS     r3,r3,#4
00000c  681b              LDR      r3,[r3,#0]
00000e  4013              ANDS     r3,r3,r2
000010  420b              TST      r3,r1
000012  d001              BEQ      |L8.24|
;;;654      {
;;;655        /* HASH_IT is set */
;;;656        bitstatus = SET;
000014  2001              MOVS     r0,#1
000016  e000              B        |L8.26|
                  |L8.24|
;;;657      }
;;;658      else
;;;659      {
;;;660        /* HASH_IT is reset */
;;;661        bitstatus = RESET;
000018  2000              MOVS     r0,#0
                  |L8.26|
;;;662      }
;;;663      /* Return the HASH_IT status */
;;;664      return bitstatus;
;;;665    }
00001a  4770              BX       lr
;;;666    
                          ENDP

                  |L8.28|
                          DCD      0x50060424

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

                  HASH_GetInFIFOWordsNbr PROC
;;;316      */
;;;317    uint8_t HASH_GetInFIFOWordsNbr(void)
000000  4802              LDR      r0,|L9.12|
;;;318    {
;;;319      /* Return the value of NBW bits */
;;;320      return ((HASH->CR & HASH_CR_NBW) >> 8);
000002  6800              LDR      r0,[r0,#0]
000004  f3c02003          UBFX     r0,r0,#8,#4
;;;321    }
000008  4770              BX       lr
;;;322    
                          ENDP

00000a  0000              DCW      0x0000
                  |L9.12|
                          DCD      0x50060400

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

                  HASH_ITConfig PROC
;;;554      */
;;;555    void HASH_ITConfig(uint8_t HASH_IT, FunctionalState NewState)
000000  b129              CBZ      r1,|L10.14|
;;;556    {
;;;557      /* Check the parameters */
;;;558      assert_param(IS_HASH_IT(HASH_IT));
;;;559      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;560    
;;;561      if (NewState != DISABLE)
;;;562      {
;;;563        /* Enable the selected HASH interrupt */
;;;564        HASH->IMR |= HASH_IT;
000002  4a07              LDR      r2,|L10.32|
000004  6812              LDR      r2,[r2,#0]
000006  4302              ORRS     r2,r2,r0
000008  4b05              LDR      r3,|L10.32|
00000a  601a              STR      r2,[r3,#0]
00000c  e006              B        |L10.28|
                  |L10.14|
;;;565      }
;;;566      else
;;;567      {
;;;568        /* Disable the selected HASH interrupt */
;;;569        HASH->IMR &= (uint8_t) ~HASH_IT;
00000e  4a04              LDR      r2,|L10.32|
000010  6812              LDR      r2,[r2,#0]
000012  43c3              MVNS     r3,r0
000014  b2db              UXTB     r3,r3
000016  401a              ANDS     r2,r2,r3
000018  4b01              LDR      r3,|L10.32|
00001a  601a              STR      r2,[r3,#0]
                  |L10.28|
;;;570      }
;;;571    }
00001c  4770              BX       lr
;;;572    
                          ENDP

00001e  0000              DCW      0x0000
                  |L10.32|
                          DCD      0x50060420

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

                  HASH_Init PROC
;;;190      */
;;;191    void HASH_Init(HASH_InitTypeDef* HASH_InitStruct)
000000  4912              LDR      r1,|L11.76|
;;;192    {
;;;193      /* Check the parameters */
;;;194      assert_param(IS_HASH_ALGOSELECTION(HASH_InitStruct->HASH_AlgoSelection));
;;;195      assert_param(IS_HASH_DATATYPE(HASH_InitStruct->HASH_DataType));
;;;196      assert_param(IS_HASH_ALGOMODE(HASH_InitStruct->HASH_AlgoMode));
;;;197      
;;;198      /* Configure the Algorithm used, algorithm mode and the datatype */
;;;199      HASH->CR &= ~ (HASH_CR_ALGO | HASH_CR_DATATYPE | HASH_CR_MODE);
000002  6809              LDR      r1,[r1,#0]
000004  f02101f0          BIC      r1,r1,#0xf0
000008  4a10              LDR      r2,|L11.76|
00000a  6011              STR      r1,[r2,#0]
;;;200      HASH->CR |= (HASH_InitStruct->HASH_AlgoSelection | \
00000c  6882              LDR      r2,[r0,#8]
00000e  6801              LDR      r1,[r0,#0]
000010  4311              ORRS     r1,r1,r2
000012  6842              LDR      r2,[r0,#4]
000014  4311              ORRS     r1,r1,r2
000016  4a0d              LDR      r2,|L11.76|
000018  6812              LDR      r2,[r2,#0]
00001a  4311              ORRS     r1,r1,r2
00001c  4a0b              LDR      r2,|L11.76|
00001e  6011              STR      r1,[r2,#0]
;;;201                   HASH_InitStruct->HASH_DataType | \
;;;202                   HASH_InitStruct->HASH_AlgoMode);
;;;203      
;;;204      /* if algorithm mode is HMAC, set the Key */  
;;;205      if(HASH_InitStruct->HASH_AlgoMode == HASH_AlgoMode_HMAC) 
000020  6841              LDR      r1,[r0,#4]
000022  2940              CMP      r1,#0x40
000024  d10a              BNE      |L11.60|
;;;206      {
;;;207        assert_param(IS_HASH_HMAC_KEYTYPE(HASH_InitStruct->HASH_HMACKeyType));
;;;208        HASH->CR &= ~HASH_CR_LKEY;
000026  4611              MOV      r1,r2
000028  6809              LDR      r1,[r1,#0]
00002a  f4213180          BIC      r1,r1,#0x10000
00002e  6011              STR      r1,[r2,#0]
;;;209        HASH->CR |= HASH_InitStruct->HASH_HMACKeyType;
000030  4611              MOV      r1,r2
000032  6809              LDR      r1,[r1,#0]
000034  68c2              LDR      r2,[r0,#0xc]
000036  4311              ORRS     r1,r1,r2
000038  4a04              LDR      r2,|L11.76|
00003a  6011              STR      r1,[r2,#0]
                  |L11.60|
;;;210      }
;;;211    
;;;212      /* Reset the HASH processor core, so that the HASH will be ready to compute 
;;;213         the message digest of a new message */
;;;214      HASH->CR |= HASH_CR_INIT;  
00003c  4903              LDR      r1,|L11.76|
00003e  6809              LDR      r1,[r1,#0]
000040  f0410104          ORR      r1,r1,#4
000044  4a01              LDR      r2,|L11.76|
000046  6011              STR      r1,[r2,#0]
;;;215    }
000048  4770              BX       lr
;;;216    
                          ENDP

00004a  0000              DCW      0x0000
                  |L11.76|
                          DCD      0x50060400

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

                  HASH_Reset PROC
;;;248      */
;;;249    void HASH_Reset(void)
000000  4803              LDR      r0,|L12.16|
;;;250    {
;;;251      /* Reset the HASH processor core */
;;;252      HASH->CR |= HASH_CR_INIT;
000002  6800              LDR      r0,[r0,#0]
000004  f0400004          ORR      r0,r0,#4
000008  4901              LDR      r1,|L12.16|
00000a  6008              STR      r0,[r1,#0]
;;;253    }
00000c  4770              BX       lr
;;;254    /**
                          ENDP

00000e  0000              DCW      0x0000
                  |L12.16|
                          DCD      0x50060400

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

                  HASH_RestoreContext PROC
;;;410      */
;;;411    void HASH_RestoreContext(HASH_Context* HASH_ContextRestore)  
000000  2100              MOVS     r1,#0
;;;412    {
;;;413      uint8_t i = 0;
;;;414      
;;;415      /* restore context registers */
;;;416      HASH->IMR = HASH_ContextRestore->HASH_IMR;   
000002  4b0f              LDR      r3,|L13.64|
000004  6802              LDR      r2,[r0,#0]
000006  601a              STR      r2,[r3,#0]
;;;417      HASH->STR = HASH_ContextRestore->HASH_STR;     
000008  4b0d              LDR      r3,|L13.64|
00000a  3b18              SUBS     r3,r3,#0x18
00000c  6842              LDR      r2,[r0,#4]
00000e  601a              STR      r2,[r3,#0]
;;;418      HASH->CR = HASH_ContextRestore->HASH_CR;
000010  4b0b              LDR      r3,|L13.64|
000012  3b20              SUBS     r3,r3,#0x20
000014  6882              LDR      r2,[r0,#8]
000016  601a              STR      r2,[r3,#0]
;;;419      
;;;420      /* Initialize the hash processor */
;;;421      HASH->CR |= HASH_CR_INIT; 
000018  461a              MOV      r2,r3
00001a  6812              LDR      r2,[r2,#0]
00001c  f0420204          ORR      r2,r2,#4
000020  601a              STR      r2,[r3,#0]
;;;422      
;;;423       /* continue restoring context registers */     
;;;424      for(i=0; i<=50;i++)
000022  bf00              NOP      
000024  e009              B        |L13.58|
                  |L13.38|
;;;425      {
;;;426         HASH->CSR[i] = HASH_ContextRestore->HASH_CSR[i];
000026  f100020c          ADD      r2,r0,#0xc
00002a  f8523021          LDR      r3,[r2,r1,LSL #2]
00002e  4a04              LDR      r2,|L13.64|
000030  32d8              ADDS     r2,r2,#0xd8
000032  f8423021          STR      r3,[r2,r1,LSL #2]
000036  1c4a              ADDS     r2,r1,#1              ;424
000038  b2d1              UXTB     r1,r2                 ;424
                  |L13.58|
00003a  2932              CMP      r1,#0x32              ;424
00003c  ddf3              BLE      |L13.38|
;;;427      }   
;;;428    }
00003e  4770              BX       lr
;;;429    /**
                          ENDP

                  |L13.64|
                          DCD      0x50060420

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

                  HASH_SaveContext PROC
;;;388      */
;;;389    void HASH_SaveContext(HASH_Context* HASH_ContextSave)
000000  2100              MOVS     r1,#0
;;;390    {
;;;391      uint8_t i = 0;
;;;392      
;;;393      /* save context registers */
;;;394      HASH_ContextSave->HASH_IMR = HASH->IMR;  
000002  4a0d              LDR      r2,|L14.56|
000004  6812              LDR      r2,[r2,#0]
000006  6002              STR      r2,[r0,#0]
;;;395      HASH_ContextSave->HASH_STR = HASH->STR;      
000008  4a0b              LDR      r2,|L14.56|
00000a  3a18              SUBS     r2,r2,#0x18
00000c  6812              LDR      r2,[r2,#0]
00000e  6042              STR      r2,[r0,#4]
;;;396      HASH_ContextSave->HASH_CR  = HASH->CR;     
000010  4a09              LDR      r2,|L14.56|
000012  3a20              SUBS     r2,r2,#0x20
000014  6812              LDR      r2,[r2,#0]
000016  6082              STR      r2,[r0,#8]
;;;397      for(i=0; i<=50;i++)
000018  bf00              NOP      
00001a  e009              B        |L14.48|
                  |L14.28|
;;;398      {
;;;399         HASH_ContextSave->HASH_CSR[i] = HASH->CSR[i];
00001c  4a06              LDR      r2,|L14.56|
00001e  32d8              ADDS     r2,r2,#0xd8
000020  f8523021          LDR      r3,[r2,r1,LSL #2]
000024  f100020c          ADD      r2,r0,#0xc
000028  f8423021          STR      r3,[r2,r1,LSL #2]
00002c  1c4a              ADDS     r2,r1,#1              ;397
00002e  b2d1              UXTB     r1,r2                 ;397
                  |L14.48|
000030  2932              CMP      r1,#0x32              ;397
000032  ddf3              BLE      |L14.28|
;;;400      }   
;;;401    }
000034  4770              BX       lr
;;;402    
                          ENDP

000036  0000              DCW      0x0000
                  |L14.56|
                          DCD      0x50060420

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

                  HASH_SetLastWordValidBitsNbr PROC
;;;290      */
;;;291    void HASH_SetLastWordValidBitsNbr(uint16_t ValidNumber)
000000  4905              LDR      r1,|L15.24|
;;;292    {
;;;293      /* Check the parameters */
;;;294      assert_param(IS_HASH_VALIDBITSNUMBER(ValidNumber));
;;;295      
;;;296      /* Configure the Number of valid bits in last word of the message */
;;;297      HASH->STR &= ~(HASH_STR_NBW);
000002  6809              LDR      r1,[r1,#0]
000004  f021011f          BIC      r1,r1,#0x1f
000008  4a03              LDR      r2,|L15.24|
00000a  6011              STR      r1,[r2,#0]
;;;298      HASH->STR |= ValidNumber;
00000c  4611              MOV      r1,r2
00000e  6809              LDR      r1,[r1,#0]
000010  4301              ORRS     r1,r1,r0
000012  6011              STR      r1,[r2,#0]
;;;299    }
000014  4770              BX       lr
;;;300    
                          ENDP

000016  0000              DCW      0x0000
                  |L15.24|
                          DCD      0x50060408

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

                  HASH_StartDigest PROC
;;;345      */
;;;346    void HASH_StartDigest(void)
000000  4803              LDR      r0,|L16.16|
;;;347    {
;;;348      /* Start the Digest calculation */
;;;349      HASH->STR |= HASH_STR_DCAL;
000002  6800              LDR      r0,[r0,#0]
000004  f4407080          ORR      r0,r0,#0x100
000008  4901              LDR      r1,|L16.16|
00000a  6008              STR      r0,[r1,#0]
;;;350    }
00000c  4770              BX       lr
;;;351    /**
                          ENDP

00000e  0000              DCW      0x0000
                  |L16.16|
                          DCD      0x50060408

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

                  HASH_StructInit PROC
;;;224      */
;;;225    void HASH_StructInit(HASH_InitTypeDef* HASH_InitStruct)
000000  2100              MOVS     r1,#0
;;;226    {
;;;227      /* Initialize the HASH_AlgoSelection member */
;;;228      HASH_InitStruct->HASH_AlgoSelection = HASH_AlgoSelection_SHA1;
000002  6001              STR      r1,[r0,#0]
;;;229    
;;;230      /* Initialize the HASH_AlgoMode member */
;;;231      HASH_InitStruct->HASH_AlgoMode = HASH_AlgoMode_HASH;
000004  6041              STR      r1,[r0,#4]
;;;232    
;;;233      /* Initialize the HASH_DataType member */
;;;234      HASH_InitStruct->HASH_DataType = HASH_DataType_32b;
000006  6081              STR      r1,[r0,#8]
;;;235    
;;;236      /* Initialize the HASH_HMACKeyType member */
;;;237      HASH_InitStruct->HASH_HMACKeyType = HASH_HMACKeyType_ShortKey;
000008  60c1              STR      r1,[r0,#0xc]
;;;238    }
00000a  4770              BX       lr
;;;239    
                          ENDP


;*** Start embedded assembler ***

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

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

 revsh r0, r0
 bx lr
	ENDP

;*** End   embedded assembler ***
