Enigma Script

#!/bin/bash

function helpandversion {

if [ "$1" == --version ];
  then
    echo "Enigma Version 1.00"
  elif [ "$1" == --help ];
    then
     echo '
######################################################## ~  Enigma Version 1.00  ~ ########################################################
## Directions:                                                                #
##                                                                    #
## bash Enigma.sh [File to Convert {$1}] [First Offset {$2}] [First Directional {$3}] [Second Offset {$4}] [Second Directional {$5}]      #
##                                                                    #
## Offset values must be between 1 and 83.                                                #
##                                                                            #
## Files can be run through Enigma any number of times. A strict rule must be followed in order to decrypt a message successfully.        #
## The Directionals must remain in their original position but the Offsets must switch position and be entered in the opposite order.     #
## Example Encryption: [ Sequence #1 = 4 + 1 - ] [ Sequence #2 = 5 - 41 + ] [ Sequence #3 = 26 - 45 + ] [ Sequence #4 = 74 + 23 + ]       #
## Example Decryption: [ Sequence #4 = 23 + 74 + ] [ Sequence #3 = 45 - 26 + ] [ Sequence #2 = 41 - 5 + ] [ Sequence #1 = 1 + 4 - ]       #
##                                                                    #
## Note: Running through multiple sequences does NOT make the code harder to crack as the character substitutions are just re-subsituted. #
## Multiple sequences only decrease the ability of someone to use the Enigma script to guess the correct Offsets and Directionals.        #
###########################################################################################################################################
'
  else
    offsetcheck "$@"
fi
}

## Check Offset Values For Validity ##

function offsetcheck {

if [ "$2" -ge 84 ];
  then
    echo "1st Offset Invalid! Must Be Between 1 - 83."
      exit
  else
    offsetcheck2 "$@"
fi
}

function offsetcheck2 {

if [ "$4" -ge 84 ];
  then
    echo "2nd Offset Invalid! Must Be Between 1 - 83."
      exit
  else
    cleaner "$@"
fi
}

## Cleaning Up Conflicting Characters and Resetting Variable N ##

function cleaner {

N=0

grep -Fl 1 "$1" | xargs -r sed -i 's/1/!one!/g'
grep -Fl 2 "$1" | xargs -r sed -i 's/2/!two!/g'
grep -Fl 3 "$1" | xargs -r sed -i 's/3/!three!/g'
grep -Fl 4 "$1" | xargs -r sed -i 's/4/!four!/g'
grep -Fl 5 "$1" | xargs -r sed -i 's/5/!five!/g'
grep -Fl 6 "$1" | xargs -r sed -i 's/6/!six!/g'
grep -Fl 7 "$1" | xargs -r sed -i 's/7/!seven!/g'
grep -Fl 8 "$1" | xargs -r sed -i 's/8/!eight!/g'
grep -Fl 9 "$1" | xargs -r sed -i 's/9/!nine!/g'
grep -Fl 0 "$1" | xargs -r sed -i 's/0/!zero!/g'
grep -Fl \( "$1" | xargs -r sed -i 's/(/![!/g'
grep -Fl \) "$1" | xargs -r sed -i 's/)/!]!/g'

## Call to 1st Offset Position ##

I"${2}" "$@"
}

## Converting Characters to Numeric Code ##

function I1 {

N=$((N+1))

grep -Fl A "$1" | xargs -r sed -i "s/A/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I2 "$@"
  elif [ "$3" == - ];
    then
      I83 "$@"
fi
}

function I2 {

N=$((N+1))

grep -Fl B "$1" | xargs -r sed -i "s/B/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I3 "$@"
  elif [ "$3" == - ];
    then
      I1 "$@"
fi
}

function I3 {

N=$((N+1))

grep -Fl C "$1" | xargs -r sed -i "s/C/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I4 "$@"
  elif [ "$3" == - ];
    then
      I2 "$@"
fi
}

function I4 {

N=$((N+1))

grep -Fl D "$1" | xargs -r sed -i "s/D/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I5 "$@"
  elif [ "$3" == - ];
    then
      I3 "$@"
fi
}

function I5 {

N=$((N+1))

grep -Fl E "$1" | xargs -r sed -i "s/E/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I6 "$@"
  elif [ "$3" == - ];
    then
      I4 "$@"
fi
}

function I6 {

N=$((N+1))

grep -Fl F "$1" | xargs -r sed -i "s/F/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I7 "$@"
  elif [ "$3" == - ];
    then
      I5 "$@"
fi
}

