Restoring authorship annotation for Mikhail Borisov <borisov.mikhail@gmail.com>. Commit 1 of 2.

5 files changed, 1783 insertions, 1783 deletions

diff --git a/contrib/python/PyYAML/py3/LICENSE b/contrib/python/PyYAML/py3/LICENSE
index 2f1b8e15e5..63edc20f2f 100644
--- a/contrib/python/PyYAML/py3/LICENSE
+++ b/contrib/python/PyYAML/py3/LICENSE
@@ -1,20 +1,20 @@
 Copyright (c) 2017-2021 Ingy döt Net
 Copyright (c) 2006-2016 Kirill Simonov
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+ 
+Permission is hereby granted, free of charge, to any person obtaining a copy of 
+this software and associated documentation files (the "Software"), to deal in 
+the Software without restriction, including without limitation the rights to 
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 
+of the Software, and to permit persons to whom the Software is furnished to do 
+so, subject to the following conditions: 
+ 
+The above copyright notice and this permission notice shall be included in all 
+copies or substantial portions of the Software. 
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+SOFTWARE. 
diff --git a/contrib/python/PyYAML/py3/ya.make b/contrib/python/PyYAML/py3/ya.make
index 0401c04651..628977356a 100644
--- a/contrib/python/PyYAML/py3/ya.make
+++ b/contrib/python/PyYAML/py3/ya.make
@@ -1,43 +1,43 @@
 PY3_LIBRARY()
-
+ 
 LICENSE(MIT)
 
 VERSION(5.4.1)
 
 OWNER(g:python-contrib borman g:testenv)
-
+ 
 PEERDIR(
     contrib/libs/yaml
 )
-
+ 
 ADDINCL(
     contrib/python/PyYAML/py3/yaml
 )
 
-PY_SRCS(
-    TOP_LEVEL
+PY_SRCS( 
+    TOP_LEVEL 
     _yaml/__init__.py
-    yaml/__init__.py
-    yaml/composer.py
-    yaml/constructor.py
-    yaml/cyaml.py
-    yaml/dumper.py
-    yaml/emitter.py
-    yaml/error.py
-    yaml/events.py
-    yaml/loader.py
-    yaml/nodes.py
-    yaml/parser.py
-    yaml/reader.py
-    yaml/representer.py
-    yaml/resolver.py
-    yaml/scanner.py
-    yaml/serializer.py
-    yaml/tokens.py
+    yaml/__init__.py 
+    yaml/composer.py 
+    yaml/constructor.py 
+    yaml/cyaml.py 
+    yaml/dumper.py 
+    yaml/emitter.py 
+    yaml/error.py 
+    yaml/events.py 
+    yaml/loader.py 
+    yaml/nodes.py 
+    yaml/parser.py 
+    yaml/reader.py 
+    yaml/representer.py 
+    yaml/resolver.py 
+    yaml/scanner.py 
+    yaml/serializer.py 
+    yaml/tokens.py 
     CYTHON_C
     yaml/_yaml.pyx
-)
-
+) 
+ 
 RESOURCE_FILES(
     PREFIX contrib/python/PyYAML/
     .dist-info/METADATA
@@ -48,4 +48,4 @@ NO_LINT()
 
 NO_COMPILER_WARNINGS()
 
-END()
+END() 
diff --git a/contrib/python/PyYAML/py3/yaml/_yaml.h b/contrib/python/PyYAML/py3/yaml/_yaml.h
index 21fd6a991b..622cfc561a 100644
--- a/contrib/python/PyYAML/py3/yaml/_yaml.h
+++ b/contrib/python/PyYAML/py3/yaml/_yaml.h
@@ -1,23 +1,23 @@
-
-#include <yaml.h>
-
-#if PY_MAJOR_VERSION < 3
-
+ 
+#include <yaml.h> 
+ 
+#if PY_MAJOR_VERSION < 3 
+ 
 #define PyUnicode_FromString(s) PyUnicode_DecodeUTF8((s), strlen(s), "strict")
-
-#else
-
-#define PyString_CheckExact PyBytes_CheckExact
-#define PyString_AS_STRING  PyBytes_AS_STRING
-#define PyString_GET_SIZE   PyBytes_GET_SIZE
-#define PyString_FromStringAndSize  PyBytes_FromStringAndSize
-
-#endif
-
-#ifdef _MSC_VER	/* MS Visual C++ 6.0 */
-#if _MSC_VER == 1200
-
-#define PyLong_FromUnsignedLongLong(z)	PyInt_FromLong(i)
-
-#endif
-#endif
+ 
+#else 
+ 
+#define PyString_CheckExact PyBytes_CheckExact 
+#define PyString_AS_STRING  PyBytes_AS_STRING 
+#define PyString_GET_SIZE   PyBytes_GET_SIZE 
+#define PyString_FromStringAndSize  PyBytes_FromStringAndSize 
+ 
+#endif 
+ 
+#ifdef _MSC_VER	/* MS Visual C++ 6.0 */ 
+#if _MSC_VER == 1200 
+ 
+#define PyLong_FromUnsignedLongLong(z)	PyInt_FromLong(i) 
+ 
+#endif 
+#endif 
diff --git a/contrib/python/PyYAML/py3/yaml/_yaml.pxd b/contrib/python/PyYAML/py3/yaml/_yaml.pxd
index 7937c9db51..b6629e26ae 100644
--- a/contrib/python/PyYAML/py3/yaml/_yaml.pxd
+++ b/contrib/python/PyYAML/py3/yaml/_yaml.pxd
@@ -1,251 +1,251 @@
-
+ 
 cdef extern from "_yaml.h":
-
-    void malloc(int l)
-    void memcpy(char *d, char *s, int l)
-    int strlen(char *s)
-    int PyString_CheckExact(object o)
-    int PyUnicode_CheckExact(object o)
-    char *PyString_AS_STRING(object o)
-    int PyString_GET_SIZE(object o)
-    object PyString_FromStringAndSize(char *v, int l)
-    object PyUnicode_FromString(char *u)
-    object PyUnicode_DecodeUTF8(char *u, int s, char *e)
-    object PyUnicode_AsUTF8String(object o)
-    int PY_MAJOR_VERSION
-
-    ctypedef enum:
-        SIZEOF_VOID_P
-    ctypedef enum yaml_encoding_t:
-        YAML_ANY_ENCODING
-        YAML_UTF8_ENCODING
-        YAML_UTF16LE_ENCODING
-        YAML_UTF16BE_ENCODING
-    ctypedef enum yaml_break_t:
-        YAML_ANY_BREAK
-        YAML_CR_BREAK
-        YAML_LN_BREAK
-        YAML_CRLN_BREAK
-    ctypedef enum yaml_error_type_t:
-        YAML_NO_ERROR
-        YAML_MEMORY_ERROR
-        YAML_READER_ERROR
-        YAML_SCANNER_ERROR
-        YAML_PARSER_ERROR
-        YAML_WRITER_ERROR
-        YAML_EMITTER_ERROR
-    ctypedef enum yaml_scalar_style_t:
-        YAML_ANY_SCALAR_STYLE
-        YAML_PLAIN_SCALAR_STYLE
-        YAML_SINGLE_QUOTED_SCALAR_STYLE
-        YAML_DOUBLE_QUOTED_SCALAR_STYLE
-        YAML_LITERAL_SCALAR_STYLE
-        YAML_FOLDED_SCALAR_STYLE
-    ctypedef enum yaml_sequence_style_t:
-        YAML_ANY_SEQUENCE_STYLE
-        YAML_BLOCK_SEQUENCE_STYLE
-        YAML_FLOW_SEQUENCE_STYLE
-    ctypedef enum yaml_mapping_style_t:
-        YAML_ANY_MAPPING_STYLE
-        YAML_BLOCK_MAPPING_STYLE
-        YAML_FLOW_MAPPING_STYLE
-    ctypedef enum yaml_token_type_t:
-        YAML_NO_TOKEN
-        YAML_STREAM_START_TOKEN
-        YAML_STREAM_END_TOKEN
-        YAML_VERSION_DIRECTIVE_TOKEN
-        YAML_TAG_DIRECTIVE_TOKEN
-        YAML_DOCUMENT_START_TOKEN
-        YAML_DOCUMENT_END_TOKEN
-        YAML_BLOCK_SEQUENCE_START_TOKEN
-        YAML_BLOCK_MAPPING_START_TOKEN
-        YAML_BLOCK_END_TOKEN
-        YAML_FLOW_SEQUENCE_START_TOKEN
-        YAML_FLOW_SEQUENCE_END_TOKEN
-        YAML_FLOW_MAPPING_START_TOKEN
-        YAML_FLOW_MAPPING_END_TOKEN
-        YAML_BLOCK_ENTRY_TOKEN
-        YAML_FLOW_ENTRY_TOKEN
-        YAML_KEY_TOKEN
-        YAML_VALUE_TOKEN
-        YAML_ALIAS_TOKEN
-        YAML_ANCHOR_TOKEN
-        YAML_TAG_TOKEN
-        YAML_SCALAR_TOKEN
-    ctypedef enum yaml_event_type_t:
-        YAML_NO_EVENT
-        YAML_STREAM_START_EVENT
-        YAML_STREAM_END_EVENT
-        YAML_DOCUMENT_START_EVENT
-        YAML_DOCUMENT_END_EVENT
-        YAML_ALIAS_EVENT
-        YAML_SCALAR_EVENT
-        YAML_SEQUENCE_START_EVENT
-        YAML_SEQUENCE_END_EVENT
-        YAML_MAPPING_START_EVENT
-        YAML_MAPPING_END_EVENT
-
+ 
+    void malloc(int l) 
+    void memcpy(char *d, char *s, int l) 
+    int strlen(char *s) 
+    int PyString_CheckExact(object o) 
+    int PyUnicode_CheckExact(object o) 
+    char *PyString_AS_STRING(object o) 
+    int PyString_GET_SIZE(object o) 
+    object PyString_FromStringAndSize(char *v, int l) 
+    object PyUnicode_FromString(char *u) 
+    object PyUnicode_DecodeUTF8(char *u, int s, char *e) 
+    object PyUnicode_AsUTF8String(object o) 
+    int PY_MAJOR_VERSION 
+ 
+    ctypedef enum: 
+        SIZEOF_VOID_P 
+    ctypedef enum yaml_encoding_t: 
+        YAML_ANY_ENCODING 
+        YAML_UTF8_ENCODING 
+        YAML_UTF16LE_ENCODING 
+        YAML_UTF16BE_ENCODING 
+    ctypedef enum yaml_break_t: 
+        YAML_ANY_BREAK 
+        YAML_CR_BREAK 
+        YAML_LN_BREAK 
+        YAML_CRLN_BREAK 
+    ctypedef enum yaml_error_type_t: 
+        YAML_NO_ERROR 
+        YAML_MEMORY_ERROR 
+        YAML_READER_ERROR 
+        YAML_SCANNER_ERROR 
+        YAML_PARSER_ERROR 
+        YAML_WRITER_ERROR 
+        YAML_EMITTER_ERROR 
+    ctypedef enum yaml_scalar_style_t: 
+        YAML_ANY_SCALAR_STYLE 
+        YAML_PLAIN_SCALAR_STYLE 
+        YAML_SINGLE_QUOTED_SCALAR_STYLE 
+        YAML_DOUBLE_QUOTED_SCALAR_STYLE 
+        YAML_LITERAL_SCALAR_STYLE 
+        YAML_FOLDED_SCALAR_STYLE 
+    ctypedef enum yaml_sequence_style_t: 
+        YAML_ANY_SEQUENCE_STYLE 
+        YAML_BLOCK_SEQUENCE_STYLE 
+        YAML_FLOW_SEQUENCE_STYLE 
+    ctypedef enum yaml_mapping_style_t: 
+        YAML_ANY_MAPPING_STYLE 
+        YAML_BLOCK_MAPPING_STYLE 
+        YAML_FLOW_MAPPING_STYLE 
+    ctypedef enum yaml_token_type_t: 
+        YAML_NO_TOKEN 
+        YAML_STREAM_START_TOKEN 
+        YAML_STREAM_END_TOKEN 
+        YAML_VERSION_DIRECTIVE_TOKEN 
+        YAML_TAG_DIRECTIVE_TOKEN 
+        YAML_DOCUMENT_START_TOKEN 
+        YAML_DOCUMENT_END_TOKEN 
+        YAML_BLOCK_SEQUENCE_START_TOKEN 
+        YAML_BLOCK_MAPPING_START_TOKEN 
+        YAML_BLOCK_END_TOKEN 
+        YAML_FLOW_SEQUENCE_START_TOKEN 
+        YAML_FLOW_SEQUENCE_END_TOKEN 
+        YAML_FLOW_MAPPING_START_TOKEN 
+        YAML_FLOW_MAPPING_END_TOKEN 
+        YAML_BLOCK_ENTRY_TOKEN 
+        YAML_FLOW_ENTRY_TOKEN 
+        YAML_KEY_TOKEN 
+        YAML_VALUE_TOKEN 
+        YAML_ALIAS_TOKEN 
+        YAML_ANCHOR_TOKEN 
+        YAML_TAG_TOKEN 
+        YAML_SCALAR_TOKEN 
+    ctypedef enum yaml_event_type_t: 
+        YAML_NO_EVENT 
+        YAML_STREAM_START_EVENT 
+        YAML_STREAM_END_EVENT 
+        YAML_DOCUMENT_START_EVENT 
+        YAML_DOCUMENT_END_EVENT 
+        YAML_ALIAS_EVENT 
+        YAML_SCALAR_EVENT 
+        YAML_SEQUENCE_START_EVENT 
+        YAML_SEQUENCE_END_EVENT 
+        YAML_MAPPING_START_EVENT 
+        YAML_MAPPING_END_EVENT 
+ 
     ctypedef int yaml_read_handler_t(void *data, char *buffer,
-            size_t size, size_t *size_read) except 0
-
+            size_t size, size_t *size_read) except 0 
+ 
     ctypedef int yaml_write_handler_t(void *data, char *buffer,
-            size_t size) except 0
-
-    ctypedef struct yaml_mark_t:
+            size_t size) except 0 
+ 
+    ctypedef struct yaml_mark_t: 
         size_t index
         size_t line
         size_t column
-    ctypedef struct yaml_version_directive_t:
-        int major
-        int minor
-    ctypedef struct yaml_tag_directive_t:
+    ctypedef struct yaml_version_directive_t: 
+        int major 
+        int minor 
+    ctypedef struct yaml_tag_directive_t: 
         char *handle
         char *prefix
-
-    ctypedef struct _yaml_token_stream_start_data_t:
-        yaml_encoding_t encoding
-    ctypedef struct _yaml_token_alias_data_t:
-        char *value
-    ctypedef struct _yaml_token_anchor_data_t:
-        char *value
-    ctypedef struct _yaml_token_tag_data_t:
+ 
+    ctypedef struct _yaml_token_stream_start_data_t: 
+        yaml_encoding_t encoding 
+    ctypedef struct _yaml_token_alias_data_t: 
+        char *value 
+    ctypedef struct _yaml_token_anchor_data_t: 
+        char *value 
+    ctypedef struct _yaml_token_tag_data_t: 
         char *handle
         char *suffix
-    ctypedef struct _yaml_token_scalar_data_t:
-        char *value
+    ctypedef struct _yaml_token_scalar_data_t: 
+        char *value 
         size_t length
-        yaml_scalar_style_t style
-    ctypedef struct _yaml_token_version_directive_data_t:
-        int major
-        int minor
-    ctypedef struct _yaml_token_tag_directive_data_t:
+        yaml_scalar_style_t style 
+    ctypedef struct _yaml_token_version_directive_data_t: 
+        int major 
+        int minor 
+    ctypedef struct _yaml_token_tag_directive_data_t: 
         char *handle
         char *prefix
-    ctypedef union _yaml_token_data_t:
-        _yaml_token_stream_start_data_t stream_start
-        _yaml_token_alias_data_t alias
-        _yaml_token_anchor_data_t anchor
-        _yaml_token_tag_data_t tag
-        _yaml_token_scalar_data_t scalar
-        _yaml_token_version_directive_data_t version_directive
-        _yaml_token_tag_directive_data_t tag_directive
-    ctypedef struct yaml_token_t:
-        yaml_token_type_t type
-        _yaml_token_data_t data
-        yaml_mark_t start_mark
-        yaml_mark_t end_mark
-
-    ctypedef struct _yaml_event_stream_start_data_t:
-        yaml_encoding_t encoding
-    ctypedef struct _yaml_event_document_start_data_tag_directives_t:
-        yaml_tag_directive_t *start
-        yaml_tag_directive_t *end
-    ctypedef struct _yaml_event_document_start_data_t:
-        yaml_version_directive_t *version_directive
-        _yaml_event_document_start_data_tag_directives_t tag_directives
-        int implicit
-    ctypedef struct _yaml_event_document_end_data_t:
-        int implicit
-    ctypedef struct _yaml_event_alias_data_t:
-        char *anchor
-    ctypedef struct _yaml_event_scalar_data_t:
-        char *anchor
-        char *tag
-        char *value
+    ctypedef union _yaml_token_data_t: 
+        _yaml_token_stream_start_data_t stream_start 
+        _yaml_token_alias_data_t alias 
+        _yaml_token_anchor_data_t anchor 
+        _yaml_token_tag_data_t tag 
+        _yaml_token_scalar_data_t scalar 
+        _yaml_token_version_directive_data_t version_directive 
+        _yaml_token_tag_directive_data_t tag_directive 
+    ctypedef struct yaml_token_t: 
+        yaml_token_type_t type 
+        _yaml_token_data_t data 
+        yaml_mark_t start_mark 
+        yaml_mark_t end_mark 
+ 
+    ctypedef struct _yaml_event_stream_start_data_t: 
+        yaml_encoding_t encoding 
+    ctypedef struct _yaml_event_document_start_data_tag_directives_t: 
+        yaml_tag_directive_t *start 
+        yaml_tag_directive_t *end 
+    ctypedef struct _yaml_event_document_start_data_t: 
+        yaml_version_directive_t *version_directive 
+        _yaml_event_document_start_data_tag_directives_t tag_directives 
+        int implicit 
+    ctypedef struct _yaml_event_document_end_data_t: 
+        int implicit 
+    ctypedef struct _yaml_event_alias_data_t: 
+        char *anchor 
+    ctypedef struct _yaml_event_scalar_data_t: 
+        char *anchor 
+        char *tag 
+        char *value 
         size_t length
