class TestCase::Operator::Increment {
  use TestCase::Simple;
  use TestCase::Point_3b;
  use TestCase::Point_3s;
  use TestCase::Point_3i;
  use TestCase::Point_3l;
  use TestCase::Point_3f;
  use TestCase::Point_3d;
  use Fn;
  use Array;
  
  our $BYTE_VALUE : byte;
  our $SHORT_VALUE : short;
  our $INT_VALUE : int;
  our $LONG_VALUE : long;
  our $FLOAT_VALUE : float;
  our $DOUBLE_VALUE : double;

  static method post_dec_field_access_invocant_not_var : int () {
    my $nums_of_nums = new TestCase::Minimal[2];
    $nums_of_nums->[1] = TestCase::Minimal->new;
    
    my $ret2 = $nums_of_nums->[1]{x}--;
    
    if ($nums_of_nums->[1]{x} == -1) {
      if ($ret2 == 0) {
        return 1;
      }
    }
    
    return 0;
  }
  
  static method post_dec_element_access_invocant_not_var : int () {
    my $nums_of_nums = new int[][2];
    $nums_of_nums->[1] = new int[1];
    
    my $ret2 = $nums_of_nums->[1][0]--;
    
    if ($nums_of_nums->[1][0] == -1) {
      if ($ret2 == 0) {
        return 1;
      }
    }
    
    return 0;
  }

  static method post_dec_array_field_access_invocant_not_var : int () {
    my $nums_of_nums = new TestCase::Point_3i[][2];
    $nums_of_nums->[1] = new TestCase::Point_3i[1];
    
    my $ret2 = $nums_of_nums->[1][0]{x}--;
    
    if ($nums_of_nums->[1][0]{x} == -1) {
      if ($ret2 == 0) {
        return 1;
      }
    }
    
    return 0;
  }

