rem: flag_dump_strings = 0;
add: flag_dump_strings = false;
context: main (int argc, char **argv){  int c;  int n_files;  size_t i;  int l_c_m;  size_t desired_width IF_LINT (= 0);  int width_specified = 0;  int n_failed_decodes = 0;  int err;  char const *short_options = (posix2_version () < 200112			       ? COMMON_SHORT_OPTIONS "s::w::"			       : COMMON_SHORT_OPTIONS "s:w:");  /* The old-style `pseudo starting address' to be printed in parentheses     after any true address.  */  uintmax_t pseudo_start IF_LINT (= 0);  program_name = argv[0];  setlocale (LC_ALL, "");  bindtextdomain (PACKAGE, LOCALEDIR);  textdomain (PACKAGE);  atexit (close_stdout);  err = 0;  for (i = 0; i <= MAX_INTEGRAL_TYPE_SIZE; i++)    integral_type_size[i] = NO_SIZE;  integral_type_size[sizeof (char)] = CHAR;  integral_type_size[sizeof (short int)] = SHORT;  integral_type_size[sizeof (int)] = INT;  integral_type_size[sizeof (long int)] = LONG;#if HAVE_UNSIGNED_LONG_LONG  /* If `long' and `long long' have the same size, it's fine     to overwrite the entry for `long' with this one.  */  integral_type_size[sizeof (ulonglong_t)] = LONG_LONG;#endif  for (i = 0; i <= MAX_FP_TYPE_SIZE; i++)    fp_type_size[i] = NO_SIZE;  fp_type_size[sizeof (float)] = FLOAT_SINGLE;  /* The array entry for `double' is filled in after that for LONG_DOUBLE     so that if `long double' is the same type or if long double isn't     supported FLOAT_LONG_DOUBLE will never be used.  */  fp_type_size[sizeof (LONG_DOUBLE)] = FLOAT_LONG_DOUBLE;  fp_type_size[sizeof (double)] = FLOAT_DOUBLE;  n_specs = 0;  n_specs_allocated = 5;  spec = (struct tspec *) xmalloc (n_specs_allocated * sizeof (struct tspec));  format_address = format_address_std;  address_base = 8;  address_pad_len = 7;  flag_dump_strings = 0;  while ((c = getopt_long (argc, argv, short_options, long_options, NULL))	 != -1)    {      uintmax_t tmp;      enum strtol_error s_err;      switch (c)	{	case 0:	  break;	case 'A':	  switch (optarg[0])	    {	    case 'd':	      format_address = format_address_std;	      address_base = 10;	      address_pad_len = 7;	      break;	    case 'o':	      format_address = format_address_std;	      address_base = 8;	      address_pad_len = 7;	      break;	    case 'x':	      format_address = format_address_std;	      address_base = 16;	      address_pad_len = 6;	      break;	    case 'n':	      format_address = format_address_none;	      address_pad_len = 0;	      break;	    default:	      error (EXIT_FAILURE, 0,		     _("invalid output address radix `%c'; \it must be one character from [doxn]"),		     optarg[0]);	      break;	    }	  break;	case 'j':	  s_err = xstrtoumax (optarg, NULL, 0, &n_bytes_to_skip, "bkm");	  if (s_err != LONGINT_OK)	    STRTOL_FATAL_ERROR (optarg, _("skip argument"), s_err);	  break;	case 'N':	  limit_bytes_to_format = 1;	  s_err = xstrtoumax (optarg, NULL, 0, &max_bytes_to_format, "bkm");	  if (s_err != LONGINT_OK)	    STRTOL_FATAL_ERROR (optarg, _("limit argument"), s_err);	  break;	case 's':	  if (optarg == NULL)	    string_min = 3;	  else	    {	      s_err = xstrtoumax (optarg, NULL, 0, &tmp, "bkm");	      if (s_err != LONGINT_OK)		STRTOL_FATAL_ERROR (optarg, _("minimum string length"), s_err);	      /* The minimum string length may be no larger than SIZE_MAX,		 since we may allocate a buffer of this size.  */	      if (SIZE_MAX < tmp)		error (EXIT_FAILURE, 0, _("%s is too large"), optarg);	      string_min = tmp;	    }	  flag_dump_strings = 1;	  break;	case 't':	  if (decode_format_string (optarg))	    ++n_failed_decodes;	  break;	case 'v':	  abbreviate_duplicate_blocks = 0;	  break;	case TRADITIONAL_OPTION:	  traditional = 1;	  break;	  /* The next several cases map the traditional format	     specification options to the corresponding modern format	     specs.  GNU od accepts any combination of old- and	     new-style options.  Format specification options accumulate.  */#define CASE_OLD_ARG(old_char,new_string)		\	case old_char:					\	  {						\	    if (decode_format_string (new_string))	\	      ++n_failed_decodes;			\	  }						\	  break	  CASE_OLD_ARG ('a', "a");	  CASE_OLD_ARG ('b', "oC");	  CASE_OLD_ARG ('c', "c");	  CASE_OLD_ARG ('d', "u2");	  CASE_OLD_ARG ('f', "fF");	  CASE_OLD_ARG ('h', "x2");	  CASE_OLD_ARG ('i', "d2");	  CASE_OLD_ARG ('l', "d4");	  CASE_OLD_ARG ('o', "o2");	  CASE_OLD_ARG ('x', "x2");	  /* FIXME: POSIX 1003.1-2001 with XSI requires this:	     CASE_OLD_ARG ('s', "d2");	     for the traditional syntax, but this conflicts with case	     's' above. */#undef CASE_OLD_ARG	case 'w':	  width_specified = 1;	  if (optarg == NULL)	    {	      desired_width = 32;	    }	  else	    {	      uintmax_t w_tmp;	      s_err = xstrtoumax (optarg, NULL, 10, &w_tmp, "");	      if (s_err != LONGINT_OK)		STRTOL_FATAL_ERROR (optarg, _("width specification"), s_err);	      if (SIZE_MAX < w_tmp)		error (EXIT_FAILURE, 0, _("%s is too large"), optarg);	      desired_width = w_tmp;	    }	  break;	case_GETOPT_HELP_CHAR;	case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);	default:	  usage (EXIT_FAILURE);	  break;	}    }  if (n_failed_decodes > 0)    exit (EXIT_FAILURE);  if (flag_dump_strings && n_specs > 0)    error (EXIT_FAILURE, 0,	   _("no type may be specified when dumping strings"));  n_files = argc - optind;  /* If the --traditional option is used, there may be from     0 to 3 remaining command line arguments;  handle each case     separately.	od [file] [[+]offset[.][b] [[+]label[.][b]]]     The offset and pseudo_start have the same syntax.     FIXME: POSIX 1003.1-2001 with XSI requires support for the     traditional syntax even if --traditional is not given.  */  if (traditional)    {      uintmax_t offset;      if (n_files == 1)	{	  if (parse_old_offset (argv[optind], &offset))	    {	      n_bytes_to_skip = offset;	      --n_files;	      ++argv;	    }	}      else if (n_files == 2)	{	  uintmax_t o1, o2;	  if (parse_old_offset (argv[optind], &o1)	      && parse_old_offset (argv[optind + 1], &o2))	    {	      n_bytes_to_skip = o1;	      flag_pseudo_start = 1;	      pseudo_start = o2;	      argv += 2;	      n_files -= 2;	    }	  else if (parse_old_offset (argv[optind + 1], &o2))	    {	      n_bytes_to_skip = o2;	      --n_files;	      argv[optind + 1] = argv[optind];	      ++argv;	    }	  else	    {	      error (0, 0,		     _("invalid second operand in compatibility mode `%s'"),		     argv[optind + 1]);	      usage (EXIT_FAILURE);	    }	}      else if (n_files == 3)	{	  uintmax_t o1, o2;	  if (parse_old_offset (argv[optind + 1], &o1)	      && parse_old_offset (argv[optind + 2], &o2))	    {	      n_bytes_to_skip = o1;	      flag_pseudo_start = 1;	      pseudo_start = o2;	      argv[optind + 2] = argv[optind];	      argv += 2;	      n_files -= 2;	    }	  else	    {	      error (0, 0,	    _("in compatibility mode, the last two arguments must be offsets"));	      usage (EXIT_FAILURE);	    }	}      else if (n_files > 3)	{	  error (0, 0,		 _("compatibility mode supports at most three arguments"));	  usage (EXIT_FAILURE);	}      if (flag_pseudo_start)	{	  if (format_address == format_address_none)	    {	      address_base = 8;	      address_pad_len = 7;	      format_address = format_address_paren;	    }	  else	    format_address = format_address_label;	}    }  if (limit_bytes_to_format)    {      end_offset = n_bytes_to_skip + max_bytes_to_format;      if (end_offset < n_bytes_to_skip)	error (EXIT_FAILURE, 0, "skip-bytes + read-bytes is too large");    }  if (n_specs == 0)    {      if (decode_one_format ("o2", "o2", NULL, &(spec[0])))	{	  /* This happens on Cray systems that don't have a 2-byte	     integral type.  */	  exit (EXIT_FAILURE);	}      n_specs = 1;    }  if (n_files > 0)    {      /* Set the global pointer FILE_LIST so that it	 references the first file-argument on the command-line.  */      file_list = (char const *const *) &argv[optind];    }  else    {      /* No files were listed on the command line.	 Set the global pointer FILE_LIST so that it	 references the null-terminated list of one name: "-".  */      file_list = default_file_list;    }  /* open the first input file */  err |= open_next_file ();  if (in_stream == NULL)    goto cleanup;  /* skip over any unwanted header bytes */  err |= skip (n_bytes_to_skip);  if (in_stream == NULL)    goto cleanup;  pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);  /* Compute output block length.  */  l_c_m = get_lcm ();  if (width_specified)    {      if (desired_width != 0 && desired_width % l_c_m == 0)	bytes_per_block = desired_width;      else	{	  error (0, 0, _("warning: invalid width %lu; using %d instead"),		 (unsigned long) desired_width, l_c_m);	  bytes_per_block = l_c_m;	}    }  else    {      if (l_c_m < DEFAULT_BYTES_PER_BLOCK)	bytes_per_block = l_c_m * (DEFAULT_BYTES_PER_BLOCK / l_c_m);      else	bytes_per_block = l_c_m;    }#ifdef DEBUG  for (i = 0; i < n_specs; i++)    {      printf (_("%d: fmt=\"%s\" width=%d\n"),	      i, spec[i].fmt_string, width_bytes[spec[i].size]);    }#endif  err |= (flag_dump_strings ? dump_strings () : dump ());cleanup:;  if (have_read_stdin && fclose (stdin) == EOF)    error (EXIT_FAILURE, errno, _("standard input"));  exit (err == 0 ? EXIT_SUCCESS : EXIT_FAILURE);}