-        int plain_implicit
-        int quoted_implicit
-        yaml_scalar_style_t style
-    ctypedef struct _yaml_event_sequence_start_data_t:
-        char *anchor
-        char *tag
-        int implicit
-        yaml_sequence_style_t style
-    ctypedef struct _yaml_event_mapping_start_data_t:
-        char *anchor
-        char *tag
-        int implicit
-        yaml_mapping_style_t style
-    ctypedef union _yaml_event_data_t:
-        _yaml_event_stream_start_data_t stream_start
-        _yaml_event_document_start_data_t document_start
-        _yaml_event_document_end_data_t document_end
-        _yaml_event_alias_data_t alias
-        _yaml_event_scalar_data_t scalar
-        _yaml_event_sequence_start_data_t sequence_start
-        _yaml_event_mapping_start_data_t mapping_start
-    ctypedef struct yaml_event_t:
-        yaml_event_type_t type
-        _yaml_event_data_t data
-        yaml_mark_t start_mark
-        yaml_mark_t end_mark
-
-    ctypedef struct yaml_parser_t:
-        yaml_error_type_t error
-        char *problem
+        int plain_implicit 
+        int quoted_implicit 
+        yaml_scalar_style_t style 
+    ctypedef struct _yaml_event_sequence_start_data_t: 
+        char *anchor 
+        char *tag 
+        int implicit 
+        yaml_sequence_style_t style 
+    ctypedef struct _yaml_event_mapping_start_data_t: 
+        char *anchor 
+        char *tag 
+        int implicit 
+        yaml_mapping_style_t style 
+    ctypedef union _yaml_event_data_t: 
+        _yaml_event_stream_start_data_t stream_start 
+        _yaml_event_document_start_data_t document_start 
+        _yaml_event_document_end_data_t document_end 
+        _yaml_event_alias_data_t alias 
+        _yaml_event_scalar_data_t scalar 
+        _yaml_event_sequence_start_data_t sequence_start 
+        _yaml_event_mapping_start_data_t mapping_start 
+    ctypedef struct yaml_event_t: 
+        yaml_event_type_t type 
+        _yaml_event_data_t data 
+        yaml_mark_t start_mark 
+        yaml_mark_t end_mark 
+ 
+    ctypedef struct yaml_parser_t: 
+        yaml_error_type_t error 
+        char *problem 
         size_t problem_offset
-        int problem_value
-        yaml_mark_t problem_mark
-        char *context
-        yaml_mark_t context_mark
-
-    ctypedef struct yaml_emitter_t:
-        yaml_error_type_t error
-        char *problem
-
-    char *yaml_get_version_string()
-    void yaml_get_version(int *major, int *minor, int *patch)
-
-    void yaml_token_delete(yaml_token_t *token)
-
-    int yaml_stream_start_event_initialize(yaml_event_t *event,
-            yaml_encoding_t encoding)
-    int yaml_stream_end_event_initialize(yaml_event_t *event)
-    int yaml_document_start_event_initialize(yaml_event_t *event,
-            yaml_version_directive_t *version_directive,
-            yaml_tag_directive_t *tag_directives_start,
-            yaml_tag_directive_t *tag_directives_end,
-            int implicit)
-    int yaml_document_end_event_initialize(yaml_event_t *event,
-            int implicit)
+        int problem_value 
+        yaml_mark_t problem_mark 
+        char *context 
+        yaml_mark_t context_mark 
+ 
+    ctypedef struct yaml_emitter_t: 
+        yaml_error_type_t error 
+        char *problem 
+ 
+    char *yaml_get_version_string() 
+    void yaml_get_version(int *major, int *minor, int *patch) 
+ 
+    void yaml_token_delete(yaml_token_t *token) 
+ 
+    int yaml_stream_start_event_initialize(yaml_event_t *event, 
+            yaml_encoding_t encoding) 
+    int yaml_stream_end_event_initialize(yaml_event_t *event) 
+    int yaml_document_start_event_initialize(yaml_event_t *event, 
+            yaml_version_directive_t *version_directive, 
+            yaml_tag_directive_t *tag_directives_start, 
+            yaml_tag_directive_t *tag_directives_end, 
+            int implicit) 
+    int yaml_document_end_event_initialize(yaml_event_t *event, 
+            int implicit) 
     int yaml_alias_event_initialize(yaml_event_t *event, char *anchor)
