Shell Programming and Scripting

 perl -e'BEGIN {
  $Pattern = "1012345678";
  $Bak_ext = ".bak";
  #@Files = glob "ABC_DEF*";
 #print "help $i";
  }

@files = <ABC_DEF*>;
  foreach $File (@files) {
  ##checking:print "1\n";
  ##checking:print $File . "\n";
  #$File = $_;
  open FH, $File or die "$File : $!\n";
   while (<FH>)
 {
      ##checking:print "\n2\n";
      ##checking:print "line $. \n" ;
      if($. == 2 && (split)[3] == $Pattern)
     {
          ##checking:print "i'm line 2\n";
          local @ARGV = ($File);
          local $^I = $Bak_ext;
          local $/ = undef;

          while (<>) {
          s/
          \A(.*?\n)
          ((?:\S+\s+){3}$Pattern\b.*?\n)
          (.*?\n)
          /$1$3$2/xos;
          print;
         }
     }
 }close FH;
  ##checking:print "3\n\n";
}'

local @ARGV = ($File); # puts $File into the array @ARGV
local $^I = $Bak_ext;  # (Backup input file, output with original filename)
local $/ = undef;      # read entire file at once

                          s/   # s/ = substitute operator
                    
                    \A(.*?\n)  # \A = match at only beginning of string
                                # () = grouping
                                # .  = allow single char to match
                                # *? = match 0 or more time
                                # \n = newline
((?:\S+\s+){3}$Pattern\b.*?\n)  # () = grouping
                                # ?: Non-capturing groupings
                                # \S+  Match a non-whitespace character  1 or more times
                                # \s+  Match a whitespace character 1 or more times
                                # {3}= Match exactly 3 times
                                # \b = Match a word boundary
                                # .  = allow single char to match
                                # *? = match 0 or more time
                                # \n = newline
                       (.*?\n)  # .  = allow single char to match
                                # *? = match 0 or more time
                                # \n = newline

                 /$1$3$2/xos;   #substitute with $1$3$2. XOS?

                      print     #print balance line?

$ cat file
header
abc  def   ghi   1012345678       500010.00                       
abc  def   ghi   2022222222             10.00 
abc  def   ghi   1022222222             10.00                       
abc  def   ghi   2012345678       500010.00

$ perl -e'BEGIN {
  $Pattern = "1012345678";
  $Bak_ext = ".bak";
  @Files = glob "file*";
  }
for (@Files) {
  $File = $_;
  open FH, $File or die "$File : $!\n";
  while (<FH>) {
    if ($. == 2 and (split)[3] == $Pattern) {
      close FH;
      local @ARGV = ($File);
#      local $^I = $Bak_ext;
#      local $/ = undef;
      while (<>) {
        s/
         \A(.*?\n)
         ((?:\S+\s+){3}$Pattern\b.*?\n)
         (.*?\n)
         /$1$3$2/xos and print;
      }
    }
  }
}'
$ # no output 

$ perl -e'BEGIN {
  $Pattern = "1012345678";
  $Bak_ext = ".bak";
  @Files = glob "file*";
  }
for (@Files) {
  $File = $_;
  open FH, $File or die "$File : $!\n";
  while (<FH>) {
    if ($. == 2 and (split)[3] == $Pattern) {
      close FH;
      local @ARGV = ($File);
#      local $^I = $Bak_ext;
      local $/ = undef; 
      while (<>) {
        s/
         \A(.*?\n)
         ((?:\S+\s+){3}$Pattern\b.*?\n)
         (.*?\n)
         /$1$3$2/xos and print;
      }
    }
  }
}'
header
abc  def   ghi   2022222222             10.00 
abc  def   ghi   1012345678       500010.00                       
abc  def   ghi   1022222222             10.00                       
abc  def   ghi   2012345678       500010.00

 s/                                     #  We can use spaces and newlines here
                                        #+ because of the x modifier (the x from xos). 
         \A(.*?\n)                      #  We can match across lines because ot the undefined
                                        #+ record separator $/. The fist group matches from
                                        #+ the begining of the string to the _first_ newline
                                        #+ (notice the * quantifier is followed by ?, so it's 
                                        #+ not greedy).
                                        #  In this case we don't need it though, if we remove the s
                                        #+ modifier (s from xos) as we don't need that too, we'll
                                        #+ get the expected result with \A(.*\n).                                         
         ((?:\S+\s+){3}$Pattern\b.*?\n) #  Here we are at the second line (i.e. after the first newline).
                                        #  This matches our pattern in the 4th field: 3 times non-spaces
                                        #+ followed by spaces. \b to match the exact pattern and exclude
                                        #+ 10123456780000 for example.                                        
         (.*?\n)                        #  This group matches the next line to be swapped.
         /$1$3$2/xos                    #  Change the order: first group, third, second:
                                        #+ first line, third line, second line.
                                        #  Again: x for legibility. o for compile only once
                                        #+ see perldoc perlreref|less -pOnce.

s/
  \A(.*\n)
  ((?:\S+\s+){3}$Pattern\b.*\n)
  (.*\n)
/$1$3$2/xo