function I7 {

N=$((N+1))

grep -Fl G "$1" | xargs -r sed -i "s/G/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I8 "$@"
  elif [ "$3" == - ];
    then
      I6 "$@"
fi
}

function I8 {

N=$((N+1))

grep -Fl H "$1" | xargs -r sed -i "s/H/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I9 "$@"
  elif [ "$3" == - ];
    then
      I7 "$@"
fi
}

function I9 {

N=$((N+1))

grep -Fl I "$1" | xargs -r sed -i "s/I/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I10 "$@"
  elif [ "$3" == - ];
    then
      I8 "$@"
fi
}

function I10 {

N=$((N+1))

grep -Fl J "$1" | xargs -r sed -i "s/J/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I11 "$@"
  elif [ "$3" == - ];
    then
      I9 "$@"
fi
}

function I11 {

N=$((N+1))

grep -Fl K "$1" | xargs -r sed -i "s/K/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I12 "$@"
  elif [ "$3" == - ];
    then
      I10 "$@"
fi
}

function I12 {

N=$((N+1))

grep -Fl L "$1" | xargs -r sed -i "s/L/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I13 "$@"
  elif [ "$3" == - ];
    then
      I11 "$@"
fi
}

function I13 {

N=$((N+1))

grep -Fl M "$1" | xargs -r sed -i "s/M/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I14 "$@"
  elif [ "$3" == - ];
    then
      I12 "$@"
fi
}

function I14 {

N=$((N+1))

grep -Fl N "$1" | xargs -r sed -i "s/N/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I15 "$@"
  elif [ "$3" == - ];
    then
      I13 "$@"
fi
}

function I15 {

N=$((N+1))

grep -Fl O "$1" | xargs -r sed -i "s/O/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I16 "$@"
  elif [ "$3" == - ];
    then
      I14 "$@"
fi
}

function I16 {

N=$((N+1))

grep -Fl P "$1" | xargs -r sed -i "s/P/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I17 "$@"
  elif [ "$3" == - ];
    then
      I15 "$@"
fi
}

function I17 {

N=$((N+1))

grep -Fl Q "$1" | xargs -r sed -i "s/Q/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I18 "$@"
  elif [ "$3" == - ];
    then
      I16 "$@"
fi
}

function I18 {

N=$((N+1))

grep -Fl R "$1" | xargs -r sed -i "s/R/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I19 "$@"
  elif [ "$3" == - ];
    then
      I17 "$@"
fi
}

function I19 {

N=$((N+1))

grep -Fl S "$1" | xargs -r sed -i "s/S/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I20 "$@"
  elif [ "$3" == - ];
    then
      I18 "$@"
fi
}

function I20 {

N=$((N+1))

grep -Fl T "$1" | xargs -r sed -i "s/T/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I21 "$@"
  elif [ "$3" == - ];
    then
      I19 "$@"
fi
}

function I21 {

N=$((N+1))

grep -Fl U "$1" | xargs -r sed -i "s/U/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I22 "$@"
  elif [ "$3" == - ];
    then
      I20 "$@"
fi
}

function I22 {

N=$((N+1))

grep -Fl V "$1" | xargs -r sed -i "s/V/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I23 "$@"
  elif [ "$3" == - ];
    then
      I21 "$@"
fi
}

function I23 {

N=$((N+1))

grep -Fl W "$1" | xargs -r sed -i "s/W/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I24 "$@"
  elif [ "$3" == - ];
    then
      I22 "$@"
fi
}

function I24 {

N=$((N+1))

grep -Fl X "$1" | xargs -r sed -i "s/X/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I25 "$@"
  elif [ "$3" == - ];
    then
      I23 "$@"
fi
}

function I25 {

N=$((N+1))

grep -Fl Y "$1" | xargs -r sed -i "s/Y/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I26 "$@"
  elif [ "$3" == - ];
    then
      I24 "$@"
fi
}

function I26 {

N=$((N+1))

grep -Fl Z "$1" | xargs -r sed -i "s/Z/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I27 "$@"
  elif [ "$3" == - ];
    then
      I25 "$@"
fi
}

function I27 {

N=$((N+1))

grep -Fl a "$1" | xargs -r sed -i "s/a/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I28 "$@"
  elif [ "$3" == - ];
    then
      I26 "$@"
fi
}

