# 2. 구문 분석

파이썬 프로그램은 파서(parser) 에 의해 읽힌다. 파서의 입력은 구문 분석기(lexical analyzer) 가 만들어내는 토큰(token) 들의 스트림이다. 이 장에서는 구문 분석기가 어떻게 파일을 토큰들로 분해하는지 설명한다.

Python uses the 7-bit ASCII character set for program text.

버전 2.3에 추가: An encoding declaration can be used to indicate that string literals and comments use an encoding different from ASCII.

For compatibility with older versions, Python only warns if it finds 8-bit characters; those warnings should be corrected by either declaring an explicit encoding, or using escape sequences if those bytes are binary data, instead of characters.

The run-time character set depends on the I/O devices connected to the program but is generally a superset of ASCII.

Future compatibility note: It may be tempting to assume that the character set for 8-bit characters is ISO Latin-1 (an ASCII superset that covers most western languages that use the Latin alphabet), but it is possible that in the future Unicode text editors will become common. These generally use the UTF-8 encoding, which is also an ASCII superset, but with very different use for the characters with ordinals 128-255. While there is no consensus on this subject yet, it is unwise to assume either Latin-1 or UTF-8, even though the current implementation appears to favor Latin-1. This applies both to the source character set and the run-time character set.

## 2.1. 줄 구조(Line structure)

파이썬 프로그램은 여러 개의 논리적인 줄(logical lines) 들로 나뉜다.

### 2.1.1. 논리적인 줄

논리적인 줄의 끝은 NEWLINE 토큰으로 표현된다. 문법이 허락하지 않는 이상 (예를 들어 복합문에서 문장들 사이) 문장은 논리적인 줄 간의 경계를 가로지를 수 없다. 논리적인 줄은 명시적이거나 묵시적인 줄 결합(line joining) 규칙에 따라 하나 이상의 물리적인 줄(physical lines) 들로 구성된다.

### 2.1.2. 물리적인 줄

A physical line is a sequence of characters terminated by an end-of-line sequence. In source files and strings, any of the standard platform line termination sequences can be used - the Unix form using ASCII LF (linefeed), the Windows form using the ASCII sequence CR LF (return followed by linefeed), or the old Macintosh form using the ASCII CR (return) character. All of these forms can be used equally, regardless of platform. The end of input also serves as an implicit terminator for the final physical line.

파이썬을 내장할 때는, 소스 코드 문자열은 반드시 줄 종료 문자에 표준 C 관행(ASCII LF를 표현하는 `\n` 문자로 줄이 종료된다)을 적용해서 파이썬 API로 전달되어야 한다.

### 2.1.3. 주석

주석은 문자열 리터럴에 포함되지 않는 해시 문자(`#`)로 시작하고 물리적인 줄의 끝에서 끝난다. 묵시적인 줄 결합 규칙이 유효하지 않은 이상, 주석은 논리적인 줄을 종료시킨다. 주석은 문법이 무시한다; 토큰으로 만들어지지 않는다.

### 2.1.4. 인코딩 선언

파이썬 스크립트의 첫 번 째나 두 번째 줄에 있는 주석이 정규식 `coding[=:]\s*([-\w.]+)` 과 매치되면, 이 주석은 인코딩 선언으로 처리된다. 이 정규식의 첫 번째 그룹은 소스 코드 파일의 인코딩 이름을 지정한다. 인코딩 선언은 줄 전체에 홀로 나와야 한다. 만약 두 번째 줄이라면, 첫 번째 줄 역시 주석만 있어야 한다. 인코딩 선언의 권장 형태는 두 개다. 하나는

    # -*- coding: <encoding-name> -*-

인데 GNU Emacs에서도 인식된다. 다른 하나는

    # vim:fileencoding=<encoding-name>

which is recognized by Bram Moolenaar’s VIM. In addition, if the first bytes of the file are the UTF-8 byte-order mark (`'\xef\xbb\xbf'`), the declared file encoding is UTF-8 (this is supported, among others, by Microsoft’s notepad).

If an encoding is declared, the encoding name must be recognized by Python. The encoding is used for all lexical analysis, in particular to find the end of a string, and to interpret the contents of Unicode literals. String literals are converted to Unicode for syntactical analysis, then converted back to their original encoding before interpretation starts.

### 2.1.5. 명시적인 줄 결합