-    int yaml_scalar_event_initialize(yaml_event_t *event,
+    int yaml_scalar_event_initialize(yaml_event_t *event, 
             char *anchor, char *tag, char *value, size_t length,
-            int plain_implicit, int quoted_implicit,
-            yaml_scalar_style_t style)
-    int yaml_sequence_start_event_initialize(yaml_event_t *event,
+            int plain_implicit, int quoted_implicit, 
+            yaml_scalar_style_t style) 
+    int yaml_sequence_start_event_initialize(yaml_event_t *event, 
             char *anchor, char *tag, int implicit, yaml_sequence_style_t style)
-    int yaml_sequence_end_event_initialize(yaml_event_t *event)
-    int yaml_mapping_start_event_initialize(yaml_event_t *event,
+    int yaml_sequence_end_event_initialize(yaml_event_t *event) 
+    int yaml_mapping_start_event_initialize(yaml_event_t *event, 
             char *anchor, char *tag, int implicit, yaml_mapping_style_t style)
-    int yaml_mapping_end_event_initialize(yaml_event_t *event)
-    void yaml_event_delete(yaml_event_t *event)
-
-    int yaml_parser_initialize(yaml_parser_t *parser)
-    void yaml_parser_delete(yaml_parser_t *parser)
-    void yaml_parser_set_input_string(yaml_parser_t *parser,
+    int yaml_mapping_end_event_initialize(yaml_event_t *event) 
+    void yaml_event_delete(yaml_event_t *event) 
+ 
+    int yaml_parser_initialize(yaml_parser_t *parser) 
+    void yaml_parser_delete(yaml_parser_t *parser) 
+    void yaml_parser_set_input_string(yaml_parser_t *parser, 
             char *input, size_t size)
-    void yaml_parser_set_input(yaml_parser_t *parser,
-            yaml_read_handler_t *handler, void *data)
-    void yaml_parser_set_encoding(yaml_parser_t *parser,
-            yaml_encoding_t encoding)
-    int yaml_parser_scan(yaml_parser_t *parser, yaml_token_t *token) except *
-    int yaml_parser_parse(yaml_parser_t *parser, yaml_event_t *event) except *
-
-    int yaml_emitter_initialize(yaml_emitter_t *emitter)
-    void yaml_emitter_delete(yaml_emitter_t *emitter)
-    void yaml_emitter_set_output_string(yaml_emitter_t *emitter,
+    void yaml_parser_set_input(yaml_parser_t *parser, 
+            yaml_read_handler_t *handler, void *data) 
+    void yaml_parser_set_encoding(yaml_parser_t *parser, 
+            yaml_encoding_t encoding) 
+    int yaml_parser_scan(yaml_parser_t *parser, yaml_token_t *token) except * 
+    int yaml_parser_parse(yaml_parser_t *parser, yaml_event_t *event) except * 
+ 
+    int yaml_emitter_initialize(yaml_emitter_t *emitter) 
+    void yaml_emitter_delete(yaml_emitter_t *emitter) 
+    void yaml_emitter_set_output_string(yaml_emitter_t *emitter, 
             char *output, size_t size, size_t *size_written)
-    void yaml_emitter_set_output(yaml_emitter_t *emitter,
-            yaml_write_handler_t *handler, void *data)
-    void yaml_emitter_set_encoding(yaml_emitter_t *emitter,
-            yaml_encoding_t encoding)
-    void yaml_emitter_set_canonical(yaml_emitter_t *emitter, int canonical)
-    void yaml_emitter_set_indent(yaml_emitter_t *emitter, int indent)
-    void yaml_emitter_set_width(yaml_emitter_t *emitter, int width)
-    void yaml_emitter_set_unicode(yaml_emitter_t *emitter, int unicode)
-    void yaml_emitter_set_break(yaml_emitter_t *emitter,
-            yaml_break_t line_break)
-    int yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event) except *
-    int yaml_emitter_flush(yaml_emitter_t *emitter)
-
+    void yaml_emitter_set_output(yaml_emitter_t *emitter, 
+            yaml_write_handler_t *handler, void *data) 
+    void yaml_emitter_set_encoding(yaml_emitter_t *emitter, 
+            yaml_encoding_t encoding) 
+    void yaml_emitter_set_canonical(yaml_emitter_t *emitter, int canonical) 
+    void yaml_emitter_set_indent(yaml_emitter_t *emitter, int indent) 
+    void yaml_emitter_set_width(yaml_emitter_t *emitter, int width) 
+    void yaml_emitter_set_unicode(yaml_emitter_t *emitter, int unicode) 
+    void yaml_emitter_set_break(yaml_emitter_t *emitter, 
+            yaml_break_t line_break) 
+    int yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event) except * 
+    int yaml_emitter_flush(yaml_emitter_t *emitter) 
+ 
diff --git a/contrib/python/PyYAML/py3/yaml/_yaml.pyx b/contrib/python/PyYAML/py3/yaml/_yaml.pyx
index ff4efe80b5..efdb347aff 100644
--- a/contrib/python/PyYAML/py3/yaml/_yaml.pyx
+++ b/contrib/python/PyYAML/py3/yaml/_yaml.pyx
@@ -1,1527 +1,1527 @@
-
-import yaml
-
-def get_version_string():
+ 
+import yaml 
+ 
+def get_version_string(): 
     cdef char *value
-    value = yaml_get_version_string()
-    if PY_MAJOR_VERSION < 3:
-        return value
-    else:
-        return PyUnicode_FromString(value)
-
-def get_version():
-    cdef int major, minor, patch
-    yaml_get_version(&major, &minor, &patch)
-    return (major, minor, patch)
-
-#Mark = yaml.error.Mark
-YAMLError = yaml.error.YAMLError
-ReaderError = yaml.reader.ReaderError
-ScannerError = yaml.scanner.ScannerError
-ParserError = yaml.parser.ParserError
-ComposerError = yaml.composer.ComposerError
-ConstructorError = yaml.constructor.ConstructorError
-EmitterError = yaml.emitter.EmitterError
-SerializerError = yaml.serializer.SerializerError
-RepresenterError = yaml.representer.RepresenterError
-
-StreamStartToken = yaml.tokens.StreamStartToken
-StreamEndToken = yaml.tokens.StreamEndToken
-DirectiveToken = yaml.tokens.DirectiveToken
-DocumentStartToken = yaml.tokens.DocumentStartToken
-DocumentEndToken = yaml.tokens.DocumentEndToken
-BlockSequenceStartToken = yaml.tokens.BlockSequenceStartToken
-BlockMappingStartToken = yaml.tokens.BlockMappingStartToken
-BlockEndToken = yaml.tokens.BlockEndToken
-FlowSequenceStartToken = yaml.tokens.FlowSequenceStartToken
-FlowMappingStartToken = yaml.tokens.FlowMappingStartToken
-FlowSequenceEndToken = yaml.tokens.FlowSequenceEndToken
-FlowMappingEndToken = yaml.tokens.FlowMappingEndToken
-KeyToken = yaml.tokens.KeyToken
-ValueToken = yaml.tokens.ValueToken
-BlockEntryToken = yaml.tokens.BlockEntryToken
-FlowEntryToken = yaml.tokens.FlowEntryToken
-AliasToken = yaml.tokens.AliasToken
-AnchorToken = yaml.tokens.AnchorToken
-TagToken = yaml.tokens.TagToken
-ScalarToken = yaml.tokens.ScalarToken
-
-StreamStartEvent = yaml.events.StreamStartEvent
-StreamEndEvent = yaml.events.StreamEndEvent
-DocumentStartEvent = yaml.events.DocumentStartEvent
-DocumentEndEvent = yaml.events.DocumentEndEvent
-AliasEvent = yaml.events.AliasEvent
-ScalarEvent = yaml.events.ScalarEvent
-SequenceStartEvent = yaml.events.SequenceStartEvent
-SequenceEndEvent = yaml.events.SequenceEndEvent
-MappingStartEvent = yaml.events.MappingStartEvent
-MappingEndEvent = yaml.events.MappingEndEvent
-
-ScalarNode = yaml.nodes.ScalarNode
-SequenceNode = yaml.nodes.SequenceNode
-MappingNode = yaml.nodes.MappingNode
-
-cdef class Mark:
-    cdef readonly object name
+    value = yaml_get_version_string() 
+    if PY_MAJOR_VERSION < 3: 
+        return value 
+    else: 
+        return PyUnicode_FromString(value) 
+ 
+def get_version(): 
+    cdef int major, minor, patch 
+    yaml_get_version(&major, &minor, &patch) 
+    return (major, minor, patch) 
+ 
+#Mark = yaml.error.Mark 
+YAMLError = yaml.error.YAMLError 
+ReaderError = yaml.reader.ReaderError 
+ScannerError = yaml.scanner.ScannerError 
+ParserError = yaml.parser.ParserError 
+ComposerError = yaml.composer.ComposerError 
+ConstructorError = yaml.constructor.ConstructorError 
+EmitterError = yaml.emitter.EmitterError 
+SerializerError = yaml.serializer.SerializerError 
+RepresenterError = yaml.representer.RepresenterError 
+ 
+StreamStartToken = yaml.tokens.StreamStartToken 
+StreamEndToken = yaml.tokens.StreamEndToken 
+DirectiveToken = yaml.tokens.DirectiveToken 
+DocumentStartToken = yaml.tokens.DocumentStartToken 
+DocumentEndToken = yaml.tokens.DocumentEndToken 
+BlockSequenceStartToken = yaml.tokens.BlockSequenceStartToken 
+BlockMappingStartToken = yaml.tokens.BlockMappingStartToken 
+BlockEndToken = yaml.tokens.BlockEndToken 
+FlowSequenceStartToken = yaml.tokens.FlowSequenceStartToken 
+FlowMappingStartToken = yaml.tokens.FlowMappingStartToken 
+FlowSequenceEndToken = yaml.tokens.FlowSequenceEndToken 
+FlowMappingEndToken = yaml.tokens.FlowMappingEndToken 
+KeyToken = yaml.tokens.KeyToken 
+ValueToken = yaml.tokens.ValueToken 
+BlockEntryToken = yaml.tokens.BlockEntryToken 
+FlowEntryToken = yaml.tokens.FlowEntryToken 
+AliasToken = yaml.tokens.AliasToken 
+AnchorToken = yaml.tokens.AnchorToken 
+TagToken = yaml.tokens.TagToken 
+ScalarToken = yaml.tokens.ScalarToken 
+ 
+StreamStartEvent = yaml.events.StreamStartEvent 
+StreamEndEvent = yaml.events.StreamEndEvent 
+DocumentStartEvent = yaml.events.DocumentStartEvent 
+DocumentEndEvent = yaml.events.DocumentEndEvent 
+AliasEvent = yaml.events.AliasEvent 
+ScalarEvent = yaml.events.ScalarEvent 
+SequenceStartEvent = yaml.events.SequenceStartEvent 
+SequenceEndEvent = yaml.events.SequenceEndEvent 
+MappingStartEvent = yaml.events.MappingStartEvent 
+MappingEndEvent = yaml.events.MappingEndEvent 
+ 
+ScalarNode = yaml.nodes.ScalarNode 
+SequenceNode = yaml.nodes.SequenceNode 
+MappingNode = yaml.nodes.MappingNode 
+ 
+cdef class Mark: 
+    cdef readonly object name 
     cdef readonly size_t index
     cdef readonly size_t line
     cdef readonly size_t column
-    cdef readonly buffer
-    cdef readonly pointer
-
+    cdef readonly buffer 
+    cdef readonly pointer 
+ 
     def __init__(self, object name, size_t index, size_t line, size_t column,
-            object buffer, object pointer):
-        self.name = name
-        self.index = index
-        self.line = line
-        self.column = column
-        self.buffer = buffer
-        self.pointer = pointer
-
-    def get_snippet(self):
-        return None
-
-    def __str__(self):
-        where = "  in \"%s\", line %d, column %d"   \
-                % (self.name, self.line+1, self.column+1)
-        return where
-
-#class YAMLError(Exception):
-#    pass
-#
-#class MarkedYAMLError(YAMLError):
-#
-#    def __init__(self, context=None, context_mark=None,
-#            problem=None, problem_mark=None, note=None):
-#        self.context = context
-#        self.context_mark = context_mark
-#        self.problem = problem
-#        self.problem_mark = problem_mark
-#        self.note = note
-#
-#    def __str__(self):
-#        lines = []
-#        if self.context is not None:
-#            lines.append(self.context)
-#        if self.context_mark is not None  \
-#            and (self.problem is None or self.problem_mark is None
-#                    or self.context_mark.name != self.problem_mark.name
-#                    or self.context_mark.line != self.problem_mark.line
-#                    or self.context_mark.column != self.problem_mark.column):
-#            lines.append(str(self.context_mark))
-#        if self.problem is not None:
-#            lines.append(self.problem)
-#        if self.problem_mark is not None:
-#            lines.append(str(self.problem_mark))
-#        if self.note is not None:
-#            lines.append(self.note)
-#        return '\n'.join(lines)
-#
-#class ReaderError(YAMLError):
-#
-#    def __init__(self, name, position, character, encoding, reason):
-#        self.name = name
-#        self.character = character
-#        self.position = position
-#        self.encoding = encoding
-#        self.reason = reason
-#
-#    def __str__(self):
-#        if isinstance(self.character, str):
-#            return "'%s' codec can't decode byte #x%02x: %s\n"  \
-#                    "  in \"%s\", position %d"    \
-#                    % (self.encoding, ord(self.character), self.reason,
-#                            self.name, self.position)
-#        else:
-#            return "unacceptable character #x%04x: %s\n"    \
-#                    "  in \"%s\", position %d"    \
-#                    % (ord(self.character), self.reason,
-#                            self.name, self.position)
-#
-#class ScannerError(MarkedYAMLError):
-#    pass
-#
-#class ParserError(MarkedYAMLError):
-#    pass
-#
-#class EmitterError(YAMLError):
-#    pass
-#
-#cdef class Token:
-#    cdef readonly Mark start_mark
-#    cdef readonly Mark end_mark
-#    def __init__(self, Mark start_mark, Mark end_mark):
-#        self.start_mark = start_mark
-#        self.end_mark = end_mark
-#
-#cdef class StreamStartToken(Token):
-#    cdef readonly object encoding
-#    def __init__(self, Mark start_mark, Mark end_mark, encoding):
-#        self.start_mark = start_mark
-#        self.end_mark = end_mark
-#        self.encoding = encoding
-#
-#cdef class StreamEndToken(Token):
-#    pass
-#
-#cdef class DirectiveToken(Token):
-#    cdef readonly object name
-#    cdef readonly object value
-#    def __init__(self, name, value, Mark start_mark, Mark end_mark):
-#        self.name = name
-#        self.value = value
-#        self.start_mark = start_mark
-#        self.end_mark = end_mark
-#
-#cdef class DocumentStartToken(Token):
-#    pass
-#
-#cdef class DocumentEndToken(Token):
-#    pass
-#
-#cdef class BlockSequenceStartToken(Token):
-#    pass
-#
-#cdef class BlockMappingStartToken(Token):
-#    pass
-#
-#cdef class BlockEndToken(Token):
-#    pass
-#
-#cdef class FlowSequenceStartToken(Token):
-#    pass
-#
-#cdef class FlowMappingStartToken(Token):
-#    pass
-#
-#cdef class FlowSequenceEndToken(Token):
-#    pass
-#
-#cdef class FlowMappingEndToken(Token):
-#    pass
-#
-#cdef class KeyToken(Token):
-#    pass
-#
-#cdef class ValueToken(Token):
-#    pass
-#
-#cdef class BlockEntryToken(Token):
-#    pass
-#
-#cdef class FlowEntryToken(Token):
-#    pass
-#
-#cdef class AliasToken(Token):
-#    cdef readonly object value
-#    def __init__(self, value, Mark start_mark, Mark end_mark):
-#        self.value = value
-#        self.start_mark = start_mark
-#        self.end_mark = end_mark
-#
-#cdef class AnchorToken(Token):
-#    cdef readonly object value
-#    def __init__(self, value, Mark start_mark, Mark end_mark):
-#        self.value = value
-#        self.start_mark = start_mark
-#        self.end_mark = end_mark
-#
-#cdef class TagToken(Token):
-#    cdef readonly object value
-#    def __init__(self, value, Mark start_mark, Mark end_mark):
-#        self.value = value
-#        self.start_mark = start_mark
-#        self.end_mark = end_mark
-#
-#cdef class ScalarToken(Token):
-#    cdef readonly object value
-#    cdef readonly object plain
-#    cdef readonly object style
-#    def __init__(self, value, plain, Mark start_mark, Mark end_mark, style=None):
-#        self.value = value
-#        self.plain = plain
-#        self.start_mark = start_mark
-#        self.end_mark = end_mark
-#        self.style = style
-
-cdef class CParser:
-
-    cdef yaml_parser_t parser
-    cdef yaml_event_t parsed_event
-
-    cdef object stream
-    cdef object stream_name
-    cdef object current_token
-    cdef object current_event
-    cdef object anchors
-    cdef object stream_cache
+            object buffer, object pointer): 
+        self.name = name 
+        self.index = index 
+        self.line = line 
+        self.column = column 
+        self.buffer = buffer 
+        self.pointer = pointer 
+ 
+    def get_snippet(self): 
+        return None 
+ 
+    def __str__(self): 
+        where = "  in \"%s\", line %d, column %d"   \ 
+                % (self.name, self.line+1, self.column+1) 
+        return where 
+ 
+#class YAMLError(Exception): 
+#    pass 
+# 
+#class MarkedYAMLError(YAMLError): 
+# 
+#    def __init__(self, context=None, context_mark=None, 
+#            problem=None, problem_mark=None, note=None): 
+#        self.context = context 
+#        self.context_mark = context_mark 
+#        self.problem = problem 
+#        self.problem_mark = problem_mark 
+#        self.note = note 
+# 
+#    def __str__(self): 
+#        lines = [] 
+#        if self.context is not None: 
+#            lines.append(self.context) 
+#        if self.context_mark is not None  \ 
+#            and (self.problem is None or self.problem_mark is None 
+#                    or self.context_mark.name != self.problem_mark.name 
+#                    or self.context_mark.line != self.problem_mark.line 
+#                    or self.context_mark.column != self.problem_mark.column): 
+#            lines.append(str(self.context_mark)) 
+#        if self.problem is not None: 
+#            lines.append(self.problem) 
+#        if self.problem_mark is not None: 
+#            lines.append(str(self.problem_mark)) 
+#        if self.note is not None: 
+#            lines.append(self.note) 
+#        return '\n'.join(lines) 
+# 
+#class ReaderError(YAMLError): 
+# 
+#    def __init__(self, name, position, character, encoding, reason): 
+#        self.name = name 
+#        self.character = character 
+#        self.position = position 
+#        self.encoding = encoding 
+#        self.reason = reason 
+# 
+#    def __str__(self): 
+#        if isinstance(self.character, str): 
+#            return "'%s' codec can't decode byte #x%02x: %s\n"  \ 
+#                    "  in \"%s\", position %d"    \ 
+#                    % (self.encoding, ord(self.character), self.reason, 
+#                            self.name, self.position) 
+#        else: 
+#            return "unacceptable character #x%04x: %s\n"    \ 
+#                    "  in \"%s\", position %d"    \ 
+#                    % (ord(self.character), self.reason, 
+#                            self.name, self.position) 
+# 
+#class ScannerError(MarkedYAMLError): 
+#    pass 
+# 
+#class ParserError(MarkedYAMLError): 
+#    pass 
+# 
+#class EmitterError(YAMLError): 
+#    pass 
+# 
+#cdef class Token: 
+#    cdef readonly Mark start_mark 
+#    cdef readonly Mark end_mark 
+#    def __init__(self, Mark start_mark, Mark end_mark): 
+#        self.start_mark = start_mark 
+#        self.end_mark = end_mark 
+# 
+#cdef class StreamStartToken(Token): 
+#    cdef readonly object encoding 
+#    def __init__(self, Mark start_mark, Mark end_mark, encoding): 
+#        self.start_mark = start_mark 
+#        self.end_mark = end_mark 
+#        self.encoding = encoding 
+# 
+#cdef class StreamEndToken(Token): 
+#    pass 
+# 
+#cdef class DirectiveToken(Token): 
+#    cdef readonly object name 
+#    cdef readonly object value 
+#    def __init__(self, name, value, Mark start_mark, Mark end_mark): 
+#        self.name = name 
+#        self.value = value 
+#        self.start_mark = start_mark 
+#        self.end_mark = end_mark 
+# 
+#cdef class DocumentStartToken(Token): 
+#    pass 
+# 
+#cdef class DocumentEndToken(Token): 
+#    pass 
+# 
+#cdef class BlockSequenceStartToken(Token): 
+#    pass 
+# 
+#cdef class BlockMappingStartToken(Token): 
+#    pass 
+# 
+#cdef class BlockEndToken(Token): 
+#    pass 
+# 
+#cdef class FlowSequenceStartToken(Token): 
+#    pass 
+# 
+#cdef class FlowMappingStartToken(Token): 
+#    pass 
+# 
+#cdef class FlowSequenceEndToken(Token): 
+#    pass 
+# 
+#cdef class FlowMappingEndToken(Token): 
+#    pass 
+# 
+#cdef class KeyToken(Token): 
+#    pass 
+# 
+#cdef class ValueToken(Token): 
+#    pass 
+# 
+#cdef class BlockEntryToken(Token): 
+#    pass 
+# 
+#cdef class FlowEntryToken(Token): 
+#    pass 
+# 
+#cdef class AliasToken(Token): 
+#    cdef readonly object value 
+#    def __init__(self, value, Mark start_mark, Mark end_mark): 
+#        self.value = value 
+#        self.start_mark = start_mark 
+#        self.end_mark = end_mark 
+# 
+#cdef class AnchorToken(Token): 
+#    cdef readonly object value 
+#    def __init__(self, value, Mark start_mark, Mark end_mark): 
+#        self.value = value 
+#        self.start_mark = start_mark 
+#        self.end_mark = end_mark 
+# 
+#cdef class TagToken(Token): 
+#    cdef readonly object value 
+#    def __init__(self, value, Mark start_mark, Mark end_mark): 
+#        self.value = value 
+#        self.start_mark = start_mark 
+#        self.end_mark = end_mark 
+# 
+#cdef class ScalarToken(Token): 
+#    cdef readonly object value 
+#    cdef readonly object plain 
+#    cdef readonly object style 
+#    def __init__(self, value, plain, Mark start_mark, Mark end_mark, style=None): 
+#        self.value = value 
+#        self.plain = plain 
+#        self.start_mark = start_mark 
+#        self.end_mark = end_mark 
+#        self.style = style 
+ 
+cdef class CParser: 
+ 
+    cdef yaml_parser_t parser 
+    cdef yaml_event_t parsed_event 
+ 
+    cdef object stream 
+    cdef object stream_name 
+    cdef object current_token 
+    cdef object current_event 
+    cdef object anchors 
+    cdef object stream_cache 
     cdef int stream_cache_len
     cdef int stream_cache_pos
-    cdef int unicode_source
-
-    def __init__(self, stream):
-        cdef is_readable
-        if yaml_parser_initialize(&self.parser) == 0:
-            raise MemoryError
-        self.parsed_event.type = YAML_NO_EVENT
-        is_readable = 1
-        try:
-            stream.read
-        except AttributeError:
-            is_readable = 0
-        self.unicode_source = 0
-        if is_readable:
-            self.stream = stream
-            try:
-                self.stream_name = stream.name
-            except AttributeError:
-                if PY_MAJOR_VERSION < 3:
-                    self.stream_name = '<file>'
-                else:
-                    self.stream_name = u'<file>'
-            self.stream_cache = None
-            self.stream_cache_len = 0
-            self.stream_cache_pos = 0
-            yaml_parser_set_input(&self.parser, input_handler, <void *>self)
-        else:
-            if PyUnicode_CheckExact(stream) != 0:
-                stream = PyUnicode_AsUTF8String(stream)
-                if PY_MAJOR_VERSION < 3:
-                    self.stream_name = '<unicode string>'
-                else:
-                    self.stream_name = u'<unicode string>'
-                self.unicode_source = 1
-            else:
-                if PY_MAJOR_VERSION < 3:
-                    self.stream_name = '<byte string>'
-                else:
-                    self.stream_name = u'<byte string>'
-            if PyString_CheckExact(stream) == 0:
-                if PY_MAJOR_VERSION < 3:
-                    raise TypeError("a string or stream input is required")
-                else:
-                    raise TypeError(u"a string or stream input is required")
-            self.stream = stream
+    cdef int unicode_source 
+ 
+    def __init__(self, stream): 
+        cdef is_readable 
+        if yaml_parser_initialize(&self.parser) == 0: 
+            raise MemoryError 
+        self.parsed_event.type = YAML_NO_EVENT 
+        is_readable = 1 
+        try: 
+            stream.read 
+        except AttributeError: 
+            is_readable = 0 
+        self.unicode_source = 0 
+        if is_readable: 
+            self.stream = stream 
+            try: 
+                self.stream_name = stream.name 
+            except AttributeError: 
+                if PY_MAJOR_VERSION < 3: 
+                    self.stream_name = '<file>' 
+                else: 
+                    self.stream_name = u'<file>' 
+            self.stream_cache = None 
+            self.stream_cache_len = 0 
+            self.stream_cache_pos = 0 
+            yaml_parser_set_input(&self.parser, input_handler, <void *>self) 
+        else: 
+            if PyUnicode_CheckExact(stream) != 0: 
+                stream = PyUnicode_AsUTF8String(stream) 
+                if PY_MAJOR_VERSION < 3: 
+                    self.stream_name = '<unicode string>' 
+                else: 
+                    self.stream_name = u'<unicode string>' 
+                self.unicode_source = 1 
+            else: 
+                if PY_MAJOR_VERSION < 3: 
+                    self.stream_name = '<byte string>' 
+                else: 
+                    self.stream_name = u'<byte string>' 
+            if PyString_CheckExact(stream) == 0: 
+                if PY_MAJOR_VERSION < 3: 
+                    raise TypeError("a string or stream input is required") 
+                else: 
+                    raise TypeError(u"a string or stream input is required") 
+            self.stream = stream 
             yaml_parser_set_input_string(&self.parser, PyString_AS_STRING(stream), PyString_GET_SIZE(stream))
-        self.current_token = None
-        self.current_event = None
-        self.anchors = {}
-
-    def __dealloc__(self):
-        yaml_parser_delete(&self.parser)
-        yaml_event_delete(&self.parsed_event)
-
-    def dispose(self):
-        pass
-
-    cdef object _parser_error(self):
-        if self.parser.error == YAML_MEMORY_ERROR:
-            return MemoryError
-        elif self.parser.error == YAML_READER_ERROR:
-            if PY_MAJOR_VERSION < 3:
-                return ReaderError(self.stream_name, self.parser.problem_offset,
-                        self.parser.problem_value, '?', self.parser.problem)
-            else:
-                return ReaderError(self.stream_name, self.parser.problem_offset,
-                        self.parser.problem_value, u'?', PyUnicode_FromString(self.parser.problem))
-        elif self.parser.error == YAML_SCANNER_ERROR    \
-                or self.parser.error == YAML_PARSER_ERROR:
-            context_mark = None
-            problem_mark = None
-            if self.parser.context != NULL:
-                context_mark = Mark(self.stream_name,
-                        self.parser.context_mark.index,
-                        self.parser.context_mark.line,
-                        self.parser.context_mark.column, None, None)
-            if self.parser.problem != NULL:
-                problem_mark = Mark(self.stream_name,
-                        self.parser.problem_mark.index,
-                        self.parser.problem_mark.line,
-                        self.parser.problem_mark.column, None, None)
-            context = None
-            if self.parser.context != NULL:
-                if PY_MAJOR_VERSION < 3:
-                    context = self.parser.context
-                else:
-                    context = PyUnicode_FromString(self.parser.context)
-            if PY_MAJOR_VERSION < 3:
-                problem = self.parser.problem
-            else:
-                problem = PyUnicode_FromString(self.parser.problem)
-            if self.parser.error == YAML_SCANNER_ERROR:
-                return ScannerError(context, context_mark, problem, problem_mark)
-            else:
-                return ParserError(context, context_mark, problem, problem_mark)
-        if PY_MAJOR_VERSION < 3:
-            raise ValueError("no parser error")
-        else:
-            raise ValueError(u"no parser error")
-
-    def raw_scan(self):
-        cdef yaml_token_t token
-        cdef int done
-        cdef int count
-        count = 0
-        done = 0
-        while done == 0:
-            if yaml_parser_scan(&self.parser, &token) == 0:
-                error = self._parser_error()
-                raise error
-            if token.type == YAML_NO_TOKEN:
-                done = 1
-            else:
-                count = count+1
-            yaml_token_delete(&token)
-        return count
-
-    cdef object _scan(self):
-        cdef yaml_token_t token
-        if yaml_parser_scan(&self.parser, &token) == 0:
-            error = self._parser_error()
-            raise error
-        token_object = self._token_to_object(&token)
-        yaml_token_delete(&token)
-        return token_object
-
-    cdef object _token_to_object(self, yaml_token_t *token):
-        start_mark = Mark(self.stream_name,
-                token.start_mark.index,
-                token.start_mark.line,
-                token.start_mark.column,
-                None, None)
-        end_mark = Mark(self.stream_name,
-                token.end_mark.index,
-                token.end_mark.line,
-                token.end_mark.column,
-                None, None)
-        if token.type == YAML_NO_TOKEN:
-            return None
-        elif token.type == YAML_STREAM_START_TOKEN:
-            encoding = None
-            if token.data.stream_start.encoding == YAML_UTF8_ENCODING:
-                if self.unicode_source == 0:
-                    encoding = u"utf-8"
-            elif token.data.stream_start.encoding == YAML_UTF16LE_ENCODING:
-                encoding = u"utf-16-le"
-            elif token.data.stream_start.encoding == YAML_UTF16BE_ENCODING:
-                encoding = u"utf-16-be"
-            return StreamStartToken(start_mark, end_mark, encoding)
-        elif token.type == YAML_STREAM_END_TOKEN:
-            return StreamEndToken(start_mark, end_mark)
-        elif token.type == YAML_VERSION_DIRECTIVE_TOKEN:
-            return DirectiveToken(u"YAML",
-                    (token.data.version_directive.major,
-                        token.data.version_directive.minor),
-                    start_mark, end_mark)
-        elif token.type == YAML_TAG_DIRECTIVE_TOKEN:
+        self.current_token = None 
+        self.current_event = None 
+        self.anchors = {} 
+ 
+    def __dealloc__(self): 
+        yaml_parser_delete(&self.parser) 
+        yaml_event_delete(&self.parsed_event) 
+ 
+    def dispose(self): 
+        pass 
+ 
+    cdef object _parser_error(self): 
+        if self.parser.error == YAML_MEMORY_ERROR: 
+            return MemoryError 
+        elif self.parser.error == YAML_READER_ERROR: 
+            if PY_MAJOR_VERSION < 3: 
+                return ReaderError(self.stream_name, self.parser.problem_offset, 
+                        self.parser.problem_value, '?', self.parser.problem) 
+            else: 
+                return ReaderError(self.stream_name, self.parser.problem_offset, 
+                        self.parser.problem_value, u'?', PyUnicode_FromString(self.parser.problem)) 
+        elif self.parser.error == YAML_SCANNER_ERROR    \ 
+                or self.parser.error == YAML_PARSER_ERROR: 
+            context_mark = None 
+            problem_mark = None 
+            if self.parser.context != NULL: 
+                context_mark = Mark(self.stream_name, 
+                        self.parser.context_mark.index, 
+                        self.parser.context_mark.line, 
+                        self.parser.context_mark.column, None, None) 
+            if self.parser.problem != NULL: 
+                problem_mark = Mark(self.stream_name, 
+                        self.parser.problem_mark.index, 
+                        self.parser.problem_mark.line, 
+                        self.parser.problem_mark.column, None, None) 
+            context = None 
+            if self.parser.context != NULL: 
+                if PY_MAJOR_VERSION < 3: 
+                    context = self.parser.context 
+                else: 
+                    context = PyUnicode_FromString(self.parser.context) 
+            if PY_MAJOR_VERSION < 3: 
+                problem = self.parser.problem 
+            else: 
+                problem = PyUnicode_FromString(self.parser.problem) 
+            if self.parser.error == YAML_SCANNER_ERROR: 
+                return ScannerError(context, context_mark, problem, problem_mark) 
+            else: 
+                return ParserError(context, context_mark, problem, problem_mark) 
+        if PY_MAJOR_VERSION < 3: 
+            raise ValueError("no parser error") 
+        else: 
+            raise ValueError(u"no parser error") 
+ 
+    def raw_scan(self): 
+        cdef yaml_token_t token 
+        cdef int done 
+        cdef int count 
+        count = 0 
+        done = 0 
+        while done == 0: 
+            if yaml_parser_scan(&self.parser, &token) == 0: 
+                error = self._parser_error() 
+                raise error 
+            if token.type == YAML_NO_TOKEN: 
+                done = 1 
+            else: 
+                count = count+1 
+            yaml_token_delete(&token) 
+        return count 
+ 
+    cdef object _scan(self): 
+        cdef yaml_token_t token 
+        if yaml_parser_scan(&self.parser, &token) == 0: 
+            error = self._parser_error() 
+            raise error 
+        token_object = self._token_to_object(&token) 
+        yaml_token_delete(&token) 
+        return token_object 
+ 
+    cdef object _token_to_object(self, yaml_token_t *token): 
+        start_mark = Mark(self.stream_name, 
+                token.start_mark.index, 
+                token.start_mark.line, 
+                token.start_mark.column, 
+                None, None) 
+        end_mark = Mark(self.stream_name, 
+                token.end_mark.index, 
+                token.end_mark.line, 
+                token.end_mark.column, 
+                None, None) 
+        if token.type == YAML_NO_TOKEN: 
+            return None 
+        elif token.type == YAML_STREAM_START_TOKEN: 
+            encoding = None 
+            if token.data.stream_start.encoding == YAML_UTF8_ENCODING: 
+                if self.unicode_source == 0: 
+                    encoding = u"utf-8" 
+            elif token.data.stream_start.encoding == YAML_UTF16LE_ENCODING: 
+                encoding = u"utf-16-le" 
+            elif token.data.stream_start.encoding == YAML_UTF16BE_ENCODING: 
+                encoding = u"utf-16-be" 
+            return StreamStartToken(start_mark, end_mark, encoding) 
+        elif token.type == YAML_STREAM_END_TOKEN: 
+            return StreamEndToken(start_mark, end_mark) 
+        elif token.type == YAML_VERSION_DIRECTIVE_TOKEN: 
+            return DirectiveToken(u"YAML", 
+                    (token.data.version_directive.major, 
+                        token.data.version_directive.minor), 
+                    start_mark, end_mark) 
+        elif token.type == YAML_TAG_DIRECTIVE_TOKEN: 
             handle = PyUnicode_FromString(token.data.tag_directive.handle)
             prefix = PyUnicode_FromString(token.data.tag_directive.prefix)
-            return DirectiveToken(u"TAG", (handle, prefix),
-                    start_mark, end_mark)
-        elif token.type == YAML_DOCUMENT_START_TOKEN:
-            return DocumentStartToken(start_mark, end_mark)
-        elif token.type == YAML_DOCUMENT_END_TOKEN:
-            return DocumentEndToken(start_mark, end_mark)
-        elif token.type == YAML_BLOCK_SEQUENCE_START_TOKEN:
-            return BlockSequenceStartToken(start_mark, end_mark)
-        elif token.type == YAML_BLOCK_MAPPING_START_TOKEN:
-            return BlockMappingStartToken(start_mark, end_mark)
-        elif token.type == YAML_BLOCK_END_TOKEN:
-            return BlockEndToken(start_mark, end_mark)
-        elif token.type == YAML_FLOW_SEQUENCE_START_TOKEN:
-            return FlowSequenceStartToken(start_mark, end_mark)
-        elif token.type == YAML_FLOW_SEQUENCE_END_TOKEN:
-            return FlowSequenceEndToken(start_mark, end_mark)
-        elif token.type == YAML_FLOW_MAPPING_START_TOKEN:
-            return FlowMappingStartToken(start_mark, end_mark)
-        elif token.type == YAML_FLOW_MAPPING_END_TOKEN:
-            return FlowMappingEndToken(start_mark, end_mark)
-        elif token.type == YAML_BLOCK_ENTRY_TOKEN:
-            return BlockEntryToken(start_mark, end_mark)
-        elif token.type == YAML_FLOW_ENTRY_TOKEN:
-            return FlowEntryToken(start_mark, end_mark)
-        elif token.type == YAML_KEY_TOKEN:
-            return KeyToken(start_mark, end_mark)
-        elif token.type == YAML_VALUE_TOKEN:
-            return ValueToken(start_mark, end_mark)
-        elif token.type == YAML_ALIAS_TOKEN:
-            value = PyUnicode_FromString(token.data.alias.value)
-            return AliasToken(value, start_mark, end_mark)
-        elif token.type == YAML_ANCHOR_TOKEN:
-            value = PyUnicode_FromString(token.data.anchor.value)
-            return AnchorToken(value, start_mark, end_mark)
-        elif token.type == YAML_TAG_TOKEN:
+            return DirectiveToken(u"TAG", (handle, prefix), 
+                    start_mark, end_mark) 
+        elif token.type == YAML_DOCUMENT_START_TOKEN: 
+            return DocumentStartToken(start_mark, end_mark) 
+        elif token.type == YAML_DOCUMENT_END_TOKEN: 
+            return DocumentEndToken(start_mark, end_mark) 
+        elif token.type == YAML_BLOCK_SEQUENCE_START_TOKEN: 
+            return BlockSequenceStartToken(start_mark, end_mark) 
+        elif token.type == YAML_BLOCK_MAPPING_START_TOKEN: 
+            return BlockMappingStartToken(start_mark, end_mark) 
+        elif token.type == YAML_BLOCK_END_TOKEN: 
+            return BlockEndToken(start_mark, end_mark) 
+        elif token.type == YAML_FLOW_SEQUENCE_START_TOKEN: 
+            return FlowSequenceStartToken(start_mark, end_mark) 
+        elif token.type == YAML_FLOW_SEQUENCE_END_TOKEN: 
+            return FlowSequenceEndToken(start_mark, end_mark) 
+        elif token.type == YAML_FLOW_MAPPING_START_TOKEN: 
+            return FlowMappingStartToken(start_mark, end_mark) 
+        elif token.type == YAML_FLOW_MAPPING_END_TOKEN: 
+            return FlowMappingEndToken(start_mark, end_mark) 
+        elif token.type == YAML_BLOCK_ENTRY_TOKEN: 
+            return BlockEntryToken(start_mark, end_mark) 
+        elif token.type == YAML_FLOW_ENTRY_TOKEN: 
+            return FlowEntryToken(start_mark, end_mark) 
+        elif token.type == YAML_KEY_TOKEN: 
+            return KeyToken(start_mark, end_mark) 
+        elif token.type == YAML_VALUE_TOKEN: 
+            return ValueToken(start_mark, end_mark) 
+        elif token.type == YAML_ALIAS_TOKEN: 
+            value = PyUnicode_FromString(token.data.alias.value) 
+            return AliasToken(value, start_mark, end_mark) 
+        elif token.type == YAML_ANCHOR_TOKEN: 
+            value = PyUnicode_FromString(token.data.anchor.value) 
+            return AnchorToken(value, start_mark, end_mark) 
+        elif token.type == YAML_TAG_TOKEN: 
             handle = PyUnicode_FromString(token.data.tag.handle)
             suffix = PyUnicode_FromString(token.data.tag.suffix)
-            if not handle:
-                handle = None
-            return TagToken((handle, suffix), start_mark, end_mark)
-        elif token.type == YAML_SCALAR_TOKEN:
+            if not handle: 
+                handle = None 
+            return TagToken((handle, suffix), start_mark, end_mark) 
+        elif token.type == YAML_SCALAR_TOKEN: 
             value = PyUnicode_DecodeUTF8(token.data.scalar.value,
-                    token.data.scalar.length, 'strict')
-            plain = False
-            style = None
-            if token.data.scalar.style == YAML_PLAIN_SCALAR_STYLE:
-                plain = True
-                style = u''
-            elif token.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE:
-                style = u'\''
-            elif token.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE:
-                style = u'"'
-            elif token.data.scalar.style == YAML_LITERAL_SCALAR_STYLE:
-                style = u'|'
-            elif token.data.scalar.style == YAML_FOLDED_SCALAR_STYLE:
-                style = u'>'
-            return ScalarToken(value, plain,
-                    start_mark, end_mark, style)
-        else:
-            if PY_MAJOR_VERSION < 3:
-                raise ValueError("unknown token type")
-            else:
-                raise ValueError(u"unknown token type")
-
-    def get_token(self):
-        if self.current_token is not None:
-            value = self.current_token
-            self.current_token = None
-        else:
-            value = self._scan()
-        return value
-
-    def peek_token(self):
-        if self.current_token is None:
-            self.current_token = self._scan()
-        return self.current_token
-
-    def check_token(self, *choices):
-        if self.current_token is None:
-            self.current_token = self._scan()
-        if self.current_token is None:
-            return False
-        if not choices:
-            return True
-        token_class = self.current_token.__class__
-        for choice in choices:
-            if token_class is choice:
-                return True
-        return False
-
-    def raw_parse(self):
-        cdef yaml_event_t event
-        cdef int done
-        cdef int count
-        count = 0
-        done = 0
-        while done == 0:
-            if yaml_parser_parse(&self.parser, &event) == 0:
-                error = self._parser_error()
-                raise error
-            if event.type == YAML_NO_EVENT:
-                done = 1
-            else:
-                count = count+1
-            yaml_event_delete(&event)
-        return count
-
-    cdef object _parse(self):
-        cdef yaml_event_t event
-        if yaml_parser_parse(&self.parser, &event) == 0:
-            error = self._parser_error()
-            raise error
-        event_object = self._event_to_object(&event)
-        yaml_event_delete(&event)
-        return event_object
-
-    cdef object _event_to_object(self, yaml_event_t *event):
-        cdef yaml_tag_directive_t *tag_directive
-        start_mark = Mark(self.stream_name,
-                event.start_mark.index,
-                event.start_mark.line,
-                event.start_mark.column,
-                None, None)
-        end_mark = Mark(self.stream_name,
-                event.end_mark.index,
-                event.end_mark.line,
-                event.end_mark.column,
-                None, None)
-        if event.type == YAML_NO_EVENT:
-            return None
-        elif event.type == YAML_STREAM_START_EVENT:
-            encoding = None
-            if event.data.stream_start.encoding == YAML_UTF8_ENCODING:
-                if self.unicode_source == 0:
-                    encoding = u"utf-8"
-            elif event.data.stream_start.encoding == YAML_UTF16LE_ENCODING:
-                encoding = u"utf-16-le"
-            elif event.data.stream_start.encoding == YAML_UTF16BE_ENCODING:
-                encoding = u"utf-16-be"
-            return StreamStartEvent(start_mark, end_mark, encoding)
-        elif event.type == YAML_STREAM_END_EVENT:
-            return StreamEndEvent(start_mark, end_mark)
-        elif event.type == YAML_DOCUMENT_START_EVENT:
-            explicit = False
-            if event.data.document_start.implicit == 0:
-                explicit = True
-            version = None
-            if event.data.document_start.version_directive != NULL:
-                version = (event.data.document_start.version_directive.major,
-                        event.data.document_start.version_directive.minor)
-            tags = None
-            if event.data.document_start.tag_directives.start != NULL:
-                tags = {}
-                tag_directive = event.data.document_start.tag_directives.start
-                while tag_directive != event.data.document_start.tag_directives.end:
+                    token.data.scalar.length, 'strict') 
+            plain = False 
+            style = None 
+            if token.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: 
+                plain = True 
+                style = u'' 
+            elif token.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: 
+                style = u'\'' 
+            elif token.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: 
+                style = u'"' 
+            elif token.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: 
+                style = u'|' 
+            elif token.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: 
+                style = u'>' 
+            return ScalarToken(value, plain, 
+                    start_mark, end_mark, style) 
+        else: 
+            if PY_MAJOR_VERSION < 3: 
+                raise ValueError("unknown token type") 
+            else: 
+                raise ValueError(u"unknown token type") 
+ 
+    def get_token(self): 
+        if self.current_token is not None: 
+            value = self.current_token 
+            self.current_token = None 
+        else: 
+            value = self._scan() 
+        return value 
+ 
+    def peek_token(self): 
+        if self.current_token is None: 
+            self.current_token = self._scan() 
+        return self.current_token 
+ 
+    def check_token(self, *choices): 
+        if self.current_token is None: 
+            self.current_token = self._scan() 
+        if self.current_token is None: 
+            return False 
+        if not choices: 
+            return True 
+        token_class = self.current_token.__class__ 
+        for choice in choices: 
+            if token_class is choice: 
+                return True 
+        return False 
+ 
+    def raw_parse(self): 
+        cdef yaml_event_t event 
+        cdef int done 
+        cdef int count 
+        count = 0 
+        done = 0 
+        while done == 0: 
+            if yaml_parser_parse(&self.parser, &event) == 0: 
+                error = self._parser_error() 
+                raise error 
+            if event.type == YAML_NO_EVENT: 
+                done = 1 
+            else: 
+                count = count+1 
+            yaml_event_delete(&event) 
+        return count 
+ 
+    cdef object _parse(self): 
+        cdef yaml_event_t event 
+        if yaml_parser_parse(&self.parser, &event) == 0: 
+            error = self._parser_error() 
+            raise error 
+        event_object = self._event_to_object(&event) 
+        yaml_event_delete(&event) 
+        return event_object 
+ 
+    cdef object _event_to_object(self, yaml_event_t *event): 
+        cdef yaml_tag_directive_t *tag_directive 
+        start_mark = Mark(self.stream_name, 
+                event.start_mark.index, 
+                event.start_mark.line, 
+                event.start_mark.column, 
+                None, None) 
+        end_mark = Mark(self.stream_name, 
+                event.end_mark.index, 
+                event.end_mark.line, 
+                event.end_mark.column, 
+                None, None) 
+        if event.type == YAML_NO_EVENT: 
+            return None 
+        elif event.type == YAML_STREAM_START_EVENT: 
+            encoding = None 
+            if event.data.stream_start.encoding == YAML_UTF8_ENCODING: 
+                if self.unicode_source == 0: 
+                    encoding = u"utf-8" 
+            elif event.data.stream_start.encoding == YAML_UTF16LE_ENCODING: 
+                encoding = u"utf-16-le" 
+            elif event.data.stream_start.encoding == YAML_UTF16BE_ENCODING: 
+                encoding = u"utf-16-be" 
+            return StreamStartEvent(start_mark, end_mark, encoding) 
+        elif event.type == YAML_STREAM_END_EVENT: 
+            return StreamEndEvent(start_mark, end_mark) 
+        elif event.type == YAML_DOCUMENT_START_EVENT: 
+            explicit = False 
+            if event.data.document_start.implicit == 0: 
+                explicit = True 
+            version = None 
+            if event.data.document_start.version_directive != NULL: 
+                version = (event.data.document_start.version_directive.major, 
+                        event.data.document_start.version_directive.minor) 
+            tags = None 
+            if event.data.document_start.tag_directives.start != NULL: 
+                tags = {} 
+                tag_directive = event.data.document_start.tag_directives.start 
+                while tag_directive != event.data.document_start.tag_directives.end: 
                     handle = PyUnicode_FromString(tag_directive.handle)
                     prefix = PyUnicode_FromString(tag_directive.prefix)