  static method post_dec_array_field_access_constant_index : int () {
    my $values_point_byte = new TestCase::Point_3b[1];
    my $values_point_short = new TestCase::Point_3s[1];
    my $values_point_int = new TestCase::Point_3i[1];
    my $values_point_long = new TestCase::Point_3l[1];
    my $values_point_float = new TestCase::Point_3f[1];
    my $values_point_double = new TestCase::Point_3d[1];
    
    $values_point_byte->[0]{x} = Fn->INT8_MAX();
    $values_point_short->[0]{x} = Fn->INT16_MAX();
    $values_point_int->[0]{x} = Fn->INT32_MAX();
    $values_point_long->[0]{x} = Fn->INT64_MAX();
    $values_point_float->[0]{x} = Fn->FLT_MAX();
    $values_point_double->[0]{x} = Fn->DBL_MAX();

    my $value_byte2 = $values_point_byte->[0]{x}--;
    my $value_short2 = $values_point_short->[0]{x}--;
    my $value_int2 = $values_point_int->[0]{x}--;
    my $value_long2 = $values_point_long->[0]{x}--;
    my $value_float2 = $values_point_float->[0]{x}--;
    my $value_double2 = $values_point_double->[0]{x}--;
    
    if ($values_point_byte->[0]{x} == Fn->INT8_MAX() - 1) {
      if ($value_byte2 == Fn->INT8_MAX()) {
        if ($values_point_short->[0]{x} == Fn->INT16_MAX() - 1) {
          if ($value_short2 == Fn->INT16_MAX()) {
            if ($values_point_int->[0]{x} == Fn->INT32_MAX() - 1) {
              if ($value_int2 == Fn->INT32_MAX()) {
                if ($values_point_long->[0]{x} == Fn->INT64_MAX() - 1) {
                  if ($value_long2 == Fn->INT64_MAX()) {
                    if ($values_point_float->[0]{x} == Fn->FLT_MAX() - 1) {
                      if ($value_float2 == Fn->FLT_MAX()) {
                        if ($values_point_double->[0]{x} == Fn->DBL_MAX() - 1) {
                          if ($value_double2 = Fn->DBL_MAX()) {
                            return 1;
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }

  static method post_dec_class_var_access : int () {
    $BYTE_VALUE = Fn->INT8_MAX();
    $SHORT_VALUE = Fn->INT16_MAX();
    $INT_VALUE = Fn->INT32_MAX();
    $LONG_VALUE = Fn->INT64_MAX();
    $FLOAT_VALUE = Fn->FLT_MAX();
    $DOUBLE_VALUE = Fn->DBL_MAX();
    
    my $value_byte2 = $BYTE_VALUE--;
    my $value_short2 = $SHORT_VALUE--;
    my $value_int2 = $INT_VALUE--;
    my $value_long2 = $LONG_VALUE--;
    my $value_float2 = $FLOAT_VALUE--;
    my $value_double2 = $DOUBLE_VALUE--;
    
    if ($BYTE_VALUE == Fn->INT8_MAX() - 1) {
      if ($value_byte2 == Fn->INT8_MAX()) {
        if ($SHORT_VALUE == Fn->INT16_MAX() - 1) {
          if ($value_short2 == Fn->INT16_MAX()) {
            if ($INT_VALUE == Fn->INT32_MAX() - 1) {
              if ($value_int2 == Fn->INT32_MAX()) {
                if ($LONG_VALUE == Fn->INT64_MAX() - 1) {
                  if ($value_long2 == Fn->INT64_MAX()) {
                    if ($FLOAT_VALUE == Fn->FLT_MAX() - 1) {
                      if ($value_float2 == Fn->FLT_MAX()) {
                        if ($DOUBLE_VALUE == Fn->DBL_MAX() - 1) {
                          if ($value_double2 = Fn->DBL_MAX()) {
                            return 1;
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }

  static method post_dec_deref : int () {
    my $value_byte = Fn->INT8_MAX();
    my $value_short = Fn->INT16_MAX();
    my $value_int = Fn->INT32_MAX();
    my $value_long = Fn->INT64_MAX();
    my $value_float = Fn->FLT_MAX();
    my $value_double = Fn->DBL_MAX();
    
    my $value_byte_ref = \$value_byte;
    my $value_short_ref = \$value_short;
    my $value_int_ref = \$value_int;
    my $value_long_ref = \$value_long;
    my $value_float_ref = \$value_float;
    my $value_double_ref = \$value_double;
    
    my $value_byte2 = $$value_byte_ref--;
    my $value_short2 = $$value_short_ref--;
    my $value_int2 = $$value_int_ref--;
    my $value_long2 = $$value_long_ref--;
    my $value_float2 = $$value_float_ref--;
    my $value_double2 = $$value_double_ref--;
    
    if ($$value_byte_ref == Fn->INT8_MAX() - 1) {
      if ($value_byte2 == Fn->INT8_MAX()) {
        if ($$value_short_ref == Fn->INT16_MAX() - 1) {
          if ($value_short2 == Fn->INT16_MAX()) {
            if ($$value_int_ref == Fn->INT32_MAX() - 1) {
              if ($value_int2 == Fn->INT32_MAX()) {
                if ($$value_long_ref == Fn->INT64_MAX() - 1) {
                  if ($value_long2 == Fn->INT64_MAX()) {
                    if ($$value_float_ref == Fn->FLT_MAX() - 1) {
                      if ($value_float2 == Fn->FLT_MAX()) {
                        if ($$value_double_ref == Fn->DBL_MAX() - 1) {
                          if ($value_double2 = Fn->DBL_MAX()) {
                            return 1;
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }

  static method post_dec_field_access : int () {
    my $simple = TestCase::Simple->new;
    
    $simple->{byte_value} = Fn->INT8_MAX();
    $simple->{short_value} = Fn->INT16_MAX();
    $simple->{int_value} = Fn->INT32_MAX();
    $simple->{long_value} = Fn->INT64_MAX();
    $simple->{float_value} = Fn->FLT_MAX();
    $simple->{double_value} = Fn->DBL_MAX();

    my $value_byte2 = $simple->{byte_value}--;
    my $value_short2 = $simple->{short_value}--;
    my $value_int2 = $simple->{int_value}--;
    my $value_long2 = $simple->{long_value}--;
    my $value_float2 = $simple->{float_value}--;
    my $value_double2 = $simple->{double_value}--;
    
    if ($simple->{byte_value} == Fn->INT8_MAX() - 1) {
      if ($value_byte2 == Fn->INT8_MAX()) {
        if ($simple->{short_value} == Fn->INT16_MAX() - 1) {
          if ($value_short2 == Fn->INT16_MAX()) {
            if ($simple->{int_value} == Fn->INT32_MAX() - 1) {
              if ($value_int2 == Fn->INT32_MAX()) {
                if ($simple->{long_value} == Fn->INT64_MAX() - 1) {
                  if ($value_long2 == Fn->INT64_MAX()) {
                    if ($simple->{float_value} == Fn->FLT_MAX() - 1) {
                      if ($value_float2 == Fn->FLT_MAX()) {
                        if ($simple->{double_value} == Fn->DBL_MAX() - 1) {
                          if ($value_double2 = Fn->DBL_MAX()) {
                            return 1;
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }

  static method post_dec_element_access_var_index : int () {
    my $values_byte = new byte[1];
    my $values_short = new short[1];
    my $values_int = new int[1];
    my $values_long = new long[1];
    my $values_float = new float[1];
    my $values_double = new double[1];
    
    $values_byte->[0] = Fn->INT8_MAX();
    $values_short->[0] = Fn->INT16_MAX();
    $values_int->[0] = Fn->INT32_MAX();
    $values_long->[0] = Fn->INT64_MAX();
    $values_float->[0] = Fn->FLT_MAX();
    $values_double->[0] = Fn->DBL_MAX();

    my $index = 0;
    my $value_byte2 = $values_byte->[$index]--;
    my $value_short2 = $values_short->[$index]--;
    my $value_int2 = $values_int->[$index]--;
    my $value_long2 = $values_long->[$index]--;
    my $value_float2 = $values_float->[$index]--;
    my $value_double2 = $values_double->[$index]--;
    
    if ($values_byte->[0] == Fn->INT8_MAX() - 1) {
      if ($value_byte2 == Fn->INT8_MAX()) {
        if ($values_short->[0] == Fn->INT16_MAX() - 1) {
          if ($value_short2 == Fn->INT16_MAX()) {
            if ($values_int->[0] == Fn->INT32_MAX() - 1) {
              if ($value_int2 == Fn->INT32_MAX()) {
                if ($values_long->[0] == Fn->INT64_MAX() - 1) {
                  if ($value_long2 == Fn->INT64_MAX()) {
                    if ($values_float->[0] == Fn->FLT_MAX() - 1) {
                      if ($value_float2 == Fn->FLT_MAX()) {
                        if ($values_double->[0] == Fn->DBL_MAX() - 1) {
                          if ($value_double2 = Fn->DBL_MAX()) {
                            return 1;
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }

  static method post_dec_element_access_constant_index : int () {
    my $values_byte = new byte[1];
    my $values_short = new short[1];
    my $values_int = new int[1];
    my $values_long = new long[1];
    my $values_float = new float[1];
    my $values_double = new double[1];
    
    $values_byte->[0] = Fn->INT8_MAX();
    $values_short->[0] = Fn->INT16_MAX();
    $values_int->[0] = Fn->INT32_MAX();
    $values_long->[0] = Fn->INT64_MAX();
    $values_float->[0] = Fn->FLT_MAX();
    $values_double->[0] = Fn->DBL_MAX();

    my $value_byte2 = $values_byte->[0]--;
    my $value_short2 = $values_short->[0]--;
    my $value_int2 = $values_int->[0]--;
    my $value_long2 = $values_long->[0]--;
    my $value_float2 = $values_float->[0]--;
    my $value_double2 = $values_double->[0]--;
    
    if ($values_byte->[0] == Fn->INT8_MAX() - 1) {
      if ($value_byte2 == Fn->INT8_MAX()) {
        if ($values_short->[0] == Fn->INT16_MAX() - 1) {
          if ($value_short2 == Fn->INT16_MAX()) {
            if ($values_int->[0] == Fn->INT32_MAX() - 1) {
              if ($value_int2 == Fn->INT32_MAX()) {
                if ($values_long->[0] == Fn->INT64_MAX() - 1) {
                  if ($value_long2 == Fn->INT64_MAX()) {
                    if ($values_float->[0] == Fn->FLT_MAX() - 1) {
                      if ($value_float2 == Fn->FLT_MAX()) {
                        if ($values_double->[0] == Fn->DBL_MAX() - 1) {
                          if ($value_double2 = Fn->DBL_MAX()) {
                            return 1;
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }

  static method post_dec_var : int () {
    my $value_byte = Fn->INT8_MAX();
    my $value_short = Fn->INT16_MAX();
    my $value_int = Fn->INT32_MAX();
    my $value_long = Fn->INT64_MAX();
    my $value_float = Fn->FLT_MAX();
    my $value_double = Fn->DBL_MAX();
    
    my $value_byte2 = $value_byte--;
    my $value_short2 = $value_short--;
    my $value_int2 = $value_int--;
    my $value_long2 = $value_long--;
    my $value_float2 = $value_float--;
    my $value_double2 = $value_double--;
    
    if ($value_byte == Fn->INT8_MAX() - 1) {
      if ($value_byte2 == Fn->INT8_MAX()) {
        if ($value_short == Fn->INT16_MAX() - 1) {
          if ($value_short2 == Fn->INT16_MAX()) {
            if ($value_int == Fn->INT32_MAX() - 1) {
              if ($value_int2 == Fn->INT32_MAX()) {
                if ($value_long == Fn->INT64_MAX() - 1) {
                  if ($value_long2 == Fn->INT64_MAX()) {
                    if ($value_float == Fn->FLT_MAX() - 1) {
                      if ($value_float2 = Fn->FLT_MAX()) {
                        if ($value_double == Fn->DBL_MAX() - 1) {
                          if ($value_double2 == Fn->DBL_MAX()) {
                            return 1;
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }

  static method post_inc_field_access_invocant_not_var : int () {
    my $nums_of_nums = new TestCase::Minimal[2];
    $nums_of_nums->[1] = TestCase::Minimal->new;
    
    my $ret2 = $nums_of_nums->[1]{x}++;
    
    if ($nums_of_nums->[1]{x} == 1) {
      if ($ret2 == 0) {
        return 1;
      }
    }
    
    return 0;
  }
  
  static method post_inc_element_access_invocant_not_var : int () {
    my $nums_of_nums = new int[][2];
    $nums_of_nums->[1] = new int[1];
    
    my $ret2 = $nums_of_nums->[1][0]++;
    
    if ($nums_of_nums->[1][0] == 1) {
      if ($ret2 == 0) {
        return 1;
      }
    }
    
    return 0;
  }

  static method post_inc_array_field_access_invocant_not_var : int () {
    my $nums_of_nums = new TestCase::Point_3i[][2];
    $nums_of_nums->[1] = new TestCase::Point_3i[1];
    
    my $ret2 = $nums_of_nums->[1][0]{x}++;
    
    if ($nums_of_nums->[1][0]{x} == 1) {
      if ($ret2 == 0) {
        return 1;
      }
    }
    
    return 0;
  }

  static method post_inc_array_field_access_constant_index : int () {
    my $values_point_byte = new TestCase::Point_3b[1];
    my $values_point_short = new TestCase::Point_3s[1];
    my $values_point_int = new TestCase::Point_3i[1];
    my $values_point_long = new TestCase::Point_3l[1];
    my $values_point_float = new TestCase::Point_3f[1];
    my $values_point_double = new TestCase::Point_3d[1];
    
    $values_point_byte->[0]{x} = Fn->INT8_MIN();
    $values_point_short->[0]{x} = Fn->INT16_MIN();
    $values_point_int->[0]{x} = Fn->INT32_MIN();
    $values_point_long->[0]{x} = Fn->INT64_MIN();
    $values_point_float->[0]{x} = Fn->FLT_MIN();
    $values_point_double->[0]{x} = Fn->DBL_MIN();

    my $value_byte2 = $values_point_byte->[0]{x}++;
    my $value_short2 = $values_point_short->[0]{x}++;
    my $value_int2 = $values_point_int->[0]{x}++;
    my $value_long2 = $values_point_long->[0]{x}++;
    my $value_float2 = $values_point_float->[0]{x}++;
    my $value_double2 = $values_point_double->[0]{x}++;
    
    if ($values_point_byte->[0]{x} == Fn->INT8_MIN() + 1) {
      if ($value_byte2 == Fn->INT8_MIN()) {
        if ($values_point_short->[0]{x} == Fn->INT16_MIN() + 1) {
          if ($value_short2 == Fn->INT16_MIN()) {
            if ($values_point_int->[0]{x} == Fn->INT32_MIN() + 1) {
              if ($value_int2 == Fn->INT32_MIN()) {
                if ($values_point_long->[0]{x} == Fn->INT64_MIN() + 1) {
                  if ($value_long2 == Fn->INT64_MIN()) {
                    if ($values_point_float->[0]{x} == Fn->FLT_MIN() + 1) {
                      if ($value_float2 == Fn->FLT_MIN()) {
                        if ($values_point_double->[0]{x} == Fn->DBL_MIN() + 1) {
                          if ($value_double2 = Fn->DBL_MIN()) {
                            return 1;
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }

  static method post_inc_class_var_access : int () {
    $BYTE_VALUE = Fn->INT8_MIN();
    $SHORT_VALUE = Fn->INT16_MIN();
    $INT_VALUE = Fn->INT32_MIN();
    $LONG_VALUE = Fn->INT64_MIN();
    $FLOAT_VALUE = Fn->FLT_MIN();
    $DOUBLE_VALUE = Fn->DBL_MIN();
    
    my $value_byte2 = $BYTE_VALUE++;
    my $value_short2 = $SHORT_VALUE++;
    my $value_int2 = $INT_VALUE++;
    my $value_long2 = $LONG_VALUE++;
    my $value_float2 = $FLOAT_VALUE++;
    my $value_double2 = $DOUBLE_VALUE++;
    
    if ($BYTE_VALUE == Fn->INT8_MIN() + 1) {
      if ($value_byte2 == Fn->INT8_MIN()) {
        if ($SHORT_VALUE == Fn->INT16_MIN() + 1) {
          if ($value_short2 == Fn->INT16_MIN()) {
            if ($INT_VALUE == Fn->INT32_MIN() + 1) {
              if ($value_int2 == Fn->INT32_MIN()) {
                if ($LONG_VALUE == Fn->INT64_MIN() + 1) {
                  if ($value_long2 == Fn->INT64_MIN()) {
                    if ($FLOAT_VALUE == Fn->FLT_MIN() + 1) {
                      if ($value_float2 == Fn->FLT_MIN()) {
                        if ($DOUBLE_VALUE == Fn->DBL_MIN() + 1) {
                          if ($value_double2 = Fn->DBL_MIN()) {
                            return 1;
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }

  static method post_inc_deref : int () {
    my $value_byte = Fn->INT8_MIN();
    my $value_short = Fn->INT16_MIN();
    my $value_int = Fn->INT32_MIN();
    my $value_long = Fn->INT64_MIN();
    my $value_float = Fn->FLT_MIN();
    my $value_double = Fn->DBL_MIN();
    
    my $value_byte_ref = \$value_byte;
    my $value_short_ref = \$value_short;
    my $value_int_ref = \$value_int;
    my $value_long_ref = \$value_long;
    my $value_float_ref = \$value_float;
    my $value_double_ref = \$value_double;
    
    my $value_byte2 = $$value_byte_ref++;
    my $value_short2 = $$value_short_ref++;
    my $value_int2 = $$value_int_ref++;
    my $value_long2 = $$value_long_ref++;
    my $value_float2 = $$value_float_ref++;
    my $value_double2 = $$value_double_ref++;
    
    if ($$value_byte_ref == Fn->INT8_MIN() + 1) {
      if ($value_byte2 == Fn->INT8_MIN()) {
        if ($$value_short_ref == Fn->INT16_MIN() + 1) {
          if ($value_short2 == Fn->INT16_MIN()) {
            if ($$value_int_ref == Fn->INT32_MIN() + 1) {
              if ($value_int2 == Fn->INT32_MIN()) {
                if ($$value_long_ref == Fn->INT64_MIN() + 1) {
                  if ($value_long2 == Fn->INT64_MIN()) {
                    if ($$value_float_ref == Fn->FLT_MIN() + 1) {
                      if ($value_float2 == Fn->FLT_MIN()) {
                        if ($$value_double_ref == Fn->DBL_MIN() + 1) {
                          if ($value_double2 = Fn->DBL_MIN()) {
                            return 1;
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }

  static method post_inc_field_access : int () {
    my $simple = TestCase::Simple->new;
    
    $simple->{byte_value} = Fn->INT8_MIN();
    $simple->{short_value} = Fn->INT16_MIN();
    $simple->{int_value} = Fn->INT32_MIN();
    $simple->{long_value} = Fn->INT64_MIN();
    $simple->{float_value} = Fn->FLT_MIN();
    $simple->{double_value} = Fn->DBL_MIN();

    my $value_byte2 = $simple->{byte_value}++;
    my $value_short2 = $simple->{short_value}++;
    my $value_int2 = $simple->{int_value}++;
    my $value_long2 = $simple->{long_value}++;
    my $value_float2 = $simple->{float_value}++;
    my $value_double2 = $simple->{double_value}++;
    
    if ($simple->{byte_value} == Fn->INT8_MIN() + 1) {
      if ($value_byte2 == Fn->INT8_MIN()) {
        if ($simple->{short_value} == Fn->INT16_MIN() + 1) {
          if ($value_short2 == Fn->INT16_MIN()) {
            if ($simple->{int_value} == Fn->INT32_MIN() + 1) {
              if ($value_int2 == Fn->INT32_MIN()) {
                if ($simple->{long_value} == Fn->INT64_MIN() + 1) {
                  if ($value_long2 == Fn->INT64_MIN()) {
                    if ($simple->{float_value} == Fn->FLT_MIN() + 1) {
                      if ($value_float2 == Fn->FLT_MIN()) {
                        if ($simple->{double_value} == Fn->DBL_MIN() + 1) {
                          if ($value_double2 = Fn->DBL_MIN()) {
                            return 1;
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }

  static method post_inc_element_access_var_index : int () {
    my $values_byte = new byte[1];
    my $values_short = new short[1];
    my $values_int = new int[1];
    my $values_long = new long[1];
    my $values_float = new float[1];
    my $values_double = new double[1];
    
    $values_byte->[0] = Fn->INT8_MIN();
    $values_short->[0] = Fn->INT16_MIN();
    $values_int->[0] = Fn->INT32_MIN();
    $values_long->[0] = Fn->INT64_MIN();
    $values_float->[0] = Fn->FLT_MIN();
    $values_double->[0] = Fn->DBL_MIN();

    my $index = 0;
    my $value_byte2 = $values_byte->[$index]++;
    my $value_short2 = $values_short->[$index]++;
    my $value_int2 = $values_int->[$index]++;
    my $value_long2 = $values_long->[$index]++;
    my $value_float2 = $values_float->[$index]++;
    my $value_double2 = $values_double->[$index]++;
    
    if ($values_byte->[0] == Fn->INT8_MIN() + 1) {
      if ($value_byte2 == Fn->INT8_MIN()) {
        if ($values_short->[0] == Fn->INT16_MIN() + 1) {
          if ($value_short2 == Fn->INT16_MIN()) {
            if ($values_int->[0] == Fn->INT32_MIN() + 1) {
              if ($value_int2 == Fn->INT32_MIN()) {
                if ($values_long->[0] == Fn->INT64_MIN() + 1) {
                  if ($value_long2 == Fn->INT64_MIN()) {
                    if ($values_float->[0] == Fn->FLT_MIN() + 1) {
                      if ($value_float2 == Fn->FLT_MIN()) {
                        if ($values_double->[0] == Fn->DBL_MIN() + 1) {
                          if ($value_double2 = Fn->DBL_MIN()) {
                            return 1;
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }

  static method post_inc_element_access_constant_index : int () {
    my $values_byte = new byte[1];
    my $values_short = new short[1];
    my $values_int = new int[1];
    my $values_long = new long[1];
    my $values_float = new float[1];
    my $values_double = new double[1];
    
    $values_byte->[0] = Fn->INT8_MIN();
    $values_short->[0] = Fn->INT16_MIN();
    $values_int->[0] = Fn->INT32_MIN();
    $values_long->[0] = Fn->INT64_MIN();
    $values_float->[0] = Fn->FLT_MIN();
    $values_double->[0] = Fn->DBL_MIN();

    my $value_byte2 = $values_byte->[0]++;
    my $value_short2 = $values_short->[0]++;
    my $value_int2 = $values_int->[0]++;
    my $value_long2 = $values_long->[0]++;
    my $value_float2 = $values_float->[0]++;
    my $value_double2 = $values_double->[0]++;
    
    if ($values_byte->[0] == Fn->INT8_MIN() + 1) {
      if ($value_byte2 == Fn->INT8_MIN()) {
        if ($values_short->[0] == Fn->INT16_MIN() + 1) {
          if ($value_short2 == Fn->INT16_MIN()) {
            if ($values_int->[0] == Fn->INT32_MIN() + 1) {
              if ($value_int2 == Fn->INT32_MIN()) {
                if ($values_long->[0] == Fn->INT64_MIN() + 1) {
                  if ($value_long2 == Fn->INT64_MIN()) {
                    if ($values_float->[0] == Fn->FLT_MIN() + 1) {
                      if ($value_float2 == Fn->FLT_MIN()) {
                        if ($values_double->[0] == Fn->DBL_MIN() + 1) {
                          if ($value_double2 = Fn->DBL_MIN()) {
                            return 1;
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }

  static method post_inc_var : int () {
    my $value_byte = Fn->INT8_MIN();
    my $value_short = Fn->INT16_MIN();
    my $value_int = Fn->INT32_MIN();
    my $value_long = Fn->INT64_MIN();
    my $value_float = Fn->FLT_MIN();
    my $value_double = Fn->DBL_MIN();
    
    my $value_byte2 = $value_byte++;
    my $value_short2 = $value_short++;
    my $value_int2 = $value_int++;
    my $value_long2 = $value_long++;
    my $value_float2 = $value_float++;
    my $value_double2 = $value_double++;
    
    if ($value_byte == Fn->INT8_MIN() + 1) {
      if ($value_byte2 == Fn->INT8_MIN()) {
        if ($value_short == Fn->INT16_MIN() + 1) {
          if ($value_short2 == Fn->INT16_MIN()) {
            if ($value_int == Fn->INT32_MIN() + 1) {
              if ($value_int2 == Fn->INT32_MIN()) {
                if ($value_long == Fn->INT64_MIN() + 1) {
                  if ($value_long2 == Fn->INT64_MIN()) {
                    if ($value_float == Fn->FLT_MIN() + 1) {
                      if ($value_float2 = Fn->FLT_MIN()) {
                        if ($value_double == Fn->DBL_MIN() + 1) {
                          if ($value_double2 == Fn->DBL_MIN()) {
                            return 1;
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }

  static method pre_dec_field_access_invocant_not_var : int () {
    my $nums_of_nums = new TestCase::Minimal[2];
    $nums_of_nums->[0] = TestCase::Minimal->new;
    
    my $ret1 = --$nums_of_nums->[0]{x};
    
    if ($nums_of_nums->[0]{x} == -1) {
      if ($ret1 == -1) {
        return 1;
      }
    }
    
    return 0;
  }
  
  static method pre_dec_element_access_invocant_not_var : int () {
    my $nums_of_nums = new int[][2];
    $nums_of_nums->[0] = new int[1];
    
    my $ret1 = --$nums_of_nums->[0][0];
    
    if ($nums_of_nums->[0][0] == -1) {
      if ($ret1 == -1) {
        return 1;
      }
    }
    
    return 0;
  }

  static method pre_dec_array_field_access_invocant_not_var : int () {
    my $nums_of_nums = new TestCase::Point_3i[][2];
    $nums_of_nums->[0] = new TestCase::Point_3i[1];
    
    my $ret1 = --$nums_of_nums->[0][0]{x};
    
    if ($nums_of_nums->[0][0]{x} == -1) {
      if ($ret1 == -1) {
        return 1;
      }
    }
    
    return 0;
  }

  static method pre_dec_array_field_access_constant_index : int () {
    my $values_point_byte = new TestCase::Point_3b[1];
    my $values_point_short = new TestCase::Point_3s[1];
    my $values_point_int = new TestCase::Point_3i[1];
    my $values_point_long = new TestCase::Point_3l[1];
    my $values_point_float = new TestCase::Point_3f[1];
    my $values_point_double = new TestCase::Point_3d[1];
    
    $values_point_byte->[0]{x} = Fn->INT8_MAX();
    $values_point_short->[0]{x} = Fn->INT16_MAX();
    $values_point_int->[0]{x} = Fn->INT32_MAX();
    $values_point_long->[0]{x} = Fn->INT64_MAX();
    $values_point_float->[0]{x} = Fn->FLT_MAX();
    $values_point_double->[0]{x} = Fn->DBL_MAX();

    my $value_byte2 = --$values_point_byte->[0]{x};
    my $value_short2 = --$values_point_short->[0]{x};
    my $value_int2 = --$values_point_int->[0]{x};
    my $value_long2 = --$values_point_long->[0]{x};
    my $value_float2 = --$values_point_float->[0]{x};
    my $value_double2 = --$values_point_double->[0]{x};
    
    if ($values_point_byte->[0]{x} == Fn->INT8_MAX() - 1) {
      if ($value_byte2 == Fn->INT8_MAX() - 1) {
        if ($values_point_short->[0]{x} == Fn->INT16_MAX() - 1) {
          if ($value_short2 == Fn->INT16_MAX() - 1) {
            if ($values_point_int->[0]{x} == Fn->INT32_MAX() - 1) {
              if ($value_int2 == Fn->INT32_MAX() - 1) {
                if ($values_point_long->[0]{x} == Fn->INT64_MAX() - 1) {
                  if ($value_long2 == Fn->INT64_MAX() - 1) {
                    if ($values_point_float->[0]{x} == Fn->FLT_MAX() - 1) {
                      if ($value_float2 == Fn->FLT_MAX() - 1) {
                        if ($values_point_double->[0]{x} == Fn->DBL_MAX() - 1) {
                          if ($value_double2 = Fn->DBL_MAX() - 1) {
                            return 1;
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }

  static method pre_dec_class_var_access : int () {
    $BYTE_VALUE = Fn->INT8_MAX();
    $SHORT_VALUE = Fn->INT16_MAX();
    $INT_VALUE = Fn->INT32_MAX();
    $LONG_VALUE = Fn->INT64_MAX();
    $FLOAT_VALUE = Fn->FLT_MAX();
    $DOUBLE_VALUE = Fn->DBL_MAX();
    
    my $value_byte2 = --$BYTE_VALUE;
    my $value_short2 = --$SHORT_VALUE;
    my $value_int2 = --$INT_VALUE;
    my $value_long2 = --$LONG_VALUE;
    my $value_float2 = --$FLOAT_VALUE;
    my $value_double2 = --$DOUBLE_VALUE;
    
    if ($BYTE_VALUE == Fn->INT8_MAX() - 1) {
      if ($value_byte2 == Fn->INT8_MAX() - 1) {
        if ($SHORT_VALUE == Fn->INT16_MAX() - 1) {
          if ($value_short2 == Fn->INT16_MAX() - 1) {
            if ($INT_VALUE == Fn->INT32_MAX() - 1) {
              if ($value_int2 == Fn->INT32_MAX() - 1) {
                if ($LONG_VALUE == Fn->INT64_MAX() - 1) {
                  if ($value_long2 == Fn->INT64_MAX() - 1) {
                    if ($FLOAT_VALUE == Fn->FLT_MAX() - 1) {
                      if ($value_float2 == Fn->FLT_MAX() - 1) {
                        if ($DOUBLE_VALUE == Fn->DBL_MAX() - 1) {
                          if ($value_double2 = Fn->DBL_MAX() - 1) {
                            return 1;
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }

  static method pre_dec_deref : int () {
    my $value_byte = Fn->INT8_MAX();
    my $value_short = Fn->INT16_MAX();
    my $value_int = Fn->INT32_MAX();
    my $value_long = Fn->INT64_MAX();
    my $value_float = Fn->FLT_MAX();
    my $value_double = Fn->DBL_MAX();
    
    my $value_byte_ref = \$value_byte;
    my $value_short_ref = \$value_short;
    my $value_int_ref = \$value_int;
    my $value_long_ref = \$value_long;
    my $value_float_ref = \$value_float;
    my $value_double_ref = \$value_double;
    
    my $value_byte2 = --$$value_byte_ref;
    my $value_short2 = --$$value_short_ref;
    my $value_int2 = --$$value_int_ref;
    my $value_long2 = --$$value_long_ref;
    my $value_float2 = --$$value_float_ref;
    my $value_double2 = --$$value_double_ref;
    
    if ($$value_byte_ref == Fn->INT8_MAX() - 1) {
      if ($value_byte2 == Fn->INT8_MAX() - 1) {
        if ($$value_short_ref == Fn->INT16_MAX() - 1) {
          if ($value_short2 == Fn->INT16_MAX() - 1) {
            if ($$value_int_ref == Fn->INT32_MAX() - 1) {
              if ($value_int2 == Fn->INT32_MAX() - 1) {
                if ($$value_long_ref == Fn->INT64_MAX() - 1) {
                  if ($value_long2 == Fn->INT64_MAX() - 1) {
                    if ($$value_float_ref == Fn->FLT_MAX() - 1) {
                      if ($value_float2 == Fn->FLT_MAX() - 1) {
                        if ($$value_double_ref == Fn->DBL_MAX() - 1) {
                          if ($value_double2 = Fn->DBL_MAX() - 1) {
                            return 1;
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }

  static method pre_dec_field_access : int () {
    my $simple = TestCase::Simple->new;
    
    $simple->{byte_value} = Fn->INT8_MAX();
    $simple->{short_value} = Fn->INT16_MAX();
    $simple->{int_value} = Fn->INT32_MAX();
    $simple->{long_value} = Fn->INT64_MAX();
    $simple->{float_value} = Fn->FLT_MAX();
    $simple->{double_value} = Fn->DBL_MAX();

    my $value_byte2 = --$simple->{byte_value};
    my $value_short2 = --$simple->{short_value};
    my $value_int2 = --$simple->{int_value};
    my $value_long2 = --$simple->{long_value};
    my $value_float2 = --$simple->{float_value};
    my $value_double2 = --$simple->{double_value};
    
    if ($simple->{byte_value} == Fn->INT8_MAX() - 1) {
      if ($value_byte2 == Fn->INT8_MAX() - 1) {
        if ($simple->{short_value} == Fn->INT16_MAX() - 1) {
          if ($value_short2 == Fn->INT16_MAX() - 1) {
            if ($simple->{int_value} == Fn->INT32_MAX() - 1) {
              if ($value_int2 == Fn->INT32_MAX() - 1) {
                if ($simple->{long_value} == Fn->INT64_MAX() - 1) {
                  if ($value_long2 == Fn->INT64_MAX() - 1) {
                    if ($simple->{float_value} == Fn->FLT_MAX() - 1) {
                      if ($value_float2 == Fn->FLT_MAX() - 1) {
                        if ($simple->{double_value} == Fn->DBL_MAX() - 1) {
                          if ($value_double2 = Fn->DBL_MAX() - 1) {
                            return 1;
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }

  static method pre_dec_element_access_var_index : int () {
    my $values_byte = new byte[1];
    my $values_short = new short[1];
    my $values_int = new int[1];
    my $values_long = new long[1];
    my $values_float = new float[1];
    my $values_double = new double[1];
    
    $values_byte->[0] = Fn->INT8_MAX();
    $values_short->[0] = Fn->INT16_MAX();
    $values_int->[0] = Fn->INT32_MAX();
    $values_long->[0] = Fn->INT64_MAX();
    $values_float->[0] = Fn->FLT_MAX();
    $values_double->[0] = Fn->DBL_MAX();

    my $index = 0;
    my $value_byte2 = --$values_byte->[$index];
    my $value_short2 = --$values_short->[$index];
    my $value_int2 = --$values_int->[$index];
    my $value_long2 = --$values_long->[$index];
    my $value_float2 = --$values_float->[$index];
    my $value_double2 = --$values_double->[$index];
    
    if ($values_byte->[0] == Fn->INT8_MAX() - 1) {
      if ($value_byte2 == Fn->INT8_MAX() - 1) {
        if ($values_short->[0] == Fn->INT16_MAX() - 1) {
          if ($value_short2 == Fn->INT16_MAX() - 1) {
            if ($values_int->[0] == Fn->INT32_MAX() - 1) {
              if ($value_int2 == Fn->INT32_MAX() - 1) {
                if ($values_long->[0] == Fn->INT64_MAX() - 1) {
                  if ($value_long2 == Fn->INT64_MAX() - 1) {
                    if ($values_float->[0] == Fn->FLT_MAX() - 1) {
                      if ($value_float2 == Fn->FLT_MAX() - 1) {
                        if ($values_double->[0] == Fn->DBL_MAX() - 1) {
                          if ($value_double2 = Fn->DBL_MAX() - 1) {
                            return 1;
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }

  static method pre_dec_element_access_constant_index : int () {
    my $values_byte = new byte[1];
    my $values_short = new short[1];
    my $values_int = new int[1];
    my $values_long = new long[1];
    my $values_float = new float[1];
    my $values_double = new double[1];
    
    $values_byte->[0] = Fn->INT8_MAX();
    $values_short->[0] = Fn->INT16_MAX();
    $values_int->[0] = Fn->INT32_MAX();
    $values_long->[0] = Fn->INT64_MAX();
    $values_float->[0] = Fn->FLT_MAX();
    $values_double->[0] = Fn->DBL_MAX();

    my $value_byte2 = --$values_byte->[0];
    my $value_short2 = --$values_short->[0];
    my $value_int2 = --$values_int->[0];
    my $value_long2 = --$values_long->[0];
    my $value_float2 = --$values_float->[0];
    my $value_double2 = --$values_double->[0];
    
    if ($values_byte->[0] == Fn->INT8_MAX() - 1) {
      if ($value_byte2 == Fn->INT8_MAX() - 1) {
        if ($values_short->[0] == Fn->INT16_MAX() - 1) {
          if ($value_short2 == Fn->INT16_MAX() - 1) {
            if ($values_int->[0] == Fn->INT32_MAX() - 1) {
              if ($value_int2 == Fn->INT32_MAX() - 1) {
                if ($values_long->[0] == Fn->INT64_MAX() - 1) {
                  if ($value_long2 == Fn->INT64_MAX() - 1) {
                    if ($values_float->[0] == Fn->FLT_MAX() - 1) {
                      if ($value_float2 == Fn->FLT_MAX() - 1) {
                        if ($values_double->[0] == Fn->DBL_MAX() - 1) {
                          if ($value_double2 = Fn->DBL_MAX() - 1) {
                            return 1;
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }

  static method pre_dec_var : int () {
    my $value_byte = Fn->INT8_MAX();
    my $value_short = Fn->INT16_MAX();
    my $value_int = Fn->INT32_MAX();
    my $value_long = Fn->INT64_MAX();
    my $value_float = Fn->FLT_MAX();
    my $value_double = Fn->DBL_MAX();
    
    my $value_byte2 = --$value_byte;
    my $value_short2 = --$value_short;
    my $value_int2 = --$value_int;
    my $value_long2 = --$value_long;
    my $value_float2 = --$value_float;
    my $value_double2 = --$value_double;
    
    
    if ($value_byte == Fn->INT8_MAX() - 1) {
      if ($value_byte2 == Fn->INT8_MAX() - 1) {
        if ($value_short == Fn->INT16_MAX() - 1) {
          if ($value_short2 == Fn->INT16_MAX() - 1) {
            if ($value_int == Fn->INT32_MAX() - 1) {
              if ($value_int2 == Fn->INT32_MAX() - 1) {
                if ($value_long == Fn->INT64_MAX() - 1) {
                  if ($value_long2 == Fn->INT64_MAX() - 1) {
                    if ($value_float == Fn->FLT_MAX() - 1) {
                      if ($value_float2 == Fn->FLT_MAX() - 1) {
                        if ($value_double == Fn->DBL_MAX() - 1) {
                          if ($value_double2 = Fn->DBL_MAX() - 1) {
                            return 1;
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }

  static method pre_inc_field_access_invocant_not_var : int () {
    my $nums_of_nums = new TestCase::Minimal[2];
    $nums_of_nums->[0] = TestCase::Minimal->new;
    
    my $ret1 = ++$nums_of_nums->[0]{x};
    
    if ($nums_of_nums->[0]{x} == 1) {
      if ($ret1 == 1) {
        return 1;
      }
    }
    
    return 0;
  }
  
  static method pre_inc_element_access_invocant_not_var : int () {
    my $nums_of_nums = new int[][2];
    $nums_of_nums->[0] = new int[1];
    
    my $ret1 = ++$nums_of_nums->[0][0];
    
    if ($nums_of_nums->[0][0] == 1) {
      if ($ret1 == 1) {
        return 1;
      }
    }
    
    return 0;
  }

  static method pre_inc_array_field_access_invocant_not_var : int () {
    my $nums_of_nums = new TestCase::Point_3i[][2];
    $nums_of_nums->[0] = new TestCase::Point_3i[1];
    
    my $ret1 = ++$nums_of_nums->[0][0]{x};
    
    if ($nums_of_nums->[0][0]{x} == 1) {
      if ($ret1 == 1) {
        return 1;
      }
    }
    
    return 0;
  }

  static method pre_inc_array_field_access_constant_index : int () {
    my $values_point_byte = new TestCase::Point_3b[1];
    my $values_point_short = new TestCase::Point_3s[1];
    my $values_point_int = new TestCase::Point_3i[1];
    my $values_point_long = new TestCase::Point_3l[1];
    my $values_point_float = new TestCase::Point_3f[1];
    my $values_point_double = new TestCase::Point_3d[1];
    
    $values_point_byte->[0]{x} = Fn->INT8_MIN();
    $values_point_short->[0]{x} = Fn->INT16_MIN();
    $values_point_int->[0]{x} = Fn->INT32_MIN();
    $values_point_long->[0]{x} = Fn->INT64_MIN();
    $values_point_float->[0]{x} = Fn->FLT_MIN();
    $values_point_double->[0]{x} = Fn->DBL_MIN();

    my $value_byte2 = ++$values_point_byte->[0]{x};
    my $value_short2 = ++$values_point_short->[0]{x};
    my $value_int2 = ++$values_point_int->[0]{x};
    my $value_long2 = ++$values_point_long->[0]{x};
    my $value_float2 = ++$values_point_float->[0]{x};
    my $value_double2 = ++$values_point_double->[0]{x};
    
    if ($values_point_byte->[0]{x} == Fn->INT8_MIN() + 1) {
      if ($value_byte2 == Fn->INT8_MIN() + 1) {
        if ($values_point_short->[0]{x} == Fn->INT16_MIN() + 1) {
          if ($value_short2 == Fn->INT16_MIN() + 1) {
            if ($values_point_int->[0]{x} == Fn->INT32_MIN() + 1) {
              if ($value_int2 == Fn->INT32_MIN() + 1) {
                if ($values_point_long->[0]{x} == Fn->INT64_MIN() + 1) {
                  if ($value_long2 == Fn->INT64_MIN() + 1) {
                    if ($values_point_float->[0]{x} == Fn->FLT_MIN() + 1) {
                      if ($value_float2 == Fn->FLT_MIN() + 1) {
                        if ($values_point_double->[0]{x} == Fn->DBL_MIN() + 1) {
                          if ($value_double2 = Fn->DBL_MIN() + 1) {
                            return 1;
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }

  static method pre_inc_class_var_access : int () {
    $BYTE_VALUE = Fn->INT8_MIN();
    $SHORT_VALUE = Fn->INT16_MIN();
    $INT_VALUE = Fn->INT32_MIN();
    $LONG_VALUE = Fn->INT64_MIN();
    $FLOAT_VALUE = Fn->FLT_MIN();
    $DOUBLE_VALUE = Fn->DBL_MIN();
    
    my $value_byte2 = ++$BYTE_VALUE;
    my $value_short2 = ++$SHORT_VALUE;
    my $value_int2 = ++$INT_VALUE;
    my $value_long2 = ++$LONG_VALUE;
    my $value_float2 = ++$FLOAT_VALUE;
    my $value_double2 = ++$DOUBLE_VALUE;
    
    if ($BYTE_VALUE == Fn->INT8_MIN() + 1) {
      if ($value_byte2 == Fn->INT8_MIN() + 1) {
        if ($SHORT_VALUE == Fn->INT16_MIN() + 1) {
          if ($value_short2 == Fn->INT16_MIN() + 1) {
            if ($INT_VALUE == Fn->INT32_MIN() + 1) {
              if ($value_int2 == Fn->INT32_MIN() + 1) {
                if ($LONG_VALUE == Fn->INT64_MIN() + 1) {
                  if ($value_long2 == Fn->INT64_MIN() + 1) {
                    if ($FLOAT_VALUE == Fn->FLT_MIN() + 1) {
                      if ($value_float2 == Fn->FLT_MIN() + 1) {
                        if ($DOUBLE_VALUE == Fn->DBL_MIN() + 1) {
                          if ($value_double2 = Fn->DBL_MIN() + 1) {
                            return 1;
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }

  static method pre_inc_deref : int () {
    my $value_byte = Fn->INT8_MIN();
    my $value_short = Fn->INT16_MIN();
    my $value_int = Fn->INT32_MIN();
    my $value_long = Fn->INT64_MIN();
    my $value_float = Fn->FLT_MIN();
    my $value_double = Fn->DBL_MIN();
    
    my $value_byte_ref = \$value_byte;
    my $value_short_ref = \$value_short;
    my $value_int_ref = \$value_int;
    my $value_long_ref = \$value_long;
    my $value_float_ref = \$value_float;
    my $value_double_ref = \$value_double;
    
    my $value_byte2 = ++$$value_byte_ref;
    my $value_short2 = ++$$value_short_ref;
    my $value_int2 = ++$$value_int_ref;
    my $value_long2 = ++$$value_long_ref;
    my $value_float2 = ++$$value_float_ref;
    my $value_double2 = ++$$value_double_ref;
    
    if ($$value_byte_ref == Fn->INT8_MIN() + 1) {
      if ($value_byte2 == Fn->INT8_MIN() + 1) {
        if ($$value_short_ref == Fn->INT16_MIN() + 1) {
          if ($value_short2 == Fn->INT16_MIN() + 1) {
            if ($$value_int_ref == Fn->INT32_MIN() + 1) {
              if ($value_int2 == Fn->INT32_MIN() + 1) {
                if ($$value_long_ref == Fn->INT64_MIN() + 1) {
                  if ($value_long2 == Fn->INT64_MIN() + 1) {
                    if ($$value_float_ref == Fn->FLT_MIN() + 1) {
                      if ($value_float2 == Fn->FLT_MIN() + 1) {
                        if ($$value_double_ref == Fn->DBL_MIN() + 1) {
                          if ($value_double2 = Fn->DBL_MIN() + 1) {
                            return 1;
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }

  static method pre_inc_field_access : int () {
    my $simple = TestCase::Simple->new;
    
    $simple->{byte_value} = Fn->INT8_MIN();
    $simple->{short_value} = Fn->INT16_MIN();
    $simple->{int_value} = Fn->INT32_MIN();
    $simple->{long_value} = Fn->INT64_MIN();
    $simple->{float_value} = Fn->FLT_MIN();
    $simple->{double_value} = Fn->DBL_MIN();

    my $value_byte2 = ++$simple->{byte_value};
    my $value_short2 = ++$simple->{short_value};
    my $value_int2 = ++$simple->{int_value};
    my $value_long2 = ++$simple->{long_value};
    my $value_float2 = ++$simple->{float_value};
    my $value_double2 = ++$simple->{double_value};
    
    if ($simple->{byte_value} == Fn->INT8_MIN() + 1) {
      if ($value_byte2 == Fn->INT8_MIN() + 1) {
        if ($simple->{short_value} == Fn->INT16_MIN() + 1) {
          if ($value_short2 == Fn->INT16_MIN() + 1) {
            if ($simple->{int_value} == Fn->INT32_MIN() + 1) {
              if ($value_int2 == Fn->INT32_MIN() + 1) {
                if ($simple->{long_value} == Fn->INT64_MIN() + 1) {
                  if ($value_long2 == Fn->INT64_MIN() + 1) {
                    if ($simple->{float_value} == Fn->FLT_MIN() + 1) {
                      if ($value_float2 == Fn->FLT_MIN() + 1) {
                        if ($simple->{double_value} == Fn->DBL_MIN() + 1) {
                          if ($value_double2 = Fn->DBL_MIN() + 1) {
                            return 1;
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }

  static method pre_inc_element_access_var_index : int () {
    my $values_byte = new byte[1];
    my $values_short = new short[1];
    my $values_int = new int[1];
    my $values_long = new long[1];
    my $values_float = new float[1];
    my $values_double = new double[1];
    
    $values_byte->[0] = Fn->INT8_MIN();
    $values_short->[0] = Fn->INT16_MIN();
    $values_int->[0] = Fn->INT32_MIN();
    $values_long->[0] = Fn->INT64_MIN();
    $values_float->[0] = Fn->FLT_MIN();
    $values_double->[0] = Fn->DBL_MIN();

    my $index = 0;
    my $value_byte2 = ++$values_byte->[$index];
    my $value_short2 = ++$values_short->[$index];
    my $value_int2 = ++$values_int->[$index];
    my $value_long2 = ++$values_long->[$index];
    my $value_float2 = ++$values_float->[$index];
    my $value_double2 = ++$values_double->[$index];
    
    if ($values_byte->[0] == Fn->INT8_MIN() + 1) {
      if ($value_byte2 == Fn->INT8_MIN() + 1) {
        if ($values_short->[0] == Fn->INT16_MIN() + 1) {
          if ($value_short2 == Fn->INT16_MIN() + 1) {
            if ($values_int->[0] == Fn->INT32_MIN() + 1) {
              if ($value_int2 == Fn->INT32_MIN() + 1) {
                if ($values_long->[0] == Fn->INT64_MIN() + 1) {
                  if ($value_long2 == Fn->INT64_MIN() + 1) {
                    if ($values_float->[0] == Fn->FLT_MIN() + 1) {
                      if ($value_float2 == Fn->FLT_MIN() + 1) {
                        if ($values_double->[0] == Fn->DBL_MIN() + 1) {
                          if ($value_double2 = Fn->DBL_MIN() + 1) {
                            return 1;
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }

  static method pre_inc_element_access_constant_index : int () {
    my $values_byte = new byte[1];
    my $values_short = new short[1];
    my $values_int = new int[1];
    my $values_long = new long[1];
    my $values_float = new float[1];
    my $values_double = new double[1];
    
    $values_byte->[0] = Fn->INT8_MIN();
    $values_short->[0] = Fn->INT16_MIN();
    $values_int->[0] = Fn->INT32_MIN();
    $values_long->[0] = Fn->INT64_MIN();
    $values_float->[0] = Fn->FLT_MIN();
    $values_double->[0] = Fn->DBL_MIN();

    my $value_byte2 = ++$values_byte->[0];
    my $value_short2 = ++$values_short->[0];
    my $value_int2 = ++$values_int->[0];
    my $value_long2 = ++$values_long->[0];
    my $value_float2 = ++$values_float->[0];
    my $value_double2 = ++$values_double->[0];
    
    if ($values_byte->[0] == Fn->INT8_MIN() + 1) {
      if ($value_byte2 == Fn->INT8_MIN() + 1) {
        if ($values_short->[0] == Fn->INT16_MIN() + 1) {
          if ($value_short2 == Fn->INT16_MIN() + 1) {
            if ($values_int->[0] == Fn->INT32_MIN() + 1) {
              if ($value_int2 == Fn->INT32_MIN() + 1) {
                if ($values_long->[0] == Fn->INT64_MIN() + 1) {
                  if ($value_long2 == Fn->INT64_MIN() + 1) {
                    if ($values_float->[0] == Fn->FLT_MIN() + 1) {
                      if ($value_float2 == Fn->FLT_MIN() + 1) {
                        if ($values_double->[0] == Fn->DBL_MIN() + 1) {
                          if ($value_double2 = Fn->DBL_MIN() + 1) {
                            return 1;
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }

  static method pre_inc_var : int () {
    my $value_byte = Fn->INT8_MIN();
    my $value_short = Fn->INT16_MIN();
    my $value_int = Fn->INT32_MIN();
    my $value_long = Fn->INT64_MIN();
    my $value_float = Fn->FLT_MIN();
    my $value_double = Fn->DBL_MIN();
    
    my $value_byte2 = ++$value_byte;
    my $value_short2 = ++$value_short;
    my $value_int2 = ++$value_int;
    my $value_long2 = ++$value_long;
    my $value_float2 = ++$value_float;
    my $value_double2 = ++$value_double;
    
    
    if ($value_byte == Fn->INT8_MIN() + 1) {
      if ($value_byte2 == Fn->INT8_MIN() + 1) {
        if ($value_short == Fn->INT16_MIN() + 1) {
          if ($value_short2 == Fn->INT16_MIN() + 1) {
            if ($value_int == Fn->INT32_MIN() + 1) {
              if ($value_int2 == Fn->INT32_MIN() + 1) {
                if ($value_long == Fn->INT64_MIN() + 1) {
                  if ($value_long2 == Fn->INT64_MIN() + 1) {
                    if ($value_float == Fn->FLT_MIN() + 1) {
                      if ($value_float2 == Fn->FLT_MIN() + 1) {
                        if ($value_double == Fn->DBL_MIN() + 1) {
                          if ($value_double2 = Fn->DBL_MIN() + 1) {
                            return 1;
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }

  static method post_dec : int () {
    my $value_byte = (byte)0;
    my $value_short = (short)0;
    my $value_int = 0;
    my $value_long = 0L;
    my $value_float = 1.25f;
    my $value_double = 1.25;
    
    my $value_byte2 = $value_byte--;
    my $value_short2 = $value_short--;
    my $value_int2 = $value_int--;
    my $value_long2 = $value_long--;
    my $value_float2 = $value_float--;
    my $value_double2 = $value_double--;
    
    if ($value_byte == -1) {
      if ($value_byte2 == 0) {
        if ($value_short == -1) {
          if ($value_short2 == 0) {
            if ($value_int == -1) {
              if ($value_int2 == 0) {
                if ($value_long == -1L) {
                  if ($value_long2 == 0L) {
                    if ($value_float == 0.25f) {
                      if ($value_float2 == 1.25f) {
                        if ($value_double == 0.25) {
                          if ($value_double2 == 1.25) {
                            return 1;
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}