둘 이상의 물리적인 줄은 역 슬래시 문자(`\`)를 사용해서 논리적인 줄로 결합할 수 있다: 물리적인 줄이 문자열 리터럴이나 주석의 일부가 아닌 역 슬래시 문자로 끝나면, 역 슬래시와 뒤따르는 개행 문자가 제거된 채로, 현재 만들어지고 있는 논리적인 줄에 합쳐진다. 예를 들어:

    if 1900 < year < 2100 and 1 <= month <= 12 \
       and 1 <= day <= 31 and 0 <= hour < 24 \
       and 0 <= minute < 60 and 0 <= second < 60:   # Looks like a valid date
            return 1

역 슬래시로 끝나는 줄은 주석이 포함될 수 없다. 역 슬래시는 주석을 결합하지 못한다. 역 슬래시는 문자열 리터럴을 제외한 어떤 토큰도 결합하지 못한다 (즉, 문자열 리터럴 이외의 어떤 토큰도 역 슬래시를 사용해서 두 줄에 나누어 기록할 수 없다.). 문자열 리터럴 밖에 있는 역 슬래시가 앞에서 언급한 장소 이외의 곳에 등장하는 것은 문법에 어긋난다.

### 2.1.6. 묵시적인 줄 결합

괄호(`()`), 꺾쇠괄호(`[]`), 중괄호(`{}`)가 사용되는 표현은 역 슬래시 없이도 여러 개의 물리적인 줄로 나눌 수 있다. 예를 들어:

    month_names = ['Januari', 'Februari', 'Maart',      # These are the
                   'April',   'Mei',      'Juni',       # Dutch names
                   'Juli',    'Augustus', 'September',  # for the months
                   'Oktober', 'November', 'December']   # of the year

묵시적으로 이어지는 줄들은 주석을 포함할 수 있다. 이어지는 줄들의 들여쓰기는 중요하지 않다. 중간에 빈 줄이 들어가도 된다. 묵시적으로 줄 결합하는 줄 들 간에는 NEWLINE 토큰이 만들어지지 않는다. 묵시적으로 이어지는 줄들은 삼중 따옴표 된 문자열들에서도 등장할 수 있는데 (아래를 보라), 이 경우는 주석이 포함될 수 없다.

### 2.1.7. 빈 줄

A logical line that contains only spaces, tabs, formfeeds and possibly a comment, is ignored (i.e., no NEWLINE token is generated). During interactive input of statements, handling of a blank line may differ depending on the implementation of the read-eval-print loop. In the standard implementation, an entirely blank logical line (i.e. one containing not even whitespace or a comment) terminates a multi-line statement.

### 2.1.8. 들여쓰기

논리적인 줄의 제일 앞에 오는 공백(스페이스와 탭)은 줄의 들여쓰기 수준을 계산하는 데 사용되고, 이는 다시 문장들의 묶음을 결정하는 데 사용되게 된다.

First, tabs are replaced (from left to right) by one to eight spaces such that the total number of characters up to and including the replacement is a multiple of eight (this is intended to be the same rule as used by Unix). The total number of spaces preceding the first non-blank character then determines the line’s indentation. Indentation cannot be split over multiple physical lines using backslashes; the whitespace up to the first backslash determines the indentation.

크로스-플랫폼 호환성 유의 사항: UNIX 이외의 플랫폼에서 편집기들이 동작하는 방식 때문에, 하나의 파일 내에서 들여쓰기를 위해 탭과 스페이스를 섞어 쓰는 것은 현명한 선택이 아니다. 다른 플랫폼들에서는 최대 들여쓰기 수준에 제한이 있을 수도 있다는 점도 주의해야 한다.

폼 피드 문자는 줄의 처음에 나올 수 있다; 앞서 설명한 들여쓰기 수준 계산에서는 무시된다. 페이지 넘김 문자 앞에 공백이나 탭이 있는 경우는 정의되지 않은 효과를 줄 수 있다 (가령, 스페이스 수가 0으로 초기화될 수 있다).

연속된 줄의 들여쓰기 수준은, 스택을 사용해서, 다음과 같은 방법으로 INDENT와 DEDENT 토큰을 만드는 데 사용된다.

파일의 첫 줄을 읽기 전에 0하나를 스택에 넣는다(push); 이 값은 다시 꺼내는(pop) 일이 없다. 스택에 넣는 값은 항상 스택의 아래에서 위로 올라갈 때 단조 증가한다. 각 논리적인 줄의 처음에서 줄의 들여쓰기 수준이 스택의 가장 위에 있는 값과 비교된다. 같다면 아무런 일도 일어나지 않는다. 더 크다면 그 값을 스택에 넣고 하나의 INDENT 토큰을 만든다. 더 작다면 이 값은 스택에 있는 값 중 하나여만 한다. 이 값보다 큰 모든 스택의 값들을 꺼내고(pop), 꺼낸 횟수만큼의 DEDENT 토큰을 만든다. 파일의 끝에서, 스택에 남아있는 0보다 큰 값의 개수만큼 DEDENT 토큰을 만든다.

여기에 (혼란스럽다 할지라도) 올바르게 들여쓰기 된 파이썬 코드 조각이 있다:

    def perm(l):
            # Compute the list of all permutations of l
        if len(l) <= 1:
                      return [l]
        r = []
        for i in range(len(l)):
                 s = l[:i] + l[i+1:]
                 p = perm(s)
                 for x in p:
                  r.append(l[i:i+1] + x)
        return r

다음 예는 여러 가지 들여쓰기 에러를 보여준다:

     def perm(l):                       # error: first line indented
    for i in range(len(l)):             # error: not indented
        s = l[:i] + l[i+1:]
            p = perm(l[:i] + l[i+1:])   # error: unexpected indent
            for x in p:
                    r.append(l[i:i+1] + x)
                return r                # error: inconsistent dedent

(사실, 처음 세 개의 에러는 파서가 감지한다. 단지 마지막 에러만 구문 분석기가 감지한다. — `return r` 의 들여쓰기가 스택에 있는 값과 일치하지 않는다.)

### 2.1.9. 토큰 사이의 공백

논리적인 줄의 처음과 문자열 리터럴을 제외하고, 공백 문자인 스페이스, 탭, 폼 피드는 토큰을 분리하기 위해 섞어 쓸 수 있다. 두 토큰을 붙여 쓸 때 다른 토큰으로 해석될 수 있는 경우만 토큰 사이에 공백이 필요하다. (예를 들어, ab 는 하나의 토큰이지만, a b 는 두 개의 토큰이다.)

## 2.2. 다른 토큰들

NEWLINE, INDENT, DEDENT 와는 별도로, 다음과 같은 유형의 토큰들이 존재한다: 식별자(identifier), 키워드(keyword), 리터럴(literal), 연산자(operator), 구분자(delimiter). (앞에서 살펴본 줄 종료 이외의) 공백 문자들은 토큰이 아니지만, 토큰을 분리하는 역할을 담당한다. 모호할 경우, 왼쪽에서 오른쪽으로 읽을 때, 하나의 토큰은 올바르고 가능한 한 최대 길이의 문자열로 구성되는 것을 선호한다.

## 2.3. 식별자와 키워드

Identifiers (also referred to as names) are described by the following lexical definitions:

    identifier ::=  (letter|"_") (letter | digit | "_")*
    letter     ::=  lowercase | uppercase
    lowercase  ::=  "a"..."z"
    uppercase  ::=  "A"..."Z"
    digit      ::=  "0"..."9"

식별자는 길이에 제한이 없고, 케이스(case)는 구분된다.

### 2.3.1. 키워드

다음 식별자들은 예약어, 또는 언어의 키워드, 로 사용되고, 일반적인 식별자로 사용될 수 없다. 여기 쓰여 있는 것과 정확히 같게 사용되어야 한다:

    and       del       from      not       while
    as        elif      global    or        with
    assert    else      if        pass      yield
    break     except    import    print
    class     exec      in        raise
    continue  finally   is        return
    def       for       lambda    try

버전 2.4에서 변경: `None` became a constant and is now recognized by the compiler as a name for the built-in object `None`. Although it is not a keyword, you cannot assign a different object to it.

버전 2.5에서 변경: Using `as` and `with` as identifiers triggers a warning. To use them as keywords, enable the `with_statement` future feature .

버전 2.6에서 변경: `as` and `with` are full keywords.

### 2.3.2. 식별자의 예약 영역

(키워드와는 별개로) 어떤 부류의 식별자들은 특별한 의미가 있다. 이 부류의 식별자들은 시작과 끝의 밑줄 문자 패턴으로 구분된다:

`_*`

  Not imported by `from module import *`. The special identifier `_` is used in the interactive interpreter to store the result of the last evaluation; it is stored in the `__builtin__` module. When not in interactive mode, `_` has no special meaning and is not defined. See section 임포트(import) 문.

  참고

  이름 `_` 은 종종 국제화(internationalization)와 관련되어 사용된다. 이 관례에 관해서는 `gettext` 모듈의 문서를 참조하라.

`__*__`

  시스템 정의 이름. 이 이름들은 인터프리터와 그 구현 (표준 라이브러리를 포함한다)이 정의한다. 현재 정의된 시스템 이름은 특수 메서드 이름들 섹션과 그 외의 곳에서 논의된다. 파이썬의 미래 버전에서는 더 많은 것들이 정의될 가능성이 크다. 어떤 문맥에서건, 명시적으로 문서로 만들어진 사용법을 벗어나는 `__*__` 이름의 모든 사용은, 경고 없이 손상될 수 있다.

`__*`

  클래스-비공개 이름. 이 부류의 이름들을 클래스 정의 문맥에서 사용하면 뒤섞인 형태로 변형된다. 부모 클래스와 자식 클래스의 《비공개(private)》 어트리뷰트 간의 이름 충돌을 피하기 위함이다. 식별자 (이름) 섹션을 보라.

## 2.4. 리터럴

리터럴(literal)은 몇몇 내장형들의 상숫값을 위한 표기법이다.

### 2.4.1. String literals

문자열 리터럴은 다음과 같은 구문 정의로 기술된다:

    stringliteral   ::=  [stringprefix](shortstring | longstring)
    stringprefix    ::=  "r" | "u" | "ur" | "R" | "U" | "UR" | "Ur" | "uR"
                         | "b" | "B" | "br" | "Br" | "bR" | "BR"
    shortstring     ::=  "'" shortstringitem* "'" | '"' shortstringitem* '"'
    longstring      ::=  "'''" longstringitem* "'''"
                         | '"""' longstringitem* '"""'
    shortstringitem ::=  shortstringchar | escapeseq
    longstringitem  ::=  longstringchar | escapeseq
    shortstringchar ::=  <any source character except "\" or newline or the quote>
    longstringchar  ::=  <any source character except "\">
    escapeseq       ::=  "\" <any ASCII character>

One syntactic restriction not indicated by these productions is that whitespace is not allowed between the `stringprefix` and the rest of the string literal. The source character set is defined by the encoding declaration; it is ASCII if no encoding declaration is given in the source file; see section 인코딩 선언.

In plain English: String literals can be enclosed in matching single quotes (`'`) or double quotes (`"`). They can also be enclosed in matching groups of three single or double quotes (these are generally referred to as triple-quoted strings). The backslash (`\`) character is used to escape characters that otherwise have a special meaning, such as newline, backslash itself, or the quote character. String literals may optionally be prefixed with a letter `'r'` or `'R'`; such strings are called raw strings and use different rules for interpreting backslash escape sequences. A prefix of `'u'` or `'U'` makes the string a Unicode string. Unicode strings use the Unicode character set as defined by the Unicode Consortium and ISO 10646. Some additional escape sequences, described below, are available in Unicode strings. A prefix of `'b'` or `'B'` is ignored in Python 2; it indicates that the literal should become a bytes literal in Python 3 (e.g. when code is automatically converted with 2to3). A `'u'` or `'b'` prefix may be followed by an `'r'` prefix.

In triple-quoted strings, unescaped newlines and quotes are allowed (and are retained), except that three unescaped quotes in a row terminate the string. (A 《quote》 is the character used to open the string, i.e. either `'` or `"`.)

Unless an `'r'` or `'R'` prefix is present, escape sequences in strings are interpreted according to rules similar to those used by Standard C. The recognized escape sequences are:

이스케이프 시퀀스 | 의미 | 유의 사항
--- | --- | ---
`\newline` | Ignored |
`\\` | 역 슬래시 (`\`) |
`\'` | 작은따옴표 (`'`) |
`\"` | 큰따옴표 (`"`) |
`\a` | ASCII 벨 (BEL) |
`\b` | ASCII 백스페이스 (BS) |
`\f` | ASCII 폼 피드 (FF) |
`\n` | ASCII 라인 피드 (LF) |
`\N{name}` | Character named name in the Unicode database (Unicode only) |
`\r` | ASCII 캐리지 리턴 (CR) |
`\t` | ASCII 가로 탭 (TAB) |
`\uxxxx` | Character with 16-bit hex value xxxx (Unicode only) | (1)
`\Uxxxxxxxx` | Character with 32-bit hex value xxxxxxxx (Unicode only) | (2)
`\v` | ASCII 세로 탭 (VT) |
`\ooo` | 8진수 ooo 로 지정된 문자 | (3,5)
`\xhh` | 16진수 hh 로 지정된 문자 | (4,5)

유의 사항:

1. Individual code units which form parts of a surrogate pair can be encoded using this escape sequence.

2. Any Unicode character can be encoded this way, but characters outside the Basic Multilingual Plane (BMP) will be encoded using a surrogate pair if Python is compiled to use 16-bit code units (the default).

3. 표준 C와 마찬가지로, 최대 세 개의 8진수가 허용된다.

4. 표준 C와는 달리, 정확히 두 개의 16진수가 제공되어야 한다.

5. In a string literal, hexadecimal and octal escapes denote the byte with the given value; it is not necessary that the byte encodes a character in the source character set. In a Unicode literal, these escapes denote a Unicode character with the given value.

Unlike Standard C, all unrecognized escape sequences are left in the string unchanged, i.e., the backslash is left in the string. (This behavior is useful when debugging: if an escape sequence is mistyped, the resulting output is more easily recognized as broken.) It is also important to note that the escape sequences marked as 《(Unicode only)》 in the table above fall into the category of unrecognized escapes for non-Unicode string literals.

When an `'r'` or `'R'` prefix is present, a character following a backslash is included in the string without change, and all backslashes are left in the string. For example, the string literal `r"\n"` consists of two characters: a backslash and a lowercase `'n'`. String quotes can be escaped with a backslash, but the backslash remains in the string; for example, `r"\""` is a valid string literal consisting of two characters: a backslash and a double quote; `r"\"` is not a valid string literal (even a raw string cannot end in an odd number of backslashes). Specifically, a raw string cannot end in a single backslash (since the backslash would escape the following quote character). Note also that a single backslash followed by a newline is interpreted as those two characters as part of the string, not as a line continuation.

When an `'r'` or `'R'` prefix is used in conjunction with a `'u'` or `'U'` prefix, then the `\uXXXX` and `\UXXXXXXXX` escape sequences are processed while all other backslashes are left in the string. For example, the string literal `ur"\u0062\n"` consists of three Unicode characters: 〈LATIN SMALL LETTER B〉, 〈REVERSE SOLIDUS〉, and 〈LATIN SMALL LETTER N〉. Backslashes can be escaped with a preceding backslash; however, both remain in the string. As a result, `\uXXXX` escape sequences are only recognized when there are an odd number of backslashes.

### 2.4.2. 문자열 리터럴 이어붙이기

Multiple adjacent string literals (delimited by whitespace), possibly using different quoting conventions, are allowed, and their meaning is the same as their concatenation. Thus, `"hello" 'world'` is equivalent to `"helloworld"`. This feature can be used to reduce the number of backslashes needed, to split long strings conveniently across long lines, or even to add comments to parts of strings, for example:

    re.compile("[A-Za-z_]"       # letter or underscore
               "[A-Za-z0-9_]*"   # letter, digit or underscore
              )

Note that this feature is defined at the syntactical level, but implemented at compile time. The 〈+〉 operator must be used to concatenate string expressions at run time. Also note that literal concatenation can use different quoting styles for each component (even mixing raw strings and triple quoted strings).

### 2.4.3. 숫자 리터럴

There are four types of numeric literals: plain integers, long integers, floating point numbers, and imaginary numbers. There are no complex literals (complex numbers can be formed by adding a real number and an imaginary number).

숫자 리터럴이 부호를 포함하지 않는 것에 주의해야 한다; `-1` 과 같은 구문은 일 항 연산자 〈`-`〈 과 리터럴 `1` 로 구성된 표현식이다.

### 2.4.4. Integer and long integer literals

Integer and long integer literals are described by the following lexical definitions:

    longinteger    ::=  integer ("l" | "L")
    integer        ::=  decimalinteger | octinteger | hexinteger | bininteger
    decimalinteger ::=  nonzerodigit digit* | "0"
    octinteger     ::=  "0" ("o" | "O") octdigit+ | "0" octdigit+
    hexinteger     ::=  "0" ("x" | "X") hexdigit+
    bininteger     ::=  "0" ("b" | "B") bindigit+
    nonzerodigit   ::=  "1"..."9"
    octdigit       ::=  "0"..."7"
    bindigit       ::=  "0" | "1"
    hexdigit       ::=  digit | "a"..."f" | "A"..."F"

Although both lower case `'l'` and upper case `'L'` are allowed as suffix for long integers, it is strongly recommended to always use `'L'`, since the letter `'l'` looks too much like the digit `'1'`.

Plain integer literals that are above the largest representable plain integer (e.g., 2147483647 when using 32-bit arithmetic) are accepted as if they were long integers instead. 1 There is no limit for long integer literals apart from what can be stored in available memory.

Some examples of plain integer literals (first row) and long integer literals (second and third rows):

    7     2147483647                        0177
    3L    79228162514264337593543950336L    0377L   0x100000000L
          79228162514264337593543950336             0xdeadbeef

### 2.4.5. 실수 리터럴

실수 리터럴은 다음과 같은 구문 정의로 표현된다:

    floatnumber   ::=  pointfloat | exponentfloat
    pointfloat    ::=  [intpart] fraction | intpart "."
    exponentfloat ::=  (intpart | pointfloat) exponent
    intpart       ::=  digit+
    fraction      ::=  "." digit+
    exponent      ::=  ("e" | "E") ["+" | "-"] digit+

Note that the integer and exponent parts of floating point numbers can look like octal integers, but are interpreted using radix 10. For example, `077e010` is legal, and denotes the same number as `77e10`. The allowed range of floating point literals is implementation-dependent. Some examples of floating point literals:

    3.14    10.    .001    1e100    3.14e-10    0e0

Note that numeric literals do not include a sign; a phrase like `-1` is actually an expression composed of the unary operator `-` and the literal `1`.

### 2.4.6. 허수 리터럴

허수 리터럴은 다음과 같은 구문 정의로 표현된다:

    imagnumber ::=  (floatnumber | intpart) ("j" | "J")

허수 리터럴은 실수부가 0.0인 복소수를 만든다. 복소수는 실수와 같은 범위 제약이 적용되는 한 쌍의 실수로 표현된다. 0이 아닌 실수부를 갖는 복소수를 만들려면, 실수를 더하면 된다. 예를 들어, `(3+4j)`. 허수 리터럴의 몇 가지 예를 든다:

    3.14j   10.j    10j     .001j   1e100j  3.14e-10j

## 2.5. 연산자

다음과 같은 토큰들은 연산자다:

    +       -       *       **      /       //      %
    <<      >>      &       |       ^       ~
    <       >       <=      >=      ==      !=      <>

The comparison operators `<>` and `!=` are alternate spellings of the same operator. `!=` is the preferred spelling; `<>` is obsolescent.

## 2.6. 구분자

다음 토큰들은 문법에서 구분자(delimiter)로 기능한다:

    (       )       [       ]       {       }      @
    ,       :       .       `       =       ;
    +=      -=      *=      /=      //=     %=
    &=      |=      ^=      >>=     <<=     **=

The period can also occur in floating-point and imaginary literals. A sequence of three periods has a special meaning as an ellipsis in slices. The second half of the list, the augmented assignment operators, serve lexically as delimiters, but also perform an operation.

다음의 인쇄되는 ASCII 문자들은 다른 토큰들 일부로서 특별한 의미를 같거나, 그 밖의 경우 구문 분석기에 유의미하다:

    '       "       #       \

다음의 인쇄되는 ASCII 문자들은 파이썬에서 사용되지 않는다. 문자열 리터럴과 주석 이외의 곳에서 사용되는 것은 조건 없는 에러다:

    $       ?

각주

1

  In versions of Python prior to 2.4, octal and hexadecimal literals in the range just above the largest representable plain integer but below the largest unsigned 32-bit number (on a machine using 32-bit arithmetic), 4294967296, were taken as the negative plain integer obtained by subtracting 4294967296 from their unsigned value.