-                    tags[handle] = prefix
-                    tag_directive = tag_directive+1
-            return DocumentStartEvent(start_mark, end_mark,
-                    explicit, version, tags)
-        elif event.type == YAML_DOCUMENT_END_EVENT:
-            explicit = False
-            if event.data.document_end.implicit == 0:
-                explicit = True
-            return DocumentEndEvent(start_mark, end_mark, explicit)
-        elif event.type == YAML_ALIAS_EVENT:
-            anchor = PyUnicode_FromString(event.data.alias.anchor)
-            return AliasEvent(anchor, start_mark, end_mark)
-        elif event.type == YAML_SCALAR_EVENT:
-            anchor = None
-            if event.data.scalar.anchor != NULL:
-                anchor = PyUnicode_FromString(event.data.scalar.anchor)
-            tag = None
-            if event.data.scalar.tag != NULL:
-                tag = PyUnicode_FromString(event.data.scalar.tag)
+                    tags[handle] = prefix 
+                    tag_directive = tag_directive+1 
+            return DocumentStartEvent(start_mark, end_mark, 
+                    explicit, version, tags) 
+        elif event.type == YAML_DOCUMENT_END_EVENT: 
+            explicit = False 
+            if event.data.document_end.implicit == 0: 
+                explicit = True 
+            return DocumentEndEvent(start_mark, end_mark, explicit) 
+        elif event.type == YAML_ALIAS_EVENT: 
+            anchor = PyUnicode_FromString(event.data.alias.anchor) 
+            return AliasEvent(anchor, start_mark, end_mark) 
+        elif event.type == YAML_SCALAR_EVENT: 
+            anchor = None 
+            if event.data.scalar.anchor != NULL: 
+                anchor = PyUnicode_FromString(event.data.scalar.anchor) 
+            tag = None 
+            if event.data.scalar.tag != NULL: 
+                tag = PyUnicode_FromString(event.data.scalar.tag) 
             value = PyUnicode_DecodeUTF8(event.data.scalar.value,
-                    event.data.scalar.length, 'strict')
-            plain_implicit = False
-            if event.data.scalar.plain_implicit == 1:
-                plain_implicit = True
-            quoted_implicit = False
-            if event.data.scalar.quoted_implicit == 1:
-                quoted_implicit = True
-            style = None
-            if event.data.scalar.style == YAML_PLAIN_SCALAR_STYLE:
-                style = u''
-            elif event.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE:
-                style = u'\''
-            elif event.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE:
-                style = u'"'
-            elif event.data.scalar.style == YAML_LITERAL_SCALAR_STYLE:
-                style = u'|'
-            elif event.data.scalar.style == YAML_FOLDED_SCALAR_STYLE:
-                style = u'>'
-            return ScalarEvent(anchor, tag,
-                    (plain_implicit, quoted_implicit),
-                    value, start_mark, end_mark, style)
-        elif event.type == YAML_SEQUENCE_START_EVENT:
-            anchor = None
-            if event.data.sequence_start.anchor != NULL:
-                anchor = PyUnicode_FromString(event.data.sequence_start.anchor)
-            tag = None
-            if event.data.sequence_start.tag != NULL:
-                tag = PyUnicode_FromString(event.data.sequence_start.tag)
-            implicit = False
-            if event.data.sequence_start.implicit == 1:
-                implicit = True
-            flow_style = None
-            if event.data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE:
-                flow_style = True
-            elif event.data.sequence_start.style == YAML_BLOCK_SEQUENCE_STYLE:
-                flow_style = False
-            return SequenceStartEvent(anchor, tag, implicit,
-                    start_mark, end_mark, flow_style)
-        elif event.type == YAML_MAPPING_START_EVENT:
-            anchor = None
-            if event.data.mapping_start.anchor != NULL:
-                anchor = PyUnicode_FromString(event.data.mapping_start.anchor)
-            tag = None
-            if event.data.mapping_start.tag != NULL:
-                tag = PyUnicode_FromString(event.data.mapping_start.tag)
-            implicit = False
-            if event.data.mapping_start.implicit == 1:
-                implicit = True
-            flow_style = None
-            if event.data.mapping_start.style == YAML_FLOW_MAPPING_STYLE:
-                flow_style = True
-            elif event.data.mapping_start.style == YAML_BLOCK_MAPPING_STYLE:
-                flow_style = False
-            return MappingStartEvent(anchor, tag, implicit,
-                    start_mark, end_mark, flow_style)
-        elif event.type == YAML_SEQUENCE_END_EVENT:
-            return SequenceEndEvent(start_mark, end_mark)
-        elif event.type == YAML_MAPPING_END_EVENT:
-            return MappingEndEvent(start_mark, end_mark)
-        else:
-            if PY_MAJOR_VERSION < 3:
-                raise ValueError("unknown event type")
-            else:
-                raise ValueError(u"unknown event type")
-
-    def get_event(self):
-        if self.current_event is not None:
-            value = self.current_event
-            self.current_event = None
-        else:
-            value = self._parse()
-        return value
-
-    def peek_event(self):
-        if self.current_event is None:
-            self.current_event = self._parse()
-        return self.current_event
-
-    def check_event(self, *choices):
-        if self.current_event is None:
-            self.current_event = self._parse()
-        if self.current_event is None:
-            return False
-        if not choices:
-            return True
-        event_class = self.current_event.__class__
-        for choice in choices:
-            if event_class is choice:
-                return True
-        return False
-
-    def check_node(self):
-        self._parse_next_event()
-        if self.parsed_event.type == YAML_STREAM_START_EVENT:
-            yaml_event_delete(&self.parsed_event)
-            self._parse_next_event()
-        if self.parsed_event.type != YAML_STREAM_END_EVENT:
-            return True
-        return False
-
-    def get_node(self):
-        self._parse_next_event()
-        if self.parsed_event.type != YAML_STREAM_END_EVENT:
-            return self._compose_document()
-
-    def get_single_node(self):
-        self._parse_next_event()
-        yaml_event_delete(&self.parsed_event)
-        self._parse_next_event()
-        document = None
-        if self.parsed_event.type != YAML_STREAM_END_EVENT:
-            document = self._compose_document()
-        self._parse_next_event()
-        if self.parsed_event.type != YAML_STREAM_END_EVENT:
-            mark = Mark(self.stream_name,
-                    self.parsed_event.start_mark.index,
-                    self.parsed_event.start_mark.line,
-                    self.parsed_event.start_mark.column,
-                    None, None)
-            if PY_MAJOR_VERSION < 3:
-                raise ComposerError("expected a single document in the stream",
-                        document.start_mark, "but found another document", mark)
-            else:
-                raise ComposerError(u"expected a single document in the stream",
-                        document.start_mark, u"but found another document", mark)
-        return document
-
-    cdef object _compose_document(self):
-        yaml_event_delete(&self.parsed_event)
-        node = self._compose_node(None, None)
-        self._parse_next_event()
-        yaml_event_delete(&self.parsed_event)
-        self.anchors = {}
-        return node
-
-    cdef object _compose_node(self, object parent, object index):
-        self._parse_next_event()
-        if self.parsed_event.type == YAML_ALIAS_EVENT:
-            anchor = PyUnicode_FromString(self.parsed_event.data.alias.anchor)
-            if anchor not in self.anchors:
-                mark = Mark(self.stream_name,
-                        self.parsed_event.start_mark.index,
-                        self.parsed_event.start_mark.line,
-                        self.parsed_event.start_mark.column,
-                        None, None)
-                if PY_MAJOR_VERSION < 3:
-                    raise ComposerError(None, None, "found undefined alias", mark)
-                else:
-                    raise ComposerError(None, None, u"found undefined alias", mark)
-            yaml_event_delete(&self.parsed_event)
-            return self.anchors[anchor]
-        anchor = None
-        if self.parsed_event.type == YAML_SCALAR_EVENT  \
-                and self.parsed_event.data.scalar.anchor != NULL:
-            anchor = PyUnicode_FromString(self.parsed_event.data.scalar.anchor)
-        elif self.parsed_event.type == YAML_SEQUENCE_START_EVENT    \
-                and self.parsed_event.data.sequence_start.anchor != NULL:
-            anchor = PyUnicode_FromString(self.parsed_event.data.sequence_start.anchor)
-        elif self.parsed_event.type == YAML_MAPPING_START_EVENT    \
-                and self.parsed_event.data.mapping_start.anchor != NULL:
-            anchor = PyUnicode_FromString(self.parsed_event.data.mapping_start.anchor)
-        if anchor is not None:
-            if anchor in self.anchors:
-                mark = Mark(self.stream_name,
-                        self.parsed_event.start_mark.index,
-                        self.parsed_event.start_mark.line,
-                        self.parsed_event.start_mark.column,
-                        None, None)
-                if PY_MAJOR_VERSION < 3:
+                    event.data.scalar.length, 'strict') 
+            plain_implicit = False 
+            if event.data.scalar.plain_implicit == 1: 
+                plain_implicit = True 
+            quoted_implicit = False 
+            if event.data.scalar.quoted_implicit == 1: 
+                quoted_implicit = True 
+            style = None 
+            if event.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: 
+                style = u'' 
+            elif event.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: 
+                style = u'\'' 
+            elif event.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: 
+                style = u'"' 
+            elif event.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: 
+                style = u'|' 
+            elif event.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: 
+                style = u'>' 
+            return ScalarEvent(anchor, tag, 
+                    (plain_implicit, quoted_implicit), 
+                    value, start_mark, end_mark, style) 
+        elif event.type == YAML_SEQUENCE_START_EVENT: 
+            anchor = None 
+            if event.data.sequence_start.anchor != NULL: 
+                anchor = PyUnicode_FromString(event.data.sequence_start.anchor) 
+            tag = None 
+            if event.data.sequence_start.tag != NULL: 
+                tag = PyUnicode_FromString(event.data.sequence_start.tag) 
+            implicit = False 
+            if event.data.sequence_start.implicit == 1: 
+                implicit = True 
+            flow_style = None 
+            if event.data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE: 
+                flow_style = True 
+            elif event.data.sequence_start.style == YAML_BLOCK_SEQUENCE_STYLE: 
+                flow_style = False 
+            return SequenceStartEvent(anchor, tag, implicit, 
+                    start_mark, end_mark, flow_style) 
+        elif event.type == YAML_MAPPING_START_EVENT: 
+            anchor = None 
+            if event.data.mapping_start.anchor != NULL: 
+                anchor = PyUnicode_FromString(event.data.mapping_start.anchor) 
+            tag = None 
+            if event.data.mapping_start.tag != NULL: 
+                tag = PyUnicode_FromString(event.data.mapping_start.tag) 
+            implicit = False 
+            if event.data.mapping_start.implicit == 1: 
+                implicit = True 
+            flow_style = None 
+            if event.data.mapping_start.style == YAML_FLOW_MAPPING_STYLE: 
+                flow_style = True 
+            elif event.data.mapping_start.style == YAML_BLOCK_MAPPING_STYLE: 
+                flow_style = False 
+            return MappingStartEvent(anchor, tag, implicit, 
+                    start_mark, end_mark, flow_style) 
+        elif event.type == YAML_SEQUENCE_END_EVENT: 
+            return SequenceEndEvent(start_mark, end_mark) 
+        elif event.type == YAML_MAPPING_END_EVENT: 
+            return MappingEndEvent(start_mark, end_mark) 
+        else: 
+            if PY_MAJOR_VERSION < 3: 
+                raise ValueError("unknown event type") 
+            else: 
+                raise ValueError(u"unknown event type") 
+ 
+    def get_event(self): 
+        if self.current_event is not None: 
+            value = self.current_event 
+            self.current_event = None 
+        else: 
+            value = self._parse() 
+        return value 
+ 
+    def peek_event(self): 
+        if self.current_event is None: 
+            self.current_event = self._parse() 
+        return self.current_event 
+ 
+    def check_event(self, *choices): 
+        if self.current_event is None: 
+            self.current_event = self._parse() 
+        if self.current_event is None: 
+            return False 
+        if not choices: 
+            return True 
+        event_class = self.current_event.__class__ 
+        for choice in choices: 
+            if event_class is choice: 
+                return True 
+        return False 
+ 
+    def check_node(self): 
+        self._parse_next_event() 
+        if self.parsed_event.type == YAML_STREAM_START_EVENT: 
+            yaml_event_delete(&self.parsed_event) 
+            self._parse_next_event() 
+        if self.parsed_event.type != YAML_STREAM_END_EVENT: 
+            return True 
+        return False 
+ 
+    def get_node(self): 
+        self._parse_next_event() 
+        if self.parsed_event.type != YAML_STREAM_END_EVENT: 
+            return self._compose_document() 
+ 
+    def get_single_node(self): 
+        self._parse_next_event() 
+        yaml_event_delete(&self.parsed_event) 
+        self._parse_next_event() 
+        document = None 
+        if self.parsed_event.type != YAML_STREAM_END_EVENT: 
+            document = self._compose_document() 
+        self._parse_next_event() 
+        if self.parsed_event.type != YAML_STREAM_END_EVENT: 
+            mark = Mark(self.stream_name, 
+                    self.parsed_event.start_mark.index, 
+                    self.parsed_event.start_mark.line, 
+                    self.parsed_event.start_mark.column, 
+                    None, None) 
+            if PY_MAJOR_VERSION < 3: 
+                raise ComposerError("expected a single document in the stream", 
+                        document.start_mark, "but found another document", mark) 
+            else: 
+                raise ComposerError(u"expected a single document in the stream", 
+                        document.start_mark, u"but found another document", mark) 
+        return document 
+ 
+    cdef object _compose_document(self): 
+        yaml_event_delete(&self.parsed_event) 
+        node = self._compose_node(None, None) 
+        self._parse_next_event() 
+        yaml_event_delete(&self.parsed_event) 
+        self.anchors = {} 
+        return node 
+ 
+    cdef object _compose_node(self, object parent, object index): 
+        self._parse_next_event() 
+        if self.parsed_event.type == YAML_ALIAS_EVENT: 
+            anchor = PyUnicode_FromString(self.parsed_event.data.alias.anchor) 
+            if anchor not in self.anchors: 
+                mark = Mark(self.stream_name, 
+                        self.parsed_event.start_mark.index, 
+                        self.parsed_event.start_mark.line, 
+                        self.parsed_event.start_mark.column, 
+                        None, None) 
+                if PY_MAJOR_VERSION < 3: 
+                    raise ComposerError(None, None, "found undefined alias", mark) 
+                else: 
+                    raise ComposerError(None, None, u"found undefined alias", mark) 
+            yaml_event_delete(&self.parsed_event) 
+            return self.anchors[anchor] 
+        anchor = None 
+        if self.parsed_event.type == YAML_SCALAR_EVENT  \ 
+                and self.parsed_event.data.scalar.anchor != NULL: 
+            anchor = PyUnicode_FromString(self.parsed_event.data.scalar.anchor) 
+        elif self.parsed_event.type == YAML_SEQUENCE_START_EVENT    \ 
+                and self.parsed_event.data.sequence_start.anchor != NULL: 
+            anchor = PyUnicode_FromString(self.parsed_event.data.sequence_start.anchor) 
+        elif self.parsed_event.type == YAML_MAPPING_START_EVENT    \ 
+                and self.parsed_event.data.mapping_start.anchor != NULL: 
+            anchor = PyUnicode_FromString(self.parsed_event.data.mapping_start.anchor) 
+        if anchor is not None: 
+            if anchor in self.anchors: 
+                mark = Mark(self.stream_name, 
+                        self.parsed_event.start_mark.index, 
+                        self.parsed_event.start_mark.line, 
+                        self.parsed_event.start_mark.column, 
+                        None, None) 
+                if PY_MAJOR_VERSION < 3: 
                     raise ComposerError("found duplicate anchor; first occurrence",
                             self.anchors[anchor].start_mark, "second occurrence", mark)