function I28 {

N=$((N+1))

grep -Fl b "$1" | xargs -r sed -i "s/b/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I29 "$@"
  elif [ "$3" == - ];
    then
      I27 "$@"
fi
}

function I29 {

N=$((N+1))

grep -Fl c "$1" | xargs -r sed -i "s/c/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I30 "$@"
  elif [ "$3" == - ];
    then
      I28 "$@"
fi
}

function I30 {

N=$((N+1))

grep -Fl d "$1" | xargs -r sed -i "s/d/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I31 "$@"
  elif [ "$3" == - ];
    then
      I29 "$@"
fi
}

function I31 {

N=$((N+1))

grep -Fl e "$1" | xargs -r sed -i "s/e/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I32 "$@"
  elif [ "$3" == - ];
    then
      I30 "$@"
fi
}

function I32 {

N=$((N+1))

grep -Fl f "$1" | xargs -r sed -i "s/f/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I33 "$@"
  elif [ "$3" == - ];
    then
      I31 "$@"
fi
}

function I33 {

N=$((N+1))

grep -Fl g "$1" | xargs -r sed -i "s/g/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I34 "$@"
  elif [ "$3" == - ];
    then
      I32 "$@"
fi
}

function I34 {

N=$((N+1))

grep -Fl h "$1" | xargs -r sed -i "s/h/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I35 "$@"
  elif [ "$3" == - ];
    then
      I33 "$@"
fi
}

function I35 {

N=$((N+1))

grep -Fl i "$1" | xargs -r sed -i "s/i/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I36 "$@"
  elif [ "$3" == - ];
    then
      I34 "$@"
fi
}

function I36 {

N=$((N+1))

grep -Fl j "$1" | xargs -r sed -i "s/j/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I37 "$@"
  elif [ "$3" == - ];
    then
      I35 "$@"
fi
}

function I37 {

N=$((N+1))

grep -Fl k "$1" | xargs -r sed -i "s/k/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I38 "$@"
  elif [ "$3" == - ];
    then
      I36 "$@"
fi
}

function I38 {

N=$((N+1))

grep -Fl l "$1" | xargs -r sed -i "s/l/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I39 "$@"
  elif [ "$3" == - ];
    then
      I37 "$@"
fi
}

function I39 {

N=$((N+1))

grep -Fl m "$1" | xargs -r sed -i "s/m/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I40 "$@"
  elif [ "$3" == - ];
    then
      I38 "$@"
fi
}

function I40 {

N=$((N+1))

grep -Fl n "$1" | xargs -r sed -i "s/n/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I41 "$@"
  elif [ "$3" == - ];
    then
      I39 "$@"
fi
}

function I41 {

N=$((N+1))

grep -Fl o "$1" | xargs -r sed -i "s/o/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I42 "$@"
  elif [ "$3" == - ];
    then
      I40 "$@"
fi
}

function I42 {

N=$((N+1))

grep -Fl p "$1" | xargs -r sed -i "s/p/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I43 "$@"
  elif [ "$3" == - ];
    then
      I41 "$@"
fi
}

function I43 {

N=$((N+1))

grep -Fl q "$1" | xargs -r sed -i "s/q/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I44 "$@"
  elif [ "$3" == - ];
    then
      I42 "$@"
fi
}

function I44 {

N=$((N+1))

grep -Fl r "$1" | xargs -r sed -i "s/r/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I45 "$@"
  elif [ "$3" == - ];
    then
      I43 "$@"
fi
}

function I45 {

N=$((N+1))

grep -Fl s "$1" | xargs -r sed -i "s/s/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I46 "$@"
  elif [ "$3" == - ];
    then
      I44 "$@"
fi
}

function I46 {

N=$((N+1))

grep -Fl t "$1" | xargs -r sed -i "s/t/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I47 "$@"
  elif [ "$3" == - ];
    then
      I45 "$@"
fi
}

function I47 {

N=$((N+1))

grep -Fl u "$1" | xargs -r sed -i "s/u/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I48 "$@"
  elif [ "$3" == - ];
    then
      I46 "$@"
fi
}

function I48 {

N=$((N+1))

grep -Fl v "$1" | xargs -r sed -i "s/v/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I49 "$@"
  elif [ "$3" == - ];
    then
      I47 "$@"
fi
}

function I49 {

N=$((N+1))

grep -Fl w "$1" | xargs -r sed -i "s/w/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I50 "$@"
  elif [ "$3" == - ];
    then
      I48 "$@"
fi
}

