There is a security department in country ABC. When they transfer information to another department, the information is sent by manipulating the original message. Manipulation is done in such a way that there are very few changes in the original message and the number of steps is minimum.

They start their manipulation from the last index and continue till they reach the start of the string while checking for the following conditions:$-$

$1.$ If the index $($i$)$ of the string is divisible by $2,$ then they can change the $($i$)$th character to underscore $(\_)$ and jump to the $($i$/2)$th index, or they can simply skip that character and jump to the $($i $-1)^($th$)$ character in that string.

$2.$ Similarly, if the index $($i$)$ of the string is divisible by $3,$ then they can change the $($i$)^($th$)$ character to hash $($#$)$ and can skip all the characters in between by jumping straight to the $($i $/3)^($th$)$ index or they can simply skip that character and jump to the $($i $-1)^($th$)$ character in that string.

$3.$ Similarly, if the index $($i$)$ of the string is neither divisible by $2$ or $3$ then you can simply skip that character and jump to $($i $-1)^$ t character.

$4.$ In case the $($i$)^($th$)$ index is divisible by both $2$ and $3,$ and the total number of changes required to get to the starting index of the string are same for both $2$ and $3,$ then divisibility by $2$ is to be prioritized.

The task is to return the manipulated message string.

Nate$-$Traversing an index of string counts as a step and indexing of string starts from

Input Specification:

input$1$: An integer denoting the size of the message string

input$2$: A string denoting the original message.

Output Specification:

Your function must return the manipulated message string with a minimum number of changes in the original message.

Example $1$:

input$1$: $11$

Input$2$: abcdefghijk

Output: ab#defgh#jk

Explanation:

$1.$ The last index of the string is $11$ which is not divisible by $2$ or $3.$ so we can slop to the $($i$-1)$ index and stepCount$=1$

$2.$ Now, the i$^$th index $10,$ is divisible by $2$ so we can skip to either the $($i$-1)$th or $($i$/2)$th index, We will skop to the $($i$-1)$th index because this will require minimal changes in the string and stepCount$=2$

$3.$ Now, the $($i$)$th index $9,$ is divisible by $3$ so we can skip to either the $($i$-1)$th or $($i$/3)$ index. We will skip to $($i$/3)$ index because these will require minimal changes in the shing and stepCount$=3$ also the $($i$)$ th character of the string is replaced by #

$4.$ Now the $($i$)$th index $3,$ is divisible by $3$ so we can skip to either the $($i$-1)$ or $($i$/3)$ index. We will skip to the $($i$/3)$ index which is the $1$st index, $\text{'}$a$\text{'},$ and the stepCount$=4$ and replace the $($i$)$ index by #

Example $2$

input$1$:$6$

input$2$: aabbcc output:aa#bc$\_$

write c$++$code