-                else:
+                else: 
                     raise ComposerError(u"found duplicate anchor; first occurrence",
                             self.anchors[anchor].start_mark, u"second occurrence", mark)
-        self.descend_resolver(parent, index)
-        if self.parsed_event.type == YAML_SCALAR_EVENT:
-            node = self._compose_scalar_node(anchor)
-        elif self.parsed_event.type == YAML_SEQUENCE_START_EVENT:
-            node = self._compose_sequence_node(anchor)
-        elif self.parsed_event.type == YAML_MAPPING_START_EVENT:
-            node = self._compose_mapping_node(anchor)
-        self.ascend_resolver()
-        return node
-
-    cdef _compose_scalar_node(self, object anchor):
-        start_mark = Mark(self.stream_name,
-                self.parsed_event.start_mark.index,
-                self.parsed_event.start_mark.line,
-                self.parsed_event.start_mark.column,
-                None, None)
-        end_mark = Mark(self.stream_name,
-                self.parsed_event.end_mark.index,
-                self.parsed_event.end_mark.line,
-                self.parsed_event.end_mark.column,
-                None, None)
+        self.descend_resolver(parent, index) 
+        if self.parsed_event.type == YAML_SCALAR_EVENT: 
+            node = self._compose_scalar_node(anchor) 
+        elif self.parsed_event.type == YAML_SEQUENCE_START_EVENT: 
+            node = self._compose_sequence_node(anchor) 
+        elif self.parsed_event.type == YAML_MAPPING_START_EVENT: 
+            node = self._compose_mapping_node(anchor) 
+        self.ascend_resolver() 
+        return node 
+ 
+    cdef _compose_scalar_node(self, object anchor): 
+        start_mark = Mark(self.stream_name, 
+                self.parsed_event.start_mark.index, 
+                self.parsed_event.start_mark.line, 
+                self.parsed_event.start_mark.column, 
+                None, None) 
+        end_mark = Mark(self.stream_name, 
+                self.parsed_event.end_mark.index, 
+                self.parsed_event.end_mark.line, 
+                self.parsed_event.end_mark.column, 
+                None, None) 
         value = PyUnicode_DecodeUTF8(self.parsed_event.data.scalar.value,
-                self.parsed_event.data.scalar.length, 'strict')
-        plain_implicit = False
-        if self.parsed_event.data.scalar.plain_implicit == 1:
-            plain_implicit = True
-        quoted_implicit = False
-        if self.parsed_event.data.scalar.quoted_implicit == 1:
-            quoted_implicit = True
-        if self.parsed_event.data.scalar.tag == NULL    \
-                or (self.parsed_event.data.scalar.tag[0] == c'!'
-                        and self.parsed_event.data.scalar.tag[1] == c'\0'):
-            tag = self.resolve(ScalarNode, value, (plain_implicit, quoted_implicit))
-        else:
-            tag = PyUnicode_FromString(self.parsed_event.data.scalar.tag)
-        style = None
-        if self.parsed_event.data.scalar.style == YAML_PLAIN_SCALAR_STYLE:
-            style = u''
-        elif self.parsed_event.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE:
-            style = u'\''
-        elif self.parsed_event.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE:
-            style = u'"'
-        elif self.parsed_event.data.scalar.style == YAML_LITERAL_SCALAR_STYLE:
-            style = u'|'
-        elif self.parsed_event.data.scalar.style == YAML_FOLDED_SCALAR_STYLE:
-            style = u'>'
-        node = ScalarNode(tag, value, start_mark, end_mark, style)
-        if anchor is not None:
-            self.anchors[anchor] = node
-        yaml_event_delete(&self.parsed_event)
-        return node
-
-    cdef _compose_sequence_node(self, object anchor):
-        cdef int index
-        start_mark = Mark(self.stream_name,
-                self.parsed_event.start_mark.index,
-                self.parsed_event.start_mark.line,
-                self.parsed_event.start_mark.column,
-                None, None)
-        implicit = False
-        if self.parsed_event.data.sequence_start.implicit == 1:
-            implicit = True
-        if self.parsed_event.data.sequence_start.tag == NULL    \
-                or (self.parsed_event.data.sequence_start.tag[0] == c'!'
-                        and self.parsed_event.data.sequence_start.tag[1] == c'\0'):
-            tag = self.resolve(SequenceNode, None, implicit)
-        else:
-            tag = PyUnicode_FromString(self.parsed_event.data.sequence_start.tag)
-        flow_style = None
-        if self.parsed_event.data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE:
-            flow_style = True
-        elif self.parsed_event.data.sequence_start.style == YAML_BLOCK_SEQUENCE_STYLE:
-            flow_style = False
-        value = []
-        node = SequenceNode(tag, value, start_mark, None, flow_style)
-        if anchor is not None:
-            self.anchors[anchor] = node
-        yaml_event_delete(&self.parsed_event)
-        index = 0
-        self._parse_next_event()
-        while self.parsed_event.type != YAML_SEQUENCE_END_EVENT:
-            value.append(self._compose_node(node, index))
-            index = index+1
-            self._parse_next_event()
-        node.end_mark = Mark(self.stream_name,
-                self.parsed_event.end_mark.index,
-                self.parsed_event.end_mark.line,
-                self.parsed_event.end_mark.column,
-                None, None)
-        yaml_event_delete(&self.parsed_event)
-        return node
-
-    cdef _compose_mapping_node(self, object anchor):
-        start_mark = Mark(self.stream_name,
-                self.parsed_event.start_mark.index,
-                self.parsed_event.start_mark.line,
-                self.parsed_event.start_mark.column,
-                None, None)
-        implicit = False
-        if self.parsed_event.data.mapping_start.implicit == 1:
-            implicit = True
-        if self.parsed_event.data.mapping_start.tag == NULL    \
-                or (self.parsed_event.data.mapping_start.tag[0] == c'!'
-                        and self.parsed_event.data.mapping_start.tag[1] == c'\0'):
-            tag = self.resolve(MappingNode, None, implicit)
-        else:
-            tag = PyUnicode_FromString(self.parsed_event.data.mapping_start.tag)
-        flow_style = None
-        if self.parsed_event.data.mapping_start.style == YAML_FLOW_MAPPING_STYLE:
-            flow_style = True
-        elif self.parsed_event.data.mapping_start.style == YAML_BLOCK_MAPPING_STYLE:
-            flow_style = False
-        value = []
-        node = MappingNode(tag, value, start_mark, None, flow_style)
-        if anchor is not None:
-            self.anchors[anchor] = node
-        yaml_event_delete(&self.parsed_event)
-        self._parse_next_event()
-        while self.parsed_event.type != YAML_MAPPING_END_EVENT:
-            item_key = self._compose_node(node, None)
-            item_value = self._compose_node(node, item_key)
-            value.append((item_key, item_value))
-            self._parse_next_event()
-        node.end_mark = Mark(self.stream_name,
-                self.parsed_event.end_mark.index,
-                self.parsed_event.end_mark.line,
-                self.parsed_event.end_mark.column,
-                None, None)
-        yaml_event_delete(&self.parsed_event)
-        return node
-
-    cdef int _parse_next_event(self) except 0:
-        if self.parsed_event.type == YAML_NO_EVENT:
-            if yaml_parser_parse(&self.parser, &self.parsed_event) == 0:
-                error = self._parser_error()
-                raise error
-        return 1
-
+                self.parsed_event.data.scalar.length, 'strict') 
+        plain_implicit = False 
+        if self.parsed_event.data.scalar.plain_implicit == 1: 
+            plain_implicit = True 
+        quoted_implicit = False 
+        if self.parsed_event.data.scalar.quoted_implicit == 1: 
+            quoted_implicit = True 
+        if self.parsed_event.data.scalar.tag == NULL    \ 
+                or (self.parsed_event.data.scalar.tag[0] == c'!' 
+                        and self.parsed_event.data.scalar.tag[1] == c'\0'): 
+            tag = self.resolve(ScalarNode, value, (plain_implicit, quoted_implicit)) 
+        else: 
+            tag = PyUnicode_FromString(self.parsed_event.data.scalar.tag) 
+        style = None 
+        if self.parsed_event.data.scalar.style == YAML_PLAIN_SCALAR_STYLE: 
+            style = u'' 
+        elif self.parsed_event.data.scalar.style == YAML_SINGLE_QUOTED_SCALAR_STYLE: 
+            style = u'\'' 
+        elif self.parsed_event.data.scalar.style == YAML_DOUBLE_QUOTED_SCALAR_STYLE: 
+            style = u'"' 
+        elif self.parsed_event.data.scalar.style == YAML_LITERAL_SCALAR_STYLE: 
+            style = u'|' 
+        elif self.parsed_event.data.scalar.style == YAML_FOLDED_SCALAR_STYLE: 
+            style = u'>' 
+        node = ScalarNode(tag, value, start_mark, end_mark, style) 
+        if anchor is not None: 
+            self.anchors[anchor] = node 
+        yaml_event_delete(&self.parsed_event) 
+        return node 
+ 
+    cdef _compose_sequence_node(self, object anchor): 
+        cdef int index 
+        start_mark = Mark(self.stream_name, 
+                self.parsed_event.start_mark.index, 
+                self.parsed_event.start_mark.line, 
+                self.parsed_event.start_mark.column, 
+                None, None) 
+        implicit = False 
+        if self.parsed_event.data.sequence_start.implicit == 1: 
+            implicit = True 
+        if self.parsed_event.data.sequence_start.tag == NULL    \ 
+                or (self.parsed_event.data.sequence_start.tag[0] == c'!' 
+                        and self.parsed_event.data.sequence_start.tag[1] == c'\0'): 
+            tag = self.resolve(SequenceNode, None, implicit) 
+        else: 
+            tag = PyUnicode_FromString(self.parsed_event.data.sequence_start.tag) 
+        flow_style = None 
+        if self.parsed_event.data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE: 
+            flow_style = True 
+        elif self.parsed_event.data.sequence_start.style == YAML_BLOCK_SEQUENCE_STYLE: 
+            flow_style = False 
+        value = [] 
+        node = SequenceNode(tag, value, start_mark, None, flow_style) 
+        if anchor is not None: 
+            self.anchors[anchor] = node 
+        yaml_event_delete(&self.parsed_event) 
+        index = 0 
+        self._parse_next_event() 
+        while self.parsed_event.type != YAML_SEQUENCE_END_EVENT: 
+            value.append(self._compose_node(node, index)) 
+            index = index+1 
+            self._parse_next_event() 
+        node.end_mark = Mark(self.stream_name, 
+                self.parsed_event.end_mark.index, 
+                self.parsed_event.end_mark.line, 
+                self.parsed_event.end_mark.column, 
+                None, None) 
+        yaml_event_delete(&self.parsed_event) 
+        return node 
+ 
+    cdef _compose_mapping_node(self, object anchor): 
+        start_mark = Mark(self.stream_name, 
+                self.parsed_event.start_mark.index, 
+                self.parsed_event.start_mark.line, 
+                self.parsed_event.start_mark.column, 
+                None, None) 
+        implicit = False 
+        if self.parsed_event.data.mapping_start.implicit == 1: 
+            implicit = True 
+        if self.parsed_event.data.mapping_start.tag == NULL    \ 
+                or (self.parsed_event.data.mapping_start.tag[0] == c'!' 
+                        and self.parsed_event.data.mapping_start.tag[1] == c'\0'): 
+            tag = self.resolve(MappingNode, None, implicit) 
+        else: 
+            tag = PyUnicode_FromString(self.parsed_event.data.mapping_start.tag) 
+        flow_style = None 
+        if self.parsed_event.data.mapping_start.style == YAML_FLOW_MAPPING_STYLE: 
+            flow_style = True 
+        elif self.parsed_event.data.mapping_start.style == YAML_BLOCK_MAPPING_STYLE: 
+            flow_style = False 
+        value = [] 
+        node = MappingNode(tag, value, start_mark, None, flow_style) 
+        if anchor is not None: 
+            self.anchors[anchor] = node 
+        yaml_event_delete(&self.parsed_event) 
+        self._parse_next_event() 
+        while self.parsed_event.type != YAML_MAPPING_END_EVENT: 
+            item_key = self._compose_node(node, None) 
+            item_value = self._compose_node(node, item_key) 
+            value.append((item_key, item_value)) 
+            self._parse_next_event() 
+        node.end_mark = Mark(self.stream_name, 
+                self.parsed_event.end_mark.index, 
+                self.parsed_event.end_mark.line, 
+                self.parsed_event.end_mark.column, 
+                None, None) 
+        yaml_event_delete(&self.parsed_event) 
+        return node 
+ 
+    cdef int _parse_next_event(self) except 0: 
+        if self.parsed_event.type == YAML_NO_EVENT: 
+            if yaml_parser_parse(&self.parser, &self.parsed_event) == 0: 
+                error = self._parser_error() 
+                raise error 
+        return 1 
+ 
 cdef int input_handler(void *data, char *buffer, size_t size, size_t *read) except 0:
