anchor.diff:                  if
                       (BogoMIPS > 50000) ->
                           1;
  +                    (BogoMIPS > 40000) ->
  +                        2;
                       (BogoMIPS > 30000) ->
  -                        2;
  +                        3;
  +                    (BogoMIPS > 20000) ->
  +                        4;
                       (BogoMIPS > 10000) ->
  -                        3;
  +                        5;
                       (BogoMIPS > 5000) ->
  -                        5;
  +                        8;
                       (BogoMIPS > 3000) ->
  -                        8;
  +                        12;
                       true ->
                           10
                   end;
  
positive.code:             _ ->
                  5
          end,
      %% Check if we need to adjust the factor because of the memory
      try linux_which_meminfo() of
          AddFactor ->
              {Factor + AddFactor, []}
      catch
          _:_:_ ->
              {Factor, []}
      end.
  
  
  linux_cpuinfo_lookup(Key) when is_list(Key) ->
      linux_info_lookup(Key, "/proc/cpuinfo").
  
  linux_cpuinfo_bogomips() ->
      case linux_cpuinfo_lookup("bogomips") of
          [] ->
              "-";
          BMips when is_list(BMips) ->
  
negative.code:                                         [$\n])] of
                  [DistroStr | _] ->
                      io:format("Linux: ~s"
                                "~n   Distro:                  ~s"
                                "~n   TS Extra Platform Label: ~s"
                                "~n   Product Name:            ~s"
                                "~n",
                                [Version, DistroStr, Label,
                                 linux_product_name()]);
                  _ ->
                      io:format("Linux: ~s"
                                "~n   Distro: ~s"
                                "~n   TS Extra Platform Label: ~s"
                                "~n   Product Name:            ~s"
                                "~n",
                                [Version, "Fedora", Label,
                                 linux_product_name()])
              end,
              throw({distro, {fedora, simplify_label(Label)}});
          _ ->
              throw({error, not_found})
      end.
  
  do_linux_which_distro_suse_release(Version, Label) ->
      %% Check if its a SuSE
      case file:read_file_info("/etc/SUSE-brand") of
          {ok, _} ->
              case file:read_file_info("/etc/SuSE-release") of
                  {ok, _} ->
                      case [string:trim(S) ||
                               S <- string:tokens(os:cmd("cat /etc/SuSE-release"),
                                                  [$\n])] of
                          ["SUSE Linux Enterprise Server" ++ _ = DistroStr | _] ->
                              io:format("Linux: ~s"
                                        "~n   Distro:                  ~s"
                                        "~n   TS Extra Platform Label: ~s"
                                        "~n   Product Name:            ~s"
                                        "~n",
                                        [Version, DistroStr, Label,
                                         linux_product_name()]),
                              throw({distro, {sles, simplify_label(Label)}});
                          [DistroStr | _] ->
                              io:format("Linux: ~s"
                                        "~n   Distro:                  ~s"
                                        "~n   TS Extra Platform Label: ~s"
                                        "~n   Product Name:            ~s"
                                        "~n",
                                        [Version, DistroStr, Label,
                                         linux_product_name()]),
                              throw({distro, {suse, simplify_label(Label)}});
                          _ ->
                              io:format("Linux: ~s"
                                        "~n   Distro:                  ~s"
                                        "~n   TS Extra Platform Label: ~s"
                                        "~n   Product Name:            ~s"
                                        "~n",
                                        [Version, "SuSE", Label,
                                         linux_product_name()]),
                              throw({distro, {suse, simplify_label(Label)}})
                      end;
                  _ ->
                      case string:tokens(os:cmd("cat /etc/SUSE-brand"), [$\n]) of
                          ["SLE" = DistroStr, VERSION | _] ->
                              case [string:strip(S) ||
                                       S <- string:tokens(VERSION, [$=])] of
                                  ["VERSION", VersionNo] ->
                                      io:format("Linux: ~s"
                                                "~n   Distro:                  ~s"
                                                "~n   Distro Version:          ~s"
                                                "~n   TS Extra Platform Label: ~s"
                                                "~n   Product Name:            ~s"
                                                "~n",
                                                [Version,
                                                 DistroStr, VersionNo,
                                                 Label,
                                                 linux_product_name()]),
                                      throw({distro,
                                             {sles, simplify_label(Label)}});
                                  _ ->
                                      io:format("Linux: ~s"
                                                "~n   Distro:                  ~s"
                                                "~n   TS Extra Platform Label: ~s"
                                                "~n   Product Name:            ~s"
                                                "~n",
                                                [Version, DistroStr, Label,
                                                 linux_product_name()]),
                                      throw({distro,
                                             {sles, simplify_label(Label)}})
                              end;
                          ["openSUSE" = DistroStr, VERSION | _] ->
                              case [string:strip(S) ||
                                       S <- string:tokens(VERSION, [$=])] of
                                  ["VERSION", VersionNo] ->
                                      io:format("Linux: ~s"
                                                "~n   Distro:                  ~s"
                                                "~n   Distro Version:          ~s"
                                                "~n   TS Extra Platform Label: ~s"
                                                "~n   Product Name:            ~s"
                                                "~n",
                                                [Version,
                                                 DistroStr, VersionNo,
                                                 Label,
                                                 linux_product_name()]),
                                      throw({distro,
                                             {suse, simplify_label(Label)}});
                                  _ ->
                                      io:format("Linux: ~s"
                                                "~n   Distro:                  ~s"
                                                "~n   TS Extra Platform Label: ~s"
                                                "~n   Product Name:            ~s"
                                                "~n",
                                                [Version, DistroStr, Label,
                                                 linux_product_name()]),
                                      throw({distro,
                                             {suse, simplify_label(Label)}})
                              end;
                          _ ->
                              io:format("Linux: ~s"
                                        "~n   Distro:                  ~s"
                                        "~n   TS Extra Platform Label: ~s"
                                        "~n   Product Name:            ~s"
                                        "~n",
                                        [Version, "Unknown SUSE", Label,
                                         linux_product_name()]),
                              throw({distro, {suse, simplify_label(Label)}})
                      end
              end;
          _ ->
              throw({error, not_found})
      end.
  
  do_linux_which_distro_issue(Version, Label) ->
      case file:read_file_info("/etc/issue") of
          {ok, _} ->
              case [string:trim(S) ||
  