function I50 {

N=$((N+1))

grep -Fl x "$1" | xargs -r sed -i "s/x/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I51 "$@"
  elif [ "$3" == - ];
    then
      I49 "$@"
fi
}

function I51 {

N=$((N+1))

grep -Fl y "$1" | xargs -r sed -i "s/y/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I52 "$@"
  elif [ "$3" == - ];
    then
      I50 "$@"
fi
}

function I52 {

N=$((N+1))

grep -Fl z "$1" | xargs -r sed -i "s/z/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I53 "$@"
  elif [ "$3" == - ];
    then
      I51 "$@"
fi
}

function I53 {

N=$((N+1))

grep -Fl \  "$1" | xargs -r sed -i "s/\ /(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I54 "$@"
  elif [ "$3" == - ];
    then
      I52 "$@"
fi
}

function I54 {

N=$((N+1))

grep -Fl . "$1" | xargs -r sed -i "s/\./(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I55 "$@"
  elif [ "$3" == - ];
    then
      I53 "$@"
fi
}

function I55 {

N=$((N+1))

grep -Fl \{ "$1" | xargs -r sed -i "s/{/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I56 "$@"
  elif [ "$3" == - ];
    then
      I54 "$@"
fi
}

function I56 {

N=$((N+1))

grep -Fl \} "$1" | xargs -r sed -i "s/}/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I57 "$@"
  elif [ "$3" == - ];
    then
      I55 "$@"
fi
}

function I57 {

N=$((N+1))

grep -Fl [ "$1" | xargs -r sed -i "s/\[/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I58 "$@"
  elif [ "$3" == - ];
    then
      I56 "$@"
fi
}

function I58 {

N=$((N+1))

grep -Fl ] "$1" | xargs -r sed -i "s/]/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I59 "$@"
  elif [ "$3" == - ];
    then
      I57 "$@"
fi
}

function I59 {

N=$((N+1))

grep -Fl \| "$1" | xargs -r sed -i "s/|/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I60 "$@"
  elif [ "$3" == - ];
    then
      I58 "$@"
fi
}

function I60 {

N=$((N+1))

grep -Fl \\ "$1" | xargs -r sed -i "s/[\]/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I61 "$@"
  elif [ "$3" == - ];
    then
      I59 "$@"
fi
}

function I61 {

N=$((N+1))

grep -Fl : "$1" | xargs -r sed -i "s/:/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I62 "$@"
  elif [ "$3" == - ];
    then
      I60 "$@"
fi
}

function I62 {

N=$((N+1))

grep -Fl \; "$1" | xargs -r sed -i "s/;/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I63 "$@"
  elif [ "$3" == - ];
    then
      I61 "$@"
fi
}

function I63 {

N=$((N+1))

grep -Fl \" "$1" | xargs -r sed -i "s/\"/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I64 "$@"
  elif [ "$3" == - ];
    then
      I62 "$@"
fi
}

function I64 {

N=$((N+1))

grep -Fl \' "$1" | xargs -r sed -i "s/'/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I65 "$@"
  elif [ "$3" == - ];
    then
      I63 "$@"
fi
}

function I65 {

N=$((N+1))

grep -Fl \< "$1" | xargs -r sed -i "s/</(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I66 "$@"
  elif [ "$3" == - ];
    then
      I64 "$@"
fi
}

function I66 {

N=$((N+1))

grep -Fl , "$1" | xargs -r sed -i "s/,/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I67 "$@"
  elif [ "$3" == - ];
    then
      I65 "$@"
fi
}

function I67 {

N=$((N+1))

grep -Fl \> "$1" | xargs -r sed -i "s/>/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I68 "$@"
  elif [ "$3" == - ];
    then
      I66 "$@"
fi
}

function I68 {

N=$((N+1))

grep -Fl \? "$1" | xargs -r sed -i "s/?/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I69 "$@"
  elif [ "$3" == - ];
    then
      I67 "$@"
fi
}

function I69 {

N=$((N+1))

grep -Fl / "$1" | xargs -r sed -i "s/\//(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I70 "$@"
  elif [ "$3" == - ];
    then
      I68 "$@"
fi
}