-    cdef CParser parser
-    parser = <CParser>data
-    if parser.stream_cache is None:
-        value = parser.stream.read(size)
-        if PyUnicode_CheckExact(value) != 0:
-            value = PyUnicode_AsUTF8String(value)
-            parser.unicode_source = 1
-        if PyString_CheckExact(value) == 0:
-            if PY_MAJOR_VERSION < 3:
-                raise TypeError("a string value is expected")
-            else:
-                raise TypeError(u"a string value is expected")
-        parser.stream_cache = value
-        parser.stream_cache_pos = 0
-        parser.stream_cache_len = PyString_GET_SIZE(value)
-    if (parser.stream_cache_len - parser.stream_cache_pos) < size:
-        size = parser.stream_cache_len - parser.stream_cache_pos
-    if size > 0:
+    cdef CParser parser 
+    parser = <CParser>data 
+    if parser.stream_cache is None: 
+        value = parser.stream.read(size) 
+        if PyUnicode_CheckExact(value) != 0: 
+            value = PyUnicode_AsUTF8String(value) 
+            parser.unicode_source = 1 
+        if PyString_CheckExact(value) == 0: 
+            if PY_MAJOR_VERSION < 3: 
+                raise TypeError("a string value is expected") 
+            else: 
+                raise TypeError(u"a string value is expected") 
+        parser.stream_cache = value 
+        parser.stream_cache_pos = 0 
+        parser.stream_cache_len = PyString_GET_SIZE(value) 
+    if (parser.stream_cache_len - parser.stream_cache_pos) < size: 
+        size = parser.stream_cache_len - parser.stream_cache_pos 
+    if size > 0: 
         memcpy(buffer, PyString_AS_STRING(parser.stream_cache)
-                            + parser.stream_cache_pos, size)
-    read[0] = size
-    parser.stream_cache_pos += size
-    if parser.stream_cache_pos == parser.stream_cache_len:
-        parser.stream_cache = None
-    return 1
-
-cdef class CEmitter:
-
-    cdef yaml_emitter_t emitter
-
-    cdef object stream
-
-    cdef int document_start_implicit
-    cdef int document_end_implicit
-    cdef object use_version
-    cdef object use_tags
-
-    cdef object serialized_nodes
-    cdef object anchors
-    cdef int last_alias_id
-    cdef int closed
-    cdef int dump_unicode
-    cdef object use_encoding
-
-    def __init__(self, stream, canonical=None, indent=None, width=None,
-            allow_unicode=None, line_break=None, encoding=None,
-            explicit_start=None, explicit_end=None, version=None, tags=None):
-        if yaml_emitter_initialize(&self.emitter) == 0:
-            raise MemoryError
-        self.stream = stream
-        self.dump_unicode = 0
-        if PY_MAJOR_VERSION < 3:
-            if getattr3(stream, 'encoding', None):
-                self.dump_unicode = 1
-        else:
-            if hasattr(stream, u'encoding'):
-                self.dump_unicode = 1
-        self.use_encoding = encoding
+                            + parser.stream_cache_pos, size) 
+    read[0] = size 
+    parser.stream_cache_pos += size 
+    if parser.stream_cache_pos == parser.stream_cache_len: 
+        parser.stream_cache = None 
+    return 1 
+ 
+cdef class CEmitter: 
+ 
+    cdef yaml_emitter_t emitter 
+ 
+    cdef object stream 
+ 
+    cdef int document_start_implicit 
+    cdef int document_end_implicit 
+    cdef object use_version 
+    cdef object use_tags 
+ 
+    cdef object serialized_nodes 
+    cdef object anchors 
+    cdef int last_alias_id 
+    cdef int closed 
+    cdef int dump_unicode 
+    cdef object use_encoding 
+ 
+    def __init__(self, stream, canonical=None, indent=None, width=None, 
+            allow_unicode=None, line_break=None, encoding=None, 
+            explicit_start=None, explicit_end=None, version=None, tags=None): 
+        if yaml_emitter_initialize(&self.emitter) == 0: 
+            raise MemoryError 
+        self.stream = stream 
+        self.dump_unicode = 0 
+        if PY_MAJOR_VERSION < 3: 
+            if getattr3(stream, 'encoding', None): 
+                self.dump_unicode = 1 
+        else: 
+            if hasattr(stream, u'encoding'): 
+                self.dump_unicode = 1 
+        self.use_encoding = encoding 
         yaml_emitter_set_output(&self.emitter, output_handler, <void *>self)    
-        if canonical:
-            yaml_emitter_set_canonical(&self.emitter, 1)
-        if indent is not None:
-            yaml_emitter_set_indent(&self.emitter, indent)
-        if width is not None:
-            yaml_emitter_set_width(&self.emitter, width)
-        if allow_unicode:
-            yaml_emitter_set_unicode(&self.emitter, 1)
-        if line_break is not None:
-            if line_break == '\r':
-                yaml_emitter_set_break(&self.emitter, YAML_CR_BREAK)
-            elif line_break == '\n':
-                yaml_emitter_set_break(&self.emitter, YAML_LN_BREAK)
-            elif line_break == '\r\n':
-                yaml_emitter_set_break(&self.emitter, YAML_CRLN_BREAK)
-        self.document_start_implicit = 1
-        if explicit_start:
-            self.document_start_implicit = 0
-        self.document_end_implicit = 1
-        if explicit_end:
-            self.document_end_implicit = 0
-        self.use_version = version
-        self.use_tags = tags
-        self.serialized_nodes = {}
-        self.anchors = {}
-        self.last_alias_id = 0
-        self.closed = -1
-
-    def __dealloc__(self):
-        yaml_emitter_delete(&self.emitter)
-
-    def dispose(self):
-        pass
-
-    cdef object _emitter_error(self):
-        if self.emitter.error == YAML_MEMORY_ERROR:
-            return MemoryError
-        elif self.emitter.error == YAML_EMITTER_ERROR:
-            if PY_MAJOR_VERSION < 3:
-                problem = self.emitter.problem
-            else:
-                problem = PyUnicode_FromString(self.emitter.problem)
-            return EmitterError(problem)
-        if PY_MAJOR_VERSION < 3:
-            raise ValueError("no emitter error")
-        else:
-            raise ValueError(u"no emitter error")
-
-    cdef int _object_to_event(self, object event_object, yaml_event_t *event) except 0:
-        cdef yaml_encoding_t encoding
-        cdef yaml_version_directive_t version_directive_value
-        cdef yaml_version_directive_t *version_directive
-        cdef yaml_tag_directive_t tag_directives_value[128]
-        cdef yaml_tag_directive_t *tag_directives_start
-        cdef yaml_tag_directive_t *tag_directives_end
-        cdef int implicit
-        cdef int plain_implicit
-        cdef int quoted_implicit
-        cdef char *anchor
-        cdef char *tag
-        cdef char *value
-        cdef int length
-        cdef yaml_scalar_style_t scalar_style
-        cdef yaml_sequence_style_t sequence_style
-        cdef yaml_mapping_style_t mapping_style
-        event_class = event_object.__class__
-        if event_class is StreamStartEvent:
-            encoding = YAML_UTF8_ENCODING
-            if event_object.encoding == u'utf-16-le' or event_object.encoding == 'utf-16-le':
-                encoding = YAML_UTF16LE_ENCODING
-            elif event_object.encoding == u'utf-16-be' or event_object.encoding == 'utf-16-be':
-                encoding = YAML_UTF16BE_ENCODING
-            if event_object.encoding is None:
-                self.dump_unicode = 1
-            if self.dump_unicode == 1:
-                encoding = YAML_UTF8_ENCODING
-            yaml_stream_start_event_initialize(event, encoding)
-        elif event_class is StreamEndEvent:
-            yaml_stream_end_event_initialize(event)
-        elif event_class is DocumentStartEvent:
-            version_directive = NULL
-            if event_object.version:
-                version_directive_value.major = event_object.version[0]
-                version_directive_value.minor = event_object.version[1]
-                version_directive = &version_directive_value
-            tag_directives_start = NULL
-            tag_directives_end = NULL
-            if event_object.tags:
-                if len(event_object.tags) > 128:
-                    if PY_MAJOR_VERSION < 3:
-                        raise ValueError("too many tags")
-                    else:
-                        raise ValueError(u"too many tags")
-                tag_directives_start = tag_directives_value
-                tag_directives_end = tag_directives_value
-                cache = []
-                for handle in event_object.tags:
-                    prefix = event_object.tags[handle]
-                    if PyUnicode_CheckExact(handle):
-                        handle = PyUnicode_AsUTF8String(handle)
-                        cache.append(handle)
-                    if not PyString_CheckExact(handle):
-                        if PY_MAJOR_VERSION < 3:
-                            raise TypeError("tag handle must be a string")
-                        else:
-                            raise TypeError(u"tag handle must be a string")
+        if canonical: 
+            yaml_emitter_set_canonical(&self.emitter, 1) 
+        if indent is not None: 
+            yaml_emitter_set_indent(&self.emitter, indent) 
+        if width is not None: 
+            yaml_emitter_set_width(&self.emitter, width) 
+        if allow_unicode: 
+            yaml_emitter_set_unicode(&self.emitter, 1) 
+        if line_break is not None: 
+            if line_break == '\r': 
+                yaml_emitter_set_break(&self.emitter, YAML_CR_BREAK) 
+            elif line_break == '\n': 
+                yaml_emitter_set_break(&self.emitter, YAML_LN_BREAK) 
+            elif line_break == '\r\n': 
+                yaml_emitter_set_break(&self.emitter, YAML_CRLN_BREAK) 
+        self.document_start_implicit = 1 
+        if explicit_start: 
+            self.document_start_implicit = 0 
+        self.document_end_implicit = 1 
+        if explicit_end: 
+            self.document_end_implicit = 0 
+        self.use_version = version 
+        self.use_tags = tags 
+        self.serialized_nodes = {} 
+        self.anchors = {} 
+        self.last_alias_id = 0 
+        self.closed = -1 
+ 
+    def __dealloc__(self): 
+        yaml_emitter_delete(&self.emitter) 
+ 
+    def dispose(self): 
+        pass 
+ 
+    cdef object _emitter_error(self): 
+        if self.emitter.error == YAML_MEMORY_ERROR: 
+            return MemoryError 
+        elif self.emitter.error == YAML_EMITTER_ERROR: 
+            if PY_MAJOR_VERSION < 3: 
+                problem = self.emitter.problem 
+            else: 
+                problem = PyUnicode_FromString(self.emitter.problem) 
+            return EmitterError(problem) 
+        if PY_MAJOR_VERSION < 3: 
+            raise ValueError("no emitter error") 
+        else: 
+            raise ValueError(u"no emitter error") 
+ 
+    cdef int _object_to_event(self, object event_object, yaml_event_t *event) except 0: 
+        cdef yaml_encoding_t encoding 
+        cdef yaml_version_directive_t version_directive_value 
+        cdef yaml_version_directive_t *version_directive 
+        cdef yaml_tag_directive_t tag_directives_value[128] 
+        cdef yaml_tag_directive_t *tag_directives_start 
+        cdef yaml_tag_directive_t *tag_directives_end 
+        cdef int implicit 
+        cdef int plain_implicit 
+        cdef int quoted_implicit 
+        cdef char *anchor 
+        cdef char *tag 
+        cdef char *value 
+        cdef int length 
+        cdef yaml_scalar_style_t scalar_style 
+        cdef yaml_sequence_style_t sequence_style 
+        cdef yaml_mapping_style_t mapping_style 
+        event_class = event_object.__class__ 
+        if event_class is StreamStartEvent: 
+            encoding = YAML_UTF8_ENCODING 
+            if event_object.encoding == u'utf-16-le' or event_object.encoding == 'utf-16-le': 
+                encoding = YAML_UTF16LE_ENCODING 
+            elif event_object.encoding == u'utf-16-be' or event_object.encoding == 'utf-16-be': 
+                encoding = YAML_UTF16BE_ENCODING 
+            if event_object.encoding is None: 
+                self.dump_unicode = 1 
+            if self.dump_unicode == 1: 
+                encoding = YAML_UTF8_ENCODING 
+            yaml_stream_start_event_initialize(event, encoding) 
+        elif event_class is StreamEndEvent: 
+            yaml_stream_end_event_initialize(event) 
+        elif event_class is DocumentStartEvent: 
+            version_directive = NULL 
+            if event_object.version: 
+                version_directive_value.major = event_object.version[0] 
+                version_directive_value.minor = event_object.version[1] 
+                version_directive = &version_directive_value 
+            tag_directives_start = NULL 
+            tag_directives_end = NULL 
+            if event_object.tags: 
+                if len(event_object.tags) > 128: 
+                    if PY_MAJOR_VERSION < 3: 
+                        raise ValueError("too many tags") 
+                    else: 
+                        raise ValueError(u"too many tags") 
+                tag_directives_start = tag_directives_value 
+                tag_directives_end = tag_directives_value 
+                cache = [] 
+                for handle in event_object.tags: 
+                    prefix = event_object.tags[handle] 
+                    if PyUnicode_CheckExact(handle): 
+                        handle = PyUnicode_AsUTF8String(handle) 
+                        cache.append(handle) 
+                    if not PyString_CheckExact(handle): 
+                        if PY_MAJOR_VERSION < 3: 
+                            raise TypeError("tag handle must be a string") 
+                        else: 
+                            raise TypeError(u"tag handle must be a string") 
                     tag_directives_end.handle = PyString_AS_STRING(handle)
-                    if PyUnicode_CheckExact(prefix):
-                        prefix = PyUnicode_AsUTF8String(prefix)
-                        cache.append(prefix)
-                    if not PyString_CheckExact(prefix):
-                        if PY_MAJOR_VERSION < 3:
-                            raise TypeError("tag prefix must be a string")
-                        else:
-                            raise TypeError(u"tag prefix must be a string")
+                    if PyUnicode_CheckExact(prefix): 
+                        prefix = PyUnicode_AsUTF8String(prefix) 
+                        cache.append(prefix) 
+                    if not PyString_CheckExact(prefix): 
+                        if PY_MAJOR_VERSION < 3: 
+                            raise TypeError("tag prefix must be a string") 
+                        else: 
+                            raise TypeError(u"tag prefix must be a string") 
                     tag_directives_end.prefix = PyString_AS_STRING(prefix)
