{$APPTYPE CONSOLE}
uses SysUtils, Math;

type
  Plist = ^Tlist;
  Tlist = record
    value : integer;
    next : Plist;
  end;

var query : string;
    val, _val, index : integer;
    l : Plist;
    found : boolean;

function size(const l : Plist) : integer; forward;
procedure push_front(var l : Plist; new_val : integer); forward;
procedure push_back(var l : Plist; new_val : integer); forward;
function get_element_by_element(const l : Plist; find_val : integer) : Plist; forward;
function get_element_by_index(const l : Plist; index : integer) : Plist; forward;
procedure delete_front(var l : Plist); forward;
procedure delete_last(var l : Plist); forward;
procedure delete_element_by_index(var l : Plist; index : integer); forward;
procedure delete_element_by_element(var l : Plist; find_val : integer); forward;
procedure delete_all(var l : Plist; find_val : integer); forward;
procedure insert_after_element(var l : Plist; value, add_value : integer); forward;
function is_palin(const l : Plist; position : integer) : boolean; forward;
//function index_of(const l : Plist; find_value, answer : integer) : integer; forward;
procedure delete_many(var l : Plist; n, k : integer); forward;
function check_sort(const l : Plist) : boolean; forward;
procedure print(const l : Plist); forward;
function all_equal(const l : Plist) : boolean; forward;
function all_differ(const l : Plist) : boolean; forward;

function size(const l : Plist) : integer;
begin
  if (l = nil) then begin
    result := 0;
    exit;
  end;
  result := size(l^.next) + 1;
end;

procedure push_front(var l : Plist; new_val : integer);
var new_list : Plist;
begin
  new(new_list);
  new_list^.value := new_val;
  new_list^.next := l;
  l := new_list;
end;

procedure push_back(var l : Plist; new_val : integer);
var new_list, last : Plist;
begin
  if (l = nil) then begin
    new(new_list);
    new_list^.value := new_val;
    new_list^.next := nil;
    l := new_list;
    exit;
  end;
  last := get_element_by_index(l, size(l));
  new(new_list);
  new_list^.value := new_val;
  new_list^.next := nil;
  last^.next := new_list;
end;

function get_element_by_element(const l : Plist; find_val : integer) : Plist;
begin
  if (l = nil) then begin
    result := nil;
    exit;
  end;
  if (l^.value = find_val) then
    result := l
  else
    result := get_element_by_element(l^.next, find_val);
end;

function get_element_by_index(const l : Plist; index : integer) : Plist;
begin
  if (l = nil) then begin
    result := nil;
    exit;
  end;
  if (index = 1) then
    result := l
  else
    result := get_element_by_index(l^.next, index - 1);
end;

procedure delete_front(var l : Plist);
begin
  if (l = nil) then
    exit;
  l := l^.next;
end;

procedure delete_last(var l : Plist);
var last : Plist;
begin
  if (l = nil) then
    exit;
  if (l^.next = nil) then begin
    l := nil;
    exit;
  end;
  last := get_element_by_index(l, size(l) - 1);
  last^.next := nil;
end;

procedure delete_element_by_index(var l : Plist; index : integer);
begin
  if (l = nil) then
    exit;
  if (index = 1) then begin
    delete_front(l);
    exit;
  end;
  if (index = 2) then begin
    l^.next := (l^.next)^.next;
    exit;
  end;
  delete_element_by_index(l^.next, index - 1);
end;

procedure delete_element_by_element(var l : Plist; find_val : integer);
begin
  if (l = nil) then
    exit;
  if (l^.next = nil) then begin
    if (l^.value = find_val) then
      delete_front(l);
    exit;
  end;
  if (l^.value = find_val) then begin
    delete_front(l);
    exit;
  end;
  if ((l^.next)^.value = find_val) then begin
    l^.next := (l^.next)^.next;
    exit;
  end;
  delete_element_by_element(l^.next, find_val);
end;

{procedure delete_all(var l : Plist; find_val : integer);
begin
  if (l = nil) or (get_element_by_element(l, find_val) = nil) then
    exit;
  delete_element_by_element(l, find_val);
  delete_all(l, find_val);
end;}

procedure delete_all(var l : Plist; find_val : integer);
begin
  if (l = nil) or (l^.next = nil) then
    exit;
  if (l^.value = find_val) then begin
    delete_front(l);
    delete_all(l^.next, find_val);
    exit;
  end;
  if ((l^.next)^.value = find_val) then
    l^.next := (l^.next)^.next;
  delete_all(l^.next, find_val);
end;

procedure insert_after_element(var l : Plist; value, add_value : integer);
var new_list : Plist;
begin
  if (l = nil) then
    exit;
  if (l^.value = value) then begin
    new(new_list);
    new_list^.value := add_value;
    new_list^.next := l^.next;
    l^.next := new_list;
    exit;
  end;
  insert_after_element(l^.next, value, add_value);
end;

function is_palin(const l : Plist; position : integer) : boolean;
begin
  if (l = nil) or (l^.next = nil) or (position > size(l) div 2) then begin
    result := true;
    exit;
  end;
  if (get_element_by_index(l, position)^.value <> get_element_by_index(l, size(l) - position + 1)^.value) then begin
    result := false;
    exit;
  end;
  result := is_palin(l^.next, position + 1);