function I70 {

N=$((N+1))

grep -Fl \` "$1" | xargs -r sed -i "s/\`/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I71 "$@"
  elif [ "$3" == - ];
    then
      I69 "$@"
fi
}

function I71 {

N=$((N+1))

grep -Fl \~ "$1" | xargs -r sed -i "s/~/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I72 "$@"
  elif [ "$3" == - ];
    then
      I70 "$@"
fi
}

function I72 {

N=$((N+1))

grep -Fl ! "$1" | xargs -r sed -i "s/!/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I73 "$@"
  elif [ "$3" == - ];
    then
      I71 "$@"
fi
}

function I73 {

N=$((N+1))

grep -Fl @ "$1" | xargs -r sed -i "s/@/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I74 "$@"
  elif [ "$3" == - ];
    then
      I72 "$@"
fi
}

function I74 {

N=$((N+1))

grep -Fl \# "$1" | xargs -r sed -i "s/#/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I75 "$@"
  elif [ "$3" == - ];
    then
      I73 "$@"
fi
}

function I75 {

N=$((N+1))

grep -Fl \$ "$1" | xargs -r sed -i "s/[$]/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I76 "$@"
  elif [ "$3" == - ];
    then
      I74 "$@"
fi
}

function I76 {

N=$((N+1))

grep -Fl % "$1" | xargs -r sed -i "s/%/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I77 "$@"
  elif [ "$3" == - ];
    then
      I75 "$@"
fi
}

function I77 {

N=$((N+1))

grep -Fl ^ "$1" | xargs -r sed -i "s/\^/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I78 "$@"
  elif [ "$3" == - ];
    then
      I76 "$@"
fi
}

function I78 {

N=$((N+1))

grep -Fl \& "$1" | xargs -r sed -i "s/&/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I79 "$@"
  elif [ "$3" == - ];
    then
      I77 "$@"
fi
}

function I79 {

N=$((N+1))

grep -Fl \* "$1" | xargs -r sed -i "s/\*/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I80 "$@"
  elif [ "$3" == - ];
    then
      I78 "$@"
fi
}

function I80 {

N=$((N+1))

grep -Fl _ "$1" | xargs -r sed -i "s/_/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I81 "$@"
  elif [ "$3" == - ];
    then
      I79 "$@"
fi
}

function I81 {

N=$((N+1))

grep -Fl - "$1" | xargs -r sed -i "s/-/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I82 "$@"
  elif [ "$3" == - ];
    then
      I80 "$@"
fi
}

function I82 {

N=$((N+1))

grep -Fl + "$1" | xargs -r sed -i "s/+/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I83 "$@"
  elif [ "$3" == - ];
    then
      I81 "$@"
fi
}

function I83 {

N=$((N+1))

grep -Fl = "$1" | xargs -r sed -i "s/=/(${N})/g"

if [ $N == 83 ];
  then
    STARTO "$@"
  elif [ "$3" == + ];
    then
      I1 "$@"
  elif [ "$3" == - ];
    then
      I82 "$@"
fi
}

####################################################################
## Point Between Letter to Number and Number to Letter Convertion ##
####################################################################

## Resetting Variable N and Call To 2nd Offset Position ##

function STARTO {

N=0

O"${4}" "$@"

}

## Converting Numeric Code to Characters ##

function O1 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/A/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O2 "$@"
  elif [ "$5" == - ];
    then
      O83 "$@"
fi
}

function O2 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/B/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O3 "$@"
  elif [ "$5" == - ];
    then
      O1 "$@"
fi
}

function O3 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/C/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O4 "$@"
  elif [ "$5" == - ];
    then
      O2 "$@"
fi
}

function O4 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/D/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O5 "$@"
  elif [ "$5" == - ];
    then
      O3 "$@"
fi
}

function O5 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/E/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O6 "$@"
  elif [ "$5" == - ];
    then
      O4 "$@"
fi
}

function O6 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/F/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O7 "$@"
  elif [ "$5" == - ];
    then
      O5 "$@"
fi
}

function O7 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/G/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O8 "$@"
  elif [ "$5" == - ];
    then
      O6 "$@"
fi
}

function O8 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/H/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O9 "$@"
  elif [ "$5" == - ];
    then
      O7 "$@"
fi
}

function O9 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/I/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O10 "$@"
  elif [ "$5" == - ];
    then
      O8 "$@"
fi
}

function O10 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/J/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O11 "$@"
  elif [ "$5" == - ];
    then
      O9 "$@"
fi
}

function O11 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/K/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O12 "$@"
  elif [ "$5" == - ];
    then
      O10 "$@"
fi
}

function O12 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/L/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O13 "$@"
  elif [ "$5" == - ];
    then
      O11 "$@"
fi
}

function O13 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/M/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O14 "$@"
  elif [ "$5" == - ];
    then
      O12 "$@"
fi
}

function O14 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/N/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O15 "$@"
  elif [ "$5" == - ];
    then
      O13 "$@"
fi
}

function O15 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/O/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O16 "$@"
  elif [ "$5" == - ];
    then
      O14 "$@"
fi
}

function O16 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/P/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O17 "$@"
  elif [ "$5" == - ];
    then
      O15 "$@"
fi
}

function O17 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/Q/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O18 "$@"
  elif [ "$5" == - ];
    then
      O16 "$@"
fi
}

function O18 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/R/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O19 "$@"
  elif [ "$5" == - ];
    then
      O17 "$@"
fi
}

function O19 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/S/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O20 "$@"
  elif [ "$5" == - ];
    then
      O18 "$@"
fi
}

function O20 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/T/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O21 "$@"
  elif [ "$5" == - ];
    then
      O19 "$@"
fi
}

function O21 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/U/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O22 "$@"
  elif [ "$5" == - ];
    then
      O20 "$@"
fi
}

function O22 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/V/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O23 "$@"
  elif [ "$5" == - ];
    then
      O21 "$@"
fi
}

function O23 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/W/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O24 "$@"
  elif [ "$5" == - ];
    then
      O22 "$@"
fi
}

function O24 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/X/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O25 "$@"
  elif [ "$5" == - ];
    then
      O23 "$@"
fi
}

function O25 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/Y/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O26 "$@"
  elif [ "$5" == - ];
    then
      O24 "$@"
fi
}

function O26 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/Z/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O27 "$@"
  elif [ "$5" == - ];
    then
      O25 "$@"
fi
}

function O27 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/a/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O28 "$@"
  elif [ "$5" == - ];
    then
      O26 "$@"
fi
}

function O28 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/b/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O29 "$@"
  elif [ "$5" == - ];
    then
      O27 "$@"
fi
}

function O29 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/c/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O30 "$@"
  elif [ "$5" == - ];
    then
      O28 "$@"
fi
}

function O30 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/d/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O31 "$@"
  elif [ "$5" == - ];
    then
      O29 "$@"
fi
}

function O31 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/e/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O32 "$@"
  elif [ "$5" == - ];
    then
      O30 "$@"
fi
}

function O32 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/f/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O33 "$@"
  elif [ "$5" == - ];
    then
      O31 "$@"
fi
}

function O33 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/g/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O34 "$@"
  elif [ "$5" == - ];
    then
      O32 "$@"
fi
}

function O34 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/h/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O35 "$@"
  elif [ "$5" == - ];
    then
      O33 "$@"
fi
}

function O35 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/i/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O36 "$@"
  elif [ "$5" == - ];
    then
      O34 "$@"
fi
}

function O36 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/j/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O37 "$@"
  elif [ "$5" == - ];
    then
      O35 "$@"
fi
}

function O37 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/k/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O38 "$@"
  elif [ "$5" == - ];
    then
      O36 "$@"
fi
}

function O38 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/l/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O39 "$@"
  elif [ "$5" == - ];
    then
      O37 "$@"
fi
}

function O39 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/m/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O40 "$@"
  elif [ "$5" == - ];
    then
      O38 "$@"
fi
}

function O40 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/n/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O41 "$@"
  elif [ "$5" == - ];
    then
      O39 "$@"
fi
}

function O41 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/o/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O42 "$@"
  elif [ "$5" == - ];
    then
      O40 "$@"
fi
}

function O42 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/p/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O43 "$@"
  elif [ "$5" == - ];
    then
      O41 "$@"
fi
}

function O43 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/q/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O44 "$@"
  elif [ "$5" == - ];
    then
      O42 "$@"
fi
}

function O44 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/r/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O45 "$@"
  elif [ "$5" == - ];
    then
      O43 "$@"
fi
}

function O45 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/s/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O46 "$@"
  elif [ "$5" == - ];
    then
      O44 "$@"
fi
}

function O46 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/t/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O47 "$@"
  elif [ "$5" == - ];
    then
      O45 "$@"
fi
}

function O47 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/u/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O48 "$@"
  elif [ "$5" == - ];
    then
      O46 "$@"
fi
}

function O48 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/v/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O49 "$@"
  elif [ "$5" == - ];
    then
      O47 "$@"
fi
}

function O49 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/w/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O50 "$@"
  elif [ "$5" == - ];
    then
      O48 "$@"
fi
}

function O50 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/x/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O51 "$@"
  elif [ "$5" == - ];
    then
      O49 "$@"
fi
}

function O51 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/y/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O52 "$@"
  elif [ "$5" == - ];
    then
      O50 "$@"
fi
}

function O52 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/z/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O53 "$@"
  elif [ "$5" == - ];
    then
      O51 "$@"
fi
}

function O53 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/\ /g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O54 "$@"
  elif [ "$5" == - ];
    then
      O52 "$@"
fi
}

function O54 {

N=$((N+1))

grep -l \(${N}\) "$1" | xargs -r sed -i "s/(${N})/./g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O55 "$@"
  elif [ "$5" == - ];
    then
      O53 "$@"
fi
}

function O55 {

N=$((N+1))

grep -Fl \(${N}\) "$1" | xargs -r sed -i "s/(${N})/{/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O56 "$@"
  elif [ "$5" == - ];
    then
      O54 "$@"
fi
}

function O56 {

N=$((N+1))

grep -Fl \(${N}\) "$1" | xargs -r sed -i "s/(${N})/}/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O57 "$@"
  elif [ "$5" == - ];
    then
      O55 "$@"
fi
}

function O57 {

N=$((N+1))

grep -Fl \(${N}\) "$1" | xargs -r sed -i "s/(${N})/[/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O58 "$@"
  elif [ "$5" == - ];
    then
      O56 "$@"
fi
}

function O58 {

N=$((N+1))

grep -Fl \(${N}\) "$1" | xargs -r sed -i "s/(${N})/]/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O59 "$@"
  elif [ "$5" == - ];
    then
      O57 "$@"
fi
}

function O59 {

N=$((N+1))

grep -Fl \(${N}\) "$1" | xargs -r sed -i "s/(${N})/|/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O60 "$@"
  elif [ "$5" == - ];
    then
      O58 "$@"
fi
}

function O60 {

N=$((N+1))

grep -Fl \(${N}\) "$1" | xargs -r sed -i "s/(${N})/\\\/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O61 "$@"
  elif [ "$5" == - ];
    then
      O59 "$@"
fi
}

function O61 {

N=$((N+1))

grep -Fl \(${N}\) "$1" | xargs -r sed -i "s/(${N})/:/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O62 "$@"
  elif [ "$5" == - ];
    then
      O60 "$@"
fi
}

function O62 {

N=$((N+1))

grep -Fl \(${N}\) "$1" | xargs -r sed -i "s/(${N})/;/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O63 "$@"
  elif [ "$5" == - ];
    then
      O61 "$@"
fi
}

function O63 {

N=$((N+1))

grep -Fl \(${N}\) "$1" | xargs -r sed -i "s/(${N})/\"/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O64 "$@"
  elif [ "$5" == - ];
    then
      O62 "$@"
fi
}

function O64 {

N=$((N+1))

grep -Fl \(${N}\) "$1" | xargs -r sed -i "s/(${N})/'/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O65 "$@"
  elif [ "$5" == - ];
    then
      O63 "$@"
fi
}

function O65 {

N=$((N+1))

grep -Fl \(${N}\) "$1" | xargs -r sed -i "s/(${N})/</g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O66 "$@"
  elif [ "$5" == - ];
    then
      O64 "$@"
fi
}

function O66 {

N=$((N+1))

grep -Fl \(${N}\) "$1" | xargs -r sed -i "s/(${N})/,/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O67 "$@"
  elif [ "$5" == - ];
    then
      O65 "$@"
fi
}

function O67 {

N=$((N+1))

grep -Fl \(${N}\) "$1" | xargs -r sed -i "s/(${N})/>/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O68 "$@"
  elif [ "$5" == - ];
    then
      O66 "$@"
fi
}

function O68 {

N=$((N+1))

grep -Fl \(${N}\) "$1" | xargs -r sed -i "s/(${N})/?/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O69 "$@"
  elif [ "$5" == - ];
    then
      O67 "$@"
fi
}

function O69 {

N=$((N+1))

grep -Fl \(${N}\) "$1" | xargs -r sed -i "s/(${N})/\//g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O70 "$@"
  elif [ "$5" == - ];
    then
      O68 "$@"
fi
}

function O70 {

N=$((N+1))

grep -Fl \(${N}\) "$1" | xargs -r sed -i "s/(${N})/\`/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O71 "$@"
  elif [ "$5" == - ];
    then
      O69 "$@"
fi
}

function O71 {

N=$((N+1))

grep -Fl \(${N}\) "$1" | xargs -r sed -i "s/(${N})/~/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O72 "$@"
  elif [ "$5" == - ];
    then
      O70 "$@"
fi
}

function O72 {

N=$((N+1))

grep -Fl \(${N}\) "$1" | xargs -r sed -i "s/(${N})/!/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O73 "$@"
  elif [ "$5" == - ];
    then
      O71 "$@"
fi
}

function O73 {

N=$((N+1))

grep -Fl \(${N}\) "$1" | xargs -r sed -i "s/(${N})/@/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O74 "$@"
  elif [ "$5" == - ];
    then
      O72 "$@"
fi
}

function O74 {

N=$((N+1))

grep -Fl \(${N}\) "$1" | xargs -r sed -i "s/(${N})/#/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O75 "$@"
  elif [ "$5" == - ];
    then
      O73 "$@"
fi
}

function O75 {

N=$((N+1))

grep -Fl \(${N}\) "$1" | xargs -r sed -i "s/(${N})/\$/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O76 "$@"
  elif [ "$5" == - ];
    then
      O74 "$@"
fi
}

function O76 {

N=$((N+1))

grep -Fl \(${N}\) "$1" | xargs -r sed -i "s/(${N})/%/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O77 "$@"
  elif [ "$5" == - ];
    then
      O75 "$@"
fi
}

function O77 {

N=$((N+1))

grep -Fl \(${N}\) "$1" | xargs -r sed -i "s/(${N})/^/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O78 "$@"
  elif [ "$5" == - ];
    then
      O76 "$@"
fi
}

function O78 {

N=$((N+1))

grep -Fl \(${N}\) "$1" | xargs -r sed -i "s/(${N})/\&/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O79 "$@"
  elif [ "$5" == - ];
    then
      O77 "$@"
fi
}

function O79 {

N=$((N+1))

grep -Fl \(${N}\) "$1" | xargs -r sed -i "s/(${N})/\*/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O80 "$@"
  elif [ "$5" == - ];
    then
      O78 "$@"
fi
}

function O80 {

N=$((N+1))

grep -Fl \(${N}\) "$1" | xargs -r sed -i "s/(${N})/_/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O81 "$@"
  elif [ "$5" == - ];
    then
      O79 "$@"
fi
}

function O81 {

N=$((N+1))

grep -Fl \(${N}\) "$1" | xargs -r sed -i "s/(${N})/-/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O82 "$@"
  elif [ "$5" == - ];
    then
      O80 "$@"
fi
}

function O82 {

N=$((N+1))

grep -Fl \(${N}\) "$1" | xargs -r sed -i "s/(${N})/+/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O83 "$@"
  elif [ "$5" == - ];
    then
      O81 "$@"
fi
}

function O83 {

N=$((N+1))

grep -Fl \(${N}\) "$1" | xargs -r sed -i "s/(${N})/=/g"

if [ $N == 83 ];
  then
    CONF "$@"
  elif [ "$5" == + ];
    then
      O1 "$@"
  elif [ "$5" == - ];
    then
      O82 "$@"
fi
}

## Reinstating Conflicting Characters ##

function CONF {

grep -Fl !one! "$1" | xargs -r sed -i 's/!one!/1/g'
grep -Fl !two! "$1" | xargs -r sed -i 's/!two!/2/g'
grep -Fl !three! "$1" | xargs -r sed -i 's/!three!/3/g'
grep -Fl !four! "$1" | xargs -r sed -i 's/!four!/4/g'
grep -Fl !five! "$1" | xargs -r sed -i 's/!five!/5/g'
grep -Fl !six! "$1" | xargs -r sed -i 's/!six!/6/g'
grep -Fl !seven! "$1" | xargs -r sed -i 's/!seven!/7/g'
grep -Fl !eight! "$1" | xargs -r sed -i 's/!eight!/8/g'
grep -Fl !nine! "$1" | xargs -r sed -i 's/!nine!/9/g'
grep -Fl !zero! "$1" | xargs -r sed -i 's/!zero!/0/g'
grep -Fl !\[! "$1" | xargs -r sed -i 's/!\[!/(/g'
grep -Fl !]! "$1" | xargs -r sed -i 's/!]!/)/g'

## Displaying Encrypted Message ##

cat "$1"

}

## Function Progression ##
helpandversion "$@"