-                    tag_directives_end = tag_directives_end+1
-            implicit = 1
-            if event_object.explicit:
-                implicit = 0
-            if yaml_document_start_event_initialize(event, version_directive,
-                    tag_directives_start, tag_directives_end, implicit) == 0:
-                raise MemoryError
-        elif event_class is DocumentEndEvent:
-            implicit = 1
-            if event_object.explicit:
-                implicit = 0
-            yaml_document_end_event_initialize(event, implicit)
-        elif event_class is AliasEvent:
-            anchor = NULL
-            anchor_object = event_object.anchor
-            if PyUnicode_CheckExact(anchor_object):
-                anchor_object = PyUnicode_AsUTF8String(anchor_object)
-            if not PyString_CheckExact(anchor_object):
-                if PY_MAJOR_VERSION < 3:
-                    raise TypeError("anchor must be a string")
-                else:
-                    raise TypeError(u"anchor must be a string")
-            anchor = PyString_AS_STRING(anchor_object)
+                    tag_directives_end = tag_directives_end+1 
+            implicit = 1 
+            if event_object.explicit: 
+                implicit = 0 
+            if yaml_document_start_event_initialize(event, version_directive, 
+                    tag_directives_start, tag_directives_end, implicit) == 0: 
+                raise MemoryError 
+        elif event_class is DocumentEndEvent: 
+            implicit = 1 
+            if event_object.explicit: 
+                implicit = 0 
+            yaml_document_end_event_initialize(event, implicit) 
+        elif event_class is AliasEvent: 
+            anchor = NULL 
+            anchor_object = event_object.anchor 
+            if PyUnicode_CheckExact(anchor_object): 
+                anchor_object = PyUnicode_AsUTF8String(anchor_object) 
+            if not PyString_CheckExact(anchor_object): 
+                if PY_MAJOR_VERSION < 3: 
+                    raise TypeError("anchor must be a string") 
+                else: 
+                    raise TypeError(u"anchor must be a string") 
+            anchor = PyString_AS_STRING(anchor_object) 
             if yaml_alias_event_initialize(event, anchor) == 0:
-                raise MemoryError
-        elif event_class is ScalarEvent:
-            anchor = NULL
-            anchor_object = event_object.anchor
-            if anchor_object is not None:
-                if PyUnicode_CheckExact(anchor_object):
-                    anchor_object = PyUnicode_AsUTF8String(anchor_object)
-                if not PyString_CheckExact(anchor_object):
-                    if PY_MAJOR_VERSION < 3:
-                        raise TypeError("anchor must be a string")
-                    else:
-                        raise TypeError(u"anchor must be a string")
-                anchor = PyString_AS_STRING(anchor_object)
-            tag = NULL
-            tag_object = event_object.tag
-            if tag_object is not None:
-                if PyUnicode_CheckExact(tag_object):
-                    tag_object = PyUnicode_AsUTF8String(tag_object)
-                if not PyString_CheckExact(tag_object):
-                    if PY_MAJOR_VERSION < 3:
-                        raise TypeError("tag must be a string")
-                    else:
-                        raise TypeError(u"tag must be a string")
-                tag = PyString_AS_STRING(tag_object)
-            value_object = event_object.value
-            if PyUnicode_CheckExact(value_object):
-                value_object = PyUnicode_AsUTF8String(value_object)
-            if not PyString_CheckExact(value_object):
-                if PY_MAJOR_VERSION < 3:
-                    raise TypeError("value must be a string")
-                else:
-                    raise TypeError(u"value must be a string")
-            value = PyString_AS_STRING(value_object)
-            length = PyString_GET_SIZE(value_object)
-            plain_implicit = 0
-            quoted_implicit = 0
-            if event_object.implicit is not None:
-                plain_implicit = event_object.implicit[0]
-                quoted_implicit = event_object.implicit[1]
-            style_object = event_object.style
-            scalar_style = YAML_PLAIN_SCALAR_STYLE
-            if style_object == "'" or style_object == u"'":
-                scalar_style = YAML_SINGLE_QUOTED_SCALAR_STYLE
-            elif style_object == "\"" or style_object == u"\"":
-                scalar_style = YAML_DOUBLE_QUOTED_SCALAR_STYLE
-            elif style_object == "|" or style_object == u"|":
-                scalar_style = YAML_LITERAL_SCALAR_STYLE
-            elif style_object == ">" or style_object == u">":
-                scalar_style = YAML_FOLDED_SCALAR_STYLE
+                raise MemoryError 
+        elif event_class is ScalarEvent: 
+            anchor = NULL 
+            anchor_object = event_object.anchor 
+            if anchor_object is not None: 
+                if PyUnicode_CheckExact(anchor_object): 
+                    anchor_object = PyUnicode_AsUTF8String(anchor_object) 
+                if not PyString_CheckExact(anchor_object): 
+                    if PY_MAJOR_VERSION < 3: 
+                        raise TypeError("anchor must be a string") 
+                    else: 
+                        raise TypeError(u"anchor must be a string") 
+                anchor = PyString_AS_STRING(anchor_object) 
+            tag = NULL 
+            tag_object = event_object.tag 
+            if tag_object is not None: 
+                if PyUnicode_CheckExact(tag_object): 
+                    tag_object = PyUnicode_AsUTF8String(tag_object) 
+                if not PyString_CheckExact(tag_object): 
+                    if PY_MAJOR_VERSION < 3: 
+                        raise TypeError("tag must be a string") 
+                    else: 
+                        raise TypeError(u"tag must be a string") 
+                tag = PyString_AS_STRING(tag_object) 
+            value_object = event_object.value 
+            if PyUnicode_CheckExact(value_object): 
+                value_object = PyUnicode_AsUTF8String(value_object) 
+            if not PyString_CheckExact(value_object): 
+                if PY_MAJOR_VERSION < 3: 
+                    raise TypeError("value must be a string") 
+                else: 
+                    raise TypeError(u"value must be a string") 
+            value = PyString_AS_STRING(value_object) 
+            length = PyString_GET_SIZE(value_object) 
+            plain_implicit = 0 
+            quoted_implicit = 0 
+            if event_object.implicit is not None: 
+                plain_implicit = event_object.implicit[0] 
+                quoted_implicit = event_object.implicit[1] 
+            style_object = event_object.style 
+            scalar_style = YAML_PLAIN_SCALAR_STYLE 
+            if style_object == "'" or style_object == u"'": 
+                scalar_style = YAML_SINGLE_QUOTED_SCALAR_STYLE 
+            elif style_object == "\"" or style_object == u"\"": 
+                scalar_style = YAML_DOUBLE_QUOTED_SCALAR_STYLE 
+            elif style_object == "|" or style_object == u"|": 
+                scalar_style = YAML_LITERAL_SCALAR_STYLE 
+            elif style_object == ">" or style_object == u">": 
+                scalar_style = YAML_FOLDED_SCALAR_STYLE 
             if yaml_scalar_event_initialize(event, anchor, tag, value, length,
-                    plain_implicit, quoted_implicit, scalar_style) == 0:
-                raise MemoryError
-        elif event_class is SequenceStartEvent:
-            anchor = NULL
-            anchor_object = event_object.anchor
-            if anchor_object is not None:
-                if PyUnicode_CheckExact(anchor_object):
-                    anchor_object = PyUnicode_AsUTF8String(anchor_object)
-                if not PyString_CheckExact(anchor_object):
-                    if PY_MAJOR_VERSION < 3:
-                        raise TypeError("anchor must be a string")
-                    else:
-                        raise TypeError(u"anchor must be a string")
-                anchor = PyString_AS_STRING(anchor_object)
-            tag = NULL
-            tag_object = event_object.tag
-            if tag_object is not None:
-                if PyUnicode_CheckExact(tag_object):
-                    tag_object = PyUnicode_AsUTF8String(tag_object)
-                if not PyString_CheckExact(tag_object):
-                    if PY_MAJOR_VERSION < 3:
-                        raise TypeError("tag must be a string")
-                    else:
-                        raise TypeError(u"tag must be a string")
-                tag = PyString_AS_STRING(tag_object)
-            implicit = 0
-            if event_object.implicit:
-                implicit = 1
-            sequence_style = YAML_BLOCK_SEQUENCE_STYLE
-            if event_object.flow_style:
-                sequence_style = YAML_FLOW_SEQUENCE_STYLE
+                    plain_implicit, quoted_implicit, scalar_style) == 0: 
+                raise MemoryError 
+        elif event_class is SequenceStartEvent: 
+            anchor = NULL 
+            anchor_object = event_object.anchor 
+            if anchor_object is not None: 
+                if PyUnicode_CheckExact(anchor_object): 
+                    anchor_object = PyUnicode_AsUTF8String(anchor_object) 
+                if not PyString_CheckExact(anchor_object): 
+                    if PY_MAJOR_VERSION < 3: 
+                        raise TypeError("anchor must be a string") 
+                    else: 
+                        raise TypeError(u"anchor must be a string") 
+                anchor = PyString_AS_STRING(anchor_object) 
+            tag = NULL 
+            tag_object = event_object.tag 
+            if tag_object is not None: 
+                if PyUnicode_CheckExact(tag_object): 
+                    tag_object = PyUnicode_AsUTF8String(tag_object) 
+                if not PyString_CheckExact(tag_object): 
+                    if PY_MAJOR_VERSION < 3: 
+                        raise TypeError("tag must be a string") 
+                    else: 
+                        raise TypeError(u"tag must be a string") 
+                tag = PyString_AS_STRING(tag_object) 
+            implicit = 0 
+            if event_object.implicit: 
+                implicit = 1 
+            sequence_style = YAML_BLOCK_SEQUENCE_STYLE 
+            if event_object.flow_style: 
+                sequence_style = YAML_FLOW_SEQUENCE_STYLE 
             if yaml_sequence_start_event_initialize(event, anchor, tag,
-                    implicit, sequence_style) == 0:
-                raise MemoryError
-        elif event_class is MappingStartEvent:
-            anchor = NULL
-            anchor_object = event_object.anchor
-            if anchor_object is not None:
-                if PyUnicode_CheckExact(anchor_object):
-                    anchor_object = PyUnicode_AsUTF8String(anchor_object)
-                if not PyString_CheckExact(anchor_object):
-                    if PY_MAJOR_VERSION < 3:
-                        raise TypeError("anchor must be a string")
-                    else:
-                        raise TypeError(u"anchor must be a string")
-                anchor = PyString_AS_STRING(anchor_object)
-            tag = NULL
-            tag_object = event_object.tag
-            if tag_object is not None:
-                if PyUnicode_CheckExact(tag_object):
-                    tag_object = PyUnicode_AsUTF8String(tag_object)
-                if not PyString_CheckExact(tag_object):
-                    if PY_MAJOR_VERSION < 3:
-                        raise TypeError("tag must be a string")
-                    else:
-                        raise TypeError(u"tag must be a string")
-                tag = PyString_AS_STRING(tag_object)
-            implicit = 0
-            if event_object.implicit:
-                implicit = 1
-            mapping_style = YAML_BLOCK_MAPPING_STYLE
-            if event_object.flow_style:
-                mapping_style = YAML_FLOW_MAPPING_STYLE
+                    implicit, sequence_style) == 0: 
+                raise MemoryError 
+        elif event_class is MappingStartEvent: 
+            anchor = NULL 
+            anchor_object = event_object.anchor 
+            if anchor_object is not None: 
+                if PyUnicode_CheckExact(anchor_object): 
+                    anchor_object = PyUnicode_AsUTF8String(anchor_object) 
+                if not PyString_CheckExact(anchor_object): 
+                    if PY_MAJOR_VERSION < 3: 
+                        raise TypeError("anchor must be a string") 
+                    else: 
+                        raise TypeError(u"anchor must be a string") 
+                anchor = PyString_AS_STRING(anchor_object) 
+            tag = NULL 
+            tag_object = event_object.tag 
+            if tag_object is not None: 
+                if PyUnicode_CheckExact(tag_object): 
+                    tag_object = PyUnicode_AsUTF8String(tag_object) 
+                if not PyString_CheckExact(tag_object): 
+                    if PY_MAJOR_VERSION < 3: 
+                        raise TypeError("tag must be a string") 
+                    else: 
+                        raise TypeError(u"tag must be a string") 
+                tag = PyString_AS_STRING(tag_object) 
+            implicit = 0 
+            if event_object.implicit: 
+                implicit = 1 
+            mapping_style = YAML_BLOCK_MAPPING_STYLE 
+            if event_object.flow_style: 
+                mapping_style = YAML_FLOW_MAPPING_STYLE 
             if yaml_mapping_start_event_initialize(event, anchor, tag,
-                    implicit, mapping_style) == 0:
-                raise MemoryError
-        elif event_class is SequenceEndEvent:
-            yaml_sequence_end_event_initialize(event)
-        elif event_class is MappingEndEvent:
-            yaml_mapping_end_event_initialize(event)
-        else:
-            if PY_MAJOR_VERSION < 3:
-                raise TypeError("invalid event %s" % event_object)
-            else:
-                raise TypeError(u"invalid event %s" % event_object)
-        return 1
-
-    def emit(self, event_object):
-        cdef yaml_event_t event
-        self._object_to_event(event_object, &event)
-        if yaml_emitter_emit(&self.emitter, &event) == 0:
-            error = self._emitter_error()
-            raise error
-
-    def open(self):
-        cdef yaml_event_t event
-        cdef yaml_encoding_t encoding
-        if self.closed == -1:
-            if self.use_encoding == u'utf-16-le' or self.use_encoding == 'utf-16-le':
-                encoding = YAML_UTF16LE_ENCODING
-            elif self.use_encoding == u'utf-16-be' or self.use_encoding == 'utf-16-be':
-                encoding = YAML_UTF16BE_ENCODING
-            else:
-                encoding = YAML_UTF8_ENCODING
-            if self.use_encoding is None:
-                self.dump_unicode = 1
-            if self.dump_unicode == 1:
-                encoding = YAML_UTF8_ENCODING
-            yaml_stream_start_event_initialize(&event, encoding)
-            if yaml_emitter_emit(&self.emitter, &event) == 0:
-                error = self._emitter_error()
-                raise error
-            self.closed = 0
-        elif self.closed == 1:
-            if PY_MAJOR_VERSION < 3:
-                raise SerializerError("serializer is closed")
-            else:
-                raise SerializerError(u"serializer is closed")
-        else:
-            if PY_MAJOR_VERSION < 3:
-                raise SerializerError("serializer is already opened")
-            else:
-                raise SerializerError(u"serializer is already opened")
-
-    def close(self):
-        cdef yaml_event_t event
-        if self.closed == -1:
-            if PY_MAJOR_VERSION < 3:
-                raise SerializerError("serializer is not opened")
-            else:
-                raise SerializerError(u"serializer is not opened")
-        elif self.closed == 0:
-            yaml_stream_end_event_initialize(&event)
-            if yaml_emitter_emit(&self.emitter, &event) == 0:
-                error = self._emitter_error()
-                raise error
-            self.closed = 1
-
-    def serialize(self, node):
-        cdef yaml_event_t event
-        cdef yaml_version_directive_t version_directive_value
-        cdef yaml_version_directive_t *version_directive
-        cdef yaml_tag_directive_t tag_directives_value[128]
-        cdef yaml_tag_directive_t *tag_directives_start
-        cdef yaml_tag_directive_t *tag_directives_end
-        if self.closed == -1:
-            if PY_MAJOR_VERSION < 3:
-                raise SerializerError("serializer is not opened")
-            else:
-                raise SerializerError(u"serializer is not opened")
-        elif self.closed == 1:
-            if PY_MAJOR_VERSION < 3:
-                raise SerializerError("serializer is closed")
-            else:
-                raise SerializerError(u"serializer is closed")
-        cache = []
-        version_directive = NULL
-        if self.use_version:
-            version_directive_value.major = self.use_version[0]
-            version_directive_value.minor = self.use_version[1]
-            version_directive = &version_directive_value
-        tag_directives_start = NULL
-        tag_directives_end = NULL
-        if self.use_tags:
-            if len(self.use_tags) > 128:
-                if PY_MAJOR_VERSION < 3:
-                    raise ValueError("too many tags")
-                else:
-                    raise ValueError(u"too many tags")
-            tag_directives_start = tag_directives_value
-            tag_directives_end = tag_directives_value
-            for handle in self.use_tags:
-                prefix = self.use_tags[handle]
-                if PyUnicode_CheckExact(handle):
-                    handle = PyUnicode_AsUTF8String(handle)
-                    cache.append(handle)
-                if not PyString_CheckExact(handle):
-                    if PY_MAJOR_VERSION < 3:
-                        raise TypeError("tag handle must be a string")
-                    else:
-                        raise TypeError(u"tag handle must be a string")
+                    implicit, mapping_style) == 0: 
+                raise MemoryError 
+        elif event_class is SequenceEndEvent: 
+            yaml_sequence_end_event_initialize(event) 
+        elif event_class is MappingEndEvent: 
+            yaml_mapping_end_event_initialize(event) 
+        else: 
+            if PY_MAJOR_VERSION < 3: 
+                raise TypeError("invalid event %s" % event_object) 
+            else: 
+                raise TypeError(u"invalid event %s" % event_object) 
+        return 1 
+ 
+    def emit(self, event_object): 
+        cdef yaml_event_t event 
+        self._object_to_event(event_object, &event) 
+        if yaml_emitter_emit(&self.emitter, &event) == 0: 
+            error = self._emitter_error() 
+            raise error 
+ 
+    def open(self): 
+        cdef yaml_event_t event 
+        cdef yaml_encoding_t encoding 
+        if self.closed == -1: 
+            if self.use_encoding == u'utf-16-le' or self.use_encoding == 'utf-16-le': 
+                encoding = YAML_UTF16LE_ENCODING 
+            elif self.use_encoding == u'utf-16-be' or self.use_encoding == 'utf-16-be': 
+                encoding = YAML_UTF16BE_ENCODING 
+            else: 
+                encoding = YAML_UTF8_ENCODING 
+            if self.use_encoding is None: 
+                self.dump_unicode = 1 
+            if self.dump_unicode == 1: 
+                encoding = YAML_UTF8_ENCODING 
+            yaml_stream_start_event_initialize(&event, encoding) 
+            if yaml_emitter_emit(&self.emitter, &event) == 0: 
+                error = self._emitter_error() 
+                raise error 
+            self.closed = 0 
+        elif self.closed == 1: 
+            if PY_MAJOR_VERSION < 3: 
+                raise SerializerError("serializer is closed") 
+            else: 
+                raise SerializerError(u"serializer is closed") 
+        else: 
+            if PY_MAJOR_VERSION < 3: 
+                raise SerializerError("serializer is already opened") 
+            else: 
+                raise SerializerError(u"serializer is already opened") 
+ 
+    def close(self): 
+        cdef yaml_event_t event 
+        if self.closed == -1: 
+            if PY_MAJOR_VERSION < 3: 
+                raise SerializerError("serializer is not opened") 
+            else: 
+                raise SerializerError(u"serializer is not opened") 
+        elif self.closed == 0: 
+            yaml_stream_end_event_initialize(&event) 
+            if yaml_emitter_emit(&self.emitter, &event) == 0: 
+                error = self._emitter_error() 
+                raise error 
+            self.closed = 1 
+ 
+    def serialize(self, node): 
+        cdef yaml_event_t event 
+        cdef yaml_version_directive_t version_directive_value 
+        cdef yaml_version_directive_t *version_directive 
+        cdef yaml_tag_directive_t tag_directives_value[128] 
+        cdef yaml_tag_directive_t *tag_directives_start 
+        cdef yaml_tag_directive_t *tag_directives_end 
+        if self.closed == -1: 
+            if PY_MAJOR_VERSION < 3: 
+                raise SerializerError("serializer is not opened") 
+            else: 
+                raise SerializerError(u"serializer is not opened") 
+        elif self.closed == 1: 
+            if PY_MAJOR_VERSION < 3: 
+                raise SerializerError("serializer is closed") 
+            else: 
+                raise SerializerError(u"serializer is closed") 
+        cache = [] 
+        version_directive = NULL 
+        if self.use_version: 
+            version_directive_value.major = self.use_version[0] 
+            version_directive_value.minor = self.use_version[1] 
+            version_directive = &version_directive_value 
+        tag_directives_start = NULL 
+        tag_directives_end = NULL 
+        if self.use_tags: 
+            if len(self.use_tags) > 128: 
+                if PY_MAJOR_VERSION < 3: 
+                    raise ValueError("too many tags") 
+                else: 
+                    raise ValueError(u"too many tags") 
+            tag_directives_start = tag_directives_value 
+            tag_directives_end = tag_directives_value 
+            for handle in self.use_tags: 
+                prefix = self.use_tags[handle] 
+                if PyUnicode_CheckExact(handle): 
+                    handle = PyUnicode_AsUTF8String(handle) 
+                    cache.append(handle) 
+                if not PyString_CheckExact(handle): 
+                    if PY_MAJOR_VERSION < 3: 
+                        raise TypeError("tag handle must be a string") 
+                    else: 
+                        raise TypeError(u"tag handle must be a string") 
                 tag_directives_end.handle = PyString_AS_STRING(handle)