end;

function index_of(const l : Plist; val, depth : integer; var found : boolean) : integer;
begin
  if (l = nil) then begin
    found := false;
    result := -1;
    exit;
  end;
  if (l^.value = val) then begin
    found := true;
    result := depth;
    exit;
  end;
  result := index_of(l^.next, val, depth + 1, found);
  if (not found) then
    result := -1;
end;

procedure delete_many(var l : Plist; n, k : integer);
begin
  if (l = nil) or (k = 0) then
    exit;
  delete_element_by_index(l, n);
  delete_many(l^.next, n, k - 1);
end;

function check_sort(const l : Plist) : boolean;
begin
  if (l = nil) or (l^.next = nil) then begin
    result := true;
    exit;
  end;
  if (l^.value > (l^.next)^.value) then begin
    result := false;
    exit;
  end;
  result := check_sort(l^.next);
end;

function all_equal(const l : Plist) : boolean;
begin
  if (l = nil) or (l^.next = nil) then begin
    result := true;
    exit;
  end;
  if (l^.value <> (l^.next)^.value) then begin
    result := false;
    exit;
  end;
  result := all_equal(l^.next);
end;

function all_differ(const l : Plist) : boolean;
var i, j : integer;
begin
  result := true;
  for i := 1 to size(l) do
    for j := i + 1 to size(l) do
      if (get_element_by_index(l, i)^.value = get_element_by_index(l, j)^.value) then begin
        result := false;
        exit;
      end;
end;

procedure insert_to_sorted(var l : Plist; x : integer);
var new_list : Plist;
begin
  if (l = nil) then
    exit;
  if (l^.next <> nil) then begin
    if ((l^.next)^.value >= x) and (l^.value <= x) then begin
      new(new_list);
      new_list^.value := x;
      new_list^.next := l^.next;
      l^.next := new_list;
      exit;
    end;
    insert_to_sorted(l^.next, x);
  end else begin
    new(new_list);
    new_list^.value := x;
    new_list^.next := nil;
    l^.next := new_list;
    exit;
  end;
end;

procedure print(const l : Plist);
begin
  if (l = nil) then
    exit;
  if (l^.next = nil) then begin
    writeln(l^.value, '.');
    exit;
  end;
  write(l^.value, ', ');
  print(l^.next);
end;

begin
  //reset(input, 'commands.txt');
  //rewrite(output, 'answer.txt');
  l := nil;
  writeln('You can enter some commands.');
  writeln('Here are the commands: "Push back", "Push front", "Delete front", "Delete last", "Delete element by index"');
  writeln('                       "Delete element by element", "Delete all elements equal to x", "Insert after element"');
  writeln('                       "Check list for palindrome", "Find Index of x", "Delete many", "Check sort", "All Equal"');
  writeln('                       "All Differ", "Insert to sorted", "Size"');
  while (not(EOF)) do begin
    readln(query);
    if (query = 'Push front') then begin
      readln(val);
      push_front(l, val);
    end;
    if (query = 'Size') then begin
      writeln(size(l));
    end;
    if (query = 'Push back') then begin
      readln(val);
      push_back(l, val);
    end;
    if (query = 'Delete front') then
      delete_front(l);
    if (query = 'Delete last') then
      delete_last(l);
    if (query = 'Delete element by index') then begin
      readln(index);
      delete_element_by_index(l, index);
    end;
    if (query = 'Delete element by element') then begin
      readln(val);
      delete_element_by_element(l, val);
    end;
    if (query = 'Delete all elements equal to x') then begin
      readln(val);
      delete_all(l, val);
    end;
    if (query = 'Insert after element') then begin
      readln(val, _val);
      insert_after_element(l, val, _val);
    end;
    if (query = 'Check list for a palindrome') then begin
      if (is_palin(l, 1)) then
        writeln('List is a palindrom')
      else
        writeln('List is not a palindrom');
      writeln;
    end;
    if (query = 'Find Index of x') then begin
      readln(val);
      found := false;
      writeln(index_of(l, val, 1, found));
    end;
    if (query = 'Delete many') then begin
      readln(val, _val);
      delete_many(l, val, _val);
    end;
    if (query = 'Check sort') then begin
      if (check_sort(l)) then
        writeln('The list is sorted')
      else
        writeln('The list is unsorted');
      writeln;
    end;
    if (query = 'All Equal') then begin
      if (all_equal(l)) then
        writeln('All elements in list are equal')
      else
        writeln('Some elements in list are differ');
      writeln;
    end;
    if (query = 'All Differ') then begin
      if (all_differ(l)) then
        writeln('All elements in list are differ')
      else
        writeln('Some elements in list are equal');
      writeln;
    end;
    if (query = 'Insert to sorted') then begin
      readln(val);
      assert(check_sort(l));
      insert_to_sorted(l, val);
    end;
    if (size(l) = 0) then begin
      writeln('List is clear');
      writeln;
      continue;
    end;
    writeln('List: ');
    print(l);
    writeln;
  end;
end.