-                if PyUnicode_CheckExact(prefix):
-                    prefix = PyUnicode_AsUTF8String(prefix)
-                    cache.append(prefix)
-                if not PyString_CheckExact(prefix):
-                    if PY_MAJOR_VERSION < 3:
-                        raise TypeError("tag prefix must be a string")
-                    else:
-                        raise TypeError(u"tag prefix must be a string")
+                if PyUnicode_CheckExact(prefix): 
+                    prefix = PyUnicode_AsUTF8String(prefix) 
+                    cache.append(prefix) 
+                if not PyString_CheckExact(prefix): 
+                    if PY_MAJOR_VERSION < 3: 
+                        raise TypeError("tag prefix must be a string") 
+                    else: 
+                        raise TypeError(u"tag prefix must be a string") 
                 tag_directives_end.prefix = PyString_AS_STRING(prefix)
-                tag_directives_end = tag_directives_end+1
-        if yaml_document_start_event_initialize(&event, version_directive,
-                tag_directives_start, tag_directives_end,
-                self.document_start_implicit) == 0:
-            raise MemoryError
-        if yaml_emitter_emit(&self.emitter, &event) == 0:
-            error = self._emitter_error()
-            raise error
-        self._anchor_node(node)
-        self._serialize_node(node, None, None)
-        yaml_document_end_event_initialize(&event, self.document_end_implicit)
-        if yaml_emitter_emit(&self.emitter, &event) == 0:
-            error = self._emitter_error()
-            raise error
-        self.serialized_nodes = {}
-        self.anchors = {}
-        self.last_alias_id = 0
-
-    cdef int _anchor_node(self, object node) except 0:
-        if node in self.anchors:
-            if self.anchors[node] is None:
-                self.last_alias_id = self.last_alias_id+1
-                self.anchors[node] = u"id%03d" % self.last_alias_id
-        else:
-            self.anchors[node] = None
-            node_class = node.__class__
-            if node_class is SequenceNode:
-                for item in node.value:
-                    self._anchor_node(item)
-            elif node_class is MappingNode:
-                for key, value in node.value:
-                    self._anchor_node(key)
-                    self._anchor_node(value)
-        return 1
-
-    cdef int _serialize_node(self, object node, object parent, object index) except 0:
-        cdef yaml_event_t event
-        cdef int implicit
-        cdef int plain_implicit
-        cdef int quoted_implicit
-        cdef char *anchor
-        cdef char *tag
-        cdef char *value
-        cdef int length
-        cdef int item_index
-        cdef yaml_scalar_style_t scalar_style
-        cdef yaml_sequence_style_t sequence_style
-        cdef yaml_mapping_style_t mapping_style
-        anchor_object = self.anchors[node]
-        anchor = NULL
-        if anchor_object is not None:
-            if PyUnicode_CheckExact(anchor_object):
-                anchor_object = PyUnicode_AsUTF8String(anchor_object)
-            if not PyString_CheckExact(anchor_object):
-                if PY_MAJOR_VERSION < 3:
-                    raise TypeError("anchor must be a string")
-                else:
-                    raise TypeError(u"anchor must be a string")
-            anchor = PyString_AS_STRING(anchor_object)
-        if node in self.serialized_nodes:
+                tag_directives_end = tag_directives_end+1 
+        if yaml_document_start_event_initialize(&event, version_directive, 
+                tag_directives_start, tag_directives_end, 
+                self.document_start_implicit) == 0: 
+            raise MemoryError 
+        if yaml_emitter_emit(&self.emitter, &event) == 0: 
+            error = self._emitter_error() 
+            raise error 
+        self._anchor_node(node) 
+        self._serialize_node(node, None, None) 
+        yaml_document_end_event_initialize(&event, self.document_end_implicit) 
+        if yaml_emitter_emit(&self.emitter, &event) == 0: 
+            error = self._emitter_error() 
+            raise error 
+        self.serialized_nodes = {} 
+        self.anchors = {} 
+        self.last_alias_id = 0 
+ 
+    cdef int _anchor_node(self, object node) except 0: 
+        if node in self.anchors: 
+            if self.anchors[node] is None: 
+                self.last_alias_id = self.last_alias_id+1 
+                self.anchors[node] = u"id%03d" % self.last_alias_id 
+        else: 
+            self.anchors[node] = None 
+            node_class = node.__class__ 
+            if node_class is SequenceNode: 
+                for item in node.value: 
+                    self._anchor_node(item) 
+            elif node_class is MappingNode: 
+                for key, value in node.value: 
+                    self._anchor_node(key) 
+                    self._anchor_node(value) 
+        return 1 
+ 
+    cdef int _serialize_node(self, object node, object parent, object index) except 0: 
+        cdef yaml_event_t event 
+        cdef int implicit 
+        cdef int plain_implicit 
+        cdef int quoted_implicit 
+        cdef char *anchor 
+        cdef char *tag 
+        cdef char *value 
+        cdef int length 
+        cdef int item_index 
+        cdef yaml_scalar_style_t scalar_style 
+        cdef yaml_sequence_style_t sequence_style 
+        cdef yaml_mapping_style_t mapping_style 
+        anchor_object = self.anchors[node] 
+        anchor = NULL 
+        if anchor_object is not None: 
+            if PyUnicode_CheckExact(anchor_object): 
+                anchor_object = PyUnicode_AsUTF8String(anchor_object) 
+            if not PyString_CheckExact(anchor_object): 
+                if PY_MAJOR_VERSION < 3: 
+                    raise TypeError("anchor must be a string") 
+                else: 
+                    raise TypeError(u"anchor must be a string") 
+            anchor = PyString_AS_STRING(anchor_object) 
+        if node in self.serialized_nodes: 
             if yaml_alias_event_initialize(&event, anchor) == 0:
-                raise MemoryError
-            if yaml_emitter_emit(&self.emitter, &event) == 0:
-                error = self._emitter_error()
-                raise error
-        else:
-            node_class = node.__class__
-            self.serialized_nodes[node] = True
-            self.descend_resolver(parent, index)
-            if node_class is ScalarNode:
-                plain_implicit = 0
-                quoted_implicit = 0
-                tag_object = node.tag
-                if self.resolve(ScalarNode, node.value, (True, False)) == tag_object:
-                    plain_implicit = 1
-                if self.resolve(ScalarNode, node.value, (False, True)) == tag_object:
-                    quoted_implicit = 1
-                tag = NULL
-                if tag_object is not None:
-                    if PyUnicode_CheckExact(tag_object):
-                        tag_object = PyUnicode_AsUTF8String(tag_object)
-                    if not PyString_CheckExact(tag_object):
-                        if PY_MAJOR_VERSION < 3:
-                            raise TypeError("tag must be a string")
-                        else:
-                            raise TypeError(u"tag must be a string")
-                    tag = PyString_AS_STRING(tag_object)
-                value_object = node.value
-                if PyUnicode_CheckExact(value_object):
-                    value_object = PyUnicode_AsUTF8String(value_object)
-                if not PyString_CheckExact(value_object):
-                    if PY_MAJOR_VERSION < 3:
-                        raise TypeError("value must be a string")
-                    else:
-                        raise TypeError(u"value must be a string")
-                value = PyString_AS_STRING(value_object)
-                length = PyString_GET_SIZE(value_object)
-                style_object = node.style
-                scalar_style = YAML_PLAIN_SCALAR_STYLE
-                if style_object == "'" or style_object == u"'":
-                    scalar_style = YAML_SINGLE_QUOTED_SCALAR_STYLE
-                elif style_object == "\"" or style_object == u"\"":
-                    scalar_style = YAML_DOUBLE_QUOTED_SCALAR_STYLE
-                elif style_object == "|" or style_object == u"|":
-                    scalar_style = YAML_LITERAL_SCALAR_STYLE
-                elif style_object == ">" or style_object == u">":
-                    scalar_style = YAML_FOLDED_SCALAR_STYLE
+                raise MemoryError 
+            if yaml_emitter_emit(&self.emitter, &event) == 0: 
+                error = self._emitter_error() 
+                raise error 
+        else: 
+            node_class = node.__class__ 
+            self.serialized_nodes[node] = True 
+            self.descend_resolver(parent, index) 
+            if node_class is ScalarNode: 
+                plain_implicit = 0 
+                quoted_implicit = 0 
+                tag_object = node.tag 
+                if self.resolve(ScalarNode, node.value, (True, False)) == tag_object: 
+                    plain_implicit = 1 
+                if self.resolve(ScalarNode, node.value, (False, True)) == tag_object: 
+                    quoted_implicit = 1 
+                tag = NULL 
+                if tag_object is not None: 
+                    if PyUnicode_CheckExact(tag_object): 
+                        tag_object = PyUnicode_AsUTF8String(tag_object) 
+                    if not PyString_CheckExact(tag_object): 
+                        if PY_MAJOR_VERSION < 3: 
+                            raise TypeError("tag must be a string") 
+                        else: 
+                            raise TypeError(u"tag must be a string") 
+                    tag = PyString_AS_STRING(tag_object) 
+                value_object = node.value 
+                if PyUnicode_CheckExact(value_object): 
+                    value_object = PyUnicode_AsUTF8String(value_object) 
+                if not PyString_CheckExact(value_object): 
+                    if PY_MAJOR_VERSION < 3: 
+                        raise TypeError("value must be a string") 
+                    else: 
+                        raise TypeError(u"value must be a string") 
+                value = PyString_AS_STRING(value_object) 
+                length = PyString_GET_SIZE(value_object) 
+                style_object = node.style 
+                scalar_style = YAML_PLAIN_SCALAR_STYLE 
+                if style_object == "'" or style_object == u"'": 
+                    scalar_style = YAML_SINGLE_QUOTED_SCALAR_STYLE 
+                elif style_object == "\"" or style_object == u"\"": 
+                    scalar_style = YAML_DOUBLE_QUOTED_SCALAR_STYLE 
+                elif style_object == "|" or style_object == u"|": 
+                    scalar_style = YAML_LITERAL_SCALAR_STYLE 
+                elif style_object == ">" or style_object == u">": 
+                    scalar_style = YAML_FOLDED_SCALAR_STYLE 
                 if yaml_scalar_event_initialize(&event, anchor, tag, value, length,
-                        plain_implicit, quoted_implicit, scalar_style) == 0:
-                    raise MemoryError
-                if yaml_emitter_emit(&self.emitter, &event) == 0:
-                    error = self._emitter_error()
-                    raise error
-            elif node_class is SequenceNode:
-                implicit = 0
-                tag_object = node.tag
-                if self.resolve(SequenceNode, node.value, True) == tag_object:
-                    implicit = 1
-                tag = NULL
-                if tag_object is not None:
-                    if PyUnicode_CheckExact(tag_object):
-                        tag_object = PyUnicode_AsUTF8String(tag_object)
-                    if not PyString_CheckExact(tag_object):
-                        if PY_MAJOR_VERSION < 3:
-                            raise TypeError("tag must be a string")
-                        else:
-                            raise TypeError(u"tag must be a string")
-                    tag = PyString_AS_STRING(tag_object)
-                sequence_style = YAML_BLOCK_SEQUENCE_STYLE
-                if node.flow_style:
-                    sequence_style = YAML_FLOW_SEQUENCE_STYLE
+                        plain_implicit, quoted_implicit, scalar_style) == 0: 
+                    raise MemoryError 
+                if yaml_emitter_emit(&self.emitter, &event) == 0: 
+                    error = self._emitter_error() 
+                    raise error 
+            elif node_class is SequenceNode: 
+                implicit = 0 
+                tag_object = node.tag 
+                if self.resolve(SequenceNode, node.value, True) == tag_object: 
+                    implicit = 1 
+                tag = NULL 
+                if tag_object is not None: 
+                    if PyUnicode_CheckExact(tag_object): 
+                        tag_object = PyUnicode_AsUTF8String(tag_object) 
+                    if not PyString_CheckExact(tag_object): 
+                        if PY_MAJOR_VERSION < 3: 
+                            raise TypeError("tag must be a string") 
+                        else: 
+                            raise TypeError(u"tag must be a string") 
+                    tag = PyString_AS_STRING(tag_object) 
+                sequence_style = YAML_BLOCK_SEQUENCE_STYLE 
+                if node.flow_style: 
+                    sequence_style = YAML_FLOW_SEQUENCE_STYLE 
                 if yaml_sequence_start_event_initialize(&event, anchor, tag,
-                        implicit, sequence_style) == 0:
-                    raise MemoryError
-                if yaml_emitter_emit(&self.emitter, &event) == 0:
-                    error = self._emitter_error()
-                    raise error
-                item_index = 0
-                for item in node.value:
-                    self._serialize_node(item, node, item_index)
-                    item_index = item_index+1
-                yaml_sequence_end_event_initialize(&event)
-                if yaml_emitter_emit(&self.emitter, &event) == 0:
-                    error = self._emitter_error()
-                    raise error
-            elif node_class is MappingNode:
-                implicit = 0
-                tag_object = node.tag
-                if self.resolve(MappingNode, node.value, True) == tag_object:
-                    implicit = 1
-                tag = NULL
-                if tag_object is not None:
-                    if PyUnicode_CheckExact(tag_object):
-                        tag_object = PyUnicode_AsUTF8String(tag_object)
-                    if not PyString_CheckExact(tag_object):
-                        if PY_MAJOR_VERSION < 3:
-                            raise TypeError("tag must be a string")
-                        else:
-                            raise TypeError(u"tag must be a string")
-                    tag = PyString_AS_STRING(tag_object)
-                mapping_style = YAML_BLOCK_MAPPING_STYLE
-                if node.flow_style:
-                    mapping_style = YAML_FLOW_MAPPING_STYLE
+                        implicit, sequence_style) == 0: 
+                    raise MemoryError 
+                if yaml_emitter_emit(&self.emitter, &event) == 0: 
+                    error = self._emitter_error() 
+                    raise error 
+                item_index = 0 
+                for item in node.value: 
+                    self._serialize_node(item, node, item_index) 
+                    item_index = item_index+1 
+                yaml_sequence_end_event_initialize(&event) 
+                if yaml_emitter_emit(&self.emitter, &event) == 0: 
+                    error = self._emitter_error() 
+                    raise error 
+            elif node_class is MappingNode: 
+                implicit = 0 
+                tag_object = node.tag 
+                if self.resolve(MappingNode, node.value, True) == tag_object: 
+                    implicit = 1 
+                tag = NULL 
+                if tag_object is not None: 
+                    if PyUnicode_CheckExact(tag_object): 
+                        tag_object = PyUnicode_AsUTF8String(tag_object) 
+                    if not PyString_CheckExact(tag_object): 
+                        if PY_MAJOR_VERSION < 3: 
+                            raise TypeError("tag must be a string") 
+                        else: 
+                            raise TypeError(u"tag must be a string") 
+                    tag = PyString_AS_STRING(tag_object) 
+                mapping_style = YAML_BLOCK_MAPPING_STYLE 
+                if node.flow_style: 
+                    mapping_style = YAML_FLOW_MAPPING_STYLE 
                 if yaml_mapping_start_event_initialize(&event, anchor, tag,
-                        implicit, mapping_style) == 0:
-                    raise MemoryError
-                if yaml_emitter_emit(&self.emitter, &event) == 0:
-                    error = self._emitter_error()
-                    raise error
-                for item_key, item_value in node.value:
-                    self._serialize_node(item_key, node, None)
-                    self._serialize_node(item_value, node, item_key)
-                yaml_mapping_end_event_initialize(&event)
-                if yaml_emitter_emit(&self.emitter, &event) == 0:
-                    error = self._emitter_error()
-                    raise error
-            self.ascend_resolver()
-        return 1
-
+                        implicit, mapping_style) == 0: 
+                    raise MemoryError 
+                if yaml_emitter_emit(&self.emitter, &event) == 0: 
+                    error = self._emitter_error() 
+                    raise error 
+                for item_key, item_value in node.value: 
+                    self._serialize_node(item_key, node, None) 
+                    self._serialize_node(item_value, node, item_key) 
+                yaml_mapping_end_event_initialize(&event) 
+                if yaml_emitter_emit(&self.emitter, &event) == 0: 
+                    error = self._emitter_error() 
+                    raise error 
+            self.ascend_resolver() 
+        return 1 
+ 
 cdef int output_handler(void *data, char *buffer, size_t size) except 0:
-    cdef CEmitter emitter
-    emitter = <CEmitter>data
-    if emitter.dump_unicode == 0:
+    cdef CEmitter emitter 
+    emitter = <CEmitter>data 
+    if emitter.dump_unicode == 0: 
         value = PyString_FromStringAndSize(buffer, size)
-    else:
+    else: 
         value = PyUnicode_DecodeUTF8(buffer, size, 'strict')
-    emitter.stream.write(value)
-    return 1
-
+    emitter.stream.write(value) 
+    return 1 
+