Restoring authorship annotation for <bnagaev@yandex-team.ru>. Commit 2 of 2.

90 files changed, 10165 insertions, 10165 deletions

diff --git a/contrib/libs/yaml-cpp/LICENSE b/contrib/libs/yaml-cpp/LICENSE
index 1c6af6d4177..991fdbbe7d3 100644
--- a/contrib/libs/yaml-cpp/LICENSE
+++ b/contrib/libs/yaml-cpp/LICENSE
@@ -1,19 +1,19 @@
-Copyright (c) 2008-2015 Jesse Beder. 
- 
-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. 
+Copyright (c) 2008-2015 Jesse Beder.
+
+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/libs/yaml-cpp/include/yaml-cpp/anchor.h b/contrib/libs/yaml-cpp/include/yaml-cpp/anchor.h
index 06965e8fbaa..06759c724d2 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/anchor.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/anchor.h
@@ -1,17 +1,17 @@
-#ifndef ANCHOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define ANCHOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include <cstddef> 
- 
-namespace YAML { 
-typedef std::size_t anchor_t; 
-const anchor_t NullAnchor = 0; 
-} 
- 
-#endif  // ANCHOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+#ifndef ANCHOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define ANCHOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <cstddef>
+
+namespace YAML {
+typedef std::size_t anchor_t;
+const anchor_t NullAnchor = 0;
+}
+
+#endif  // ANCHOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/binary.h b/contrib/libs/yaml-cpp/include/yaml-cpp/binary.h
index ed61f438ddb..29d5dbd027a 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/binary.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/binary.h
@@ -1,67 +1,67 @@
-#ifndef BASE64_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define BASE64_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include <string> 
-#include <vector> 
- 
-#include "yaml-cpp/dll.h" 
- 
-namespace YAML { 
-YAML_CPP_API std::string EncodeBase64(const unsigned char *data, 
-                                      std::size_t size); 
-YAML_CPP_API std::vector<unsigned char> DecodeBase64(const std::string &input); 
- 
-class YAML_CPP_API Binary { 
- public: 
-  Binary() : m_unownedData(0), m_unownedSize(0) {} 
-  Binary(const unsigned char *data_, std::size_t size_) 
-      : m_unownedData(data_), m_unownedSize(size_) {} 
- 
-  bool owned() const { return !m_unownedData; } 
-  std::size_t size() const { return owned() ? m_data.size() : m_unownedSize; } 
-  const unsigned char *data() const { 
-    return owned() ? &m_data[0] : m_unownedData; 
-  } 
- 
-  void swap(std::vector<unsigned char> &rhs) { 
-    if (m_unownedData) { 
-      m_data.swap(rhs); 
-      rhs.clear(); 
-      rhs.resize(m_unownedSize); 
-      std::copy(m_unownedData, m_unownedData + m_unownedSize, rhs.begin()); 
-      m_unownedData = 0; 
-      m_unownedSize = 0; 
-    } else { 
-      m_data.swap(rhs); 
-    } 
-  } 
- 
-  bool operator==(const Binary &rhs) const { 
-    const std::size_t s = size(); 
-    if (s != rhs.size()) 
-      return false; 
-    const unsigned char *d1 = data(); 
-    const unsigned char *d2 = rhs.data(); 
-    for (std::size_t i = 0; i < s; i++) { 
-      if (*d1++ != *d2++) 
-        return false; 
-    } 
-    return true; 
-  } 
- 
-  bool operator!=(const Binary &rhs) const { return !(*this == rhs); } 
- 
- private: 
-  std::vector<unsigned char> m_data; 
-  const unsigned char *m_unownedData; 
-  std::size_t m_unownedSize; 
-}; 
-} 
- 
-#endif  // BASE64_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+#ifndef BASE64_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define BASE64_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <string>
+#include <vector>
+
+#include "yaml-cpp/dll.h"
+
+namespace YAML {
+YAML_CPP_API std::string EncodeBase64(const unsigned char *data,
+                                      std::size_t size);
+YAML_CPP_API std::vector<unsigned char> DecodeBase64(const std::string &input);
+
+class YAML_CPP_API Binary {
+ public:
+  Binary() : m_unownedData(0), m_unownedSize(0) {}
+  Binary(const unsigned char *data_, std::size_t size_)
+      : m_unownedData(data_), m_unownedSize(size_) {}
+
+  bool owned() const { return !m_unownedData; }
+  std::size_t size() const { return owned() ? m_data.size() : m_unownedSize; }
+  const unsigned char *data() const {
+    return owned() ? &m_data[0] : m_unownedData;
+  }
+
+  void swap(std::vector<unsigned char> &rhs) {
+    if (m_unownedData) {
+      m_data.swap(rhs);
+      rhs.clear();
+      rhs.resize(m_unownedSize);
+      std::copy(m_unownedData, m_unownedData + m_unownedSize, rhs.begin());
+      m_unownedData = 0;
+      m_unownedSize = 0;
+    } else {
+      m_data.swap(rhs);
+    }
+  }
+
+  bool operator==(const Binary &rhs) const {
+    const std::size_t s = size();
+    if (s != rhs.size())
+      return false;
+    const unsigned char *d1 = data();
+    const unsigned char *d2 = rhs.data();
+    for (std::size_t i = 0; i < s; i++) {
+      if (*d1++ != *d2++)
+        return false;
+    }
+    return true;
+  }
+
+  bool operator!=(const Binary &rhs) const { return !(*this == rhs); }
+
+ private:
+  std::vector<unsigned char> m_data;
+  const unsigned char *m_unownedData;
+  std::size_t m_unownedSize;
+};
+}
+
+#endif  // BASE64_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/contrib/anchordict.h b/contrib/libs/yaml-cpp/include/yaml-cpp/contrib/anchordict.h
index 132f4e7f4a2..78db9ec9288 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/contrib/anchordict.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/contrib/anchordict.h
@@ -1,17 +1,17 @@
-#ifndef ANCHORDICT_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define ANCHORDICT_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include <vector> 
- 
-#include "../anchor.h" 
- 
-namespace YAML { 
+#ifndef ANCHORDICT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define ANCHORDICT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <vector>
+
+#include "../anchor.h"
+
+namespace YAML {
 /**
  * An object that stores and retrieves values correlating to {@link anchor_t}
  * values.
@@ -19,21 +19,21 @@ namespace YAML {
  * <p>Efficient implementation that can make assumptions about how
  * {@code anchor_t} values are assigned by the {@link Parser} class.
  */
-template <class T> 
-class AnchorDict { 
- public: 
-  void Register(anchor_t anchor, T value) { 
-    if (anchor > m_data.size()) { 
-      m_data.resize(anchor); 
-    } 
-    m_data[anchor - 1] = value; 
-  } 
- 
-  T Get(anchor_t anchor) const { return m_data[anchor - 1]; } 
- 
- private: 
-  std::vector<T> m_data; 
-}; 
-} 
- 
-#endif  // ANCHORDICT_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+template <class T>
+class AnchorDict {
+ public:
+  void Register(anchor_t anchor, T value) {
+    if (anchor > m_data.size()) {
+      m_data.resize(anchor);
+    }
+    m_data[anchor - 1] = value;
+  }
+
+  T Get(anchor_t anchor) const { return m_data[anchor - 1]; }
+
+ private:
+  std::vector<T> m_data;
+};
+}
+
+#endif  // ANCHORDICT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/contrib/graphbuilder.h b/contrib/libs/yaml-cpp/include/yaml-cpp/contrib/graphbuilder.h
index 4555291d419..f0a38f28873 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/contrib/graphbuilder.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/contrib/graphbuilder.h
@@ -1,149 +1,149 @@
-#ifndef GRAPHBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define GRAPHBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include "yaml-cpp/mark.h" 
-#include <string> 
- 
-namespace YAML { 
-class Parser; 
- 
-// GraphBuilderInterface 
-// . Abstraction of node creation 
-// . pParentNode is always NULL or the return value of one of the NewXXX() 
-//   functions. 
-class GraphBuilderInterface { 
- public: 
+#ifndef GRAPHBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define GRAPHBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/mark.h"
+#include <string>
+
+namespace YAML {
+class Parser;
+
+// GraphBuilderInterface
+// . Abstraction of node creation
+// . pParentNode is always NULL or the return value of one of the NewXXX()
+//   functions.
+class GraphBuilderInterface {
+ public:
   virtual ~GraphBuilderInterface() = 0;
 
-  // Create and return a new node with a null value. 
-  virtual void *NewNull(const Mark &mark, void *pParentNode) = 0; 
- 
-  // Create and return a new node with the given tag and value. 
-  virtual void *NewScalar(const Mark &mark, const std::string &tag, 
-                          void *pParentNode, const std::string &value) = 0; 
- 
-  // Create and return a new sequence node 
-  virtual void *NewSequence(const Mark &mark, const std::string &tag, 
-                            void *pParentNode) = 0; 
- 
-  // Add pNode to pSequence.  pNode was created with one of the NewXxx() 
-  // functions and pSequence with NewSequence(). 
-  virtual void AppendToSequence(void *pSequence, void *pNode) = 0; 
- 
-  // Note that no moew entries will be added to pSequence 
-  virtual void SequenceComplete(void *pSequence) { (void)pSequence; } 
- 
-  // Create and return a new map node 
-  virtual void *NewMap(const Mark &mark, const std::string &tag, 
-                       void *pParentNode) = 0; 
- 
-  // Add the pKeyNode => pValueNode mapping to pMap.  pKeyNode and pValueNode 
-  // were created with one of the NewXxx() methods and pMap with NewMap(). 
-  virtual void AssignInMap(void *pMap, void *pKeyNode, void *pValueNode) = 0; 
- 
-  // Note that no more assignments will be made in pMap 
-  virtual void MapComplete(void *pMap) { (void)pMap; } 
- 
-  // Return the node that should be used in place of an alias referencing 
-  // pNode (pNode by default) 
-  virtual void *AnchorReference(const Mark &mark, void *pNode) { 
-    (void)mark; 
-    return pNode; 
-  } 
-}; 
- 
-// Typesafe wrapper for GraphBuilderInterface.  Assumes that Impl defines 
-// Node, Sequence, and Map types.  Sequence and Map must derive from Node 
-// (unless Node is defined as void).  Impl must also implement function with 
-// all of the same names as the virtual functions in GraphBuilderInterface 
-// -- including the ones with default implementations -- but with the 
-// prototypes changed to accept an explicit Node*, Sequence*, or Map* where 
-// appropriate. 
-template <class Impl> 
-class GraphBuilder : public GraphBuilderInterface { 
- public: 
-  typedef typename Impl::Node Node; 
-  typedef typename Impl::Sequence Sequence; 
-  typedef typename Impl::Map Map; 
- 
-  GraphBuilder(Impl &impl) : m_impl(impl) { 
-    Map *pMap = NULL; 
-    Sequence *pSeq = NULL; 
-    Node *pNode = NULL; 
- 
-    // Type consistency checks 
-    pNode = pMap; 
-    pNode = pSeq; 
-  } 
- 
-  GraphBuilderInterface &AsBuilderInterface() { return *this; } 
- 
-  virtual void *NewNull(const Mark &mark, void *pParentNode) { 
-    return CheckType<Node>(m_impl.NewNull(mark, AsNode(pParentNode))); 
-  } 
- 
-  virtual void *NewScalar(const Mark &mark, const std::string &tag, 
-                          void *pParentNode, const std::string &value) { 
-    return CheckType<Node>( 
-        m_impl.NewScalar(mark, tag, AsNode(pParentNode), value)); 
-  } 
- 
-  virtual void *NewSequence(const Mark &mark, const std::string &tag, 
-                            void *pParentNode) { 
-    return CheckType<Sequence>( 
-        m_impl.NewSequence(mark, tag, AsNode(pParentNode))); 
-  } 
-  virtual void AppendToSequence(void *pSequence, void *pNode) { 
-    m_impl.AppendToSequence(AsSequence(pSequence), AsNode(pNode)); 
-  } 
-  virtual void SequenceComplete(void *pSequence) { 
-    m_impl.SequenceComplete(AsSequence(pSequence)); 
-  } 
- 
-  virtual void *NewMap(const Mark &mark, const std::string &tag, 
-                       void *pParentNode) { 
-    return CheckType<Map>(m_impl.NewMap(mark, tag, AsNode(pParentNode))); 
-  } 
-  virtual void AssignInMap(void *pMap, void *pKeyNode, void *pValueNode) { 
-    m_impl.AssignInMap(AsMap(pMap), AsNode(pKeyNode), AsNode(pValueNode)); 
-  } 
-  virtual void MapComplete(void *pMap) { m_impl.MapComplete(AsMap(pMap)); } 
- 
-  virtual void *AnchorReference(const Mark &mark, void *pNode) { 
-    return CheckType<Node>(m_impl.AnchorReference(mark, AsNode(pNode))); 
-  } 
- 
- private: 
-  Impl &m_impl; 
- 
-  // Static check for pointer to T 
-  template <class T, class U> 
-  static T *CheckType(U *p) { 
-    return p; 
-  } 
- 
-  static Node *AsNode(void *pNode) { return static_cast<Node *>(pNode); } 
-  static Sequence *AsSequence(void *pSeq) { 
-    return static_cast<Sequence *>(pSeq); 
-  } 
-  static Map *AsMap(void *pMap) { return static_cast<Map *>(pMap); } 
-}; 
- 
-void *BuildGraphOfNextDocument(Parser &parser, 
-                               GraphBuilderInterface &graphBuilder); 
- 
-template <class Impl> 
-typename Impl::Node *BuildGraphOfNextDocument(Parser &parser, Impl &impl) { 
-  GraphBuilder<Impl> graphBuilder(impl); 
-  return static_cast<typename Impl::Node *>( 
-      BuildGraphOfNextDocument(parser, graphBuilder)); 
-} 
-} 
- 
-#endif  // GRAPHBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+  // Create and return a new node with a null value.
+  virtual void *NewNull(const Mark &mark, void *pParentNode) = 0;
+
+  // Create and return a new node with the given tag and value.
+  virtual void *NewScalar(const Mark &mark, const std::string &tag,
+                          void *pParentNode, const std::string &value) = 0;
+
+  // Create and return a new sequence node
+  virtual void *NewSequence(const Mark &mark, const std::string &tag,
+                            void *pParentNode) = 0;
+
+  // Add pNode to pSequence.  pNode was created with one of the NewXxx()
+  // functions and pSequence with NewSequence().
+  virtual void AppendToSequence(void *pSequence, void *pNode) = 0;
+
+  // Note that no moew entries will be added to pSequence
+  virtual void SequenceComplete(void *pSequence) { (void)pSequence; }
+
+  // Create and return a new map node
+  virtual void *NewMap(const Mark &mark, const std::string &tag,
+                       void *pParentNode) = 0;
+
+  // Add the pKeyNode => pValueNode mapping to pMap.  pKeyNode and pValueNode
+  // were created with one of the NewXxx() methods and pMap with NewMap().
+  virtual void AssignInMap(void *pMap, void *pKeyNode, void *pValueNode) = 0;
+
+  // Note that no more assignments will be made in pMap
+  virtual void MapComplete(void *pMap) { (void)pMap; }
+
+  // Return the node that should be used in place of an alias referencing
+  // pNode (pNode by default)
+  virtual void *AnchorReference(const Mark &mark, void *pNode) {
+    (void)mark;
+    return pNode;
+  }
+};
+
+// Typesafe wrapper for GraphBuilderInterface.  Assumes that Impl defines
+// Node, Sequence, and Map types.  Sequence and Map must derive from Node
+// (unless Node is defined as void).  Impl must also implement function with
+// all of the same names as the virtual functions in GraphBuilderInterface
+// -- including the ones with default implementations -- but with the
+// prototypes changed to accept an explicit Node*, Sequence*, or Map* where
+// appropriate.
+template <class Impl>
+class GraphBuilder : public GraphBuilderInterface {
+ public:
+  typedef typename Impl::Node Node;
+  typedef typename Impl::Sequence Sequence;
+  typedef typename Impl::Map Map;
+
+  GraphBuilder(Impl &impl) : m_impl(impl) {
+    Map *pMap = NULL;
+    Sequence *pSeq = NULL;
+    Node *pNode = NULL;
+
+    // Type consistency checks
+    pNode = pMap;
+    pNode = pSeq;
+  }
+
+  GraphBuilderInterface &AsBuilderInterface() { return *this; }
+
+  virtual void *NewNull(const Mark &mark, void *pParentNode) {
+    return CheckType<Node>(m_impl.NewNull(mark, AsNode(pParentNode)));
+  }
+
+  virtual void *NewScalar(const Mark &mark, const std::string &tag,
+                          void *pParentNode, const std::string &value) {
+    return CheckType<Node>(
+        m_impl.NewScalar(mark, tag, AsNode(pParentNode), value));
+  }
+
+  virtual void *NewSequence(const Mark &mark, const std::string &tag,
+                            void *pParentNode) {
+    return CheckType<Sequence>(
+        m_impl.NewSequence(mark, tag, AsNode(pParentNode)));
+  }
+  virtual void AppendToSequence(void *pSequence, void *pNode) {
+    m_impl.AppendToSequence(AsSequence(pSequence), AsNode(pNode));
+  }
+  virtual void SequenceComplete(void *pSequence) {
+    m_impl.SequenceComplete(AsSequence(pSequence));
+  }
+
+  virtual void *NewMap(const Mark &mark, const std::string &tag,
+                       void *pParentNode) {
+    return CheckType<Map>(m_impl.NewMap(mark, tag, AsNode(pParentNode)));
+  }
+  virtual void AssignInMap(void *pMap, void *pKeyNode, void *pValueNode) {
+    m_impl.AssignInMap(AsMap(pMap), AsNode(pKeyNode), AsNode(pValueNode));
+  }
+  virtual void MapComplete(void *pMap) { m_impl.MapComplete(AsMap(pMap)); }
+
+  virtual void *AnchorReference(const Mark &mark, void *pNode) {
+    return CheckType<Node>(m_impl.AnchorReference(mark, AsNode(pNode)));
+  }
+
+ private:
+  Impl &m_impl;
+
+  // Static check for pointer to T
+  template <class T, class U>
+  static T *CheckType(U *p) {
+    return p;
+  }
+
+  static Node *AsNode(void *pNode) { return static_cast<Node *>(pNode); }
+  static Sequence *AsSequence(void *pSeq) {
+    return static_cast<Sequence *>(pSeq);
+  }
+  static Map *AsMap(void *pMap) { return static_cast<Map *>(pMap); }
+};
+
+void *BuildGraphOfNextDocument(Parser &parser,
+                               GraphBuilderInterface &graphBuilder);
+
+template <class Impl>
+typename Impl::Node *BuildGraphOfNextDocument(Parser &parser, Impl &impl) {
+  GraphBuilder<Impl> graphBuilder(impl);
+  return static_cast<typename Impl::Node *>(
+      BuildGraphOfNextDocument(parser, graphBuilder));
+}
+}
+
+#endif  // GRAPHBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/dll.h b/contrib/libs/yaml-cpp/include/yaml-cpp/dll.h
index 639f5410a96..a32c06b2e30 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/dll.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/dll.h
@@ -1,33 +1,33 @@
-#ifndef DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-// The following ifdef block is the standard way of creating macros which make 
+#ifndef DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+// The following ifdef block is the standard way of creating macros which make
 // exporting from a DLL simpler. All files within this DLL are compiled with the
 // yaml_cpp_EXPORTS symbol defined on the command line. This symbol should not
 // be defined on any project that uses this DLL. This way any other project
 // whose source files include this file see YAML_CPP_API functions as being
 // imported from a DLL, whereas this DLL sees symbols defined with this macro as
 // being exported.
-#undef YAML_CPP_API 
- 
-#ifdef YAML_CPP_DLL      // Using or Building YAML-CPP DLL (definition defined 
-                         // manually) 
-#ifdef yaml_cpp_EXPORTS  // Building YAML-CPP DLL (definition created by CMake 
-                         // or defined manually) 
-//	#pragma message( "Defining YAML_CPP_API for DLL export" ) 
-#define YAML_CPP_API __declspec(dllexport) 
-#else  // yaml_cpp_EXPORTS 
-//	#pragma message( "Defining YAML_CPP_API for DLL import" ) 
-#define YAML_CPP_API __declspec(dllimport) 
-#endif  // yaml_cpp_EXPORTS 
-#else   // YAML_CPP_DLL 
-#define YAML_CPP_API 
-#endif  // YAML_CPP_DLL 
- 
-#endif  // DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+#undef YAML_CPP_API
+
+#ifdef YAML_CPP_DLL      // Using or Building YAML-CPP DLL (definition defined
+                         // manually)
+#ifdef yaml_cpp_EXPORTS  // Building YAML-CPP DLL (definition created by CMake
+                         // or defined manually)
+//	#pragma message( "Defining YAML_CPP_API for DLL export" )
+#define YAML_CPP_API __declspec(dllexport)
+#else  // yaml_cpp_EXPORTS
+//	#pragma message( "Defining YAML_CPP_API for DLL import" )
+#define YAML_CPP_API __declspec(dllimport)
+#endif  // yaml_cpp_EXPORTS
+#else   // YAML_CPP_DLL
+#define YAML_CPP_API
+#endif  // YAML_CPP_DLL
+
+#endif  // DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/emitfromevents.h b/contrib/libs/yaml-cpp/include/yaml-cpp/emitfromevents.h
index bb4eee77893..f14b051ab0e 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/emitfromevents.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/emitfromevents.h
@@ -1,57 +1,57 @@
-#ifndef EMITFROMEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define EMITFROMEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include <stack> 
- 
-#include "yaml-cpp/anchor.h" 
-#include "yaml-cpp/emitterstyle.h" 
-#include "yaml-cpp/eventhandler.h" 
- 
-namespace YAML { 
-struct Mark; 
-}  // namespace YAML 
- 
-namespace YAML { 
-class Emitter; 
- 
-class EmitFromEvents : public EventHandler { 
- public: 
-  EmitFromEvents(Emitter& emitter); 
- 
-  virtual void OnDocumentStart(const Mark& mark); 
-  virtual void OnDocumentEnd(); 
- 
-  virtual void OnNull(const Mark& mark, anchor_t anchor); 
-  virtual void OnAlias(const Mark& mark, anchor_t anchor); 
-  virtual void OnScalar(const Mark& mark, const std::string& tag, 
-                        anchor_t anchor, const std::string& value); 
- 
-  virtual void OnSequenceStart(const Mark& mark, const std::string& tag, 
-                               anchor_t anchor, EmitterStyle::value style); 
-  virtual void OnSequenceEnd(); 
- 
-  virtual void OnMapStart(const Mark& mark, const std::string& tag, 
-                          anchor_t anchor, EmitterStyle::value style); 
-  virtual void OnMapEnd(); 
- 
- private: 
-  void BeginNode(); 
-  void EmitProps(const std::string& tag, anchor_t anchor); 
- 
- private: 
-  Emitter& m_emitter; 
- 
-  struct State { 
-    enum value { WaitingForSequenceEntry, WaitingForKey, WaitingForValue }; 
-  }; 
-  std::stack<State::value> m_stateStack; 
-}; 
-} 
- 
-#endif  // EMITFROMEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+#ifndef EMITFROMEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define EMITFROMEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <stack>
+
+#include "yaml-cpp/anchor.h"
+#include "yaml-cpp/emitterstyle.h"
+#include "yaml-cpp/eventhandler.h"
+
+namespace YAML {
+struct Mark;
+}  // namespace YAML
+
+namespace YAML {
+class Emitter;
+
+class EmitFromEvents : public EventHandler {
+ public:
+  EmitFromEvents(Emitter& emitter);
+
+  virtual void OnDocumentStart(const Mark& mark);
+  virtual void OnDocumentEnd();
+
+  virtual void OnNull(const Mark& mark, anchor_t anchor);
+  virtual void OnAlias(const Mark& mark, anchor_t anchor);
+  virtual void OnScalar(const Mark& mark, const std::string& tag,
+                        anchor_t anchor, const std::string& value);
+
+  virtual void OnSequenceStart(const Mark& mark, const std::string& tag,
+                               anchor_t anchor, EmitterStyle::value style);
+  virtual void OnSequenceEnd();
+
+  virtual void OnMapStart(const Mark& mark, const std::string& tag,
+                          anchor_t anchor, EmitterStyle::value style);
+  virtual void OnMapEnd();
+
+ private:
+  void BeginNode();
+  void EmitProps(const std::string& tag, anchor_t anchor);
+
+ private:
+  Emitter& m_emitter;
+
+  struct State {
+    enum value { WaitingForSequenceEntry, WaitingForKey, WaitingForValue };
+  };
+  std::stack<State::value> m_stateStack;
+};
+}
+
+#endif  // EMITFROMEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/emitter.h b/contrib/libs/yaml-cpp/include/yaml-cpp/emitter.h
index 0567704148c..ef92cc4035b 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/emitter.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/emitter.h
@@ -1,254 +1,254 @@
-#ifndef EMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define EMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include <cstddef> 
-#include <memory> 
-#include <sstream> 
-#include <string> 
- 
-#include "yaml-cpp/binary.h" 
-#include "yaml-cpp/dll.h" 
-#include "yaml-cpp/emitterdef.h" 
-#include "yaml-cpp/emittermanip.h" 
-#include "yaml-cpp/noncopyable.h" 
-#include "yaml-cpp/null.h" 
-#include "yaml-cpp/ostream_wrapper.h" 
- 
-namespace YAML { 
-class Binary; 
-struct _Null; 
-}  // namespace YAML 
- 
-namespace YAML { 
-class EmitterState; 
- 
-class YAML_CPP_API Emitter : private noncopyable { 
- public: 
-  Emitter(); 
-  explicit Emitter(std::ostream& stream); 
-  ~Emitter(); 
- 
-  // output 
-  const char* c_str() const; 
-  std::size_t size() const; 
- 
-  // state checking 
-  bool good() const; 
-  const std::string GetLastError() const; 
- 
-  // global setters 
-  bool SetOutputCharset(EMITTER_MANIP value); 
-  bool SetStringFormat(EMITTER_MANIP value); 
-  bool SetBoolFormat(EMITTER_MANIP value); 
-  bool SetIntBase(EMITTER_MANIP value); 
-  bool SetSeqFormat(EMITTER_MANIP value); 
-  bool SetMapFormat(EMITTER_MANIP value); 
-  bool SetIndent(std::size_t n); 
-  bool SetPreCommentIndent(std::size_t n); 
-  bool SetPostCommentIndent(std::size_t n); 
-  bool SetFloatPrecision(std::size_t n); 
-  bool SetDoublePrecision(std::size_t n); 
- 
-  // local setters 
-  Emitter& SetLocalValue(EMITTER_MANIP value); 
-  Emitter& SetLocalIndent(const _Indent& indent); 
-  Emitter& SetLocalPrecision(const _Precision& precision); 
- 
-  // overloads of write 
-  Emitter& Write(const std::string& str); 
-  Emitter& Write(bool b); 
-  Emitter& Write(char ch); 
-  Emitter& Write(const _Alias& alias); 
-  Emitter& Write(const _Anchor& anchor); 
-  Emitter& Write(const _Tag& tag); 
-  Emitter& Write(const _Comment& comment); 
-  Emitter& Write(const _Null& n); 
-  Emitter& Write(const Binary& binary); 
- 
-  template <typename T> 
-  Emitter& WriteIntegralType(T value); 
- 
-  template <typename T> 
-  Emitter& WriteStreamable(T value); 
- 
- private: 
-  template <typename T> 
-  void SetStreamablePrecision(std::stringstream&) {} 
-  std::size_t GetFloatPrecision() const; 
-  std::size_t GetDoublePrecision() const; 
- 
-  void PrepareIntegralStream(std::stringstream& stream) const; 
-  void StartedScalar(); 
- 
- private: 
-  void EmitBeginDoc(); 
-  void EmitEndDoc(); 
-  void EmitBeginSeq(); 
-  void EmitEndSeq(); 
-  void EmitBeginMap(); 
-  void EmitEndMap(); 
-  void EmitNewline(); 
-  void EmitKindTag(); 
-  void EmitTag(bool verbatim, const _Tag& tag); 
- 
-  void PrepareNode(EmitterNodeType::value child); 
-  void PrepareTopNode(EmitterNodeType::value child); 
-  void FlowSeqPrepareNode(EmitterNodeType::value child); 
-  void BlockSeqPrepareNode(EmitterNodeType::value child); 
- 
-  void FlowMapPrepareNode(EmitterNodeType::value child); 
- 
-  void FlowMapPrepareLongKey(EmitterNodeType::value child); 
-  void FlowMapPrepareLongKeyValue(EmitterNodeType::value child); 
-  void FlowMapPrepareSimpleKey(EmitterNodeType::value child); 
-  void FlowMapPrepareSimpleKeyValue(EmitterNodeType::value child); 
- 
-  void BlockMapPrepareNode(EmitterNodeType::value child); 
- 
-  void BlockMapPrepareLongKey(EmitterNodeType::value child); 
-  void BlockMapPrepareLongKeyValue(EmitterNodeType::value child); 
-  void BlockMapPrepareSimpleKey(EmitterNodeType::value child); 
-  void BlockMapPrepareSimpleKeyValue(EmitterNodeType::value child); 
- 
-  void SpaceOrIndentTo(bool requireSpace, std::size_t indent); 
- 
-  const char* ComputeFullBoolName(bool b) const; 
-  bool CanEmitNewline() const; 
- 
- private: 
+#ifndef EMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define EMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <cstddef>
+#include <memory>
+#include <sstream>
+#include <string>
+
+#include "yaml-cpp/binary.h"
+#include "yaml-cpp/dll.h"
+#include "yaml-cpp/emitterdef.h"
+#include "yaml-cpp/emittermanip.h"
+#include "yaml-cpp/noncopyable.h"
+#include "yaml-cpp/null.h"
+#include "yaml-cpp/ostream_wrapper.h"
+
+namespace YAML {
+class Binary;
+struct _Null;
+}  // namespace YAML
+
+namespace YAML {
+class EmitterState;
+
+class YAML_CPP_API Emitter : private noncopyable {
+ public:
+  Emitter();
+  explicit Emitter(std::ostream& stream);
+  ~Emitter();
+
+  // output
+  const char* c_str() const;
+  std::size_t size() const;
+
+  // state checking
+  bool good() const;
+  const std::string GetLastError() const;
+
+  // global setters
+  bool SetOutputCharset(EMITTER_MANIP value);
+  bool SetStringFormat(EMITTER_MANIP value);
+  bool SetBoolFormat(EMITTER_MANIP value);
+  bool SetIntBase(EMITTER_MANIP value);
+  bool SetSeqFormat(EMITTER_MANIP value);
+  bool SetMapFormat(EMITTER_MANIP value);
+  bool SetIndent(std::size_t n);
+  bool SetPreCommentIndent(std::size_t n);
+  bool SetPostCommentIndent(std::size_t n);
+  bool SetFloatPrecision(std::size_t n);
+  bool SetDoublePrecision(std::size_t n);
+
+  // local setters
+  Emitter& SetLocalValue(EMITTER_MANIP value);
+  Emitter& SetLocalIndent(const _Indent& indent);
+  Emitter& SetLocalPrecision(const _Precision& precision);
+
+  // overloads of write
+  Emitter& Write(const std::string& str);
+  Emitter& Write(bool b);
+  Emitter& Write(char ch);
+  Emitter& Write(const _Alias& alias);
+  Emitter& Write(const _Anchor& anchor);
+  Emitter& Write(const _Tag& tag);
+  Emitter& Write(const _Comment& comment);
+  Emitter& Write(const _Null& n);
+  Emitter& Write(const Binary& binary);
+
+  template <typename T>
+  Emitter& WriteIntegralType(T value);
+
+  template <typename T>
+  Emitter& WriteStreamable(T value);
+
+ private:
+  template <typename T>
+  void SetStreamablePrecision(std::stringstream&) {}
+  std::size_t GetFloatPrecision() const;
+  std::size_t GetDoublePrecision() const;
+
+  void PrepareIntegralStream(std::stringstream& stream) const;
+  void StartedScalar();
+
+ private:
+  void EmitBeginDoc();
+  void EmitEndDoc();
+  void EmitBeginSeq();
+  void EmitEndSeq();
+  void EmitBeginMap();
+  void EmitEndMap();
+  void EmitNewline();
+  void EmitKindTag();
+  void EmitTag(bool verbatim, const _Tag& tag);
+
+  void PrepareNode(EmitterNodeType::value child);
+  void PrepareTopNode(EmitterNodeType::value child);
+  void FlowSeqPrepareNode(EmitterNodeType::value child);
+  void BlockSeqPrepareNode(EmitterNodeType::value child);
+
+  void FlowMapPrepareNode(EmitterNodeType::value child);
+
+  void FlowMapPrepareLongKey(EmitterNodeType::value child);
+  void FlowMapPrepareLongKeyValue(EmitterNodeType::value child);
+  void FlowMapPrepareSimpleKey(EmitterNodeType::value child);
+  void FlowMapPrepareSimpleKeyValue(EmitterNodeType::value child);
+
+  void BlockMapPrepareNode(EmitterNodeType::value child);
+
+  void BlockMapPrepareLongKey(EmitterNodeType::value child);
+  void BlockMapPrepareLongKeyValue(EmitterNodeType::value child);
+  void BlockMapPrepareSimpleKey(EmitterNodeType::value child);
+  void BlockMapPrepareSimpleKeyValue(EmitterNodeType::value child);
+
+  void SpaceOrIndentTo(bool requireSpace, std::size_t indent);
+
+  const char* ComputeFullBoolName(bool b) const;
+  bool CanEmitNewline() const;
+
+ private:
   std::unique_ptr<EmitterState> m_pState;
-  ostream_wrapper m_stream; 
-}; 
- 
-template <typename T> 
-inline Emitter& Emitter::WriteIntegralType(T value) { 
-  if (!good()) 
-    return *this; 
- 
-  PrepareNode(EmitterNodeType::Scalar); 
- 
-  std::stringstream stream; 
-  PrepareIntegralStream(stream); 
-  stream << value; 
-  m_stream << stream.str(); 
- 
-  StartedScalar(); 
- 
-  return *this; 
-} 
- 
-template <typename T> 
-inline Emitter& Emitter::WriteStreamable(T value) { 
-  if (!good()) 
-    return *this; 
- 
-  PrepareNode(EmitterNodeType::Scalar); 
- 
-  std::stringstream stream; 
-  SetStreamablePrecision<T>(stream); 
-  stream << value; 
-  m_stream << stream.str(); 
- 
-  StartedScalar(); 
- 
-  return *this; 
-} 
- 
-template <> 
-inline void Emitter::SetStreamablePrecision<float>(std::stringstream& stream) { 
+  ostream_wrapper m_stream;
+};
+
+template <typename T>
+inline Emitter& Emitter::WriteIntegralType(T value) {
+  if (!good())
+    return *this;
+
+  PrepareNode(EmitterNodeType::Scalar);
+
+  std::stringstream stream;
+  PrepareIntegralStream(stream);
+  stream << value;
+  m_stream << stream.str();
+
+  StartedScalar();
+
+  return *this;
+}
+
+template <typename T>
+inline Emitter& Emitter::WriteStreamable(T value) {
+  if (!good())
+    return *this;
+
+  PrepareNode(EmitterNodeType::Scalar);
+
+  std::stringstream stream;
+  SetStreamablePrecision<T>(stream);
+  stream << value;
+  m_stream << stream.str();
+
+  StartedScalar();
+
+  return *this;
+}
+
+template <>
+inline void Emitter::SetStreamablePrecision<float>(std::stringstream& stream) {
   stream.precision(static_cast<std::streamsize>(GetFloatPrecision()));
-} 
- 
-template <> 
-inline void Emitter::SetStreamablePrecision<double>(std::stringstream& stream) { 
+}
+
+template <>
+inline void Emitter::SetStreamablePrecision<double>(std::stringstream& stream) {
   stream.precision(static_cast<std::streamsize>(GetDoublePrecision()));
-} 
- 
-// overloads of insertion 
-inline Emitter& operator<<(Emitter& emitter, const std::string& v) { 
-  return emitter.Write(v); 
-} 
-inline Emitter& operator<<(Emitter& emitter, bool v) { 
-  return emitter.Write(v); 
-} 
-inline Emitter& operator<<(Emitter& emitter, char v) { 
-  return emitter.Write(v); 
-} 
-inline Emitter& operator<<(Emitter& emitter, unsigned char v) { 
-  return emitter.Write(static_cast<char>(v)); 
-} 
-inline Emitter& operator<<(Emitter& emitter, const _Alias& v) { 
-  return emitter.Write(v); 
-} 
-inline Emitter& operator<<(Emitter& emitter, const _Anchor& v) { 
-  return emitter.Write(v); 
-} 
-inline Emitter& operator<<(Emitter& emitter, const _Tag& v) { 
-  return emitter.Write(v); 
-} 
-inline Emitter& operator<<(Emitter& emitter, const _Comment& v) { 
-  return emitter.Write(v); 
-} 
-inline Emitter& operator<<(Emitter& emitter, const _Null& v) { 
-  return emitter.Write(v); 
-} 
-inline Emitter& operator<<(Emitter& emitter, const Binary& b) { 
-  return emitter.Write(b); 
-} 
- 
-inline Emitter& operator<<(Emitter& emitter, const char* v) { 
-  return emitter.Write(std::string(v)); 
-} 
- 
-inline Emitter& operator<<(Emitter& emitter, int v) { 
-  return emitter.WriteIntegralType(v); 
-} 
-inline Emitter& operator<<(Emitter& emitter, unsigned int v) { 
-  return emitter.WriteIntegralType(v); 
-} 
-inline Emitter& operator<<(Emitter& emitter, short v) { 
-  return emitter.WriteIntegralType(v); 
-} 
-inline Emitter& operator<<(Emitter& emitter, unsigned short v) { 
-  return emitter.WriteIntegralType(v); 
-} 
-inline Emitter& operator<<(Emitter& emitter, long v) { 
-  return emitter.WriteIntegralType(v); 
-} 
-inline Emitter& operator<<(Emitter& emitter, unsigned long v) { 
-  return emitter.WriteIntegralType(v); 
-} 
-inline Emitter& operator<<(Emitter& emitter, long long v) { 
-  return emitter.WriteIntegralType(v); 
-} 
-inline Emitter& operator<<(Emitter& emitter, unsigned long long v) { 
-  return emitter.WriteIntegralType(v); 
-} 
- 
-inline Emitter& operator<<(Emitter& emitter, float v) { 
-  return emitter.WriteStreamable(v); 
-} 
-inline Emitter& operator<<(Emitter& emitter, double v) { 
-  return emitter.WriteStreamable(v); 
-} 
- 
-inline Emitter& operator<<(Emitter& emitter, EMITTER_MANIP value) { 
-  return emitter.SetLocalValue(value); 
-} 
- 
-inline Emitter& operator<<(Emitter& emitter, _Indent indent) { 
-  return emitter.SetLocalIndent(indent); 
-} 
- 
-inline Emitter& operator<<(Emitter& emitter, _Precision precision) { 
-  return emitter.SetLocalPrecision(precision); 
-} 
-} 
- 
-#endif  // EMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+}
+
+// overloads of insertion
+inline Emitter& operator<<(Emitter& emitter, const std::string& v) {
+  return emitter.Write(v);
+}
+inline Emitter& operator<<(Emitter& emitter, bool v) {
+  return emitter.Write(v);
+}
+inline Emitter& operator<<(Emitter& emitter, char v) {
+  return emitter.Write(v);
+}
+inline Emitter& operator<<(Emitter& emitter, unsigned char v) {
+  return emitter.Write(static_cast<char>(v));
+}
+inline Emitter& operator<<(Emitter& emitter, const _Alias& v) {
+  return emitter.Write(v);
+}
+inline Emitter& operator<<(Emitter& emitter, const _Anchor& v) {
+  return emitter.Write(v);
+}
+inline Emitter& operator<<(Emitter& emitter, const _Tag& v) {
+  return emitter.Write(v);
+}
+inline Emitter& operator<<(Emitter& emitter, const _Comment& v) {
+  return emitter.Write(v);
+}
+inline Emitter& operator<<(Emitter& emitter, const _Null& v) {
+  return emitter.Write(v);
+}
+inline Emitter& operator<<(Emitter& emitter, const Binary& b) {
+  return emitter.Write(b);
+}
+
+inline Emitter& operator<<(Emitter& emitter, const char* v) {
+  return emitter.Write(std::string(v));
+}
+
+inline Emitter& operator<<(Emitter& emitter, int v) {
+  return emitter.WriteIntegralType(v);
+}
+inline Emitter& operator<<(Emitter& emitter, unsigned int v) {
+  return emitter.WriteIntegralType(v);
+}
+inline Emitter& operator<<(Emitter& emitter, short v) {
+  return emitter.WriteIntegralType(v);
+}
+inline Emitter& operator<<(Emitter& emitter, unsigned short v) {
+  return emitter.WriteIntegralType(v);
+}
+inline Emitter& operator<<(Emitter& emitter, long v) {
+  return emitter.WriteIntegralType(v);
+}
+inline Emitter& operator<<(Emitter& emitter, unsigned long v) {
+  return emitter.WriteIntegralType(v);
+}
+inline Emitter& operator<<(Emitter& emitter, long long v) {
+  return emitter.WriteIntegralType(v);
+}
+inline Emitter& operator<<(Emitter& emitter, unsigned long long v) {
+  return emitter.WriteIntegralType(v);
+}
+
+inline Emitter& operator<<(Emitter& emitter, float v) {
+  return emitter.WriteStreamable(v);
+}
+inline Emitter& operator<<(Emitter& emitter, double v) {
+  return emitter.WriteStreamable(v);
+}
+
+inline Emitter& operator<<(Emitter& emitter, EMITTER_MANIP value) {
+  return emitter.SetLocalValue(value);
+}
+
+inline Emitter& operator<<(Emitter& emitter, _Indent indent) {
+  return emitter.SetLocalIndent(indent);
+}
+
+inline Emitter& operator<<(Emitter& emitter, _Precision precision) {
+  return emitter.SetLocalPrecision(precision);
+}
+}
+
+#endif  // EMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/emitterdef.h b/contrib/libs/yaml-cpp/include/yaml-cpp/emitterdef.h
index f610a1cfcb9..0b426957fae 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/emitterdef.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/emitterdef.h
@@ -1,16 +1,16 @@
-#ifndef EMITTERDEF_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define EMITTERDEF_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-namespace YAML { 
-struct EmitterNodeType { 
-  enum value { NoType, Property, Scalar, FlowSeq, BlockSeq, FlowMap, BlockMap }; 
-}; 
-} 
- 
-#endif  // EMITTERDEF_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+#ifndef EMITTERDEF_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define EMITTERDEF_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+namespace YAML {
+struct EmitterNodeType {
+  enum value { NoType, Property, Scalar, FlowSeq, BlockSeq, FlowMap, BlockMap };
+};
+}
+
+#endif  // EMITTERDEF_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/emittermanip.h b/contrib/libs/yaml-cpp/include/yaml-cpp/emittermanip.h
index 06e855ae9ee..89f7256714e 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/emittermanip.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/emittermanip.h
@@ -1,137 +1,137 @@
-#ifndef EMITTERMANIP_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define EMITTERMANIP_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include <string> 
- 
-namespace YAML { 
-enum EMITTER_MANIP { 
-  // general manipulators 
-  Auto, 
-  TagByKind, 
-  Newline, 
- 
-  // output character set 
-  EmitNonAscii, 
-  EscapeNonAscii, 
- 
-  // string manipulators 
-  // Auto, // duplicate 
-  SingleQuoted, 
-  DoubleQuoted, 
-  Literal, 
- 
-  // bool manipulators 
-  YesNoBool,      // yes, no 
-  TrueFalseBool,  // true, false 
-  OnOffBool,      // on, off 
-  UpperCase,      // TRUE, N 
-  LowerCase,      // f, yes 
-  CamelCase,      // No, Off 
-  LongBool,       // yes, On 
-  ShortBool,      // y, t 
- 
-  // int manipulators 
-  Dec, 
-  Hex, 
-  Oct, 
- 
-  // document manipulators 
-  BeginDoc, 
-  EndDoc, 
- 
-  // sequence manipulators 
-  BeginSeq, 
-  EndSeq, 
-  Flow, 
-  Block, 
- 
-  // map manipulators 
-  BeginMap, 
-  EndMap, 
-  Key, 
-  Value, 
-  // Flow, // duplicate 
-  // Block, // duplicate 
-  // Auto, // duplicate 
-  LongKey 
-}; 
- 
-struct _Indent { 
-  _Indent(int value_) : value(value_) {} 
-  int value; 
-}; 
- 
-inline _Indent Indent(int value) { return _Indent(value); } 
- 
-struct _Alias { 
-  _Alias(const std::string& content_) : content(content_) {} 
-  std::string content; 
-}; 
- 
-inline _Alias Alias(const std::string content) { return _Alias(content); } 
- 
-struct _Anchor { 
-  _Anchor(const std::string& content_) : content(content_) {} 
-  std::string content; 
-}; 
- 
-inline _Anchor Anchor(const std::string content) { return _Anchor(content); } 
- 
-struct _Tag { 
-  struct Type { 
-    enum value { Verbatim, PrimaryHandle, NamedHandle }; 
-  }; 
- 
-  explicit _Tag(const std::string& prefix_, const std::string& content_, 
-                Type::value type_) 
-      : prefix(prefix_), content(content_), type(type_) {} 
-  std::string prefix; 
-  std::string content; 
-  Type::value type; 
-}; 
- 
-inline _Tag VerbatimTag(const std::string content) { 
-  return _Tag("", content, _Tag::Type::Verbatim); 
-} 
- 
-inline _Tag LocalTag(const std::string content) { 
-  return _Tag("", content, _Tag::Type::PrimaryHandle); 
-} 
- 
-inline _Tag LocalTag(const std::string& prefix, const std::string content) { 
-  return _Tag(prefix, content, _Tag::Type::NamedHandle); 
-} 
- 
-inline _Tag SecondaryTag(const std::string content) { 
-  return _Tag("", content, _Tag::Type::NamedHandle); 
-} 
- 
-struct _Comment { 
-  _Comment(const std::string& content_) : content(content_) {} 
-  std::string content; 
-}; 
- 
-inline _Comment Comment(const std::string content) { return _Comment(content); } 
- 
-struct _Precision { 
-  _Precision(int floatPrecision_, int doublePrecision_) 
-      : floatPrecision(floatPrecision_), doublePrecision(doublePrecision_) {} 
- 
-  int floatPrecision; 
-  int doublePrecision; 
-}; 
- 
-inline _Precision FloatPrecision(int n) { return _Precision(n, -1); } 
- 
-inline _Precision DoublePrecision(int n) { return _Precision(-1, n); } 
- 
-inline _Precision Precision(int n) { return _Precision(n, n); } 
-} 
- 
-#endif  // EMITTERMANIP_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+#ifndef EMITTERMANIP_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define EMITTERMANIP_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <string>
+
+namespace YAML {
+enum EMITTER_MANIP {
+  // general manipulators
+  Auto,
+  TagByKind,
+  Newline,
+
+  // output character set
+  EmitNonAscii,
+  EscapeNonAscii,
+
+  // string manipulators
+  // Auto, // duplicate
+  SingleQuoted,
+  DoubleQuoted,
+  Literal,
+
+  // bool manipulators
+  YesNoBool,      // yes, no
+  TrueFalseBool,  // true, false
+  OnOffBool,      // on, off
+  UpperCase,      // TRUE, N
+  LowerCase,      // f, yes
+  CamelCase,      // No, Off
+  LongBool,       // yes, On
+  ShortBool,      // y, t
+
+  // int manipulators
+  Dec,
+  Hex,
+  Oct,
+
+  // document manipulators
+  BeginDoc,
+  EndDoc,
+
+  // sequence manipulators
+  BeginSeq,
+  EndSeq,
+  Flow,
+  Block,
+
+  // map manipulators
+  BeginMap,
+  EndMap,
+  Key,
+  Value,
+  // Flow, // duplicate
+  // Block, // duplicate
+  // Auto, // duplicate
+  LongKey
+};
+
+struct _Indent {
+  _Indent(int value_) : value(value_) {}
+  int value;
+};
+
+inline _Indent Indent(int value) { return _Indent(value); }
+
+struct _Alias {
+  _Alias(const std::string& content_) : content(content_) {}
+  std::string content;
+};
+
+inline _Alias Alias(const std::string content) { return _Alias(content); }
+
+struct _Anchor {
+  _Anchor(const std::string& content_) : content(content_) {}
+  std::string content;
+};
+
+inline _Anchor Anchor(const std::string content) { return _Anchor(content); }
+
+struct _Tag {
+  struct Type {
+    enum value { Verbatim, PrimaryHandle, NamedHandle };
+  };
+
+  explicit _Tag(const std::string& prefix_, const std::string& content_,
+                Type::value type_)
+      : prefix(prefix_), content(content_), type(type_) {}
+  std::string prefix;
+  std::string content;
+  Type::value type;
+};
+
+inline _Tag VerbatimTag(const std::string content) {
+  return _Tag("", content, _Tag::Type::Verbatim);
+}
+
+inline _Tag LocalTag(const std::string content) {
+  return _Tag("", content, _Tag::Type::PrimaryHandle);
+}
+
+inline _Tag LocalTag(const std::string& prefix, const std::string content) {
+  return _Tag(prefix, content, _Tag::Type::NamedHandle);
+}
+
+inline _Tag SecondaryTag(const std::string content) {
+  return _Tag("", content, _Tag::Type::NamedHandle);
+}
+
+struct _Comment {
+  _Comment(const std::string& content_) : content(content_) {}
+  std::string content;
+};
+
+inline _Comment Comment(const std::string content) { return _Comment(content); }
+
+struct _Precision {
+  _Precision(int floatPrecision_, int doublePrecision_)
+      : floatPrecision(floatPrecision_), doublePrecision(doublePrecision_) {}
+
+  int floatPrecision;
+  int doublePrecision;
+};
+
+inline _Precision FloatPrecision(int n) { return _Precision(n, -1); }
+
+inline _Precision DoublePrecision(int n) { return _Precision(-1, n); }
+
+inline _Precision Precision(int n) { return _Precision(n, n); }
+}
+
+#endif  // EMITTERMANIP_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/emitterstyle.h b/contrib/libs/yaml-cpp/include/yaml-cpp/emitterstyle.h
index 623b80260e9..67bb3981b12 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/emitterstyle.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/emitterstyle.h
@@ -1,16 +1,16 @@
-#ifndef EMITTERSTYLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define EMITTERSTYLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-namespace YAML { 
-struct EmitterStyle { 
-  enum value { Default, Block, Flow }; 
-}; 
-} 
- 
-#endif  // EMITTERSTYLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+#ifndef EMITTERSTYLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define EMITTERSTYLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+namespace YAML {
+struct EmitterStyle {
+  enum value { Default, Block, Flow };
+};
+}
+
+#endif  // EMITTERSTYLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/eventhandler.h b/contrib/libs/yaml-cpp/include/yaml-cpp/eventhandler.h
index e1e793f5d9a..efe381c6218 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/eventhandler.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/eventhandler.h
@@ -1,40 +1,40 @@
-#ifndef EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include <string> 
- 
-#include "yaml-cpp/anchor.h" 
-#include "yaml-cpp/emitterstyle.h" 
- 
-namespace YAML { 
-struct Mark; 
- 
-class EventHandler { 
- public: 
-  virtual ~EventHandler() {} 
- 
-  virtual void OnDocumentStart(const Mark& mark) = 0; 
-  virtual void OnDocumentEnd() = 0; 
- 
-  virtual void OnNull(const Mark& mark, anchor_t anchor) = 0; 
-  virtual void OnAlias(const Mark& mark, anchor_t anchor) = 0; 
-  virtual void OnScalar(const Mark& mark, const std::string& tag, 
-                        anchor_t anchor, const std::string& value) = 0; 
- 
-  virtual void OnSequenceStart(const Mark& mark, const std::string& tag, 
-                               anchor_t anchor, EmitterStyle::value style) = 0; 
-  virtual void OnSequenceEnd() = 0; 
- 
-  virtual void OnMapStart(const Mark& mark, const std::string& tag, 
-                          anchor_t anchor, EmitterStyle::value style) = 0; 
-  virtual void OnMapEnd() = 0; 
-}; 
-} 
- 
-#endif  // EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+#ifndef EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <string>
+
+#include "yaml-cpp/anchor.h"
+#include "yaml-cpp/emitterstyle.h"
+
+namespace YAML {
+struct Mark;
+
+class EventHandler {
+ public:
+  virtual ~EventHandler() {}
+
+  virtual void OnDocumentStart(const Mark& mark) = 0;
+  virtual void OnDocumentEnd() = 0;
+
+  virtual void OnNull(const Mark& mark, anchor_t anchor) = 0;
+  virtual void OnAlias(const Mark& mark, anchor_t anchor) = 0;
+  virtual void OnScalar(const Mark& mark, const std::string& tag,
+                        anchor_t anchor, const std::string& value) = 0;
+
+  virtual void OnSequenceStart(const Mark& mark, const std::string& tag,
+                               anchor_t anchor, EmitterStyle::value style) = 0;
+  virtual void OnSequenceEnd() = 0;
+
+  virtual void OnMapStart(const Mark& mark, const std::string& tag,
+                          anchor_t anchor, EmitterStyle::value style) = 0;
+  virtual void OnMapEnd() = 0;
+};
+}
+
+#endif  // EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/exceptions.h b/contrib/libs/yaml-cpp/include/yaml-cpp/exceptions.h
index 78f22d42d5b..9c96859b2c9 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/exceptions.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/exceptions.h
@@ -1,18 +1,18 @@
-#ifndef EXCEPTIONS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define EXCEPTIONS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include "yaml-cpp/mark.h" 
-#include "yaml-cpp/traits.h" 
+#ifndef EXCEPTIONS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define EXCEPTIONS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/mark.h"
+#include "yaml-cpp/traits.h"
 #include <sstream>
-#include <stdexcept> 
-#include <string> 
- 
+#include <stdexcept>
+#include <string>
+
 // This is here for compatibility with older versions of Visual Studio
 // which don't support noexcept
 #ifdef _MSC_VER
@@ -21,247 +21,247 @@
     #define YAML_CPP_NOEXCEPT noexcept
 #endif
 
-namespace YAML { 
-// error messages 
-namespace ErrorMsg { 
-const char* const YAML_DIRECTIVE_ARGS = 
-    "YAML directives must have exactly one argument"; 
-const char* const YAML_VERSION = "bad YAML version: "; 
-const char* const YAML_MAJOR_VERSION = "YAML major version too large"; 
-const char* const REPEATED_YAML_DIRECTIVE = "repeated YAML directive"; 
-const char* const TAG_DIRECTIVE_ARGS = 
-    "TAG directives must have exactly two arguments"; 
-const char* const REPEATED_TAG_DIRECTIVE = "repeated TAG directive"; 
-const char* const CHAR_IN_TAG_HANDLE = 
-    "illegal character found while scanning tag handle"; 
-const char* const TAG_WITH_NO_SUFFIX = "tag handle with no suffix"; 
-const char* const END_OF_VERBATIM_TAG = "end of verbatim tag not found"; 
-const char* const END_OF_MAP = "end of map not found"; 
-const char* const END_OF_MAP_FLOW = "end of map flow not found"; 
-const char* const END_OF_SEQ = "end of sequence not found"; 
-const char* const END_OF_SEQ_FLOW = "end of sequence flow not found"; 
-const char* const MULTIPLE_TAGS = 
-    "cannot assign multiple tags to the same node"; 
-const char* const MULTIPLE_ANCHORS = 
-    "cannot assign multiple anchors to the same node"; 
-const char* const MULTIPLE_ALIASES = 
-    "cannot assign multiple aliases to the same node"; 
-const char* const ALIAS_CONTENT = 
-    "aliases can't have any content, *including* tags"; 
-const char* const INVALID_HEX = "bad character found while scanning hex number"; 
-const char* const INVALID_UNICODE = "invalid unicode: "; 
-const char* const INVALID_ESCAPE = "unknown escape character: "; 
-const char* const UNKNOWN_TOKEN = "unknown token"; 
-const char* const DOC_IN_SCALAR = "illegal document indicator in scalar"; 
-const char* const EOF_IN_SCALAR = "illegal EOF in scalar"; 
-const char* const CHAR_IN_SCALAR = "illegal character in scalar"; 
-const char* const TAB_IN_INDENTATION = 
-    "illegal tab when looking for indentation"; 
-const char* const FLOW_END = "illegal flow end"; 
-const char* const BLOCK_ENTRY = "illegal block entry"; 
-const char* const MAP_KEY = "illegal map key"; 
-const char* const MAP_VALUE = "illegal map value"; 
-const char* const ALIAS_NOT_FOUND = "alias not found after *"; 
-const char* const ANCHOR_NOT_FOUND = "anchor not found after &"; 
-const char* const CHAR_IN_ALIAS = 
-    "illegal character found while scanning alias"; 
-const char* const CHAR_IN_ANCHOR = 
-    "illegal character found while scanning anchor"; 
-const char* const ZERO_INDENT_IN_BLOCK = 
-    "cannot set zero indentation for a block scalar"; 
-const char* const CHAR_IN_BLOCK = "unexpected character in block scalar"; 
-const char* const AMBIGUOUS_ANCHOR = 
-    "cannot assign the same alias to multiple nodes"; 
-const char* const UNKNOWN_ANCHOR = "the referenced anchor is not defined"; 
- 
-const char* const INVALID_NODE = 
-    "invalid node; this may result from using a map iterator as a sequence " 
-    "iterator, or vice-versa"; 
-const char* const INVALID_SCALAR = "invalid scalar"; 
-const char* const KEY_NOT_FOUND = "key not found"; 
-const char* const BAD_CONVERSION = "bad conversion"; 
-const char* const BAD_DEREFERENCE = "bad dereference"; 
-const char* const BAD_SUBSCRIPT = "operator[] call on a scalar"; 
-const char* const BAD_PUSHBACK = "appending to a non-sequence"; 
-const char* const BAD_INSERT = "inserting in a non-convertible-to-map"; 
- 
-const char* const UNMATCHED_GROUP_TAG = "unmatched group tag"; 
-const char* const UNEXPECTED_END_SEQ = "unexpected end sequence token"; 
-const char* const UNEXPECTED_END_MAP = "unexpected end map token"; 
-const char* const SINGLE_QUOTED_CHAR = 
-    "invalid character in single-quoted string"; 
-const char* const INVALID_ANCHOR = "invalid anchor"; 
-const char* const INVALID_ALIAS = "invalid alias"; 
-const char* const INVALID_TAG = "invalid tag"; 
-const char* const BAD_FILE = "bad file"; 
- 
-template <typename T> 
-inline const std::string KEY_NOT_FOUND_WITH_KEY( 
+namespace YAML {
+// error messages
+namespace ErrorMsg {
+const char* const YAML_DIRECTIVE_ARGS =
+    "YAML directives must have exactly one argument";
+const char* const YAML_VERSION = "bad YAML version: ";
+const char* const YAML_MAJOR_VERSION = "YAML major version too large";
+const char* const REPEATED_YAML_DIRECTIVE = "repeated YAML directive";
+const char* const TAG_DIRECTIVE_ARGS =
+    "TAG directives must have exactly two arguments";
+const char* const REPEATED_TAG_DIRECTIVE = "repeated TAG directive";
+const char* const CHAR_IN_TAG_HANDLE =
+    "illegal character found while scanning tag handle";
+const char* const TAG_WITH_NO_SUFFIX = "tag handle with no suffix";
+const char* const END_OF_VERBATIM_TAG = "end of verbatim tag not found";
+const char* const END_OF_MAP = "end of map not found";
+const char* const END_OF_MAP_FLOW = "end of map flow not found";
+const char* const END_OF_SEQ = "end of sequence not found";
+const char* const END_OF_SEQ_FLOW = "end of sequence flow not found";
+const char* const MULTIPLE_TAGS =
+    "cannot assign multiple tags to the same node";
+const char* const MULTIPLE_ANCHORS =
+    "cannot assign multiple anchors to the same node";
+const char* const MULTIPLE_ALIASES =
+    "cannot assign multiple aliases to the same node";
+const char* const ALIAS_CONTENT =
+    "aliases can't have any content, *including* tags";
+const char* const INVALID_HEX = "bad character found while scanning hex number";
+const char* const INVALID_UNICODE = "invalid unicode: ";
+const char* const INVALID_ESCAPE = "unknown escape character: ";
+const char* const UNKNOWN_TOKEN = "unknown token";
+const char* const DOC_IN_SCALAR = "illegal document indicator in scalar";
+const char* const EOF_IN_SCALAR = "illegal EOF in scalar";
+const char* const CHAR_IN_SCALAR = "illegal character in scalar";
+const char* const TAB_IN_INDENTATION =
+    "illegal tab when looking for indentation";
+const char* const FLOW_END = "illegal flow end";
+const char* const BLOCK_ENTRY = "illegal block entry";
+const char* const MAP_KEY = "illegal map key";
+const char* const MAP_VALUE = "illegal map value";
+const char* const ALIAS_NOT_FOUND = "alias not found after *";
+const char* const ANCHOR_NOT_FOUND = "anchor not found after &";
+const char* const CHAR_IN_ALIAS =
+    "illegal character found while scanning alias";
+const char* const CHAR_IN_ANCHOR =
+    "illegal character found while scanning anchor";
+const char* const ZERO_INDENT_IN_BLOCK =
+    "cannot set zero indentation for a block scalar";
+const char* const CHAR_IN_BLOCK = "unexpected character in block scalar";
+const char* const AMBIGUOUS_ANCHOR =
+    "cannot assign the same alias to multiple nodes";
+const char* const UNKNOWN_ANCHOR = "the referenced anchor is not defined";
+
+const char* const INVALID_NODE =
+    "invalid node; this may result from using a map iterator as a sequence "
+    "iterator, or vice-versa";
+const char* const INVALID_SCALAR = "invalid scalar";
+const char* const KEY_NOT_FOUND = "key not found";
+const char* const BAD_CONVERSION = "bad conversion";
+const char* const BAD_DEREFERENCE = "bad dereference";
+const char* const BAD_SUBSCRIPT = "operator[] call on a scalar";
+const char* const BAD_PUSHBACK = "appending to a non-sequence";
+const char* const BAD_INSERT = "inserting in a non-convertible-to-map";
+
+const char* const UNMATCHED_GROUP_TAG = "unmatched group tag";
+const char* const UNEXPECTED_END_SEQ = "unexpected end sequence token";
+const char* const UNEXPECTED_END_MAP = "unexpected end map token";
+const char* const SINGLE_QUOTED_CHAR =
+    "invalid character in single-quoted string";
+const char* const INVALID_ANCHOR = "invalid anchor";
+const char* const INVALID_ALIAS = "invalid alias";
+const char* const INVALID_TAG = "invalid tag";
+const char* const BAD_FILE = "bad file";
+
+template <typename T>
+inline const std::string KEY_NOT_FOUND_WITH_KEY(
     const T&, typename disable_if<is_numeric<T>>::type* = 0) {
-  return KEY_NOT_FOUND; 
-} 
- 
-inline const std::string KEY_NOT_FOUND_WITH_KEY(const std::string& key) { 
-  std::stringstream stream; 
-  stream << KEY_NOT_FOUND << ": " << key; 
-  return stream.str(); 
-} 
- 
-template <typename T> 
-inline const std::string KEY_NOT_FOUND_WITH_KEY( 
+  return KEY_NOT_FOUND;
+}
+
+inline const std::string KEY_NOT_FOUND_WITH_KEY(const std::string& key) {
+  std::stringstream stream;
+  stream << KEY_NOT_FOUND << ": " << key;
+  return stream.str();
+}
+
+template <typename T>
+inline const std::string KEY_NOT_FOUND_WITH_KEY(
     const T& key, typename enable_if<is_numeric<T>>::type* = 0) {
-  std::stringstream stream; 
-  stream << KEY_NOT_FOUND << ": " << key; 
-  return stream.str(); 
-} 
-} 
- 
+  std::stringstream stream;
+  stream << KEY_NOT_FOUND << ": " << key;
+  return stream.str();
+}
+}
+
 class YAML_CPP_API Exception : public std::runtime_error {
- public: 
-  Exception(const Mark& mark_, const std::string& msg_) 
-      : std::runtime_error(build_what(mark_, msg_)), mark(mark_), msg(msg_) {} 
+ public:
+  Exception(const Mark& mark_, const std::string& msg_)
+      : std::runtime_error(build_what(mark_, msg_)), mark(mark_), msg(msg_) {}
   virtual ~Exception() YAML_CPP_NOEXCEPT;
- 
+
   Exception(const Exception&) = default;
 
-  Mark mark; 
-  std::string msg; 
- 
- private: 
-  static const std::string build_what(const Mark& mark, 
-                                      const std::string& msg) { 
-    if (mark.is_null()) { 
-      return msg.c_str(); 
-    } 
- 
-    std::stringstream output; 
-    output << "yaml-cpp: error at line " << mark.line + 1 << ", column " 
-           << mark.column + 1 << ": " << msg; 
-    return output.str(); 
-  } 
-}; 
- 
+  Mark mark;
+  std::string msg;
+
+ private:
+  static const std::string build_what(const Mark& mark,
+                                      const std::string& msg) {
+    if (mark.is_null()) {
+      return msg.c_str();
+    }
+
+    std::stringstream output;
+    output << "yaml-cpp: error at line " << mark.line + 1 << ", column "
+           << mark.column + 1 << ": " << msg;
+    return output.str();
+  }
+};
+
 class YAML_CPP_API ParserException : public Exception {
- public: 
-  ParserException(const Mark& mark_, const std::string& msg_) 
-      : Exception(mark_, msg_) {} 
+ public:
+  ParserException(const Mark& mark_, const std::string& msg_)
+      : Exception(mark_, msg_) {}
   ParserException(const ParserException&) = default;
   virtual ~ParserException() YAML_CPP_NOEXCEPT;
-}; 
- 
+};
+
 class YAML_CPP_API RepresentationException : public Exception {
- public: 
-  RepresentationException(const Mark& mark_, const std::string& msg_) 
-      : Exception(mark_, msg_) {} 
+ public:
+  RepresentationException(const Mark& mark_, const std::string& msg_)
+      : Exception(mark_, msg_) {}
   RepresentationException(const RepresentationException&) = default;
   virtual ~RepresentationException() YAML_CPP_NOEXCEPT;
-}; 
- 
-// representation exceptions 
+};
+
+// representation exceptions
 class YAML_CPP_API InvalidScalar : public RepresentationException {
- public: 
-  InvalidScalar(const Mark& mark_) 
-      : RepresentationException(mark_, ErrorMsg::INVALID_SCALAR) {} 
+ public:
+  InvalidScalar(const Mark& mark_)
+      : RepresentationException(mark_, ErrorMsg::INVALID_SCALAR) {}
   InvalidScalar(const InvalidScalar&) = default;
   virtual ~InvalidScalar() YAML_CPP_NOEXCEPT;
-}; 
- 
+};
+
 class YAML_CPP_API KeyNotFound : public RepresentationException {
- public: 
-  template <typename T> 
-  KeyNotFound(const Mark& mark_, const T& key_) 
-      : RepresentationException(mark_, ErrorMsg::KEY_NOT_FOUND_WITH_KEY(key_)) { 
-  } 
+ public:
+  template <typename T>
+  KeyNotFound(const Mark& mark_, const T& key_)
+      : RepresentationException(mark_, ErrorMsg::KEY_NOT_FOUND_WITH_KEY(key_)) {
+  }
   KeyNotFound(const KeyNotFound&) = default;
   virtual ~KeyNotFound() YAML_CPP_NOEXCEPT;
-}; 
- 
-template <typename T> 
+};
+
+template <typename T>
 class YAML_CPP_API TypedKeyNotFound : public KeyNotFound {
- public: 
-  TypedKeyNotFound(const Mark& mark_, const T& key_) 
-      : KeyNotFound(mark_, key_), key(key_) {} 
+ public:
+  TypedKeyNotFound(const Mark& mark_, const T& key_)
+      : KeyNotFound(mark_, key_), key(key_) {}
   virtual ~TypedKeyNotFound() YAML_CPP_NOEXCEPT {}
- 
-  T key; 
-}; 
- 
-template <typename T> 
-inline TypedKeyNotFound<T> MakeTypedKeyNotFound(const Mark& mark, 
-                                                const T& key) { 
-  return TypedKeyNotFound<T>(mark, key); 
-} 
- 
+
+  T key;
+};
+
+template <typename T>
+inline TypedKeyNotFound<T> MakeTypedKeyNotFound(const Mark& mark,
+                                                const T& key) {
+  return TypedKeyNotFound<T>(mark, key);
+}
+
 class YAML_CPP_API InvalidNode : public RepresentationException {
- public: 
-  InvalidNode() 
-      : RepresentationException(Mark::null_mark(), ErrorMsg::INVALID_NODE) {} 
+ public:
+  InvalidNode()
+      : RepresentationException(Mark::null_mark(), ErrorMsg::INVALID_NODE) {}
   InvalidNode(const InvalidNode&) = default;
   virtual ~InvalidNode() YAML_CPP_NOEXCEPT;
-}; 
- 
+};
+
 class YAML_CPP_API BadConversion : public RepresentationException {
- public: 
-  explicit BadConversion(const Mark& mark_) 
-      : RepresentationException(mark_, ErrorMsg::BAD_CONVERSION) {} 
+ public:
+  explicit BadConversion(const Mark& mark_)
+      : RepresentationException(mark_, ErrorMsg::BAD_CONVERSION) {}
   BadConversion(const BadConversion&) = default;
   virtual ~BadConversion() YAML_CPP_NOEXCEPT;
-}; 
- 
-template <typename T> 
-class TypedBadConversion : public BadConversion { 
- public: 
-  explicit TypedBadConversion(const Mark& mark_) : BadConversion(mark_) {} 
-}; 
- 
+};
+
+template <typename T>
+class TypedBadConversion : public BadConversion {
+ public:
+  explicit TypedBadConversion(const Mark& mark_) : BadConversion(mark_) {}
+};
+
 class YAML_CPP_API BadDereference : public RepresentationException {
- public: 
-  BadDereference() 
-      : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_DEREFERENCE) {} 
+ public:
+  BadDereference()
+      : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_DEREFERENCE) {}
   BadDereference(const BadDereference&) = default;
   virtual ~BadDereference() YAML_CPP_NOEXCEPT;
-}; 
- 
+};
+
 class YAML_CPP_API BadSubscript : public RepresentationException {
- public: 
-  BadSubscript() 
-      : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_SUBSCRIPT) {} 
+ public:
+  BadSubscript()
+      : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_SUBSCRIPT) {}
   BadSubscript(const BadSubscript&) = default;
   virtual ~BadSubscript() YAML_CPP_NOEXCEPT;
-}; 
- 
+};
+
 class YAML_CPP_API BadPushback : public RepresentationException {
- public: 
-  BadPushback() 
-      : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_PUSHBACK) {} 
+ public:
+  BadPushback()
+      : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_PUSHBACK) {}
   BadPushback(const BadPushback&) = default;
   virtual ~BadPushback() YAML_CPP_NOEXCEPT;
-}; 
- 
+};
+
 class YAML_CPP_API BadInsert : public RepresentationException {
- public: 
-  BadInsert() 
-      : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_INSERT) {} 
+ public:
+  BadInsert()
+      : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_INSERT) {}
   BadInsert(const BadInsert&) = default;
   virtual ~BadInsert() YAML_CPP_NOEXCEPT;
-}; 
- 
+};
+
 class YAML_CPP_API EmitterException : public Exception {
- public: 
-  EmitterException(const std::string& msg_) 
-      : Exception(Mark::null_mark(), msg_) {} 
+ public:
+  EmitterException(const std::string& msg_)
+      : Exception(Mark::null_mark(), msg_) {}
   EmitterException(const EmitterException&) = default;
   virtual ~EmitterException() YAML_CPP_NOEXCEPT;
-}; 
- 
+};
+
 class YAML_CPP_API BadFile : public Exception {
- public: 
-  BadFile() : Exception(Mark::null_mark(), ErrorMsg::BAD_FILE) {} 
+ public:
+  BadFile() : Exception(Mark::null_mark(), ErrorMsg::BAD_FILE) {}
   BadFile(const BadFile&) = default;
   virtual ~BadFile() YAML_CPP_NOEXCEPT;
-}; 
-} 
- 
+};
+}
+
 #undef YAML_CPP_NOEXCEPT
 
-#endif  // EXCEPTIONS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+#endif  // EXCEPTIONS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/mark.h b/contrib/libs/yaml-cpp/include/yaml-cpp/mark.h
index 27c4f741282..bf94b4f41fc 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/mark.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/mark.h
@@ -1,29 +1,29 @@
-#ifndef MARK_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define MARK_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include "yaml-cpp/dll.h" 
- 
-namespace YAML { 
-struct YAML_CPP_API Mark { 
-  Mark() : pos(0), line(0), column(0) {} 
- 
-  static const Mark null_mark() { return Mark(-1, -1, -1); } 
- 
-  bool is_null() const { return pos == -1 && line == -1 && column == -1; } 
- 
-  int pos; 
-  int line, column; 
- 
- private: 
-  Mark(int pos_, int line_, int column_) 
-      : pos(pos_), line(line_), column(column_) {} 
-}; 
-} 
- 
-#endif  // MARK_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+#ifndef MARK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define MARK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/dll.h"
+
+namespace YAML {
+struct YAML_CPP_API Mark {
+  Mark() : pos(0), line(0), column(0) {}
+
+  static const Mark null_mark() { return Mark(-1, -1, -1); }
+
+  bool is_null() const { return pos == -1 && line == -1 && column == -1; }
+
+  int pos;
+  int line, column;
+
+ private:
+  Mark(int pos_, int line_, int column_)
+      : pos(pos_), line(line_), column(column_) {}
+};
+}
+
+#endif  // MARK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/node/convert.h b/contrib/libs/yaml-cpp/include/yaml-cpp/node/convert.h
index 791036869e1..45a878ab0c0 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/node/convert.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/node/convert.h
@@ -1,247 +1,247 @@
-#ifndef NODE_CONVERT_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define NODE_CONVERT_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
+#ifndef NODE_CONVERT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODE_CONVERT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
 #include <array>
-#include <limits> 
-#include <list> 
-#include <map> 
-#include <sstream> 
-#include <vector> 
- 
-#include "yaml-cpp/binary.h" 
-#include "yaml-cpp/node/impl.h" 
-#include "yaml-cpp/node/iterator.h" 
-#include "yaml-cpp/node/node.h" 
-#include "yaml-cpp/node/type.h" 
-#include "yaml-cpp/null.h" 
- 
-namespace YAML { 
-class Binary; 
-struct _Null; 
-template <typename T> 
-struct convert; 
-}  // namespace YAML 
- 
-namespace YAML { 
-namespace conversion { 
-inline bool IsInfinity(const std::string& input) { 
-  return input == ".inf" || input == ".Inf" || input == ".INF" || 
-         input == "+.inf" || input == "+.Inf" || input == "+.INF"; 
-} 
- 
-inline bool IsNegativeInfinity(const std::string& input) { 
-  return input == "-.inf" || input == "-.Inf" || input == "-.INF"; 
-} 
- 
-inline bool IsNaN(const std::string& input) { 
-  return input == ".nan" || input == ".NaN" || input == ".NAN"; 
-} 
-} 
- 
-// Node 
-template <> 
-struct convert<Node> { 
-  static Node encode(const Node& rhs) { return rhs; } 
- 
-  static bool decode(const Node& node, Node& rhs) { 
-    rhs.reset(node); 
-    return true; 
-  } 
-}; 
- 
-// std::string 
-template <> 
-struct convert<std::string> { 
-  static Node encode(const std::string& rhs) { return Node(rhs); } 
- 
-  static bool decode(const Node& node, std::string& rhs) { 
-    if (!node.IsScalar()) 
-      return false; 
-    rhs = node.Scalar(); 
-    return true; 
-  } 
-}; 
- 
-// C-strings can only be encoded 
-template <> 
-struct convert<const char*> { 
-  static Node encode(const char*& rhs) { return Node(rhs); } 
-}; 
- 
-template <std::size_t N> 
-struct convert<const char[N]> { 
-  static Node encode(const char(&rhs)[N]) { return Node(rhs); } 
-}; 
- 
-template <> 
-struct convert<_Null> { 
-  static Node encode(const _Null& /* rhs */) { return Node(); } 
- 
-  static bool decode(const Node& node, _Null& /* rhs */) { 
-    return node.IsNull(); 
-  } 
-}; 
- 
-#define YAML_DEFINE_CONVERT_STREAMABLE(type, negative_op)                \ 
-  template <>                                                            \ 
-  struct convert<type> {                                                 \ 
-    static Node encode(const type& rhs) {                                \ 
-      std::stringstream stream;                                          \ 
-      stream.precision(std::numeric_limits<type>::digits10 + 1);         \ 
-      stream << rhs;                                                     \ 
-      return Node(stream.str());                                         \ 
-    }                                                                    \ 
-                                                                         \ 
-    static bool decode(const Node& node, type& rhs) {                    \ 
-      if (node.Type() != NodeType::Scalar)                               \ 
-        return false;                                                    \ 
-      const std::string& input = node.Scalar();                          \ 
-      std::stringstream stream(input);                                   \ 
-      stream.unsetf(std::ios::dec);                                      \ 
-      if ((stream >> std::noskipws >> rhs) && (stream >> std::ws).eof()) \ 
-        return true;                                                     \ 
-      if (std::numeric_limits<type>::has_infinity) {                     \ 
-        if (conversion::IsInfinity(input)) {                             \ 
-          rhs = std::numeric_limits<type>::infinity();                   \ 
-          return true;                                                   \ 
-        } else if (conversion::IsNegativeInfinity(input)) {              \ 
-          rhs = negative_op std::numeric_limits<type>::infinity();       \ 
-          return true;                                                   \ 
-        }                                                                \ 
-      }                                                                  \ 
-                                                                         \ 
-      if (std::numeric_limits<type>::has_quiet_NaN &&                    \ 
-          conversion::IsNaN(input)) {                                    \ 
-        rhs = std::numeric_limits<type>::quiet_NaN();                    \ 
-        return true;                                                     \ 
-      }                                                                  \ 
-                                                                         \ 
-      return false;                                                      \ 
-    }                                                                    \ 
-  } 
- 
-#define YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(type) \ 
-  YAML_DEFINE_CONVERT_STREAMABLE(type, -) 
- 
-#define YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(type) \ 
-  YAML_DEFINE_CONVERT_STREAMABLE(type, +) 
- 
-YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(int); 
-YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(short); 
-YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(long); 
-YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(long long); 
-YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned); 
-YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned short); 
-YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned long); 
-YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned long long); 
- 
-YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(char); 
-YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(signed char); 
-YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned char); 
- 
-YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(float); 
-YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(double); 
-YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(long double); 
- 
-#undef YAML_DEFINE_CONVERT_STREAMABLE_SIGNED 
-#undef YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED 
-#undef YAML_DEFINE_CONVERT_STREAMABLE 
- 
-// bool 
-template <> 
-struct convert<bool> { 
-  static Node encode(bool rhs) { return rhs ? Node("true") : Node("false"); } 
- 
-  YAML_CPP_API static bool decode(const Node& node, bool& rhs); 
-}; 
- 
-// std::map 
-template <typename K, typename V> 
+#include <limits>
+#include <list>
+#include <map>
+#include <sstream>
+#include <vector>
+
+#include "yaml-cpp/binary.h"
+#include "yaml-cpp/node/impl.h"
+#include "yaml-cpp/node/iterator.h"
+#include "yaml-cpp/node/node.h"
+#include "yaml-cpp/node/type.h"
+#include "yaml-cpp/null.h"
+
+namespace YAML {
+class Binary;
+struct _Null;
+template <typename T>
+struct convert;
+}  // namespace YAML
+
+namespace YAML {
+namespace conversion {
+inline bool IsInfinity(const std::string& input) {
+  return input == ".inf" || input == ".Inf" || input == ".INF" ||
+         input == "+.inf" || input == "+.Inf" || input == "+.INF";
+}
+
+inline bool IsNegativeInfinity(const std::string& input) {
+  return input == "-.inf" || input == "-.Inf" || input == "-.INF";
+}
+
+inline bool IsNaN(const std::string& input) {
+  return input == ".nan" || input == ".NaN" || input == ".NAN";
+}
+}
+
+// Node
+template <>
+struct convert<Node> {
+  static Node encode(const Node& rhs) { return rhs; }
+
+  static bool decode(const Node& node, Node& rhs) {
+    rhs.reset(node);
+    return true;
+  }
+};
+
+// std::string
+template <>
+struct convert<std::string> {
+  static Node encode(const std::string& rhs) { return Node(rhs); }
+
+  static bool decode(const Node& node, std::string& rhs) {
+    if (!node.IsScalar())
+      return false;
+    rhs = node.Scalar();
+    return true;
+  }
+};
+
+// C-strings can only be encoded
+template <>
+struct convert<const char*> {
+  static Node encode(const char*& rhs) { return Node(rhs); }
+};
+
+template <std::size_t N>
+struct convert<const char[N]> {
+  static Node encode(const char(&rhs)[N]) { return Node(rhs); }
+};
+
+template <>
+struct convert<_Null> {
+  static Node encode(const _Null& /* rhs */) { return Node(); }
+
+  static bool decode(const Node& node, _Null& /* rhs */) {
+    return node.IsNull();
+  }
+};
+
+#define YAML_DEFINE_CONVERT_STREAMABLE(type, negative_op)                \
+  template <>                                                            \
+  struct convert<type> {                                                 \
+    static Node encode(const type& rhs) {                                \
+      std::stringstream stream;                                          \
+      stream.precision(std::numeric_limits<type>::digits10 + 1);         \
+      stream << rhs;                                                     \
+      return Node(stream.str());                                         \
+    }                                                                    \
+                                                                         \
+    static bool decode(const Node& node, type& rhs) {                    \
+      if (node.Type() != NodeType::Scalar)                               \
+        return false;                                                    \
+      const std::string& input = node.Scalar();                          \
+      std::stringstream stream(input);                                   \
+      stream.unsetf(std::ios::dec);                                      \
+      if ((stream >> std::noskipws >> rhs) && (stream >> std::ws).eof()) \
+        return true;                                                     \
+      if (std::numeric_limits<type>::has_infinity) {                     \
+        if (conversion::IsInfinity(input)) {                             \
+          rhs = std::numeric_limits<type>::infinity();                   \
+          return true;                                                   \
+        } else if (conversion::IsNegativeInfinity(input)) {              \
+          rhs = negative_op std::numeric_limits<type>::infinity();       \
+          return true;                                                   \
+        }                                                                \
+      }                                                                  \
+                                                                         \
+      if (std::numeric_limits<type>::has_quiet_NaN &&                    \
+          conversion::IsNaN(input)) {                                    \
+        rhs = std::numeric_limits<type>::quiet_NaN();                    \
+        return true;                                                     \
+      }                                                                  \
+                                                                         \
+      return false;                                                      \
+    }                                                                    \
+  }
+
+#define YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(type) \
+  YAML_DEFINE_CONVERT_STREAMABLE(type, -)
+
+#define YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(type) \
+  YAML_DEFINE_CONVERT_STREAMABLE(type, +)
+
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(int);
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(short);
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(long);
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(long long);
+YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned);
+YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned short);
+YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned long);
+YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned long long);
+
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(char);
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(signed char);
+YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned char);
+
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(float);
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(double);
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(long double);
+
+#undef YAML_DEFINE_CONVERT_STREAMABLE_SIGNED
+#undef YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED
+#undef YAML_DEFINE_CONVERT_STREAMABLE
+
+// bool
+template <>
+struct convert<bool> {
+  static Node encode(bool rhs) { return rhs ? Node("true") : Node("false"); }
+
+  YAML_CPP_API static bool decode(const Node& node, bool& rhs);
+};
+
+// std::map
+template <typename K, typename V>
 struct convert<std::map<K, V>> {
-  static Node encode(const std::map<K, V>& rhs) { 
-    Node node(NodeType::Map); 
-    for (typename std::map<K, V>::const_iterator it = rhs.begin(); 
-         it != rhs.end(); ++it) 
-      node.force_insert(it->first, it->second); 
-    return node; 
-  } 
- 
-  static bool decode(const Node& node, std::map<K, V>& rhs) { 
-    if (!node.IsMap()) 
-      return false; 
- 
-    rhs.clear(); 
-    for (const_iterator it = node.begin(); it != node.end(); ++it) 
-#if defined(__GNUC__) && __GNUC__ < 4 
-      // workaround for GCC 3: 
-      rhs[it->first.template as<K>()] = it->second.template as<V>(); 
-#else 
-      rhs[it->first.as<K>()] = it->second.as<V>(); 
-#endif 
-    return true; 
-  } 
-}; 
- 
-// std::vector 
-template <typename T> 
+  static Node encode(const std::map<K, V>& rhs) {
+    Node node(NodeType::Map);
+    for (typename std::map<K, V>::const_iterator it = rhs.begin();
+         it != rhs.end(); ++it)
+      node.force_insert(it->first, it->second);
+    return node;
+  }
+
+  static bool decode(const Node& node, std::map<K, V>& rhs) {
+    if (!node.IsMap())
+      return false;
+
+    rhs.clear();
+    for (const_iterator it = node.begin(); it != node.end(); ++it)
+#if defined(__GNUC__) && __GNUC__ < 4
+      // workaround for GCC 3:
+      rhs[it->first.template as<K>()] = it->second.template as<V>();
+#else
+      rhs[it->first.as<K>()] = it->second.as<V>();
+#endif
+    return true;
+  }
+};
+
+// std::vector
+template <typename T>
 struct convert<std::vector<T>> {
-  static Node encode(const std::vector<T>& rhs) { 
-    Node node(NodeType::Sequence); 
-    for (typename std::vector<T>::const_iterator it = rhs.begin(); 
-         it != rhs.end(); ++it) 
-      node.push_back(*it); 
-    return node; 
-  } 
- 
-  static bool decode(const Node& node, std::vector<T>& rhs) { 
-    if (!node.IsSequence()) 
-      return false; 
- 
-    rhs.clear(); 
-    for (const_iterator it = node.begin(); it != node.end(); ++it) 
-#if defined(__GNUC__) && __GNUC__ < 4 
-      // workaround for GCC 3: 
-      rhs.push_back(it->template as<T>()); 
-#else 
-      rhs.push_back(it->as<T>()); 
-#endif 
-    return true; 
-  } 
-}; 
- 
-// std::list 
-template <typename T> 
+  static Node encode(const std::vector<T>& rhs) {
+    Node node(NodeType::Sequence);
+    for (typename std::vector<T>::const_iterator it = rhs.begin();
+         it != rhs.end(); ++it)
+      node.push_back(*it);
+    return node;
+  }
+
+  static bool decode(const Node& node, std::vector<T>& rhs) {
+    if (!node.IsSequence())
+      return false;
+
+    rhs.clear();
+    for (const_iterator it = node.begin(); it != node.end(); ++it)
+#if defined(__GNUC__) && __GNUC__ < 4
+      // workaround for GCC 3:
+      rhs.push_back(it->template as<T>());
+#else
+      rhs.push_back(it->as<T>());
+#endif
+    return true;
+  }
+};
+
+// std::list
+template <typename T>
 struct convert<std::list<T>> {
-  static Node encode(const std::list<T>& rhs) { 
-    Node node(NodeType::Sequence); 
-    for (typename std::list<T>::const_iterator it = rhs.begin(); 
-         it != rhs.end(); ++it) 
-      node.push_back(*it); 
-    return node; 
-  } 
- 
-  static bool decode(const Node& node, std::list<T>& rhs) { 
-    if (!node.IsSequence()) 
-      return false; 
- 
-    rhs.clear(); 
-    for (const_iterator it = node.begin(); it != node.end(); ++it) 
-#if defined(__GNUC__) && __GNUC__ < 4 
-      // workaround for GCC 3: 
-      rhs.push_back(it->template as<T>()); 
-#else 
-      rhs.push_back(it->as<T>()); 
-#endif 
-    return true; 
-  } 
-}; 
- 
+  static Node encode(const std::list<T>& rhs) {
+    Node node(NodeType::Sequence);
+    for (typename std::list<T>::const_iterator it = rhs.begin();
+         it != rhs.end(); ++it)
+      node.push_back(*it);
+    return node;
+  }
+
+  static bool decode(const Node& node, std::list<T>& rhs) {
+    if (!node.IsSequence())
+      return false;
+
+    rhs.clear();
+    for (const_iterator it = node.begin(); it != node.end(); ++it)
+#if defined(__GNUC__) && __GNUC__ < 4
+      // workaround for GCC 3:
+      rhs.push_back(it->template as<T>());
+#else
+      rhs.push_back(it->as<T>());
+#endif
+    return true;
+  }
+};
+
 // std::array
 template <typename T, std::size_t N>
 struct convert<std::array<T, N>> {
@@ -275,57 +275,57 @@ struct convert<std::array<T, N>> {
   }
 };
 
-// std::pair 
-template <typename T, typename U> 
+// std::pair
+template <typename T, typename U>
 struct convert<std::pair<T, U>> {
-  static Node encode(const std::pair<T, U>& rhs) { 
-    Node node(NodeType::Sequence); 
-    node.push_back(rhs.first); 
-    node.push_back(rhs.second); 
-    return node; 
-  } 
- 
-  static bool decode(const Node& node, std::pair<T, U>& rhs) { 
-    if (!node.IsSequence()) 
-      return false; 
-    if (node.size() != 2) 
-      return false; 
- 
-#if defined(__GNUC__) && __GNUC__ < 4 
-    // workaround for GCC 3: 
-    rhs.first = node[0].template as<T>(); 
-#else 
-    rhs.first = node[0].as<T>(); 
-#endif 
-#if defined(__GNUC__) && __GNUC__ < 4 
-    // workaround for GCC 3: 
-    rhs.second = node[1].template as<U>(); 
-#else 
-    rhs.second = node[1].as<U>(); 
-#endif 
-    return true; 
-  } 
-}; 
- 
-// binary 
-template <> 
-struct convert<Binary> { 
-  static Node encode(const Binary& rhs) { 
-    return Node(EncodeBase64(rhs.data(), rhs.size())); 
-  } 
- 
-  static bool decode(const Node& node, Binary& rhs) { 
-    if (!node.IsScalar()) 
-      return false; 
- 
-    std::vector<unsigned char> data = DecodeBase64(node.Scalar()); 
-    if (data.empty() && !node.Scalar().empty()) 
-      return false; 
- 
-    rhs.swap(data); 
-    return true; 
-  } 
-}; 
-} 
- 
-#endif  // NODE_CONVERT_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+  static Node encode(const std::pair<T, U>& rhs) {
+    Node node(NodeType::Sequence);
+    node.push_back(rhs.first);
+    node.push_back(rhs.second);
+    return node;
+  }
+
+  static bool decode(const Node& node, std::pair<T, U>& rhs) {
+    if (!node.IsSequence())
+      return false;
+    if (node.size() != 2)
+      return false;
+
+#if defined(__GNUC__) && __GNUC__ < 4
+    // workaround for GCC 3:
+    rhs.first = node[0].template as<T>();
+#else
+    rhs.first = node[0].as<T>();
+#endif
+#if defined(__GNUC__) && __GNUC__ < 4
+    // workaround for GCC 3:
+    rhs.second = node[1].template as<U>();
+#else
+    rhs.second = node[1].as<U>();
+#endif
+    return true;
+  }
+};
+
+// binary
+template <>
+struct convert<Binary> {
+  static Node encode(const Binary& rhs) {
+    return Node(EncodeBase64(rhs.data(), rhs.size()));
+  }
+
+  static bool decode(const Node& node, Binary& rhs) {
+    if (!node.IsScalar())
+      return false;
+
+    std::vector<unsigned char> data = DecodeBase64(node.Scalar());
+    if (data.empty() && !node.Scalar().empty())
+      return false;
+
+    rhs.swap(data);
+    return true;
+  }
+};
+}
+
+#endif  // NODE_CONVERT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/node/detail/bool_type.h b/contrib/libs/yaml-cpp/include/yaml-cpp/node/detail/bool_type.h
index 203a7a4f276..2c80705c9ae 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/node/detail/bool_type.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/node/detail/bool_type.h
@@ -1,26 +1,26 @@
-#ifndef NODE_DETAIL_BOOL_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define NODE_DETAIL_BOOL_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-namespace YAML { 
-namespace detail { 
-struct unspecified_bool { 
-  struct NOT_ALLOWED; 
-  static void true_value(NOT_ALLOWED*) {} 
-}; 
-typedef void (*unspecified_bool_type)(unspecified_bool::NOT_ALLOWED*); 
-} 
-} 
- 
-#define YAML_CPP_OPERATOR_BOOL()                                            \ 
-  operator YAML::detail::unspecified_bool_type() const {                    \ 
-    return this->operator!() ? 0                                            \ 
-                             : &YAML::detail::unspecified_bool::true_value; \ 
-  } 
- 
-#endif  // NODE_DETAIL_BOOL_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+#ifndef NODE_DETAIL_BOOL_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODE_DETAIL_BOOL_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+namespace YAML {
+namespace detail {
+struct unspecified_bool {
+  struct NOT_ALLOWED;
+  static void true_value(NOT_ALLOWED*) {}
+};
+typedef void (*unspecified_bool_type)(unspecified_bool::NOT_ALLOWED*);
+}
+}
+
+#define YAML_CPP_OPERATOR_BOOL()                                            \
+  operator YAML::detail::unspecified_bool_type() const {                    \
+    return this->operator!() ? 0                                            \
+                             : &YAML::detail::unspecified_bool::true_value; \
+  }
+
+#endif  // NODE_DETAIL_BOOL_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/node/detail/impl.h b/contrib/libs/yaml-cpp/include/yaml-cpp/node/detail/impl.h
index c058852e634..09e55f838c2 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/node/detail/impl.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/node/detail/impl.h
@@ -1,137 +1,137 @@
-#ifndef NODE_DETAIL_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define NODE_DETAIL_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include "yaml-cpp/node/detail/node.h" 
-#include "yaml-cpp/node/detail/node_data.h" 
+#ifndef NODE_DETAIL_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODE_DETAIL_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/node/detail/node.h"
+#include "yaml-cpp/node/detail/node_data.h"
 #include <type_traits>
- 
-namespace YAML { 
-namespace detail { 
-template <typename Key, typename Enable = void> 
-struct get_idx { 
-  static node* get(const std::vector<node*>& /* sequence */, 
-                   const Key& /* key */, shared_memory_holder /* pMemory */) { 
-    return 0; 
-  } 
-}; 
- 
-template <typename Key> 
+
+namespace YAML {
+namespace detail {
+template <typename Key, typename Enable = void>
+struct get_idx {
+  static node* get(const std::vector<node*>& /* sequence */,
+                   const Key& /* key */, shared_memory_holder /* pMemory */) {
+    return 0;
+  }
+};
+
+template <typename Key>
 struct get_idx<Key,
                typename std::enable_if<std::is_unsigned<Key>::value &&
                                        !std::is_same<Key, bool>::value>::type> {
-  static node* get(const std::vector<node*>& sequence, const Key& key, 
-                   shared_memory_holder /* pMemory */) { 
-    return key < sequence.size() ? sequence[key] : 0; 
-  } 
- 
-  static node* get(std::vector<node*>& sequence, const Key& key, 
-                   shared_memory_holder pMemory) { 
+  static node* get(const std::vector<node*>& sequence, const Key& key,
+                   shared_memory_holder /* pMemory */) {
+    return key < sequence.size() ? sequence[key] : 0;
+  }
+
+  static node* get(std::vector<node*>& sequence, const Key& key,
+                   shared_memory_holder pMemory) {
    if (key > sequence.size() || (key > 0 && !sequence[key-1]->is_defined()))
-      return 0; 
-    if (key == sequence.size()) 
-      sequence.push_back(&pMemory->create_node()); 
-    return sequence[key]; 
-  } 
-}; 
- 
-template <typename Key> 
+      return 0;
+    if (key == sequence.size())
+      sequence.push_back(&pMemory->create_node());
+    return sequence[key];
+  }
+};
+
+template <typename Key>
 struct get_idx<Key, typename std::enable_if<std::is_signed<Key>::value>::type> {
-  static node* get(const std::vector<node*>& sequence, const Key& key, 
-                   shared_memory_holder pMemory) { 
-    return key >= 0 ? get_idx<std::size_t>::get( 
-                          sequence, static_cast<std::size_t>(key), pMemory) 
-                    : 0; 
-  } 
-  static node* get(std::vector<node*>& sequence, const Key& key, 
-                   shared_memory_holder pMemory) { 
-    return key >= 0 ? get_idx<std::size_t>::get( 
-                          sequence, static_cast<std::size_t>(key), pMemory) 
-                    : 0; 
-  } 
-}; 
- 
-template <typename T> 
-inline bool node::equals(const T& rhs, shared_memory_holder pMemory) { 
-  T lhs; 
-  if (convert<T>::decode(Node(*this, pMemory), lhs)) { 
-    return lhs == rhs; 
-  } 
-  return false; 
-} 
- 
-inline bool node::equals(const char* rhs, shared_memory_holder pMemory) { 
-  return equals<std::string>(rhs, pMemory); 
-} 
- 
-// indexing 
-template <typename Key> 
-inline node* node_data::get(const Key& key, 
-                            shared_memory_holder pMemory) const { 
-  switch (m_type) { 
-    case NodeType::Map: 
-      break; 
-    case NodeType::Undefined: 
-    case NodeType::Null: 
-      return NULL; 
-    case NodeType::Sequence: 
-      if (node* pNode = get_idx<Key>::get(m_sequence, key, pMemory)) 
-        return pNode; 
-      return NULL; 
-    case NodeType::Scalar: 
-      throw BadSubscript(); 
-  } 
- 
-  for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) { 
-    if (it->first->equals(key, pMemory)) { 
-      return it->second; 
-    } 
-  } 
- 
-  return NULL; 
-} 
- 
-template <typename Key> 
-inline node& node_data::get(const Key& key, shared_memory_holder pMemory) { 
-  switch (m_type) { 
-    case NodeType::Map: 
-      break; 
-    case NodeType::Undefined: 
-    case NodeType::Null: 
-    case NodeType::Sequence: 
-      if (node* pNode = get_idx<Key>::get(m_sequence, key, pMemory)) { 
-        m_type = NodeType::Sequence; 
-        return *pNode; 
-      } 
- 
-      convert_to_map(pMemory); 
-      break; 
-    case NodeType::Scalar: 
-      throw BadSubscript(); 
-  } 
- 
-  for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) { 
-    if (it->first->equals(key, pMemory)) { 
-      return *it->second; 
-    } 
-  } 
- 
-  node& k = convert_to_node(key, pMemory); 
-  node& v = pMemory->create_node(); 
-  insert_map_pair(k, v); 
-  return v; 
-} 
- 
-template <typename Key> 
-inline bool node_data::remove(const Key& key, shared_memory_holder pMemory) { 
-  if (m_type != NodeType::Map) 
-    return false; 
- 
+  static node* get(const std::vector<node*>& sequence, const Key& key,
+                   shared_memory_holder pMemory) {
+    return key >= 0 ? get_idx<std::size_t>::get(
+                          sequence, static_cast<std::size_t>(key), pMemory)
+                    : 0;
+  }
+  static node* get(std::vector<node*>& sequence, const Key& key,
+                   shared_memory_holder pMemory) {
+    return key >= 0 ? get_idx<std::size_t>::get(
+                          sequence, static_cast<std::size_t>(key), pMemory)
+                    : 0;
+  }
+};
+
+template <typename T>
+inline bool node::equals(const T& rhs, shared_memory_holder pMemory) {
+  T lhs;
+  if (convert<T>::decode(Node(*this, pMemory), lhs)) {
+    return lhs == rhs;
+  }
+  return false;
+}
+
+inline bool node::equals(const char* rhs, shared_memory_holder pMemory) {
+  return equals<std::string>(rhs, pMemory);
+}
+
+// indexing
+template <typename Key>
+inline node* node_data::get(const Key& key,
+                            shared_memory_holder pMemory) const {
+  switch (m_type) {
+    case NodeType::Map:
+      break;
+    case NodeType::Undefined:
+    case NodeType::Null:
+      return NULL;
+    case NodeType::Sequence:
+      if (node* pNode = get_idx<Key>::get(m_sequence, key, pMemory))
+        return pNode;
+      return NULL;
+    case NodeType::Scalar:
+      throw BadSubscript();
+  }
+
+  for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) {
+    if (it->first->equals(key, pMemory)) {
+      return it->second;
+    }
+  }
+
+  return NULL;
+}
+
+template <typename Key>
+inline node& node_data::get(const Key& key, shared_memory_holder pMemory) {
+  switch (m_type) {
+    case NodeType::Map:
+      break;
+    case NodeType::Undefined:
+    case NodeType::Null:
+    case NodeType::Sequence:
+      if (node* pNode = get_idx<Key>::get(m_sequence, key, pMemory)) {
+        m_type = NodeType::Sequence;
+        return *pNode;
+      }
+
+      convert_to_map(pMemory);
+      break;
+    case NodeType::Scalar:
+      throw BadSubscript();
+  }
+
+  for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) {
+    if (it->first->equals(key, pMemory)) {
+      return *it->second;
+    }
+  }
+
+  node& k = convert_to_node(key, pMemory);
+  node& v = pMemory->create_node();
+  insert_map_pair(k, v);
+  return v;
+}
+
+template <typename Key>
+inline bool node_data::remove(const Key& key, shared_memory_holder pMemory) {
+  if (m_type != NodeType::Map)
+    return false;
+
   for (kv_pairs::iterator it = m_undefinedPairs.begin();
        it != m_undefinedPairs.end();) {
     kv_pairs::iterator jt = std::next(it);
@@ -140,46 +140,46 @@ inline bool node_data::remove(const Key& key, shared_memory_holder pMemory) {
     it = jt;
   }
 
-  for (node_map::iterator it = m_map.begin(); it != m_map.end(); ++it) { 
-    if (it->first->equals(key, pMemory)) { 
-      m_map.erase(it); 
-      return true; 
-    } 
-  } 
- 
-  return false; 
-} 
- 
-// map 
-template <typename Key, typename Value> 
-inline void node_data::force_insert(const Key& key, const Value& value, 
-                                    shared_memory_holder pMemory) { 
-  switch (m_type) { 
-    case NodeType::Map: 
-      break; 
-    case NodeType::Undefined: 
-    case NodeType::Null: 
-    case NodeType::Sequence: 
-      convert_to_map(pMemory); 
-      break; 
-    case NodeType::Scalar: 
-      throw BadInsert(); 
-  } 
- 
-  node& k = convert_to_node(key, pMemory); 
-  node& v = convert_to_node(value, pMemory); 
-  insert_map_pair(k, v); 
-} 
- 
-template <typename T> 
-inline node& node_data::convert_to_node(const T& rhs, 
-                                        shared_memory_holder pMemory) { 
-  Node value = convert<T>::encode(rhs); 
-  value.EnsureNodeExists(); 
-  pMemory->merge(*value.m_pMemory); 
-  return *value.m_pNode; 
-} 
-} 
-} 
- 
-#endif  // NODE_DETAIL_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+  for (node_map::iterator it = m_map.begin(); it != m_map.end(); ++it) {
+    if (it->first->equals(key, pMemory)) {
+      m_map.erase(it);
+      return true;
+    }
+  }
+
+  return false;
+}
+
+// map
+template <typename Key, typename Value>
+inline void node_data::force_insert(const Key& key, const Value& value,
+                                    shared_memory_holder pMemory) {
+  switch (m_type) {
+    case NodeType::Map:
+      break;
+    case NodeType::Undefined:
+    case NodeType::Null:
+    case NodeType::Sequence:
+      convert_to_map(pMemory);
+      break;
+    case NodeType::Scalar:
+      throw BadInsert();
+  }
+
+  node& k = convert_to_node(key, pMemory);
+  node& v = convert_to_node(value, pMemory);
+  insert_map_pair(k, v);
+}
+
+template <typename T>
+inline node& node_data::convert_to_node(const T& rhs,
+                                        shared_memory_holder pMemory) {
+  Node value = convert<T>::encode(rhs);
+  value.EnsureNodeExists();
+  pMemory->merge(*value.m_pMemory);
+  return *value.m_pNode;
+}
+}
+}
+
+#endif  // NODE_DETAIL_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/node/detail/iterator.h b/contrib/libs/yaml-cpp/include/yaml-cpp/node/detail/iterator.h
index 2dd31391dd1..deec8fb62cd 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/node/detail/iterator.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/node/detail/iterator.h
@@ -1,33 +1,33 @@
-#ifndef VALUE_DETAIL_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define VALUE_DETAIL_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include "yaml-cpp/dll.h" 
+#ifndef VALUE_DETAIL_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define VALUE_DETAIL_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/dll.h"
 #include "yaml-cpp/node/node.h"
-#include "yaml-cpp/node/ptr.h" 
-#include "yaml-cpp/node/detail/node_iterator.h" 
+#include "yaml-cpp/node/ptr.h"
+#include "yaml-cpp/node/detail/node_iterator.h"
 #include <cstddef>
 #include <iterator>
- 
-namespace YAML { 
-namespace detail { 
-struct iterator_value; 
- 
-template <typename V> 
+
+namespace YAML {
+namespace detail {
+struct iterator_value;
+
+template <typename V>
 class iterator_base : public std::iterator<std::forward_iterator_tag, V,
                                            std::ptrdiff_t, V*, V> {
 
- private: 
-  template <typename> 
-  friend class iterator_base; 
-  struct enabler {}; 
+ private:
+  template <typename>
+  friend class iterator_base;
+  struct enabler {};
   typedef node_iterator base_type;
- 
+
   struct proxy {
     explicit proxy(const V& x) : m_ref(x) {}
     V* operator->() { return std::addressof(m_ref); }
@@ -36,31 +36,31 @@ class iterator_base : public std::iterator<std::forward_iterator_tag, V,
     V m_ref;
   };
 
- public: 
-  typedef typename iterator_base::value_type value_type; 
- 
- public: 
+ public:
+  typedef typename iterator_base::value_type value_type;
+
+ public:
   iterator_base() : m_iterator(), m_pMemory() {}
-  explicit iterator_base(base_type rhs, shared_memory_holder pMemory) 
+  explicit iterator_base(base_type rhs, shared_memory_holder pMemory)
       : m_iterator(rhs), m_pMemory(pMemory) {}
- 
-  template <class W> 
-  iterator_base(const iterator_base<W>& rhs, 
+
+  template <class W>
+  iterator_base(const iterator_base<W>& rhs,
                 typename std::enable_if<std::is_convertible<W*, V*>::value,
                                         enabler>::type = enabler())
       : m_iterator(rhs.m_iterator), m_pMemory(rhs.m_pMemory) {}
- 
+
   iterator_base<V>& operator++() {
     ++m_iterator;
     return *this;
   }
- 
+
   iterator_base<V> operator++(int) {
     iterator_base<V> iterator_pre(*this);
     ++(*this);
     return iterator_pre;
   }
- 
+
   template <typename W>
   bool operator==(const iterator_base<W>& rhs) const {
     return m_iterator == rhs.m_iterator;
@@ -73,20 +73,20 @@ class iterator_base : public std::iterator<std::forward_iterator_tag, V,
 
   value_type operator*() const {
     const typename base_type::value_type& v = *m_iterator;
-    if (v.pNode) 
-      return value_type(Node(*v, m_pMemory)); 
-    if (v.first && v.second) 
-      return value_type(Node(*v.first, m_pMemory), Node(*v.second, m_pMemory)); 
-    return value_type(); 
-  } 
- 
+    if (v.pNode)
+      return value_type(Node(*v, m_pMemory));
+    if (v.first && v.second)
+      return value_type(Node(*v.first, m_pMemory), Node(*v.second, m_pMemory));
+    return value_type();
+  }
+
   proxy operator->() const { return proxy(**this); }
 
- private: 
+ private:
   base_type m_iterator;
-  shared_memory_holder m_pMemory; 
-}; 
-} 
-} 
- 
-#endif  // VALUE_DETAIL_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+  shared_memory_holder m_pMemory;
+};
+}
+}
+
+#endif  // VALUE_DETAIL_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/node/detail/iterator_fwd.h b/contrib/libs/yaml-cpp/include/yaml-cpp/node/detail/iterator_fwd.h
index 4a1490ecc6a..5f1ffe7436d 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/node/detail/iterator_fwd.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/node/detail/iterator_fwd.h
@@ -1,27 +1,27 @@
-#ifndef VALUE_DETAIL_ITERATOR_FWD_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define VALUE_DETAIL_ITERATOR_FWD_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include "yaml-cpp/dll.h" 
-#include <list> 
-#include <utility> 
-#include <vector> 
- 
-namespace YAML { 
- 
-namespace detail { 
-struct iterator_value; 
-template <typename V> 
-class iterator_base; 
-} 
- 
-typedef detail::iterator_base<detail::iterator_value> iterator; 
-typedef detail::iterator_base<const detail::iterator_value> const_iterator; 
-} 
- 
-#endif  // VALUE_DETAIL_ITERATOR_FWD_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+#ifndef VALUE_DETAIL_ITERATOR_FWD_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define VALUE_DETAIL_ITERATOR_FWD_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/dll.h"
+#include <list>
+#include <utility>
+#include <vector>
+
+namespace YAML {
+
+namespace detail {
+struct iterator_value;
+template <typename V>
+class iterator_base;
+}
+
+typedef detail::iterator_base<detail::iterator_value> iterator;
+typedef detail::iterator_base<const detail::iterator_value> const_iterator;
+}
+
+#endif  // VALUE_DETAIL_ITERATOR_FWD_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/node/detail/memory.h b/contrib/libs/yaml-cpp/include/yaml-cpp/node/detail/memory.h
index bdd190bc4c4..8f2bc2657a2 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/node/detail/memory.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/node/detail/memory.h
@@ -1,46 +1,46 @@
-#ifndef VALUE_DETAIL_MEMORY_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define VALUE_DETAIL_MEMORY_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include <set> 
- 
-#include "yaml-cpp/dll.h" 
-#include "yaml-cpp/node/ptr.h" 
- 
-namespace YAML { 
-namespace detail { 
-class node; 
-}  // namespace detail 
-}  // namespace YAML 
- 
-namespace YAML { 
-namespace detail { 
-class YAML_CPP_API memory { 
- public: 
-  node& create_node(); 
-  void merge(const memory& rhs); 
- 
- private: 
-  typedef std::set<shared_node> Nodes; 
-  Nodes m_nodes; 
-}; 
- 
-class YAML_CPP_API memory_holder { 
- public: 
-  memory_holder() : m_pMemory(new memory) {} 
- 
-  node& create_node() { return m_pMemory->create_node(); } 
-  void merge(memory_holder& rhs); 
- 
- private: 
-  shared_memory m_pMemory; 
-}; 
-} 
-} 
- 
-#endif  // VALUE_DETAIL_MEMORY_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+#ifndef VALUE_DETAIL_MEMORY_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define VALUE_DETAIL_MEMORY_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <set>
+
+#include "yaml-cpp/dll.h"
+#include "yaml-cpp/node/ptr.h"
+
+namespace YAML {
+namespace detail {
+class node;
+}  // namespace detail
+}  // namespace YAML
+
+namespace YAML {
+namespace detail {
+class YAML_CPP_API memory {
+ public:
+  node& create_node();
+  void merge(const memory& rhs);
+
+ private:
+  typedef std::set<shared_node> Nodes;
+  Nodes m_nodes;
+};
+
+class YAML_CPP_API memory_holder {
+ public:
+  memory_holder() : m_pMemory(new memory) {}
+
+  node& create_node() { return m_pMemory->create_node(); }
+  void merge(memory_holder& rhs);
+
+ private:
+  shared_memory m_pMemory;
+};
+}
+}
+
+#endif  // VALUE_DETAIL_MEMORY_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/node/detail/node.h b/contrib/libs/yaml-cpp/include/yaml-cpp/node/detail/node.h
index e7a77ef6713..8a776f62a9e 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/node/detail/node.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/node/detail/node.h
@@ -1,169 +1,169 @@
-#ifndef NODE_DETAIL_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define NODE_DETAIL_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include "yaml-cpp/emitterstyle.h" 
-#include "yaml-cpp/dll.h" 
-#include "yaml-cpp/node/type.h" 
-#include "yaml-cpp/node/ptr.h" 
-#include "yaml-cpp/node/detail/node_ref.h" 
-#include <set> 
- 
-namespace YAML { 
-namespace detail { 
+#ifndef NODE_DETAIL_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODE_DETAIL_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/emitterstyle.h"
+#include "yaml-cpp/dll.h"
+#include "yaml-cpp/node/type.h"
+#include "yaml-cpp/node/ptr.h"
+#include "yaml-cpp/node/detail/node_ref.h"
+#include <set>
+
+namespace YAML {
+namespace detail {
 class node {
- public: 
-  node() : m_pRef(new node_ref) {} 
+ public:
+  node() : m_pRef(new node_ref) {}
   node(const node&) = delete;
   node& operator=(const node&) = delete;
- 
-  bool is(const node& rhs) const { return m_pRef == rhs.m_pRef; } 
-  const node_ref* ref() const { return m_pRef.get(); } 
- 
-  bool is_defined() const { return m_pRef->is_defined(); } 
-  const Mark& mark() const { return m_pRef->mark(); } 
-  NodeType::value type() const { return m_pRef->type(); } 
- 
-  const std::string& scalar() const { return m_pRef->scalar(); } 
-  const std::string& tag() const { return m_pRef->tag(); } 
-  EmitterStyle::value style() const { return m_pRef->style(); } 
- 
-  template <typename T> 
-  bool equals(const T& rhs, shared_memory_holder pMemory); 
-  bool equals(const char* rhs, shared_memory_holder pMemory); 
- 
-  void mark_defined() { 
-    if (is_defined()) 
-      return; 
- 
-    m_pRef->mark_defined(); 
-    for (nodes::iterator it = m_dependencies.begin(); 
-         it != m_dependencies.end(); ++it) 
-      (*it)->mark_defined(); 
-    m_dependencies.clear(); 
-  } 
- 
-  void add_dependency(node& rhs) { 
-    if (is_defined()) 
-      rhs.mark_defined(); 
-    else 
-      m_dependencies.insert(&rhs); 
-  } 
- 
-  void set_ref(const node& rhs) { 
-    if (rhs.is_defined()) 
-      mark_defined(); 
-    m_pRef = rhs.m_pRef; 
-  } 
-  void set_data(const node& rhs) { 
-    if (rhs.is_defined()) 
-      mark_defined(); 
-    m_pRef->set_data(*rhs.m_pRef); 
-  } 
- 
+
+  bool is(const node& rhs) const { return m_pRef == rhs.m_pRef; }
+  const node_ref* ref() const { return m_pRef.get(); }
+
+  bool is_defined() const { return m_pRef->is_defined(); }
+  const Mark& mark() const { return m_pRef->mark(); }
+  NodeType::value type() const { return m_pRef->type(); }
+
+  const std::string& scalar() const { return m_pRef->scalar(); }
+  const std::string& tag() const { return m_pRef->tag(); }
+  EmitterStyle::value style() const { return m_pRef->style(); }
+
+  template <typename T>
+  bool equals(const T& rhs, shared_memory_holder pMemory);
+  bool equals(const char* rhs, shared_memory_holder pMemory);
+
+  void mark_defined() {
+    if (is_defined())
+      return;
+
+    m_pRef->mark_defined();
+    for (nodes::iterator it = m_dependencies.begin();
+         it != m_dependencies.end(); ++it)
+      (*it)->mark_defined();
+    m_dependencies.clear();
+  }
+
+  void add_dependency(node& rhs) {
+    if (is_defined())
+      rhs.mark_defined();
+    else
+      m_dependencies.insert(&rhs);
+  }
+
+  void set_ref(const node& rhs) {
+    if (rhs.is_defined())
+      mark_defined();
+    m_pRef = rhs.m_pRef;
+  }
+  void set_data(const node& rhs) {
+    if (rhs.is_defined())
+      mark_defined();
+    m_pRef->set_data(*rhs.m_pRef);
+  }
+
   void set_mark(const Mark& mark) { m_pRef->set_mark(mark); }
- 
-  void set_type(NodeType::value type) { 
-    if (type != NodeType::Undefined) 
-      mark_defined(); 
-    m_pRef->set_type(type); 
-  } 
-  void set_null() { 
-    mark_defined(); 
-    m_pRef->set_null(); 
-  } 
-  void set_scalar(const std::string& scalar) { 
-    mark_defined(); 
-    m_pRef->set_scalar(scalar); 
-  } 
-  void set_tag(const std::string& tag) { 
-    mark_defined(); 
-    m_pRef->set_tag(tag); 
-  } 
- 
-  // style 
-  void set_style(EmitterStyle::value style) { 
-    mark_defined(); 
-    m_pRef->set_style(style); 
-  } 
- 
-  // size/iterator 
-  std::size_t size() const { return m_pRef->size(); } 
- 
-  const_node_iterator begin() const { 
-    return static_cast<const node_ref&>(*m_pRef).begin(); 
-  } 
-  node_iterator begin() { return m_pRef->begin(); } 
- 
-  const_node_iterator end() const { 
-    return static_cast<const node_ref&>(*m_pRef).end(); 
-  } 
-  node_iterator end() { return m_pRef->end(); } 
- 
-  // sequence 
+
+  void set_type(NodeType::value type) {
+    if (type != NodeType::Undefined)
+      mark_defined();
+    m_pRef->set_type(type);
+  }
+  void set_null() {
+    mark_defined();
+    m_pRef->set_null();
+  }
+  void set_scalar(const std::string& scalar) {
+    mark_defined();
+    m_pRef->set_scalar(scalar);
+  }
+  void set_tag(const std::string& tag) {
+    mark_defined();
+    m_pRef->set_tag(tag);
+  }
+
+  // style
+  void set_style(EmitterStyle::value style) {
+    mark_defined();
+    m_pRef->set_style(style);
+  }
+
+  // size/iterator
+  std::size_t size() const { return m_pRef->size(); }
+
+  const_node_iterator begin() const {
+    return static_cast<const node_ref&>(*m_pRef).begin();
+  }
+  node_iterator begin() { return m_pRef->begin(); }
+
+  const_node_iterator end() const {
+    return static_cast<const node_ref&>(*m_pRef).end();
+  }
+  node_iterator end() { return m_pRef->end(); }
+
+  // sequence
   void push_back(node& input, shared_memory_holder pMemory) {
     m_pRef->push_back(input, pMemory);
     input.add_dependency(*this);
-  } 
-  void insert(node& key, node& value, shared_memory_holder pMemory) { 
-    m_pRef->insert(key, value, pMemory); 
-    key.add_dependency(*this); 
-    value.add_dependency(*this); 
-  } 
- 
-  // indexing 
-  template <typename Key> 
-  node* get(const Key& key, shared_memory_holder pMemory) const { 
-    // NOTE: this returns a non-const node so that the top-level Node can wrap 
-    // it, and returns a pointer so that it can be NULL (if there is no such 
-    // key). 
-    return static_cast<const node_ref&>(*m_pRef).get(key, pMemory); 
-  } 
-  template <typename Key> 
-  node& get(const Key& key, shared_memory_holder pMemory) { 
-    node& value = m_pRef->get(key, pMemory); 
-    value.add_dependency(*this); 
-    return value; 
-  } 
-  template <typename Key> 
-  bool remove(const Key& key, shared_memory_holder pMemory) { 
-    return m_pRef->remove(key, pMemory); 
-  } 
- 
-  node* get(node& key, shared_memory_holder pMemory) const { 
-    // NOTE: this returns a non-const node so that the top-level Node can wrap 
-    // it, and returns a pointer so that it can be NULL (if there is no such 
-    // key). 
-    return static_cast<const node_ref&>(*m_pRef).get(key, pMemory); 
-  } 
-  node& get(node& key, shared_memory_holder pMemory) { 
-    node& value = m_pRef->get(key, pMemory); 
-    key.add_dependency(*this); 
-    value.add_dependency(*this); 
-    return value; 
-  } 
-  bool remove(node& key, shared_memory_holder pMemory) { 
-    return m_pRef->remove(key, pMemory); 
-  } 
- 
-  // map 
-  template <typename Key, typename Value> 
-  void force_insert(const Key& key, const Value& value, 
-                    shared_memory_holder pMemory) { 
-    m_pRef->force_insert(key, value, pMemory); 
-  } 
- 
- private: 
-  shared_node_ref m_pRef; 
-  typedef std::set<node*> nodes; 
-  nodes m_dependencies; 
-}; 
-} 
-} 
- 
-#endif  // NODE_DETAIL_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+  }
+  void insert(node& key, node& value, shared_memory_holder pMemory) {
+    m_pRef->insert(key, value, pMemory);
+    key.add_dependency(*this);
+    value.add_dependency(*this);
+  }
+
+  // indexing
+  template <typename Key>
+  node* get(const Key& key, shared_memory_holder pMemory) const {
+    // NOTE: this returns a non-const node so that the top-level Node can wrap
+    // it, and returns a pointer so that it can be NULL (if there is no such
+    // key).
+    return static_cast<const node_ref&>(*m_pRef).get(key, pMemory);
+  }
+  template <typename Key>
+  node& get(const Key& key, shared_memory_holder pMemory) {
+    node& value = m_pRef->get(key, pMemory);
+    value.add_dependency(*this);
+    return value;
+  }
+  template <typename Key>
+  bool remove(const Key& key, shared_memory_holder pMemory) {
+    return m_pRef->remove(key, pMemory);
+  }
+
+  node* get(node& key, shared_memory_holder pMemory) const {
+    // NOTE: this returns a non-const node so that the top-level Node can wrap
+    // it, and returns a pointer so that it can be NULL (if there is no such
+    // key).
+    return static_cast<const node_ref&>(*m_pRef).get(key, pMemory);
+  }
+  node& get(node& key, shared_memory_holder pMemory) {
+    node& value = m_pRef->get(key, pMemory);
+    key.add_dependency(*this);
+    value.add_dependency(*this);
+    return value;
+  }
+  bool remove(node& key, shared_memory_holder pMemory) {
+    return m_pRef->remove(key, pMemory);
+  }
+
+  // map
+  template <typename Key, typename Value>
+  void force_insert(const Key& key, const Value& value,
+                    shared_memory_holder pMemory) {
+    m_pRef->force_insert(key, value, pMemory);
+  }
+
+ private:
+  shared_node_ref m_pRef;
+  typedef std::set<node*> nodes;
+  nodes m_dependencies;
+};
+}
+}
+
+#endif  // NODE_DETAIL_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/node/detail/node_data.h b/contrib/libs/yaml-cpp/include/yaml-cpp/node/detail/node_data.h
index e3001efae2f..50bcd74352d 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/node/detail/node_data.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/node/detail/node_data.h
@@ -1,127 +1,127 @@
-#ifndef VALUE_DETAIL_NODE_DATA_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define VALUE_DETAIL_NODE_DATA_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include <list> 
-#include <map> 
-#include <string> 
-#include <utility> 
-#include <vector> 
- 
-#include "yaml-cpp/dll.h" 
-#include "yaml-cpp/node/detail/node_iterator.h" 
-#include "yaml-cpp/node/iterator.h" 
-#include "yaml-cpp/node/ptr.h" 
-#include "yaml-cpp/node/type.h" 
- 
-namespace YAML { 
-namespace detail { 
-class node; 
-}  // namespace detail 
-}  // namespace YAML 
- 
-namespace YAML { 
-namespace detail { 
+#ifndef VALUE_DETAIL_NODE_DATA_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define VALUE_DETAIL_NODE_DATA_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <list>
+#include <map>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "yaml-cpp/dll.h"
+#include "yaml-cpp/node/detail/node_iterator.h"
+#include "yaml-cpp/node/iterator.h"
+#include "yaml-cpp/node/ptr.h"
+#include "yaml-cpp/node/type.h"
+
+namespace YAML {
+namespace detail {
+class node;
+}  // namespace detail
+}  // namespace YAML
+
+namespace YAML {
+namespace detail {
 class YAML_CPP_API node_data {
- public: 
-  node_data(); 
+ public:
+  node_data();
   node_data(const node_data&) = delete;
   node_data& operator=(const node_data&) = delete;
- 
-  void mark_defined(); 
-  void set_mark(const Mark& mark); 
-  void set_type(NodeType::value type); 
-  void set_tag(const std::string& tag); 
-  void set_null(); 
-  void set_scalar(const std::string& scalar); 
-  void set_style(EmitterStyle::value style); 
- 
-  bool is_defined() const { return m_isDefined; } 
-  const Mark& mark() const { return m_mark; } 
-  NodeType::value type() const { 
-    return m_isDefined ? m_type : NodeType::Undefined; 
-  } 
-  const std::string& scalar() const { return m_scalar; } 
-  const std::string& tag() const { return m_tag; } 
-  EmitterStyle::value style() const { return m_style; } 
- 
-  // size/iterator 
-  std::size_t size() const; 
- 
-  const_node_iterator begin() const; 
-  node_iterator begin(); 
- 
-  const_node_iterator end() const; 
-  node_iterator end(); 
- 
-  // sequence 
-  void push_back(node& node, shared_memory_holder pMemory); 
-  void insert(node& key, node& value, shared_memory_holder pMemory); 
- 
-  // indexing 
-  template <typename Key> 
-  node* get(const Key& key, shared_memory_holder pMemory) const; 
-  template <typename Key> 
-  node& get(const Key& key, shared_memory_holder pMemory); 
-  template <typename Key> 
-  bool remove(const Key& key, shared_memory_holder pMemory); 
- 
-  node* get(node& key, shared_memory_holder pMemory) const; 
-  node& get(node& key, shared_memory_holder pMemory); 
-  bool remove(node& key, shared_memory_holder pMemory); 
- 
-  // map 
-  template <typename Key, typename Value> 
-  void force_insert(const Key& key, const Value& value, 
-                    shared_memory_holder pMemory); 
- 
- public: 
-  static std::string empty_scalar; 
- 
- private: 
-  void compute_seq_size() const; 
-  void compute_map_size() const; 
- 
-  void reset_sequence(); 
-  void reset_map(); 
- 
-  void insert_map_pair(node& key, node& value); 
-  void convert_to_map(shared_memory_holder pMemory); 
-  void convert_sequence_to_map(shared_memory_holder pMemory); 
- 
-  template <typename T> 
-  static node& convert_to_node(const T& rhs, shared_memory_holder pMemory); 
- 
- private: 
-  bool m_isDefined; 
-  Mark m_mark; 
-  NodeType::value m_type; 
-  std::string m_tag; 
-  EmitterStyle::value m_style; 
- 
-  // scalar 
-  std::string m_scalar; 
- 
-  // sequence 
-  typedef std::vector<node*> node_seq; 
-  node_seq m_sequence; 
- 
-  mutable std::size_t m_seqSize; 
- 
-  // map 
+
+  void mark_defined();
+  void set_mark(const Mark& mark);
+  void set_type(NodeType::value type);
+  void set_tag(const std::string& tag);
+  void set_null();
+  void set_scalar(const std::string& scalar);
+  void set_style(EmitterStyle::value style);
+
+  bool is_defined() const { return m_isDefined; }
+  const Mark& mark() const { return m_mark; }
+  NodeType::value type() const {
+    return m_isDefined ? m_type : NodeType::Undefined;
+  }
+  const std::string& scalar() const { return m_scalar; }
+  const std::string& tag() const { return m_tag; }
+  EmitterStyle::value style() const { return m_style; }
+
+  // size/iterator
+  std::size_t size() const;
+
+  const_node_iterator begin() const;
+  node_iterator begin();
+
+  const_node_iterator end() const;
+  node_iterator end();
+
+  // sequence
+  void push_back(node& node, shared_memory_holder pMemory);
+  void insert(node& key, node& value, shared_memory_holder pMemory);
+
+  // indexing
+  template <typename Key>
+  node* get(const Key& key, shared_memory_holder pMemory) const;
+  template <typename Key>
+  node& get(const Key& key, shared_memory_holder pMemory);
+  template <typename Key>
+  bool remove(const Key& key, shared_memory_holder pMemory);
+
+  node* get(node& key, shared_memory_holder pMemory) const;
+  node& get(node& key, shared_memory_holder pMemory);
+  bool remove(node& key, shared_memory_holder pMemory);
+
+  // map
+  template <typename Key, typename Value>
+  void force_insert(const Key& key, const Value& value,
+                    shared_memory_holder pMemory);
+
+ public:
+  static std::string empty_scalar;
+
+ private:
+  void compute_seq_size() const;
+  void compute_map_size() const;
+
+  void reset_sequence();
+  void reset_map();
+
+  void insert_map_pair(node& key, node& value);
+  void convert_to_map(shared_memory_holder pMemory);
+  void convert_sequence_to_map(shared_memory_holder pMemory);
+
+  template <typename T>
+  static node& convert_to_node(const T& rhs, shared_memory_holder pMemory);
+
+ private:
+  bool m_isDefined;
+  Mark m_mark;
+  NodeType::value m_type;
+  std::string m_tag;
+  EmitterStyle::value m_style;
+
+  // scalar
+  std::string m_scalar;
+
+  // sequence
+  typedef std::vector<node*> node_seq;
+  node_seq m_sequence;
+
+  mutable std::size_t m_seqSize;
+
+  // map
   typedef std::vector<std::pair<node*, node*>> node_map;
-  node_map m_map; 
- 
-  typedef std::pair<node*, node*> kv_pair; 
-  typedef std::list<kv_pair> kv_pairs; 
-  mutable kv_pairs m_undefinedPairs; 
-}; 
-} 
-} 
- 
-#endif  // VALUE_DETAIL_NODE_DATA_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+  node_map m_map;
+
+  typedef std::pair<node*, node*> kv_pair;
+  typedef std::list<kv_pair> kv_pairs;
+  mutable kv_pairs m_undefinedPairs;
+};
+}
+}
+
+#endif  // VALUE_DETAIL_NODE_DATA_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/node/detail/node_iterator.h b/contrib/libs/yaml-cpp/include/yaml-cpp/node/detail/node_iterator.h
index c97e48adc84..088090fe743 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/node/detail/node_iterator.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/node/detail/node_iterator.h
@@ -1,64 +1,64 @@
-#ifndef VALUE_DETAIL_NODE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define VALUE_DETAIL_NODE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include "yaml-cpp/dll.h" 
-#include "yaml-cpp/node/ptr.h" 
+#ifndef VALUE_DETAIL_NODE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define VALUE_DETAIL_NODE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/dll.h"
+#include "yaml-cpp/node/ptr.h"
 #include <cstddef>
 #include <iterator>
 #include <memory>
-#include <map> 
-#include <utility> 
-#include <vector> 
- 
-namespace YAML { 
-namespace detail { 
-struct iterator_type { 
+#include <map>
+#include <utility>
+#include <vector>
+
+namespace YAML {
+namespace detail {
+struct iterator_type {
   enum value { NoneType, Sequence, Map };
-}; 
- 
-template <typename V> 
-struct node_iterator_value : public std::pair<V*, V*> { 
-  typedef std::pair<V*, V*> kv; 
- 
-  node_iterator_value() : kv(), pNode(0) {} 
-  explicit node_iterator_value(V& rhs) : kv(), pNode(&rhs) {} 
-  explicit node_iterator_value(V& key, V& value) : kv(&key, &value), pNode(0) {} 
- 
-  V& operator*() const { return *pNode; } 
-  V& operator->() const { return *pNode; } 
- 
-  V* pNode; 
-}; 
- 
-typedef std::vector<node*> node_seq; 
+};
+
+template <typename V>
+struct node_iterator_value : public std::pair<V*, V*> {
+  typedef std::pair<V*, V*> kv;
+
+  node_iterator_value() : kv(), pNode(0) {}
+  explicit node_iterator_value(V& rhs) : kv(), pNode(&rhs) {}
+  explicit node_iterator_value(V& key, V& value) : kv(&key, &value), pNode(0) {}
+
+  V& operator*() const { return *pNode; }
+  V& operator->() const { return *pNode; }
+
+  V* pNode;
+};
+
+typedef std::vector<node*> node_seq;
 typedef std::vector<std::pair<node*, node*>> node_map;
- 
-template <typename V> 
-struct node_iterator_type { 
-  typedef node_seq::iterator seq; 
-  typedef node_map::iterator map; 
-}; 
- 
-template <typename V> 
-struct node_iterator_type<const V> { 
-  typedef node_seq::const_iterator seq; 
-  typedef node_map::const_iterator map; 
-}; 
- 
-template <typename V> 
-class node_iterator_base 
+
+template <typename V>
+struct node_iterator_type {
+  typedef node_seq::iterator seq;
+  typedef node_map::iterator map;
+};
+
+template <typename V>
+struct node_iterator_type<const V> {
+  typedef node_seq::const_iterator seq;
+  typedef node_map::const_iterator map;
+};
+
+template <typename V>
+class node_iterator_base
     : public std::iterator<std::forward_iterator_tag, node_iterator_value<V>,
                            std::ptrdiff_t, node_iterator_value<V>*,
                            node_iterator_value<V>> {
- private: 
-  struct enabler {}; 
- 
+ private:
+  struct enabler {};
+
   struct proxy {
     explicit proxy(const node_iterator_value<V>& x) : m_ref(x) {}
     node_iterator_value<V>* operator->() { return std::addressof(m_ref); }
@@ -67,74 +67,74 @@ class node_iterator_base
     node_iterator_value<V> m_ref;
   };
 
- public: 
-  typedef typename node_iterator_type<V>::seq SeqIter; 
-  typedef typename node_iterator_type<V>::map MapIter; 
-  typedef node_iterator_value<V> value_type; 
- 
-  node_iterator_base() 
+ public:
+  typedef typename node_iterator_type<V>::seq SeqIter;
+  typedef typename node_iterator_type<V>::map MapIter;
+  typedef node_iterator_value<V> value_type;
+
+  node_iterator_base()
       : m_type(iterator_type::NoneType), m_seqIt(), m_mapIt(), m_mapEnd() {}
-  explicit node_iterator_base(SeqIter seqIt) 
-      : m_type(iterator_type::Sequence), 
-        m_seqIt(seqIt), 
-        m_mapIt(), 
-        m_mapEnd() {} 
-  explicit node_iterator_base(MapIter mapIt, MapIter mapEnd) 
-      : m_type(iterator_type::Map), 
-        m_seqIt(), 
-        m_mapIt(mapIt), 
-        m_mapEnd(mapEnd) { 
-    m_mapIt = increment_until_defined(m_mapIt); 
-  } 
- 
-  template <typename W> 
-  node_iterator_base(const node_iterator_base<W>& rhs, 
+  explicit node_iterator_base(SeqIter seqIt)
+      : m_type(iterator_type::Sequence),
+        m_seqIt(seqIt),
+        m_mapIt(),
+        m_mapEnd() {}
+  explicit node_iterator_base(MapIter mapIt, MapIter mapEnd)
+      : m_type(iterator_type::Map),
+        m_seqIt(),
+        m_mapIt(mapIt),
+        m_mapEnd(mapEnd) {
+    m_mapIt = increment_until_defined(m_mapIt);
+  }
+
+  template <typename W>
+  node_iterator_base(const node_iterator_base<W>& rhs,
                      typename std::enable_if<std::is_convertible<W*, V*>::value,
                                              enabler>::type = enabler())
-      : m_type(rhs.m_type), 
-        m_seqIt(rhs.m_seqIt), 
-        m_mapIt(rhs.m_mapIt), 
-        m_mapEnd(rhs.m_mapEnd) {} 
- 
-  template <typename> 
-  friend class node_iterator_base; 
- 
-  template <typename W> 
+      : m_type(rhs.m_type),
+        m_seqIt(rhs.m_seqIt),
+        m_mapIt(rhs.m_mapIt),
+        m_mapEnd(rhs.m_mapEnd) {}
+
+  template <typename>
+  friend class node_iterator_base;
+
+  template <typename W>
   bool operator==(const node_iterator_base<W>& rhs) const {
-    if (m_type != rhs.m_type) 
-      return false; 
- 
-    switch (m_type) { 
+    if (m_type != rhs.m_type)
+      return false;
+
+    switch (m_type) {
       case iterator_type::NoneType:
-        return true; 
-      case iterator_type::Sequence: 
-        return m_seqIt == rhs.m_seqIt; 
-      case iterator_type::Map: 
-        return m_mapIt == rhs.m_mapIt; 
-    } 
-    return true; 
-  } 
- 
+        return true;
+      case iterator_type::Sequence:
+        return m_seqIt == rhs.m_seqIt;
+      case iterator_type::Map:
+        return m_mapIt == rhs.m_mapIt;
+    }
+    return true;
+  }
+
   template <typename W>
   bool operator!=(const node_iterator_base<W>& rhs) const {
     return !(*this == rhs);
   }
 
   node_iterator_base<V>& operator++() {
-    switch (m_type) { 
+    switch (m_type) {
       case iterator_type::NoneType:
-        break; 
-      case iterator_type::Sequence: 
-        ++m_seqIt; 
-        break; 
-      case iterator_type::Map: 
-        ++m_mapIt; 
-        m_mapIt = increment_until_defined(m_mapIt); 
-        break; 
-    } 
+        break;
+      case iterator_type::Sequence:
+        ++m_seqIt;
+        break;
+      case iterator_type::Map:
+        ++m_mapIt;
+        m_mapIt = increment_until_defined(m_mapIt);
+        break;
+    }
     return *this;
-  } 
- 
+  }
+
   node_iterator_base<V> operator++(int) {
     node_iterator_base<V> iterator_pre(*this);
     ++(*this);
@@ -142,39 +142,39 @@ class node_iterator_base
   }
 
   value_type operator*() const {
-    switch (m_type) { 
+    switch (m_type) {
       case iterator_type::NoneType:
-        return value_type(); 
-      case iterator_type::Sequence: 
-        return value_type(**m_seqIt); 
-      case iterator_type::Map: 
-        return value_type(*m_mapIt->first, *m_mapIt->second); 
-    } 
-    return value_type(); 
-  } 
- 
+        return value_type();
+      case iterator_type::Sequence:
+        return value_type(**m_seqIt);
+      case iterator_type::Map:
+        return value_type(*m_mapIt->first, *m_mapIt->second);
+    }
+    return value_type();
+  }
+
   proxy operator->() const { return proxy(**this); }
 
-  MapIter increment_until_defined(MapIter it) { 
-    while (it != m_mapEnd && !is_defined(it)) 
-      ++it; 
-    return it; 
-  } 
- 
-  bool is_defined(MapIter it) const { 
-    return it->first->is_defined() && it->second->is_defined(); 
-  } 
- 
- private: 
-  typename iterator_type::value m_type; 
- 
-  SeqIter m_seqIt; 
-  MapIter m_mapIt, m_mapEnd; 
-}; 
- 
-typedef node_iterator_base<node> node_iterator; 
-typedef node_iterator_base<const node> const_node_iterator; 
-} 
-} 
- 
-#endif  // VALUE_DETAIL_NODE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+  MapIter increment_until_defined(MapIter it) {
+    while (it != m_mapEnd && !is_defined(it))
+      ++it;
+    return it;
+  }
+
+  bool is_defined(MapIter it) const {
+    return it->first->is_defined() && it->second->is_defined();
+  }
+
+ private:
+  typename iterator_type::value m_type;
+
+  SeqIter m_seqIt;
+  MapIter m_mapIt, m_mapEnd;
+};
+
+typedef node_iterator_base<node> node_iterator;
+typedef node_iterator_base<const node> const_node_iterator;
+}
+}
+
+#endif  // VALUE_DETAIL_NODE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/node/detail/node_ref.h b/contrib/libs/yaml-cpp/include/yaml-cpp/node/detail/node_ref.h
index 6b0f3dae892..d8a94f8b804 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/node/detail/node_ref.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/node/detail/node_ref.h
@@ -1,98 +1,98 @@
-#ifndef VALUE_DETAIL_NODE_REF_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define VALUE_DETAIL_NODE_REF_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include "yaml-cpp/dll.h" 
-#include "yaml-cpp/node/type.h" 
-#include "yaml-cpp/node/ptr.h" 
-#include "yaml-cpp/node/detail/node_data.h" 
- 
-namespace YAML { 
-namespace detail { 
+#ifndef VALUE_DETAIL_NODE_REF_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define VALUE_DETAIL_NODE_REF_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/dll.h"
+#include "yaml-cpp/node/type.h"
+#include "yaml-cpp/node/ptr.h"
+#include "yaml-cpp/node/detail/node_data.h"
+
+namespace YAML {
+namespace detail {
 class node_ref {
- public: 
-  node_ref() : m_pData(new node_data) {} 
+ public:
+  node_ref() : m_pData(new node_data) {}
   node_ref(const node_ref&) = delete;
   node_ref& operator=(const node_ref&) = delete;
- 
-  bool is_defined() const { return m_pData->is_defined(); } 
-  const Mark& mark() const { return m_pData->mark(); } 
-  NodeType::value type() const { return m_pData->type(); } 
-  const std::string& scalar() const { return m_pData->scalar(); } 
-  const std::string& tag() const { return m_pData->tag(); } 
-  EmitterStyle::value style() const { return m_pData->style(); } 
- 
-  void mark_defined() { m_pData->mark_defined(); } 
-  void set_data(const node_ref& rhs) { m_pData = rhs.m_pData; } 
- 
-  void set_mark(const Mark& mark) { m_pData->set_mark(mark); } 
-  void set_type(NodeType::value type) { m_pData->set_type(type); } 
-  void set_tag(const std::string& tag) { m_pData->set_tag(tag); } 
-  void set_null() { m_pData->set_null(); } 
-  void set_scalar(const std::string& scalar) { m_pData->set_scalar(scalar); } 
-  void set_style(EmitterStyle::value style) { m_pData->set_style(style); } 
- 
-  // size/iterator 
-  std::size_t size() const { return m_pData->size(); } 
- 
-  const_node_iterator begin() const { 
-    return static_cast<const node_data&>(*m_pData).begin(); 
-  } 
-  node_iterator begin() { return m_pData->begin(); } 
- 
-  const_node_iterator end() const { 
-    return static_cast<const node_data&>(*m_pData).end(); 
-  } 
-  node_iterator end() { return m_pData->end(); } 
- 
-  // sequence 
-  void push_back(node& node, shared_memory_holder pMemory) { 
-    m_pData->push_back(node, pMemory); 
-  } 
-  void insert(node& key, node& value, shared_memory_holder pMemory) { 
-    m_pData->insert(key, value, pMemory); 
-  } 
- 
-  // indexing 
-  template <typename Key> 
-  node* get(const Key& key, shared_memory_holder pMemory) const { 
-    return static_cast<const node_data&>(*m_pData).get(key, pMemory); 
-  } 
-  template <typename Key> 
-  node& get(const Key& key, shared_memory_holder pMemory) { 
-    return m_pData->get(key, pMemory); 
-  } 
-  template <typename Key> 
-  bool remove(const Key& key, shared_memory_holder pMemory) { 
-    return m_pData->remove(key, pMemory); 
-  } 
- 
-  node* get(node& key, shared_memory_holder pMemory) const { 
-    return static_cast<const node_data&>(*m_pData).get(key, pMemory); 
-  } 
-  node& get(node& key, shared_memory_holder pMemory) { 
-    return m_pData->get(key, pMemory); 
-  } 
-  bool remove(node& key, shared_memory_holder pMemory) { 
-    return m_pData->remove(key, pMemory); 
-  } 
- 
-  // map 
-  template <typename Key, typename Value> 
-  void force_insert(const Key& key, const Value& value, 
-                    shared_memory_holder pMemory) { 
-    m_pData->force_insert(key, value, pMemory); 
-  } 
- 
- private: 
-  shared_node_data m_pData; 
-}; 
-} 
-} 
- 
-#endif  // VALUE_DETAIL_NODE_REF_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+
+  bool is_defined() const { return m_pData->is_defined(); }
+  const Mark& mark() const { return m_pData->mark(); }
+  NodeType::value type() const { return m_pData->type(); }
+  const std::string& scalar() const { return m_pData->scalar(); }
+  const std::string& tag() const { return m_pData->tag(); }
+  EmitterStyle::value style() const { return m_pData->style(); }
+
+  void mark_defined() { m_pData->mark_defined(); }
+  void set_data(const node_ref& rhs) { m_pData = rhs.m_pData; }
+
+  void set_mark(const Mark& mark) { m_pData->set_mark(mark); }
+  void set_type(NodeType::value type) { m_pData->set_type(type); }
+  void set_tag(const std::string& tag) { m_pData->set_tag(tag); }
+  void set_null() { m_pData->set_null(); }
+  void set_scalar(const std::string& scalar) { m_pData->set_scalar(scalar); }
+  void set_style(EmitterStyle::value style) { m_pData->set_style(style); }
+
+  // size/iterator
+  std::size_t size() const { return m_pData->size(); }
+
+  const_node_iterator begin() const {
+    return static_cast<const node_data&>(*m_pData).begin();
+  }
+  node_iterator begin() { return m_pData->begin(); }
+
+  const_node_iterator end() const {
+    return static_cast<const node_data&>(*m_pData).end();
+  }
+  node_iterator end() { return m_pData->end(); }
+
+  // sequence
+  void push_back(node& node, shared_memory_holder pMemory) {
+    m_pData->push_back(node, pMemory);
+  }
+  void insert(node& key, node& value, shared_memory_holder pMemory) {
+    m_pData->insert(key, value, pMemory);
+  }
+
+  // indexing
+  template <typename Key>
+  node* get(const Key& key, shared_memory_holder pMemory) const {
+    return static_cast<const node_data&>(*m_pData).get(key, pMemory);
+  }
+  template <typename Key>
+  node& get(const Key& key, shared_memory_holder pMemory) {
+    return m_pData->get(key, pMemory);
+  }
+  template <typename Key>
+  bool remove(const Key& key, shared_memory_holder pMemory) {
+    return m_pData->remove(key, pMemory);
+  }
+
+  node* get(node& key, shared_memory_holder pMemory) const {
+    return static_cast<const node_data&>(*m_pData).get(key, pMemory);
+  }
+  node& get(node& key, shared_memory_holder pMemory) {
+    return m_pData->get(key, pMemory);
+  }
+  bool remove(node& key, shared_memory_holder pMemory) {
+    return m_pData->remove(key, pMemory);
+  }
+
+  // map
+  template <typename Key, typename Value>
+  void force_insert(const Key& key, const Value& value,
+                    shared_memory_holder pMemory) {
+    m_pData->force_insert(key, value, pMemory);
+  }
+
+ private:
+  shared_node_data m_pData;
+};
+}
+}
+
+#endif  // VALUE_DETAIL_NODE_REF_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/node/emit.h b/contrib/libs/yaml-cpp/include/yaml-cpp/node/emit.h
index df61813c4e5..032268c5d04 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/node/emit.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/node/emit.h
@@ -1,32 +1,32 @@
-#ifndef NODE_EMIT_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define NODE_EMIT_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include <string> 
-#include <iosfwd> 
- 
-#include "yaml-cpp/dll.h" 
- 
-namespace YAML { 
-class Emitter; 
-class Node; 
- 
+#ifndef NODE_EMIT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODE_EMIT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <string>
+#include <iosfwd>
+
+#include "yaml-cpp/dll.h"
+
+namespace YAML {
+class Emitter;
+class Node;
+
 /**
  * Emits the node to the given {@link Emitter}. If there is an error in writing,
  * {@link Emitter#good} will return false.
  */
-YAML_CPP_API Emitter& operator<<(Emitter& out, const Node& node); 
+YAML_CPP_API Emitter& operator<<(Emitter& out, const Node& node);
 
 /** Emits the node to the given output stream. */
-YAML_CPP_API std::ostream& operator<<(std::ostream& out, const Node& node); 
- 
+YAML_CPP_API std::ostream& operator<<(std::ostream& out, const Node& node);
+
 /** Converts the node to a YAML string. */
-YAML_CPP_API std::string Dump(const Node& node); 
+YAML_CPP_API std::string Dump(const Node& node);
 }  // namespace YAML
- 
-#endif  // NODE_EMIT_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+
+#endif  // NODE_EMIT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/node/impl.h b/contrib/libs/yaml-cpp/include/yaml-cpp/node/impl.h
index fc048a9f8ec..20c487a687f 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/node/impl.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/node/impl.h
@@ -1,448 +1,448 @@
-#ifndef NODE_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define NODE_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include "yaml-cpp/node/node.h" 
-#include "yaml-cpp/node/iterator.h" 
-#include "yaml-cpp/node/detail/memory.h" 
-#include "yaml-cpp/node/detail/node.h" 
-#include "yaml-cpp/exceptions.h" 
-#include <string> 
- 
-namespace YAML { 
-inline Node::Node() : m_isValid(true), m_pNode(NULL) {} 
- 
-inline Node::Node(NodeType::value type) 
-    : m_isValid(true), 
-      m_pMemory(new detail::memory_holder), 
-      m_pNode(&m_pMemory->create_node()) { 
-  m_pNode->set_type(type); 
-} 
- 
-template <typename T> 
-inline Node::Node(const T& rhs) 
-    : m_isValid(true), 
-      m_pMemory(new detail::memory_holder), 
-      m_pNode(&m_pMemory->create_node()) { 
-  Assign(rhs); 
-} 
- 
-inline Node::Node(const detail::iterator_value& rhs) 
-    : m_isValid(rhs.m_isValid), 
-      m_pMemory(rhs.m_pMemory), 
-      m_pNode(rhs.m_pNode) {} 
- 
-inline Node::Node(const Node& rhs) 
-    : m_isValid(rhs.m_isValid), 
-      m_pMemory(rhs.m_pMemory), 
-      m_pNode(rhs.m_pNode) {} 
- 
-inline Node::Node(Zombie) : m_isValid(false), m_pNode(NULL) {} 
- 
-inline Node::Node(detail::node& node, detail::shared_memory_holder pMemory) 
-    : m_isValid(true), m_pMemory(pMemory), m_pNode(&node) {} 
- 
-inline Node::~Node() {} 
- 
-inline void Node::EnsureNodeExists() const { 
-  if (!m_isValid) 
-    throw InvalidNode(); 
-  if (!m_pNode) { 
-    m_pMemory.reset(new detail::memory_holder); 
-    m_pNode = &m_pMemory->create_node(); 
-    m_pNode->set_null(); 
-  } 
-} 
- 
-inline bool Node::IsDefined() const { 
-  if (!m_isValid) { 
-    return false; 
-  } 
-  return m_pNode ? m_pNode->is_defined() : true; 
-} 
- 
-inline Mark Node::Mark() const { 
-  if (!m_isValid) { 
-    throw InvalidNode(); 
-  } 
-  return m_pNode ? m_pNode->mark() : Mark::null_mark(); 
-} 
- 
-inline NodeType::value Node::Type() const { 
-  if (!m_isValid) 
-    throw InvalidNode(); 
-  return m_pNode ? m_pNode->type() : NodeType::Null; 
-} 
- 
-// access 
- 
-// template helpers 
-template <typename T, typename S> 
-struct as_if { 
-  explicit as_if(const Node& node_) : node(node_) {} 
-  const Node& node; 
- 
-  T operator()(const S& fallback) const { 
-    if (!node.m_pNode) 
-      return fallback; 
- 
-    T t; 
-    if (convert<T>::decode(node, t)) 
-      return t; 
-    return fallback; 
-  } 
-}; 
- 
-template <typename S> 
-struct as_if<std::string, S> { 
-  explicit as_if(const Node& node_) : node(node_) {} 
-  const Node& node; 
- 
+#ifndef NODE_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODE_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/node/node.h"
+#include "yaml-cpp/node/iterator.h"
+#include "yaml-cpp/node/detail/memory.h"
+#include "yaml-cpp/node/detail/node.h"
+#include "yaml-cpp/exceptions.h"
+#include <string>
+
+namespace YAML {
+inline Node::Node() : m_isValid(true), m_pNode(NULL) {}
+
+inline Node::Node(NodeType::value type)
+    : m_isValid(true),
+      m_pMemory(new detail::memory_holder),
+      m_pNode(&m_pMemory->create_node()) {
+  m_pNode->set_type(type);
+}
+
+template <typename T>
+inline Node::Node(const T& rhs)
+    : m_isValid(true),
+      m_pMemory(new detail::memory_holder),
+      m_pNode(&m_pMemory->create_node()) {
+  Assign(rhs);
+}
+
+inline Node::Node(const detail::iterator_value& rhs)
+    : m_isValid(rhs.m_isValid),
+      m_pMemory(rhs.m_pMemory),
+      m_pNode(rhs.m_pNode) {}
+
+inline Node::Node(const Node& rhs)
+    : m_isValid(rhs.m_isValid),
+      m_pMemory(rhs.m_pMemory),
+      m_pNode(rhs.m_pNode) {}
+
+inline Node::Node(Zombie) : m_isValid(false), m_pNode(NULL) {}
+
+inline Node::Node(detail::node& node, detail::shared_memory_holder pMemory)
+    : m_isValid(true), m_pMemory(pMemory), m_pNode(&node) {}
+
+inline Node::~Node() {}
+
+inline void Node::EnsureNodeExists() const {
+  if (!m_isValid)
+    throw InvalidNode();
+  if (!m_pNode) {
+    m_pMemory.reset(new detail::memory_holder);
+    m_pNode = &m_pMemory->create_node();
+    m_pNode->set_null();
+  }
+}
+
+inline bool Node::IsDefined() const {
+  if (!m_isValid) {
+    return false;
+  }
+  return m_pNode ? m_pNode->is_defined() : true;
+}
+
+inline Mark Node::Mark() const {
+  if (!m_isValid) {
+    throw InvalidNode();
+  }
+  return m_pNode ? m_pNode->mark() : Mark::null_mark();
+}
+
+inline NodeType::value Node::Type() const {
+  if (!m_isValid)
+    throw InvalidNode();
+  return m_pNode ? m_pNode->type() : NodeType::Null;
+}
+
+// access
+
+// template helpers
+template <typename T, typename S>
+struct as_if {
+  explicit as_if(const Node& node_) : node(node_) {}
+  const Node& node;
+
+  T operator()(const S& fallback) const {
+    if (!node.m_pNode)
+      return fallback;
+
+    T t;
+    if (convert<T>::decode(node, t))
+      return t;
+    return fallback;
+  }
+};
+
+template <typename S>
+struct as_if<std::string, S> {
+  explicit as_if(const Node& node_) : node(node_) {}
+  const Node& node;
+
   std::string operator()(const S& fallback) const {
-    if (node.Type() != NodeType::Scalar) 
-      return fallback; 
-    return node.Scalar(); 
-  } 
-}; 
- 
-template <typename T> 
-struct as_if<T, void> { 
-  explicit as_if(const Node& node_) : node(node_) {} 
-  const Node& node; 
- 
+    if (node.Type() != NodeType::Scalar)
+      return fallback;
+    return node.Scalar();
+  }
+};
+
+template <typename T>
+struct as_if<T, void> {
+  explicit as_if(const Node& node_) : node(node_) {}
+  const Node& node;
+
   T operator()() const {
-    if (!node.m_pNode) 
-      throw TypedBadConversion<T>(node.Mark()); 
- 
-    T t; 
-    if (convert<T>::decode(node, t)) 
-      return t; 
-    throw TypedBadConversion<T>(node.Mark()); 
-  } 
-}; 
- 
-template <> 
-struct as_if<std::string, void> { 
-  explicit as_if(const Node& node_) : node(node_) {} 
-  const Node& node; 
- 
+    if (!node.m_pNode)
+      throw TypedBadConversion<T>(node.Mark());
+
+    T t;
+    if (convert<T>::decode(node, t))
+      return t;
+    throw TypedBadConversion<T>(node.Mark());
+  }
+};
+
+template <>
+struct as_if<std::string, void> {
+  explicit as_if(const Node& node_) : node(node_) {}
+  const Node& node;
+
   std::string operator()() const {
-    if (node.Type() != NodeType::Scalar) 
-      throw TypedBadConversion<std::string>(node.Mark()); 
-    return node.Scalar(); 
-  } 
-}; 
- 
-// access functions 
-template <typename T> 
-inline T Node::as() const { 
-  if (!m_isValid) 
-    throw InvalidNode(); 
-  return as_if<T, void>(*this)(); 
-} 
- 
-template <typename T, typename S> 
-inline T Node::as(const S& fallback) const { 
-  if (!m_isValid) 
-    return fallback; 
-  return as_if<T, S>(*this)(fallback); 
-} 
- 
-inline const std::string& Node::Scalar() const { 
-  if (!m_isValid) 
-    throw InvalidNode(); 
-  return m_pNode ? m_pNode->scalar() : detail::node_data::empty_scalar; 
-} 
- 
-inline const std::string& Node::Tag() const { 
-  if (!m_isValid) 
-    throw InvalidNode(); 
-  return m_pNode ? m_pNode->tag() : detail::node_data::empty_scalar; 
-} 
- 
-inline void Node::SetTag(const std::string& tag) { 
-  if (!m_isValid) 
-    throw InvalidNode(); 
-  EnsureNodeExists(); 
-  m_pNode->set_tag(tag); 
-} 
- 
-inline EmitterStyle::value Node::Style() const { 
-  if (!m_isValid) 
-    throw InvalidNode(); 
-  return m_pNode ? m_pNode->style() : EmitterStyle::Default; 
-} 
- 
-inline void Node::SetStyle(EmitterStyle::value style) { 
-  if (!m_isValid) 
-    throw InvalidNode(); 
-  EnsureNodeExists(); 
-  m_pNode->set_style(style); 
-} 
- 
-// assignment 
-inline bool Node::is(const Node& rhs) const { 
-  if (!m_isValid || !rhs.m_isValid) 
-    throw InvalidNode(); 
-  if (!m_pNode || !rhs.m_pNode) 
-    return false; 
-  return m_pNode->is(*rhs.m_pNode); 
-} 
- 
-template <typename T> 
-inline Node& Node::operator=(const T& rhs) { 
-  if (!m_isValid) 
-    throw InvalidNode(); 
-  Assign(rhs); 
-  return *this; 
-} 
- 
-inline void Node::reset(const YAML::Node& rhs) { 
-  if (!m_isValid || !rhs.m_isValid) 
-    throw InvalidNode(); 
-  m_pMemory = rhs.m_pMemory; 
-  m_pNode = rhs.m_pNode; 
-} 
- 
-template <typename T> 
-inline void Node::Assign(const T& rhs) { 
-  if (!m_isValid) 
-    throw InvalidNode(); 
-  AssignData(convert<T>::encode(rhs)); 
-} 
- 
-template <> 
-inline void Node::Assign(const std::string& rhs) { 
-  if (!m_isValid) 
-    throw InvalidNode(); 
-  EnsureNodeExists(); 
-  m_pNode->set_scalar(rhs); 
-} 
- 
-inline void Node::Assign(const char* rhs) { 
-  if (!m_isValid) 
-    throw InvalidNode(); 
-  EnsureNodeExists(); 
-  m_pNode->set_scalar(rhs); 
-} 
- 
-inline void Node::Assign(char* rhs) { 
-  if (!m_isValid) 
-    throw InvalidNode(); 
-  EnsureNodeExists(); 
-  m_pNode->set_scalar(rhs); 
-} 
- 
-inline Node& Node::operator=(const Node& rhs) { 
-  if (!m_isValid || !rhs.m_isValid) 
-    throw InvalidNode(); 
-  if (is(rhs)) 
-    return *this; 
-  AssignNode(rhs); 
-  return *this; 
-} 
- 
-inline void Node::AssignData(const Node& rhs) { 
-  if (!m_isValid || !rhs.m_isValid) 
-    throw InvalidNode(); 
-  EnsureNodeExists(); 
-  rhs.EnsureNodeExists(); 
- 
-  m_pNode->set_data(*rhs.m_pNode); 
-  m_pMemory->merge(*rhs.m_pMemory); 
-} 
- 
-inline void Node::AssignNode(const Node& rhs) { 
-  if (!m_isValid || !rhs.m_isValid) 
-    throw InvalidNode(); 
-  rhs.EnsureNodeExists(); 
- 
-  if (!m_pNode) { 
-    m_pNode = rhs.m_pNode; 
-    m_pMemory = rhs.m_pMemory; 
-    return; 
-  } 
- 
-  m_pNode->set_ref(*rhs.m_pNode); 
-  m_pMemory->merge(*rhs.m_pMemory); 
-  m_pNode = rhs.m_pNode; 
-} 
- 
-// size/iterator 
-inline std::size_t Node::size() const { 
-  if (!m_isValid) 
-    throw InvalidNode(); 
-  return m_pNode ? m_pNode->size() : 0; 
-} 
- 
-inline const_iterator Node::begin() const { 
-  if (!m_isValid) 
-    return const_iterator(); 
-  return m_pNode ? const_iterator(m_pNode->begin(), m_pMemory) 
-                 : const_iterator(); 
-} 
- 
-inline iterator Node::begin() { 
-  if (!m_isValid) 
-    return iterator(); 
-  return m_pNode ? iterator(m_pNode->begin(), m_pMemory) : iterator(); 
-} 
- 
-inline const_iterator Node::end() const { 
-  if (!m_isValid) 
-    return const_iterator(); 
-  return m_pNode ? const_iterator(m_pNode->end(), m_pMemory) : const_iterator(); 
-} 
- 
-inline iterator Node::end() { 
-  if (!m_isValid) 
-    return iterator(); 
-  return m_pNode ? iterator(m_pNode->end(), m_pMemory) : iterator(); 
-} 
- 
-// sequence 
-template <typename T> 
-inline void Node::push_back(const T& rhs) { 
-  if (!m_isValid) 
-    throw InvalidNode(); 
-  push_back(Node(rhs)); 
-} 
- 
-inline void Node::push_back(const Node& rhs) { 
-  if (!m_isValid || !rhs.m_isValid) 
-    throw InvalidNode(); 
-  EnsureNodeExists(); 
-  rhs.EnsureNodeExists(); 
- 
-  m_pNode->push_back(*rhs.m_pNode, m_pMemory); 
-  m_pMemory->merge(*rhs.m_pMemory); 
-} 
- 
-// helpers for indexing 
-namespace detail { 
-template <typename T> 
-struct to_value_t { 
-  explicit to_value_t(const T& t_) : t(t_) {} 
-  const T& t; 
-  typedef const T& return_type; 
- 
-  const T& operator()() const { return t; } 
-}; 
- 
-template <> 
-struct to_value_t<const char*> { 
-  explicit to_value_t(const char* t_) : t(t_) {} 
-  const char* t; 
-  typedef std::string return_type; 
- 
-  const std::string operator()() const { return t; } 
-}; 
- 
-template <> 
-struct to_value_t<char*> { 
-  explicit to_value_t(char* t_) : t(t_) {} 
-  const char* t; 
-  typedef std::string return_type; 
- 
-  const std::string operator()() const { return t; } 
-}; 
- 
-template <std::size_t N> 
-struct to_value_t<char[N]> { 
-  explicit to_value_t(const char* t_) : t(t_) {} 
-  const char* t; 
-  typedef std::string return_type; 
- 
-  const std::string operator()() const { return t; } 
-}; 
- 
-// converts C-strings to std::strings so they can be copied 
-template <typename T> 
-inline typename to_value_t<T>::return_type to_value(const T& t) { 
-  return to_value_t<T>(t)(); 
-} 
-} 
- 
-// indexing 
-template <typename Key> 
-inline const Node Node::operator[](const Key& key) const { 
-  if (!m_isValid) 
-    throw InvalidNode(); 
-  EnsureNodeExists(); 
-  detail::node* value = static_cast<const detail::node&>(*m_pNode) 
-                            .get(detail::to_value(key), m_pMemory); 
-  if (!value) { 
-    return Node(ZombieNode); 
-  } 
-  return Node(*value, m_pMemory); 
-} 
- 
-template <typename Key> 
-inline Node Node::operator[](const Key& key) { 
-  if (!m_isValid) 
-    throw InvalidNode(); 
-  EnsureNodeExists(); 
-  detail::node& value = m_pNode->get(detail::to_value(key), m_pMemory); 
-  return Node(value, m_pMemory); 
-} 
- 
-template <typename Key> 
-inline bool Node::remove(const Key& key) { 
-  if (!m_isValid) 
-    throw InvalidNode(); 
-  EnsureNodeExists(); 
-  return m_pNode->remove(detail::to_value(key), m_pMemory); 
-} 
- 
-inline const Node Node::operator[](const Node& key) const { 
-  if (!m_isValid || !key.m_isValid) 
-    throw InvalidNode(); 
-  EnsureNodeExists(); 
-  key.EnsureNodeExists(); 
-  m_pMemory->merge(*key.m_pMemory); 
-  detail::node* value = 
-      static_cast<const detail::node&>(*m_pNode).get(*key.m_pNode, m_pMemory); 
-  if (!value) { 
-    return Node(ZombieNode); 
-  } 
-  return Node(*value, m_pMemory); 
-} 
- 
-inline Node Node::operator[](const Node& key) { 
-  if (!m_isValid || !key.m_isValid) 
-    throw InvalidNode(); 
-  EnsureNodeExists(); 
-  key.EnsureNodeExists(); 
-  m_pMemory->merge(*key.m_pMemory); 
-  detail::node& value = m_pNode->get(*key.m_pNode, m_pMemory); 
-  return Node(value, m_pMemory); 
-} 
- 
-inline bool Node::remove(const Node& key) { 
-  if (!m_isValid || !key.m_isValid) 
-    throw InvalidNode(); 
-  EnsureNodeExists(); 
-  key.EnsureNodeExists(); 
-  return m_pNode->remove(*key.m_pNode, m_pMemory); 
-} 
- 
-// map 
-template <typename Key, typename Value> 
-inline void Node::force_insert(const Key& key, const Value& value) { 
-  if (!m_isValid) 
-    throw InvalidNode(); 
-  EnsureNodeExists(); 
-  m_pNode->force_insert(detail::to_value(key), detail::to_value(value), 
-                        m_pMemory); 
-} 
- 
-// free functions 
-inline bool operator==(const Node& lhs, const Node& rhs) { return lhs.is(rhs); } 
-} 
- 
-#endif  // NODE_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+    if (node.Type() != NodeType::Scalar)
+      throw TypedBadConversion<std::string>(node.Mark());
+    return node.Scalar();
+  }
+};
+
+// access functions
+template <typename T>
+inline T Node::as() const {
+  if (!m_isValid)
+    throw InvalidNode();
+  return as_if<T, void>(*this)();
+}
+
+template <typename T, typename S>
+inline T Node::as(const S& fallback) const {
+  if (!m_isValid)
+    return fallback;
+  return as_if<T, S>(*this)(fallback);
+}
+
+inline const std::string& Node::Scalar() const {
+  if (!m_isValid)
+    throw InvalidNode();
+  return m_pNode ? m_pNode->scalar() : detail::node_data::empty_scalar;
+}
+
+inline const std::string& Node::Tag() const {
+  if (!m_isValid)
+    throw InvalidNode();
+  return m_pNode ? m_pNode->tag() : detail::node_data::empty_scalar;
+}
+
+inline void Node::SetTag(const std::string& tag) {
+  if (!m_isValid)
+    throw InvalidNode();
+  EnsureNodeExists();
+  m_pNode->set_tag(tag);
+}
+
+inline EmitterStyle::value Node::Style() const {
+  if (!m_isValid)
+    throw InvalidNode();
+  return m_pNode ? m_pNode->style() : EmitterStyle::Default;
+}
+
+inline void Node::SetStyle(EmitterStyle::value style) {
+  if (!m_isValid)
+    throw InvalidNode();
+  EnsureNodeExists();
+  m_pNode->set_style(style);
+}
+
+// assignment
+inline bool Node::is(const Node& rhs) const {
+  if (!m_isValid || !rhs.m_isValid)
+    throw InvalidNode();
+  if (!m_pNode || !rhs.m_pNode)
+    return false;
+  return m_pNode->is(*rhs.m_pNode);
+}
+
+template <typename T>
+inline Node& Node::operator=(const T& rhs) {
+  if (!m_isValid)
+    throw InvalidNode();
+  Assign(rhs);
+  return *this;
+}
+
+inline void Node::reset(const YAML::Node& rhs) {
+  if (!m_isValid || !rhs.m_isValid)
+    throw InvalidNode();
+  m_pMemory = rhs.m_pMemory;
+  m_pNode = rhs.m_pNode;
+}
+
+template <typename T>
+inline void Node::Assign(const T& rhs) {
+  if (!m_isValid)
+    throw InvalidNode();
+  AssignData(convert<T>::encode(rhs));
+}
+
+template <>
+inline void Node::Assign(const std::string& rhs) {
+  if (!m_isValid)
+    throw InvalidNode();
+  EnsureNodeExists();
+  m_pNode->set_scalar(rhs);
+}
+
+inline void Node::Assign(const char* rhs) {
+  if (!m_isValid)
+    throw InvalidNode();
+  EnsureNodeExists();
+  m_pNode->set_scalar(rhs);
+}
+
+inline void Node::Assign(char* rhs) {
+  if (!m_isValid)
+    throw InvalidNode();
+  EnsureNodeExists();
+  m_pNode->set_scalar(rhs);
+}
+
+inline Node& Node::operator=(const Node& rhs) {
+  if (!m_isValid || !rhs.m_isValid)
+    throw InvalidNode();
+  if (is(rhs))
+    return *this;
+  AssignNode(rhs);
+  return *this;
+}
+
+inline void Node::AssignData(const Node& rhs) {
+  if (!m_isValid || !rhs.m_isValid)
+    throw InvalidNode();
+  EnsureNodeExists();
+  rhs.EnsureNodeExists();
+
+  m_pNode->set_data(*rhs.m_pNode);
+  m_pMemory->merge(*rhs.m_pMemory);
+}
+
+inline void Node::AssignNode(const Node& rhs) {
+  if (!m_isValid || !rhs.m_isValid)
+    throw InvalidNode();
+  rhs.EnsureNodeExists();
+
+  if (!m_pNode) {
+    m_pNode = rhs.m_pNode;
+    m_pMemory = rhs.m_pMemory;
+    return;
+  }
+
+  m_pNode->set_ref(*rhs.m_pNode);
+  m_pMemory->merge(*rhs.m_pMemory);
+  m_pNode = rhs.m_pNode;
+}
+
+// size/iterator
+inline std::size_t Node::size() const {
+  if (!m_isValid)
+    throw InvalidNode();
+  return m_pNode ? m_pNode->size() : 0;
+}
+
+inline const_iterator Node::begin() const {
+  if (!m_isValid)
+    return const_iterator();
+  return m_pNode ? const_iterator(m_pNode->begin(), m_pMemory)
+                 : const_iterator();
+}
+
+inline iterator Node::begin() {
+  if (!m_isValid)
+    return iterator();
+  return m_pNode ? iterator(m_pNode->begin(), m_pMemory) : iterator();
+}
+
+inline const_iterator Node::end() const {
+  if (!m_isValid)
+    return const_iterator();
+  return m_pNode ? const_iterator(m_pNode->end(), m_pMemory) : const_iterator();
+}
+
+inline iterator Node::end() {
+  if (!m_isValid)
+    return iterator();
+  return m_pNode ? iterator(m_pNode->end(), m_pMemory) : iterator();
+}
+
+// sequence
+template <typename T>
+inline void Node::push_back(const T& rhs) {
+  if (!m_isValid)
+    throw InvalidNode();
+  push_back(Node(rhs));
+}
+
+inline void Node::push_back(const Node& rhs) {
+  if (!m_isValid || !rhs.m_isValid)
+    throw InvalidNode();
+  EnsureNodeExists();
+  rhs.EnsureNodeExists();
+
+  m_pNode->push_back(*rhs.m_pNode, m_pMemory);
+  m_pMemory->merge(*rhs.m_pMemory);
+}
+
+// helpers for indexing
+namespace detail {
+template <typename T>
+struct to_value_t {
+  explicit to_value_t(const T& t_) : t(t_) {}
+  const T& t;
+  typedef const T& return_type;
+
+  const T& operator()() const { return t; }
+};
+
+template <>
+struct to_value_t<const char*> {
+  explicit to_value_t(const char* t_) : t(t_) {}
+  const char* t;
+  typedef std::string return_type;
+
+  const std::string operator()() const { return t; }
+};
+
+template <>
+struct to_value_t<char*> {
+  explicit to_value_t(char* t_) : t(t_) {}
+  const char* t;
+  typedef std::string return_type;
+
+  const std::string operator()() const { return t; }
+};
+
+template <std::size_t N>
+struct to_value_t<char[N]> {
+  explicit to_value_t(const char* t_) : t(t_) {}
+  const char* t;
+  typedef std::string return_type;
+
+  const std::string operator()() const { return t; }
+};
+
+// converts C-strings to std::strings so they can be copied
+template <typename T>
+inline typename to_value_t<T>::return_type to_value(const T& t) {
+  return to_value_t<T>(t)();
+}
+}
+
+// indexing
+template <typename Key>
+inline const Node Node::operator[](const Key& key) const {
+  if (!m_isValid)
+    throw InvalidNode();
+  EnsureNodeExists();
+  detail::node* value = static_cast<const detail::node&>(*m_pNode)
+                            .get(detail::to_value(key), m_pMemory);
+  if (!value) {
+    return Node(ZombieNode);
+  }
+  return Node(*value, m_pMemory);
+}
+
+template <typename Key>
+inline Node Node::operator[](const Key& key) {
+  if (!m_isValid)
+    throw InvalidNode();
+  EnsureNodeExists();
+  detail::node& value = m_pNode->get(detail::to_value(key), m_pMemory);
+  return Node(value, m_pMemory);
+}
+
+template <typename Key>
+inline bool Node::remove(const Key& key) {
+  if (!m_isValid)
+    throw InvalidNode();
+  EnsureNodeExists();
+  return m_pNode->remove(detail::to_value(key), m_pMemory);
+}
+
+inline const Node Node::operator[](const Node& key) const {
+  if (!m_isValid || !key.m_isValid)
+    throw InvalidNode();
+  EnsureNodeExists();
+  key.EnsureNodeExists();
+  m_pMemory->merge(*key.m_pMemory);
+  detail::node* value =
+      static_cast<const detail::node&>(*m_pNode).get(*key.m_pNode, m_pMemory);
+  if (!value) {
+    return Node(ZombieNode);
+  }
+  return Node(*value, m_pMemory);
+}
+
+inline Node Node::operator[](const Node& key) {
+  if (!m_isValid || !key.m_isValid)
+    throw InvalidNode();
+  EnsureNodeExists();
+  key.EnsureNodeExists();
+  m_pMemory->merge(*key.m_pMemory);
+  detail::node& value = m_pNode->get(*key.m_pNode, m_pMemory);
+  return Node(value, m_pMemory);
+}
+
+inline bool Node::remove(const Node& key) {
+  if (!m_isValid || !key.m_isValid)
+    throw InvalidNode();
+  EnsureNodeExists();
+  key.EnsureNodeExists();
+  return m_pNode->remove(*key.m_pNode, m_pMemory);
+}
+
+// map
+template <typename Key, typename Value>
+inline void Node::force_insert(const Key& key, const Value& value) {
+  if (!m_isValid)
+    throw InvalidNode();
+  EnsureNodeExists();
+  m_pNode->force_insert(detail::to_value(key), detail::to_value(value),
+                        m_pMemory);
+}
+
+// free functions
+inline bool operator==(const Node& lhs, const Node& rhs) { return lhs.is(rhs); }
+}
+
+#endif  // NODE_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/node/iterator.h b/contrib/libs/yaml-cpp/include/yaml-cpp/node/iterator.h
index 551a693331b..6618169c53f 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/node/iterator.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/node/iterator.h
@@ -1,22 +1,22 @@
-#ifndef VALUE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define VALUE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include "yaml-cpp/dll.h" 
-#include "yaml-cpp/node/node.h" 
-#include "yaml-cpp/node/detail/iterator_fwd.h" 
-#include "yaml-cpp/node/detail/iterator.h" 
-#include <list> 
-#include <utility> 
-#include <vector> 
- 
-namespace YAML { 
-namespace detail { 
+#ifndef VALUE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define VALUE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/dll.h"
+#include "yaml-cpp/node/node.h"
+#include "yaml-cpp/node/detail/iterator_fwd.h"
+#include "yaml-cpp/node/detail/iterator.h"
+#include <list>
+#include <utility>
+#include <vector>
+
+namespace YAML {
+namespace detail {
 struct node_pair: public std::pair<Node, Node> {
     node_pair() = default;
     node_pair(const Node& first, const Node& second)
@@ -26,14 +26,14 @@ struct node_pair: public std::pair<Node, Node> {
 };
 
 struct iterator_value : public Node, node_pair {
-  iterator_value() {} 
-  explicit iterator_value(const Node& rhs) 
-      : Node(rhs), 
+  iterator_value() {}
+  explicit iterator_value(const Node& rhs)
+      : Node(rhs),
         node_pair(Node(Node::ZombieNode), Node(Node::ZombieNode)) {}
-  explicit iterator_value(const Node& key, const Node& value) 
+  explicit iterator_value(const Node& key, const Node& value)
       : Node(Node::ZombieNode), node_pair(key, value) {}
-}; 
-} 
-} 
- 
-#endif  // VALUE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+};
+}
+}
+
+#endif  // VALUE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/node/node.h b/contrib/libs/yaml-cpp/include/yaml-cpp/node/node.h
index 5e1bd5510fb..1ded7d27b72 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/node/node.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/node/node.h
@@ -1,145 +1,145 @@
-#ifndef NODE_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define NODE_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include <stdexcept> 
- 
-#include "yaml-cpp/dll.h" 
-#include "yaml-cpp/emitterstyle.h" 
-#include "yaml-cpp/mark.h" 
-#include "yaml-cpp/node/detail/bool_type.h" 
-#include "yaml-cpp/node/detail/iterator_fwd.h" 
-#include "yaml-cpp/node/ptr.h" 
-#include "yaml-cpp/node/type.h" 
- 
-namespace YAML { 
-namespace detail { 
-class node; 
-class node_data; 
-struct iterator_value; 
-}  // namespace detail 
-}  // namespace YAML 
- 
-namespace YAML { 
-class YAML_CPP_API Node { 
- public: 
-  friend class NodeBuilder; 
-  friend class NodeEvents; 
-  friend struct detail::iterator_value; 
-  friend class detail::node; 
-  friend class detail::node_data; 
-  template <typename> 
-  friend class detail::iterator_base; 
-  template <typename T, typename S> 
-  friend struct as_if; 
- 
-  typedef YAML::iterator iterator; 
-  typedef YAML::const_iterator const_iterator; 
- 
-  Node(); 
-  explicit Node(NodeType::value type); 
-  template <typename T> 
-  explicit Node(const T& rhs); 
-  explicit Node(const detail::iterator_value& rhs); 
-  Node(const Node& rhs); 
-  ~Node(); 
- 
-  YAML::Mark Mark() const; 
-  NodeType::value Type() const; 
-  bool IsDefined() const; 
-  bool IsNull() const { return Type() == NodeType::Null; } 
-  bool IsScalar() const { return Type() == NodeType::Scalar; } 
-  bool IsSequence() const { return Type() == NodeType::Sequence; } 
-  bool IsMap() const { return Type() == NodeType::Map; } 
- 
-  // bool conversions 
+#ifndef NODE_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODE_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <stdexcept>
+
+#include "yaml-cpp/dll.h"
+#include "yaml-cpp/emitterstyle.h"
+#include "yaml-cpp/mark.h"
+#include "yaml-cpp/node/detail/bool_type.h"
+#include "yaml-cpp/node/detail/iterator_fwd.h"
+#include "yaml-cpp/node/ptr.h"
+#include "yaml-cpp/node/type.h"
+
+namespace YAML {
+namespace detail {
+class node;
+class node_data;
+struct iterator_value;
+}  // namespace detail
+}  // namespace YAML
+
+namespace YAML {
+class YAML_CPP_API Node {
+ public:
+  friend class NodeBuilder;
+  friend class NodeEvents;
+  friend struct detail::iterator_value;
+  friend class detail::node;
+  friend class detail::node_data;
+  template <typename>
+  friend class detail::iterator_base;
+  template <typename T, typename S>
+  friend struct as_if;
+
+  typedef YAML::iterator iterator;
+  typedef YAML::const_iterator const_iterator;
+
+  Node();
+  explicit Node(NodeType::value type);
+  template <typename T>
+  explicit Node(const T& rhs);
+  explicit Node(const detail::iterator_value& rhs);
+  Node(const Node& rhs);
+  ~Node();
+
+  YAML::Mark Mark() const;
+  NodeType::value Type() const;
+  bool IsDefined() const;
+  bool IsNull() const { return Type() == NodeType::Null; }
+  bool IsScalar() const { return Type() == NodeType::Scalar; }
+  bool IsSequence() const { return Type() == NodeType::Sequence; }
+  bool IsMap() const { return Type() == NodeType::Map; }
+
+  // bool conversions
   YAML_CPP_OPERATOR_BOOL()
-  bool operator!() const { return !IsDefined(); } 
- 
-  // access 
-  template <typename T> 
-  T as() const; 
-  template <typename T, typename S> 
-  T as(const S& fallback) const; 
-  const std::string& Scalar() const; 
- 
-  const std::string& Tag() const; 
-  void SetTag(const std::string& tag); 
- 
-  // style 
-  // WARNING: This API might change in future releases. 
-  EmitterStyle::value Style() const; 
-  void SetStyle(EmitterStyle::value style); 
- 
-  // assignment 
-  bool is(const Node& rhs) const; 
-  template <typename T> 
-  Node& operator=(const T& rhs); 
-  Node& operator=(const Node& rhs); 
-  void reset(const Node& rhs = Node()); 
- 
-  // size/iterator 
-  std::size_t size() const; 
- 
-  const_iterator begin() const; 
-  iterator begin(); 
- 
-  const_iterator end() const; 
-  iterator end(); 
- 
-  // sequence 
-  template <typename T> 
-  void push_back(const T& rhs); 
-  void push_back(const Node& rhs); 
- 
-  // indexing 
-  template <typename Key> 
-  const Node operator[](const Key& key) const; 
-  template <typename Key> 
-  Node operator[](const Key& key); 
-  template <typename Key> 
-  bool remove(const Key& key); 
- 
-  const Node operator[](const Node& key) const; 
-  Node operator[](const Node& key); 
-  bool remove(const Node& key); 
- 
-  // map 
-  template <typename Key, typename Value> 
-  void force_insert(const Key& key, const Value& value); 
- 
- private: 
-  enum Zombie { ZombieNode }; 
-  explicit Node(Zombie); 
-  explicit Node(detail::node& node, detail::shared_memory_holder pMemory); 
- 
-  void EnsureNodeExists() const; 
- 
-  template <typename T> 
-  void Assign(const T& rhs); 
-  void Assign(const char* rhs); 
-  void Assign(char* rhs); 
- 
-  void AssignData(const Node& rhs); 
-  void AssignNode(const Node& rhs); 
- 
- private: 
-  bool m_isValid; 
-  mutable detail::shared_memory_holder m_pMemory; 
-  mutable detail::node* m_pNode; 
-}; 
- 
-YAML_CPP_API bool operator==(const Node& lhs, const Node& rhs); 
- 
-YAML_CPP_API Node Clone(const Node& node); 
- 
-template <typename T> 
-struct convert; 
-} 
- 
-#endif  // NODE_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+  bool operator!() const { return !IsDefined(); }
+
+  // access
+  template <typename T>
+  T as() const;
+  template <typename T, typename S>
+  T as(const S& fallback) const;
+  const std::string& Scalar() const;
+
+  const std::string& Tag() const;
+  void SetTag(const std::string& tag);
+
+  // style
+  // WARNING: This API might change in future releases.
+  EmitterStyle::value Style() const;
+  void SetStyle(EmitterStyle::value style);
+
+  // assignment
+  bool is(const Node& rhs) const;
+  template <typename T>
+  Node& operator=(const T& rhs);
+  Node& operator=(const Node& rhs);
+  void reset(const Node& rhs = Node());
+
+  // size/iterator
+  std::size_t size() const;
+
+  const_iterator begin() const;
+  iterator begin();
+
+  const_iterator end() const;
+  iterator end();
+
+  // sequence
+  template <typename T>
+  void push_back(const T& rhs);
+  void push_back(const Node& rhs);
+
+  // indexing
+  template <typename Key>
+  const Node operator[](const Key& key) const;
+  template <typename Key>
+  Node operator[](const Key& key);
+  template <typename Key>
+  bool remove(const Key& key);
+
+  const Node operator[](const Node& key) const;
+  Node operator[](const Node& key);
+  bool remove(const Node& key);
+
+  // map
+  template <typename Key, typename Value>
+  void force_insert(const Key& key, const Value& value);
+
+ private:
+  enum Zombie { ZombieNode };
+  explicit Node(Zombie);
+  explicit Node(detail::node& node, detail::shared_memory_holder pMemory);
+
+  void EnsureNodeExists() const;
+
+  template <typename T>
+  void Assign(const T& rhs);
+  void Assign(const char* rhs);
+  void Assign(char* rhs);
+
+  void AssignData(const Node& rhs);
+  void AssignNode(const Node& rhs);
+
+ private:
+  bool m_isValid;
+  mutable detail::shared_memory_holder m_pMemory;
+  mutable detail::node* m_pNode;
+};
+
+YAML_CPP_API bool operator==(const Node& lhs, const Node& rhs);
+
+YAML_CPP_API Node Clone(const Node& node);
+
+template <typename T>
+struct convert;
+}
+
+#endif  // NODE_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/node/parse.h b/contrib/libs/yaml-cpp/include/yaml-cpp/node/parse.h
index af5352ad140..7745fd7245b 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/node/parse.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/node/parse.h
@@ -1,41 +1,41 @@
-#ifndef VALUE_PARSE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define VALUE_PARSE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include <iosfwd> 
-#include <string> 
-#include <vector> 
- 
-#include "yaml-cpp/dll.h" 
- 
-namespace YAML { 
-class Node; 
- 
+#ifndef VALUE_PARSE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define VALUE_PARSE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <iosfwd>
+#include <string>
+#include <vector>
+
+#include "yaml-cpp/dll.h"
+
+namespace YAML {
+class Node;
+
 /**
  * Loads the input string as a single YAML document.
  *
  * @throws {@link ParserException} if it is malformed.
  */
-YAML_CPP_API Node Load(const std::string& input); 
+YAML_CPP_API Node Load(const std::string& input);
 
 /**
  * Loads the input string as a single YAML document.
  *
  * @throws {@link ParserException} if it is malformed.
  */
-YAML_CPP_API Node Load(const char* input); 
+YAML_CPP_API Node Load(const char* input);
 
 /**
  * Loads the input stream as a single YAML document.
  *
  * @throws {@link ParserException} if it is malformed.
  */
-YAML_CPP_API Node Load(std::istream& input); 
+YAML_CPP_API Node Load(std::istream& input);
 
 /**
  * Loads the input file as a single YAML document.
@@ -43,28 +43,28 @@ YAML_CPP_API Node Load(std::istream& input);
  * @throws {@link ParserException} if it is malformed.
  * @throws {@link BadFile} if the file cannot be loaded.
  */
-YAML_CPP_API Node LoadFile(const std::string& filename); 
- 
+YAML_CPP_API Node LoadFile(const std::string& filename);
+
 /**
  * Loads the input string as a list of YAML documents.
  *
  * @throws {@link ParserException} if it is malformed.
  */
-YAML_CPP_API std::vector<Node> LoadAll(const std::string& input); 
+YAML_CPP_API std::vector<Node> LoadAll(const std::string& input);
 
 /**
  * Loads the input string as a list of YAML documents.
  *
  * @throws {@link ParserException} if it is malformed.
  */
-YAML_CPP_API std::vector<Node> LoadAll(const char* input); 
+YAML_CPP_API std::vector<Node> LoadAll(const char* input);
 
 /**
  * Loads the input stream as a list of YAML documents.
  *
  * @throws {@link ParserException} if it is malformed.
  */
-YAML_CPP_API std::vector<Node> LoadAll(std::istream& input); 
+YAML_CPP_API std::vector<Node> LoadAll(std::istream& input);
 
 /**
  * Loads the input file as a list of YAML documents.
@@ -72,7 +72,7 @@ YAML_CPP_API std::vector<Node> LoadAll(std::istream& input);
  * @throws {@link ParserException} if it is malformed.
  * @throws {@link BadFile} if the file cannot be loaded.
  */
-YAML_CPP_API std::vector<Node> LoadAllFromFile(const std::string& filename); 
+YAML_CPP_API std::vector<Node> LoadAllFromFile(const std::string& filename);
 }  // namespace YAML
- 
-#endif  // VALUE_PARSE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+
+#endif  // VALUE_PARSE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/node/ptr.h b/contrib/libs/yaml-cpp/include/yaml-cpp/node/ptr.h
index 7f30642edb4..ce085dd5cd8 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/node/ptr.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/node/ptr.h
@@ -1,29 +1,29 @@
-#ifndef VALUE_PTR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define VALUE_PTR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include "yaml-cpp/dll.h" 
+#ifndef VALUE_PTR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define VALUE_PTR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/dll.h"
 #include <memory>
- 
-namespace YAML { 
-namespace detail { 
-class node; 
-class node_ref; 
-class node_data; 
-class memory; 
-class memory_holder; 
- 
+
+namespace YAML {
+namespace detail {
+class node;
+class node_ref;
+class node_data;
+class memory;
+class memory_holder;
+
 typedef std::shared_ptr<node> shared_node;
 typedef std::shared_ptr<node_ref> shared_node_ref;
 typedef std::shared_ptr<node_data> shared_node_data;
 typedef std::shared_ptr<memory_holder> shared_memory_holder;
 typedef std::shared_ptr<memory> shared_memory;
-} 
-} 
- 
-#endif  // VALUE_PTR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+}
+}
+
+#endif  // VALUE_PTR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/node/type.h b/contrib/libs/yaml-cpp/include/yaml-cpp/node/type.h
index 4a56d8e3ace..9d55ca96621 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/node/type.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/node/type.h
@@ -1,16 +1,16 @@
-#ifndef VALUE_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define VALUE_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-namespace YAML { 
-struct NodeType { 
-  enum value { Undefined, Null, Scalar, Sequence, Map }; 
-}; 
-} 
- 
-#endif  // VALUE_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+#ifndef VALUE_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define VALUE_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+namespace YAML {
+struct NodeType {
+  enum value { Undefined, Null, Scalar, Sequence, Map };
+};
+}
+
+#endif  // VALUE_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/noncopyable.h b/contrib/libs/yaml-cpp/include/yaml-cpp/noncopyable.h
index c33c294590a..a261040739b 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/noncopyable.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/noncopyable.h
@@ -1,25 +1,25 @@
-#ifndef NONCOPYABLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define NONCOPYABLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include "yaml-cpp/dll.h" 
- 
-namespace YAML { 
-// this is basically boost::noncopyable 
-class YAML_CPP_API noncopyable { 
- protected: 
-  noncopyable() {} 
-  ~noncopyable() {} 
- 
- private: 
-  noncopyable(const noncopyable&); 
-  const noncopyable& operator=(const noncopyable&); 
-}; 
-} 
- 
-#endif  // NONCOPYABLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+#ifndef NONCOPYABLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NONCOPYABLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/dll.h"
+
+namespace YAML {
+// this is basically boost::noncopyable
+class YAML_CPP_API noncopyable {
+ protected:
+  noncopyable() {}
+  ~noncopyable() {}
+
+ private:
+  noncopyable(const noncopyable&);
+  const noncopyable& operator=(const noncopyable&);
+};
+}
+
+#endif  // NONCOPYABLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/null.h b/contrib/libs/yaml-cpp/include/yaml-cpp/null.h
index 79ebe4db07d..b9521d488a6 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/null.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/null.h
@@ -1,26 +1,26 @@
-#ifndef NULL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define NULL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include "yaml-cpp/dll.h" 
+#ifndef NULL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NULL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/dll.h"
 #include <string>
- 
-namespace YAML { 
-class Node; 
- 
-struct YAML_CPP_API _Null {}; 
-inline bool operator==(const _Null&, const _Null&) { return true; } 
-inline bool operator!=(const _Null&, const _Null&) { return false; } 
- 
-YAML_CPP_API bool IsNull(const Node& node);  // old API only 
+
+namespace YAML {
+class Node;
+
+struct YAML_CPP_API _Null {};
+inline bool operator==(const _Null&, const _Null&) { return true; }
+inline bool operator!=(const _Null&, const _Null&) { return false; }
+
+YAML_CPP_API bool IsNull(const Node& node);  // old API only
 YAML_CPP_API bool IsNullString(const std::string& str);
- 
-extern YAML_CPP_API _Null Null; 
-} 
- 
-#endif  // NULL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+
+extern YAML_CPP_API _Null Null;
+}
+
+#endif  // NULL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/ostream_wrapper.h b/contrib/libs/yaml-cpp/include/yaml-cpp/ostream_wrapper.h
index bf79511d165..09d45f39b78 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/ostream_wrapper.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/ostream_wrapper.h
@@ -1,72 +1,72 @@
-#ifndef OSTREAM_WRAPPER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define OSTREAM_WRAPPER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include <string> 
-#include <vector> 
- 
-#include "yaml-cpp/dll.h" 
- 
-namespace YAML { 
-class YAML_CPP_API ostream_wrapper { 
- public: 
-  ostream_wrapper(); 
-  explicit ostream_wrapper(std::ostream& stream); 
-  ~ostream_wrapper(); 
- 
-  void write(const std::string& str); 
-  void write(const char* str, std::size_t size); 
- 
-  void set_comment() { m_comment = true; } 
- 
-  const char* str() const { 
-    if (m_pStream) { 
-      return 0; 
-    } else { 
-      m_buffer[m_pos] = '\0'; 
-      return &m_buffer[0]; 
-    } 
-  } 
- 
-  std::size_t row() const { return m_row; } 
-  std::size_t col() const { return m_col; } 
-  std::size_t pos() const { return m_pos; } 
-  bool comment() const { return m_comment; } 
- 
- private: 
-  void update_pos(char ch); 
- 
- private: 
-  mutable std::vector<char> m_buffer; 
-  std::ostream* const m_pStream; 
- 
-  std::size_t m_pos; 
-  std::size_t m_row, m_col; 
-  bool m_comment; 
-}; 
- 
-template <std::size_t N> 
-inline ostream_wrapper& operator<<(ostream_wrapper& stream, 
-                                   const char(&str)[N]) { 
-  stream.write(str, N - 1); 
-  return stream; 
-} 
- 
-inline ostream_wrapper& operator<<(ostream_wrapper& stream, 
-                                   const std::string& str) { 
-  stream.write(str); 
-  return stream; 
-} 
- 
-inline ostream_wrapper& operator<<(ostream_wrapper& stream, char ch) { 
-  stream.write(&ch, 1); 
-  return stream; 
-} 
-} 
- 
-#endif  // OSTREAM_WRAPPER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+#ifndef OSTREAM_WRAPPER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define OSTREAM_WRAPPER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <string>
+#include <vector>
+
+#include "yaml-cpp/dll.h"
+
+namespace YAML {
+class YAML_CPP_API ostream_wrapper {
+ public:
+  ostream_wrapper();
+  explicit ostream_wrapper(std::ostream& stream);
+  ~ostream_wrapper();
+
+  void write(const std::string& str);
+  void write(const char* str, std::size_t size);
+
+  void set_comment() { m_comment = true; }
+
+  const char* str() const {
+    if (m_pStream) {
+      return 0;
+    } else {
+      m_buffer[m_pos] = '\0';
+      return &m_buffer[0];
+    }
+  }
+
+  std::size_t row() const { return m_row; }
+  std::size_t col() const { return m_col; }
+  std::size_t pos() const { return m_pos; }
+  bool comment() const { return m_comment; }
+
+ private:
+  void update_pos(char ch);
+
+ private:
+  mutable std::vector<char> m_buffer;
+  std::ostream* const m_pStream;
+
+  std::size_t m_pos;
+  std::size_t m_row, m_col;
+  bool m_comment;
+};
+
+template <std::size_t N>
+inline ostream_wrapper& operator<<(ostream_wrapper& stream,
+                                   const char(&str)[N]) {
+  stream.write(str, N - 1);
+  return stream;
+}
+
+inline ostream_wrapper& operator<<(ostream_wrapper& stream,
+                                   const std::string& str) {
+  stream.write(str);
+  return stream;
+}
+
+inline ostream_wrapper& operator<<(ostream_wrapper& stream, char ch) {
+  stream.write(&ch, 1);
+  return stream;
+}
+}
+
+#endif  // OSTREAM_WRAPPER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/parser.h b/contrib/libs/yaml-cpp/include/yaml-cpp/parser.h
index 9d22439769b..ceac22d0268 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/parser.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/parser.h
@@ -1,33 +1,33 @@
-#ifndef PARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define PARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include <ios> 
-#include <memory> 
- 
-#include "yaml-cpp/dll.h" 
-#include "yaml-cpp/noncopyable.h" 
- 
-namespace YAML { 
-class EventHandler; 
-class Node; 
-class Scanner; 
-struct Directives; 
-struct Token; 
- 
+#ifndef PARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define PARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <ios>
+#include <memory>
+
+#include "yaml-cpp/dll.h"
+#include "yaml-cpp/noncopyable.h"
+
+namespace YAML {
+class EventHandler;
+class Node;
+class Scanner;
+struct Directives;
+struct Token;
+
 /**
  * A parser turns a stream of bytes into one stream of "events" per YAML
  * document in the input stream.
  */
-class YAML_CPP_API Parser : private noncopyable { 
- public: 
+class YAML_CPP_API Parser : private noncopyable {
+ public:
   /** Constructs an empty parser (with no input. */
-  Parser(); 
+  Parser();
 
   /**
    * Constructs a parser from the given input stream. The input stream must
@@ -35,16 +35,16 @@ class YAML_CPP_API Parser : private noncopyable {
    */
   explicit Parser(std::istream& in);
 
-  ~Parser(); 
- 
+  ~Parser();
+
   /** Evaluates to true if the parser has some valid input to be read. */
   explicit operator bool() const;
- 
+
   /**
    * Resets the parser with the given input stream. Any existing state is
    * erased.
    */
-  void Load(std::istream& in); 
+  void Load(std::istream& in);
 
   /**
    * Handles the next document by calling events on the {@code eventHandler}.
@@ -52,35 +52,35 @@ class YAML_CPP_API Parser : private noncopyable {
    * @throw a ParserException on error.
    * @return false if there are no more documents
    */
-  bool HandleNextDocument(EventHandler& eventHandler); 
- 
-  void PrintTokens(std::ostream& out); 
- 
- private: 
+  bool HandleNextDocument(EventHandler& eventHandler);
+
+  void PrintTokens(std::ostream& out);
+
+ private:
   /**
    * Reads any directives that are next in the queue, setting the internal
    * {@code m_pDirectives} state.
    */
-  void ParseDirectives(); 
+  void ParseDirectives();
 
-  void HandleDirective(const Token& token); 
+  void HandleDirective(const Token& token);
 
   /**
    * Handles a "YAML" directive, which should be of the form 'major.minor' (like
    * a version number).
    */
-  void HandleYamlDirective(const Token& token); 
+  void HandleYamlDirective(const Token& token);
 
   /**
    * Handles a "TAG" directive, which should be of the form 'handle prefix',
    * where 'handle' is converted to 'prefix' in the file.
    */
-  void HandleTagDirective(const Token& token); 
- 
- private: 
+  void HandleTagDirective(const Token& token);
+
+ private:
   std::unique_ptr<Scanner> m_pScanner;
   std::unique_ptr<Directives> m_pDirectives;
-}; 
-} 
- 
-#endif  // PARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+};
+}
+
+#endif  // PARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/stlemitter.h b/contrib/libs/yaml-cpp/include/yaml-cpp/stlemitter.h
index 4c19a67277c..06780c861f1 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/stlemitter.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/stlemitter.h
@@ -1,51 +1,51 @@
-#ifndef STLEMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define STLEMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include <vector> 
-#include <list> 
-#include <set> 
-#include <map> 
- 
-namespace YAML { 
-template <typename Seq> 
-inline Emitter& EmitSeq(Emitter& emitter, const Seq& seq) { 
-  emitter << BeginSeq; 
-  for (typename Seq::const_iterator it = seq.begin(); it != seq.end(); ++it) 
-    emitter << *it; 
-  emitter << EndSeq; 
-  return emitter; 
-} 
- 
-template <typename T> 
-inline Emitter& operator<<(Emitter& emitter, const std::vector<T>& v) { 
-  return EmitSeq(emitter, v); 
-} 
- 
-template <typename T> 
-inline Emitter& operator<<(Emitter& emitter, const std::list<T>& v) { 
-  return EmitSeq(emitter, v); 
-} 
- 
-template <typename T> 
-inline Emitter& operator<<(Emitter& emitter, const std::set<T>& v) { 
-  return EmitSeq(emitter, v); 
-} 
- 
-template <typename K, typename V> 
-inline Emitter& operator<<(Emitter& emitter, const std::map<K, V>& m) { 
-  typedef typename std::map<K, V> map; 
-  emitter << BeginMap; 
-  for (typename map::const_iterator it = m.begin(); it != m.end(); ++it) 
-    emitter << Key << it->first << Value << it->second; 
-  emitter << EndMap; 
-  return emitter; 
-} 
-} 
- 
-#endif  // STLEMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+#ifndef STLEMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define STLEMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <vector>
+#include <list>
+#include <set>
+#include <map>
+
+namespace YAML {
+template <typename Seq>
+inline Emitter& EmitSeq(Emitter& emitter, const Seq& seq) {
+  emitter << BeginSeq;
+  for (typename Seq::const_iterator it = seq.begin(); it != seq.end(); ++it)
+    emitter << *it;
+  emitter << EndSeq;
+  return emitter;
+}
+
+template <typename T>
+inline Emitter& operator<<(Emitter& emitter, const std::vector<T>& v) {
+  return EmitSeq(emitter, v);
+}
+
+template <typename T>
+inline Emitter& operator<<(Emitter& emitter, const std::list<T>& v) {
+  return EmitSeq(emitter, v);
+}
+
+template <typename T>
+inline Emitter& operator<<(Emitter& emitter, const std::set<T>& v) {
+  return EmitSeq(emitter, v);
+}
+
+template <typename K, typename V>
+inline Emitter& operator<<(Emitter& emitter, const std::map<K, V>& m) {
+  typedef typename std::map<K, V> map;
+  emitter << BeginMap;
+  for (typename map::const_iterator it = m.begin(); it != m.end(); ++it)
+    emitter << Key << it->first << Value << it->second;
+  emitter << EndMap;
+  return emitter;
+}
+}
+
+#endif  // STLEMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/traits.h b/contrib/libs/yaml-cpp/include/yaml-cpp/traits.h
index 8775085a398..f33d0e1f637 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/traits.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/traits.h
@@ -1,103 +1,103 @@
-#ifndef TRAITS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define TRAITS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-namespace YAML { 
-template <typename> 
-struct is_numeric { 
-  enum { value = false }; 
-}; 
- 
-template <> 
-struct is_numeric<char> { 
-  enum { value = true }; 
-}; 
-template <> 
-struct is_numeric<unsigned char> { 
-  enum { value = true }; 
-}; 
-template <> 
-struct is_numeric<int> { 
-  enum { value = true }; 
-}; 
-template <> 
-struct is_numeric<unsigned int> { 
-  enum { value = true }; 
-}; 
-template <> 
-struct is_numeric<long int> { 
-  enum { value = true }; 
-}; 
-template <> 
-struct is_numeric<unsigned long int> { 
-  enum { value = true }; 
-}; 
-template <> 
-struct is_numeric<short int> { 
-  enum { value = true }; 
-}; 
-template <> 
-struct is_numeric<unsigned short int> { 
-  enum { value = true }; 
-}; 
-#if defined(_MSC_VER) && (_MSC_VER < 1310) 
-template <> 
-struct is_numeric<__int64> { 
-  enum { value = true }; 
-}; 
-template <> 
-struct is_numeric<unsigned __int64> { 
-  enum { value = true }; 
-}; 
-#else 
-template <> 
-struct is_numeric<long long> { 
-  enum { value = true }; 
-}; 
-template <> 
-struct is_numeric<unsigned long long> { 
-  enum { value = true }; 
-}; 
-#endif 
-template <> 
-struct is_numeric<float> { 
-  enum { value = true }; 
-}; 
-template <> 
-struct is_numeric<double> { 
-  enum { value = true }; 
-}; 
-template <> 
-struct is_numeric<long double> { 
-  enum { value = true }; 
-}; 
- 
-template <bool, class T = void> 
-struct enable_if_c { 
-  typedef T type; 
-}; 
- 
-template <class T> 
-struct enable_if_c<false, T> {}; 
- 
-template <class Cond, class T = void> 
-struct enable_if : public enable_if_c<Cond::value, T> {}; 
- 
-template <bool, class T = void> 
-struct disable_if_c { 
-  typedef T type; 
-}; 
- 
-template <class T> 
-struct disable_if_c<true, T> {}; 
- 
-template <class Cond, class T = void> 
-struct disable_if : public disable_if_c<Cond::value, T> {}; 
-} 
- 
-#endif  // TRAITS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+#ifndef TRAITS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define TRAITS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+namespace YAML {
+template <typename>
+struct is_numeric {
+  enum { value = false };
+};
+
+template <>
+struct is_numeric<char> {
+  enum { value = true };
+};
+template <>
+struct is_numeric<unsigned char> {
+  enum { value = true };
+};
+template <>
+struct is_numeric<int> {
+  enum { value = true };
+};
+template <>
+struct is_numeric<unsigned int> {
+  enum { value = true };
+};
+template <>
+struct is_numeric<long int> {
+  enum { value = true };
+};
+template <>
+struct is_numeric<unsigned long int> {
+  enum { value = true };
+};
+template <>
+struct is_numeric<short int> {
+  enum { value = true };
+};
+template <>
+struct is_numeric<unsigned short int> {
+  enum { value = true };
+};
+#if defined(_MSC_VER) && (_MSC_VER < 1310)
+template <>
+struct is_numeric<__int64> {
+  enum { value = true };
+};
+template <>
+struct is_numeric<unsigned __int64> {
+  enum { value = true };
+};
+#else
+template <>
+struct is_numeric<long long> {
+  enum { value = true };
+};
+template <>
+struct is_numeric<unsigned long long> {
+  enum { value = true };
+};
+#endif
+template <>
+struct is_numeric<float> {
+  enum { value = true };
+};
+template <>
+struct is_numeric<double> {
+  enum { value = true };
+};
+template <>
+struct is_numeric<long double> {
+  enum { value = true };
+};
+
+template <bool, class T = void>
+struct enable_if_c {
+  typedef T type;
+};
+
+template <class T>
+struct enable_if_c<false, T> {};
+
+template <class Cond, class T = void>
+struct enable_if : public enable_if_c<Cond::value, T> {};
+
+template <bool, class T = void>
+struct disable_if_c {
+  typedef T type;
+};
+
+template <class T>
+struct disable_if_c<true, T> {};
+
+template <class Cond, class T = void>
+struct disable_if : public disable_if_c<Cond::value, T> {};
+}
+
+#endif  // TRAITS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/yaml.h b/contrib/libs/yaml-cpp/include/yaml-cpp/yaml.h
index 11b6ad8ba94..7f515efb961 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/yaml.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/yaml.h
@@ -1,24 +1,24 @@
-#ifndef YAML_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define YAML_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include "yaml-cpp/parser.h" 
-#include "yaml-cpp/emitter.h" 
-#include "yaml-cpp/emitterstyle.h" 
-#include "yaml-cpp/stlemitter.h" 
-#include "yaml-cpp/exceptions.h" 
- 
-#include "yaml-cpp/node/node.h" 
-#include "yaml-cpp/node/impl.h" 
-#include "yaml-cpp/node/convert.h" 
-#include "yaml-cpp/node/iterator.h" 
-#include "yaml-cpp/node/detail/impl.h" 
-#include "yaml-cpp/node/parse.h" 
-#include "yaml-cpp/node/emit.h" 
- 
-#endif  // YAML_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+#ifndef YAML_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define YAML_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/parser.h"
+#include "yaml-cpp/emitter.h"
+#include "yaml-cpp/emitterstyle.h"
+#include "yaml-cpp/stlemitter.h"
+#include "yaml-cpp/exceptions.h"
+
+#include "yaml-cpp/node/node.h"
+#include "yaml-cpp/node/impl.h"
+#include "yaml-cpp/node/convert.h"
+#include "yaml-cpp/node/iterator.h"
+#include "yaml-cpp/node/detail/impl.h"
+#include "yaml-cpp/node/parse.h"
+#include "yaml-cpp/node/emit.h"
+
+#endif  // YAML_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/src/binary.cpp b/contrib/libs/yaml-cpp/src/binary.cpp
index a01abcb7858..a7e51301b82 100644
--- a/contrib/libs/yaml-cpp/src/binary.cpp
+++ b/contrib/libs/yaml-cpp/src/binary.cpp
@@ -1,93 +1,93 @@
-#include "yaml-cpp/binary.h" 
- 
-namespace YAML { 
-static const char encoding[] = 
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; 
- 
-std::string EncodeBase64(const unsigned char *data, std::size_t size) { 
-  const char PAD = '='; 
- 
-  std::string ret; 
-  ret.resize(4 * size / 3 + 3); 
-  char *out = &ret[0]; 
- 
-  std::size_t chunks = size / 3; 
-  std::size_t remainder = size % 3; 
- 
-  for (std::size_t i = 0; i < chunks; i++, data += 3) { 
-    *out++ = encoding[data[0] >> 2]; 
-    *out++ = encoding[((data[0] & 0x3) << 4) | (data[1] >> 4)]; 
-    *out++ = encoding[((data[1] & 0xf) << 2) | (data[2] >> 6)]; 
-    *out++ = encoding[data[2] & 0x3f]; 
-  } 
- 
-  switch (remainder) { 
-    case 0: 
-      break; 
-    case 1: 
-      *out++ = encoding[data[0] >> 2]; 
-      *out++ = encoding[((data[0] & 0x3) << 4)]; 
-      *out++ = PAD; 
-      *out++ = PAD; 
-      break; 
-    case 2: 
-      *out++ = encoding[data[0] >> 2]; 
-      *out++ = encoding[((data[0] & 0x3) << 4) | (data[1] >> 4)]; 
-      *out++ = encoding[((data[1] & 0xf) << 2)]; 
-      *out++ = PAD; 
-      break; 
-  } 
- 
-  ret.resize(out - &ret[0]); 
-  return ret; 
-} 
- 
-static const unsigned char decoding[] = { 
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 62,  255, 
-    255, 255, 63,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  255, 255, 
-    255, 0,   255, 255, 255, 0,   1,   2,   3,   4,   5,   6,   7,   8,   9, 
-    10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24, 
-    25,  255, 255, 255, 255, 255, 255, 26,  27,  28,  29,  30,  31,  32,  33, 
-    34,  35,  36,  37,  38,  39,  40,  41,  42,  43,  44,  45,  46,  47,  48, 
-    49,  50,  51,  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 
-    255, 
-}; 
- 
-std::vector<unsigned char> DecodeBase64(const std::string &input) { 
-  typedef std::vector<unsigned char> ret_type; 
-  if (input.empty()) 
-    return ret_type(); 
- 
-  ret_type ret(3 * input.size() / 4 + 1); 
-  unsigned char *out = &ret[0]; 
- 
-  unsigned value = 0; 
-  for (std::size_t i = 0; i < input.size(); i++) { 
-    unsigned char d = decoding[static_cast<unsigned>(input[i])]; 
-    if (d == 255) 
-      return ret_type(); 
- 
-    value = (value << 6) | d; 
-    if (i % 4 == 3) { 
-      *out++ = value >> 16; 
-      if (i > 0 && input[i - 1] != '=') 
-        *out++ = value >> 8; 
-      if (input[i] != '=') 
-        *out++ = value; 
-    } 
-  } 
- 
-  ret.resize(out - &ret[0]); 
-  return ret; 
-} 
-} 
+#include "yaml-cpp/binary.h"
+
+namespace YAML {
+static const char encoding[] =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+std::string EncodeBase64(const unsigned char *data, std::size_t size) {
+  const char PAD = '=';
+
+  std::string ret;
+  ret.resize(4 * size / 3 + 3);
+  char *out = &ret[0];
+
+  std::size_t chunks = size / 3;
+  std::size_t remainder = size % 3;
+
+  for (std::size_t i = 0; i < chunks; i++, data += 3) {
+    *out++ = encoding[data[0] >> 2];
+    *out++ = encoding[((data[0] & 0x3) << 4) | (data[1] >> 4)];
+    *out++ = encoding[((data[1] & 0xf) << 2) | (data[2] >> 6)];
+    *out++ = encoding[data[2] & 0x3f];
+  }
+
+  switch (remainder) {
+    case 0:
+      break;
+    case 1:
+      *out++ = encoding[data[0] >> 2];
+      *out++ = encoding[((data[0] & 0x3) << 4)];
+      *out++ = PAD;
+      *out++ = PAD;
+      break;
+    case 2:
+      *out++ = encoding[data[0] >> 2];
+      *out++ = encoding[((data[0] & 0x3) << 4) | (data[1] >> 4)];
+      *out++ = encoding[((data[1] & 0xf) << 2)];
+      *out++ = PAD;
+      break;
+  }
+
+  ret.resize(out - &ret[0]);
+  return ret;
+}
+
+static const unsigned char decoding[] = {
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 62,  255,
+    255, 255, 63,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  255, 255,
+    255, 0,   255, 255, 255, 0,   1,   2,   3,   4,   5,   6,   7,   8,   9,
+    10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,
+    25,  255, 255, 255, 255, 255, 255, 26,  27,  28,  29,  30,  31,  32,  33,
+    34,  35,  36,  37,  38,  39,  40,  41,  42,  43,  44,  45,  46,  47,  48,
+    49,  50,  51,  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255,
+};
+
+std::vector<unsigned char> DecodeBase64(const std::string &input) {
+  typedef std::vector<unsigned char> ret_type;
+  if (input.empty())
+    return ret_type();
+
+  ret_type ret(3 * input.size() / 4 + 1);
+  unsigned char *out = &ret[0];
+
+  unsigned value = 0;
+  for (std::size_t i = 0; i < input.size(); i++) {
+    unsigned char d = decoding[static_cast<unsigned>(input[i])];
+    if (d == 255)
+      return ret_type();
+
+    value = (value << 6) | d;
+    if (i % 4 == 3) {
+      *out++ = value >> 16;
+      if (i > 0 && input[i - 1] != '=')
+        *out++ = value >> 8;
+      if (input[i] != '=')
+        *out++ = value;
+    }
+  }
+
+  ret.resize(out - &ret[0]);
+  return ret;
+}
+}
diff --git a/contrib/libs/yaml-cpp/src/collectionstack.h b/contrib/libs/yaml-cpp/src/collectionstack.h
index 415444ad061..46c463ebce1 100644
--- a/contrib/libs/yaml-cpp/src/collectionstack.h
+++ b/contrib/libs/yaml-cpp/src/collectionstack.h
@@ -1,40 +1,40 @@
-#ifndef COLLECTIONSTACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define COLLECTIONSTACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include <stack> 
-#include <cassert> 
- 
-namespace YAML { 
-struct CollectionType { 
-  enum value { NoCollection, BlockMap, BlockSeq, FlowMap, FlowSeq, CompactMap }; 
-}; 
- 
-class CollectionStack { 
- public: 
-  CollectionType::value GetCurCollectionType() const { 
-    if (collectionStack.empty()) 
-      return CollectionType::NoCollection; 
-    return collectionStack.top(); 
-  } 
- 
-  void PushCollectionType(CollectionType::value type) { 
-    collectionStack.push(type); 
-  } 
-  void PopCollectionType(CollectionType::value type) { 
+#ifndef COLLECTIONSTACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define COLLECTIONSTACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <stack>
+#include <cassert>
+
+namespace YAML {
+struct CollectionType {
+  enum value { NoCollection, BlockMap, BlockSeq, FlowMap, FlowSeq, CompactMap };
+};
+
+class CollectionStack {
+ public:
+  CollectionType::value GetCurCollectionType() const {
+    if (collectionStack.empty())
+      return CollectionType::NoCollection;
+    return collectionStack.top();
+  }
+
+  void PushCollectionType(CollectionType::value type) {
+    collectionStack.push(type);
+  }
+  void PopCollectionType(CollectionType::value type) {
     (void)type;
-    assert(type == GetCurCollectionType()); 
-    collectionStack.pop(); 
-  } 
- 
- private: 
-  std::stack<CollectionType::value> collectionStack; 
-}; 
-} 
- 
-#endif  // COLLECTIONSTACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+    assert(type == GetCurCollectionType());
+    collectionStack.pop();
+  }
+
+ private:
+  std::stack<CollectionType::value> collectionStack;
+};
+}
+
+#endif  // COLLECTIONSTACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/src/contrib/graphbuilder.cpp b/contrib/libs/yaml-cpp/src/contrib/graphbuilder.cpp
index e33597bb87e..416c1359db6 100644
--- a/contrib/libs/yaml-cpp/src/contrib/graphbuilder.cpp
+++ b/contrib/libs/yaml-cpp/src/contrib/graphbuilder.cpp
@@ -1,17 +1,17 @@
-#include "graphbuilderadapter.h" 
- 
-#include "yaml-cpp/parser.h"  // IWYU pragma: keep 
- 
-namespace YAML { 
-class GraphBuilderInterface; 
- 
-void* BuildGraphOfNextDocument(Parser& parser, 
-                               GraphBuilderInterface& graphBuilder) { 
-  GraphBuilderAdapter eventHandler(graphBuilder); 
-  if (parser.HandleNextDocument(eventHandler)) { 
-    return eventHandler.RootNode(); 
-  } else { 
-    return NULL; 
-  } 
-} 
-} 
+#include "graphbuilderadapter.h"
+
+#include "yaml-cpp/parser.h"  // IWYU pragma: keep
+
+namespace YAML {
+class GraphBuilderInterface;
+
+void* BuildGraphOfNextDocument(Parser& parser,
+                               GraphBuilderInterface& graphBuilder) {
+  GraphBuilderAdapter eventHandler(graphBuilder);
+  if (parser.HandleNextDocument(eventHandler)) {
+    return eventHandler.RootNode();
+  } else {
+    return NULL;
+  }
+}
+}
diff --git a/contrib/libs/yaml-cpp/src/contrib/graphbuilderadapter.cpp b/contrib/libs/yaml-cpp/src/contrib/graphbuilderadapter.cpp
index 6ea3128f2ab..02a3d972a50 100644
--- a/contrib/libs/yaml-cpp/src/contrib/graphbuilderadapter.cpp
+++ b/contrib/libs/yaml-cpp/src/contrib/graphbuilderadapter.cpp
@@ -1,94 +1,94 @@
-#include "graphbuilderadapter.h" 
-#include "yaml-cpp/contrib/graphbuilder.h" 
- 
-namespace YAML { 
-struct Mark; 
- 
-int GraphBuilderAdapter::ContainerFrame::sequenceMarker; 
- 
-void GraphBuilderAdapter::OnNull(const Mark &mark, anchor_t anchor) { 
-  void *pParent = GetCurrentParent(); 
-  void *pNode = m_builder.NewNull(mark, pParent); 
-  RegisterAnchor(anchor, pNode); 
- 
-  DispositionNode(pNode); 
-} 
- 
-void GraphBuilderAdapter::OnAlias(const Mark &mark, anchor_t anchor) { 
-  void *pReffedNode = m_anchors.Get(anchor); 
-  DispositionNode(m_builder.AnchorReference(mark, pReffedNode)); 
-} 
- 
-void GraphBuilderAdapter::OnScalar(const Mark &mark, const std::string &tag, 
-                                   anchor_t anchor, const std::string &value) { 
-  void *pParent = GetCurrentParent(); 
-  void *pNode = m_builder.NewScalar(mark, tag, pParent, value); 
-  RegisterAnchor(anchor, pNode); 
- 
-  DispositionNode(pNode); 
-} 
- 
-void GraphBuilderAdapter::OnSequenceStart(const Mark &mark, 
-                                          const std::string &tag, 
-                                          anchor_t anchor, 
-                                          EmitterStyle::value /* style */) { 
-  void *pNode = m_builder.NewSequence(mark, tag, GetCurrentParent()); 
-  m_containers.push(ContainerFrame(pNode)); 
-  RegisterAnchor(anchor, pNode); 
-} 
- 
-void GraphBuilderAdapter::OnSequenceEnd() { 
-  void *pSequence = m_containers.top().pContainer; 
-  m_containers.pop(); 
- 
-  DispositionNode(pSequence); 
-} 
- 
-void GraphBuilderAdapter::OnMapStart(const Mark &mark, const std::string &tag, 
-                                     anchor_t anchor, 
-                                     EmitterStyle::value /* style */) { 
-  void *pNode = m_builder.NewMap(mark, tag, GetCurrentParent()); 
-  m_containers.push(ContainerFrame(pNode, m_pKeyNode)); 
-  m_pKeyNode = NULL; 
-  RegisterAnchor(anchor, pNode); 
-} 
- 
-void GraphBuilderAdapter::OnMapEnd() { 
-  void *pMap = m_containers.top().pContainer; 
-  m_pKeyNode = m_containers.top().pPrevKeyNode; 
-  m_containers.pop(); 
-  DispositionNode(pMap); 
-} 
- 
-void *GraphBuilderAdapter::GetCurrentParent() const { 
-  if (m_containers.empty()) { 
-    return NULL; 
-  } 
-  return m_containers.top().pContainer; 
-} 
- 
-void GraphBuilderAdapter::RegisterAnchor(anchor_t anchor, void *pNode) { 
-  if (anchor) { 
-    m_anchors.Register(anchor, pNode); 
-  } 
-} 
- 
-void GraphBuilderAdapter::DispositionNode(void *pNode) { 
-  if (m_containers.empty()) { 
-    m_pRootNode = pNode; 
-    return; 
-  } 
- 
-  void *pContainer = m_containers.top().pContainer; 
-  if (m_containers.top().isMap()) { 
-    if (m_pKeyNode) { 
-      m_builder.AssignInMap(pContainer, m_pKeyNode, pNode); 
-      m_pKeyNode = NULL; 
-    } else { 
-      m_pKeyNode = pNode; 
-    } 
-  } else { 
-    m_builder.AppendToSequence(pContainer, pNode); 
-  } 
-} 
-} 
+#include "graphbuilderadapter.h"
+#include "yaml-cpp/contrib/graphbuilder.h"
+
+namespace YAML {
+struct Mark;
+
+int GraphBuilderAdapter::ContainerFrame::sequenceMarker;
+
+void GraphBuilderAdapter::OnNull(const Mark &mark, anchor_t anchor) {
+  void *pParent = GetCurrentParent();
+  void *pNode = m_builder.NewNull(mark, pParent);
+  RegisterAnchor(anchor, pNode);
+
+  DispositionNode(pNode);
+}
+
+void GraphBuilderAdapter::OnAlias(const Mark &mark, anchor_t anchor) {
+  void *pReffedNode = m_anchors.Get(anchor);
+  DispositionNode(m_builder.AnchorReference(mark, pReffedNode));
+}
+
+void GraphBuilderAdapter::OnScalar(const Mark &mark, const std::string &tag,
+                                   anchor_t anchor, const std::string &value) {
+  void *pParent = GetCurrentParent();
+  void *pNode = m_builder.NewScalar(mark, tag, pParent, value);
+  RegisterAnchor(anchor, pNode);
+
+  DispositionNode(pNode);
+}
+
+void GraphBuilderAdapter::OnSequenceStart(const Mark &mark,
+                                          const std::string &tag,
+                                          anchor_t anchor,
+                                          EmitterStyle::value /* style */) {
+  void *pNode = m_builder.NewSequence(mark, tag, GetCurrentParent());
+  m_containers.push(ContainerFrame(pNode));
+  RegisterAnchor(anchor, pNode);
+}
+
+void GraphBuilderAdapter::OnSequenceEnd() {
+  void *pSequence = m_containers.top().pContainer;
+  m_containers.pop();
+
+  DispositionNode(pSequence);
+}
+
+void GraphBuilderAdapter::OnMapStart(const Mark &mark, const std::string &tag,
+                                     anchor_t anchor,
+                                     EmitterStyle::value /* style */) {
+  void *pNode = m_builder.NewMap(mark, tag, GetCurrentParent());
+  m_containers.push(ContainerFrame(pNode, m_pKeyNode));
+  m_pKeyNode = NULL;
+  RegisterAnchor(anchor, pNode);
+}
+
+void GraphBuilderAdapter::OnMapEnd() {
+  void *pMap = m_containers.top().pContainer;
+  m_pKeyNode = m_containers.top().pPrevKeyNode;
+  m_containers.pop();
+  DispositionNode(pMap);
+}
+
+void *GraphBuilderAdapter::GetCurrentParent() const {
+  if (m_containers.empty()) {
+    return NULL;
+  }
+  return m_containers.top().pContainer;
+}
+
+void GraphBuilderAdapter::RegisterAnchor(anchor_t anchor, void *pNode) {
+  if (anchor) {
+    m_anchors.Register(anchor, pNode);
+  }
+}
+
+void GraphBuilderAdapter::DispositionNode(void *pNode) {
+  if (m_containers.empty()) {
+    m_pRootNode = pNode;
+    return;
+  }
+
+  void *pContainer = m_containers.top().pContainer;
+  if (m_containers.top().isMap()) {
+    if (m_pKeyNode) {
+      m_builder.AssignInMap(pContainer, m_pKeyNode, pNode);
+      m_pKeyNode = NULL;
+    } else {
+      m_pKeyNode = pNode;
+    }
+  } else {
+    m_builder.AppendToSequence(pContainer, pNode);
+  }
+}
+}
diff --git a/contrib/libs/yaml-cpp/src/contrib/graphbuilderadapter.h b/contrib/libs/yaml-cpp/src/contrib/graphbuilderadapter.h
index 1665d986cac..0d1e579208c 100644
--- a/contrib/libs/yaml-cpp/src/contrib/graphbuilderadapter.h
+++ b/contrib/libs/yaml-cpp/src/contrib/graphbuilderadapter.h
@@ -1,79 +1,79 @@
-#ifndef GRAPHBUILDERADAPTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define GRAPHBUILDERADAPTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include <cstdlib> 
-#include <map> 
-#include <stack> 
- 
-#include "yaml-cpp/anchor.h" 
-#include "yaml-cpp/contrib/anchordict.h" 
-#include "yaml-cpp/contrib/graphbuilder.h" 
-#include "yaml-cpp/emitterstyle.h" 
-#include "yaml-cpp/eventhandler.h" 
- 
-namespace YAML { 
-class GraphBuilderInterface; 
-struct Mark; 
-}  // namespace YAML 
- 
-namespace YAML { 
-class GraphBuilderAdapter : public EventHandler { 
- public: 
-  GraphBuilderAdapter(GraphBuilderInterface& builder) 
-      : m_builder(builder), m_pRootNode(NULL), m_pKeyNode(NULL) {} 
- 
-  virtual void OnDocumentStart(const Mark& mark) { (void)mark; } 
-  virtual void OnDocumentEnd() {} 
- 
-  virtual void OnNull(const Mark& mark, anchor_t anchor); 
-  virtual void OnAlias(const Mark& mark, anchor_t anchor); 
-  virtual void OnScalar(const Mark& mark, const std::string& tag, 
-                        anchor_t anchor, const std::string& value); 
- 
-  virtual void OnSequenceStart(const Mark& mark, const std::string& tag, 
-                               anchor_t anchor, EmitterStyle::value style); 
-  virtual void OnSequenceEnd(); 
- 
-  virtual void OnMapStart(const Mark& mark, const std::string& tag, 
-                          anchor_t anchor, EmitterStyle::value style); 
-  virtual void OnMapEnd(); 
- 
-  void* RootNode() const { return m_pRootNode; } 
- 
- private: 
-  struct ContainerFrame { 
-    ContainerFrame(void* pSequence) 
-        : pContainer(pSequence), pPrevKeyNode(&sequenceMarker) {} 
-    ContainerFrame(void* pMap, void* pPrevKeyNode) 
-        : pContainer(pMap), pPrevKeyNode(pPrevKeyNode) {} 
- 
-    void* pContainer; 
-    void* pPrevKeyNode; 
- 
-    bool isMap() const { return pPrevKeyNode != &sequenceMarker; } 
- 
-   private: 
-    static int sequenceMarker; 
-  }; 
-  typedef std::stack<ContainerFrame> ContainerStack; 
-  typedef AnchorDict<void*> AnchorMap; 
- 
-  GraphBuilderInterface& m_builder; 
-  ContainerStack m_containers; 
-  AnchorMap m_anchors; 
-  void* m_pRootNode; 
-  void* m_pKeyNode; 
- 
-  void* GetCurrentParent() const; 
-  void RegisterAnchor(anchor_t anchor, void* pNode); 
-  void DispositionNode(void* pNode); 
-}; 
-} 
- 
-#endif  // GRAPHBUILDERADAPTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+#ifndef GRAPHBUILDERADAPTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define GRAPHBUILDERADAPTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <cstdlib>
+#include <map>
+#include <stack>
+
+#include "yaml-cpp/anchor.h"
+#include "yaml-cpp/contrib/anchordict.h"
+#include "yaml-cpp/contrib/graphbuilder.h"
+#include "yaml-cpp/emitterstyle.h"
+#include "yaml-cpp/eventhandler.h"
+
+namespace YAML {
+class GraphBuilderInterface;
+struct Mark;
+}  // namespace YAML
+
+namespace YAML {
+class GraphBuilderAdapter : public EventHandler {
+ public:
+  GraphBuilderAdapter(GraphBuilderInterface& builder)
+      : m_builder(builder), m_pRootNode(NULL), m_pKeyNode(NULL) {}
+
+  virtual void OnDocumentStart(const Mark& mark) { (void)mark; }
+  virtual void OnDocumentEnd() {}
+
+  virtual void OnNull(const Mark& mark, anchor_t anchor);
+  virtual void OnAlias(const Mark& mark, anchor_t anchor);
+  virtual void OnScalar(const Mark& mark, const std::string& tag,
+                        anchor_t anchor, const std::string& value);
+
+  virtual void OnSequenceStart(const Mark& mark, const std::string& tag,
+                               anchor_t anchor, EmitterStyle::value style);
+  virtual void OnSequenceEnd();
+
+  virtual void OnMapStart(const Mark& mark, const std::string& tag,
+                          anchor_t anchor, EmitterStyle::value style);
+  virtual void OnMapEnd();
+
+  void* RootNode() const { return m_pRootNode; }
+
+ private:
+  struct ContainerFrame {
+    ContainerFrame(void* pSequence)
+        : pContainer(pSequence), pPrevKeyNode(&sequenceMarker) {}
+    ContainerFrame(void* pMap, void* pPrevKeyNode)
+        : pContainer(pMap), pPrevKeyNode(pPrevKeyNode) {}
+
+    void* pContainer;
+    void* pPrevKeyNode;
+
+    bool isMap() const { return pPrevKeyNode != &sequenceMarker; }
+
+   private:
+    static int sequenceMarker;
+  };
+  typedef std::stack<ContainerFrame> ContainerStack;
+  typedef AnchorDict<void*> AnchorMap;
+
+  GraphBuilderInterface& m_builder;
+  ContainerStack m_containers;
+  AnchorMap m_anchors;
+  void* m_pRootNode;
+  void* m_pKeyNode;
+
+  void* GetCurrentParent() const;
+  void RegisterAnchor(anchor_t anchor, void* pNode);
+  void DispositionNode(void* pNode);
+};
+}
+
+#endif  // GRAPHBUILDERADAPTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/src/convert.cpp b/contrib/libs/yaml-cpp/src/convert.cpp
index b7e9d7f7f47..ec05b77826b 100644
--- a/contrib/libs/yaml-cpp/src/convert.cpp
+++ b/contrib/libs/yaml-cpp/src/convert.cpp
@@ -1,75 +1,75 @@
-#include <algorithm> 
- 
-#include "yaml-cpp/node/convert.h" 
- 
-namespace { 
-// we're not gonna mess with the mess that is all the isupper/etc. functions 
-bool IsLower(char ch) { return 'a' <= ch && ch <= 'z'; } 
-bool IsUpper(char ch) { return 'A' <= ch && ch <= 'Z'; } 
-char ToLower(char ch) { return IsUpper(ch) ? ch + 'a' - 'A' : ch; } 
- 
-std::string tolower(const std::string& str) { 
-  std::string s(str); 
-  std::transform(s.begin(), s.end(), s.begin(), ToLower); 
-  return s; 
-} 
- 
-template <typename T> 
-bool IsEntirely(const std::string& str, T func) { 
-  for (std::size_t i = 0; i < str.size(); i++) 
-    if (!func(str[i])) 
-      return false; 
- 
-  return true; 
-} 
- 
-// IsFlexibleCase 
-// . Returns true if 'str' is: 
-//   . UPPERCASE 
-//   . lowercase 
-//   . Capitalized 
-bool IsFlexibleCase(const std::string& str) { 
-  if (str.empty()) 
-    return true; 
- 
-  if (IsEntirely(str, IsLower)) 
-    return true; 
- 
-  bool firstcaps = IsUpper(str[0]); 
-  std::string rest = str.substr(1); 
-  return firstcaps && (IsEntirely(rest, IsLower) || IsEntirely(rest, IsUpper)); 
-} 
-} 
- 
-namespace YAML { 
-bool convert<bool>::decode(const Node& node, bool& rhs) { 
-  if (!node.IsScalar()) 
-    return false; 
- 
-  // we can't use iostream bool extraction operators as they don't 
-  // recognize all possible values in the table below (taken from 
-  // http://yaml.org/type/bool.html) 
-  static const struct { 
-    std::string truename, falsename; 
-  } names[] = { 
-      {"y", "n"}, {"yes", "no"}, {"true", "false"}, {"on", "off"}, 
-  }; 
- 
-  if (!IsFlexibleCase(node.Scalar())) 
-    return false; 
- 
-  for (unsigned i = 0; i < sizeof(names) / sizeof(names[0]); i++) { 
-    if (names[i].truename == tolower(node.Scalar())) { 
-      rhs = true; 
-      return true; 
-    } 
- 
-    if (names[i].falsename == tolower(node.Scalar())) { 
-      rhs = false; 
-      return true; 
-    } 
-  } 
- 
-  return false; 
-} 
-} 
+#include <algorithm>
+
+#include "yaml-cpp/node/convert.h"
+
+namespace {
+// we're not gonna mess with the mess that is all the isupper/etc. functions
+bool IsLower(char ch) { return 'a' <= ch && ch <= 'z'; }
+bool IsUpper(char ch) { return 'A' <= ch && ch <= 'Z'; }
+char ToLower(char ch) { return IsUpper(ch) ? ch + 'a' - 'A' : ch; }
+
+std::string tolower(const std::string& str) {
+  std::string s(str);
+  std::transform(s.begin(), s.end(), s.begin(), ToLower);
+  return s;
+}
+
+template <typename T>
+bool IsEntirely(const std::string& str, T func) {
+  for (std::size_t i = 0; i < str.size(); i++)
+    if (!func(str[i]))
+      return false;
+
+  return true;
+}
+
+// IsFlexibleCase
+// . Returns true if 'str' is:
+//   . UPPERCASE
+//   . lowercase
+//   . Capitalized
+bool IsFlexibleCase(const std::string& str) {
+  if (str.empty())
+    return true;
+
+  if (IsEntirely(str, IsLower))
+    return true;
+
+  bool firstcaps = IsUpper(str[0]);
+  std::string rest = str.substr(1);
+  return firstcaps && (IsEntirely(rest, IsLower) || IsEntirely(rest, IsUpper));
+}
+}
+
+namespace YAML {
+bool convert<bool>::decode(const Node& node, bool& rhs) {
+  if (!node.IsScalar())
+    return false;
+
+  // we can't use iostream bool extraction operators as they don't
+  // recognize all possible values in the table below (taken from
+  // http://yaml.org/type/bool.html)
+  static const struct {
+    std::string truename, falsename;
+  } names[] = {
+      {"y", "n"}, {"yes", "no"}, {"true", "false"}, {"on", "off"},
+  };
+
+  if (!IsFlexibleCase(node.Scalar()))
+    return false;
+
+  for (unsigned i = 0; i < sizeof(names) / sizeof(names[0]); i++) {
+    if (names[i].truename == tolower(node.Scalar())) {
+      rhs = true;
+      return true;
+    }
+
+    if (names[i].falsename == tolower(node.Scalar())) {
+      rhs = false;
+      return true;
+    }
+  }
+
+  return false;
+}
+}
diff --git a/contrib/libs/yaml-cpp/src/directives.cpp b/contrib/libs/yaml-cpp/src/directives.cpp
index db778f2fffd..963bd2cd379 100644
--- a/contrib/libs/yaml-cpp/src/directives.cpp
+++ b/contrib/libs/yaml-cpp/src/directives.cpp
@@ -1,22 +1,22 @@
-#include "directives.h" 
- 
-namespace YAML { 
-Directives::Directives() { 
-  // version 
-  version.isDefault = true; 
-  version.major = 1; 
-  version.minor = 2; 
-} 
- 
-const std::string Directives::TranslateTagHandle( 
-    const std::string& handle) const { 
-  std::map<std::string, std::string>::const_iterator it = tags.find(handle); 
-  if (it == tags.end()) { 
-    if (handle == "!!") 
-      return "tag:yaml.org,2002:"; 
-    return handle; 
-  } 
- 
-  return it->second; 
-} 
-} 
+#include "directives.h"
+
+namespace YAML {
+Directives::Directives() {
+  // version
+  version.isDefault = true;
+  version.major = 1;
+  version.minor = 2;
+}
+
+const std::string Directives::TranslateTagHandle(
+    const std::string& handle) const {
+  std::map<std::string, std::string>::const_iterator it = tags.find(handle);
+  if (it == tags.end()) {
+    if (handle == "!!")
+      return "tag:yaml.org,2002:";
+    return handle;
+  }
+
+  return it->second;
+}
+}
diff --git a/contrib/libs/yaml-cpp/src/directives.h b/contrib/libs/yaml-cpp/src/directives.h
index 40523d93c3e..333af26e374 100644
--- a/contrib/libs/yaml-cpp/src/directives.h
+++ b/contrib/libs/yaml-cpp/src/directives.h
@@ -1,29 +1,29 @@
-#ifndef DIRECTIVES_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define DIRECTIVES_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include <string> 
-#include <map> 
- 
-namespace YAML { 
-struct Version { 
-  bool isDefault; 
-  int major, minor; 
-}; 
- 
-struct Directives { 
-  Directives(); 
- 
-  const std::string TranslateTagHandle(const std::string& handle) const; 
- 
-  Version version; 
-  std::map<std::string, std::string> tags; 
-}; 
-} 
- 
-#endif  // DIRECTIVES_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+#ifndef DIRECTIVES_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define DIRECTIVES_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <string>
+#include <map>
+
+namespace YAML {
+struct Version {
+  bool isDefault;
+  int major, minor;
+};
+
+struct Directives {
+  Directives();
+
+  const std::string TranslateTagHandle(const std::string& handle) const;
+
+  Version version;
+  std::map<std::string, std::string> tags;
+};
+}
+
+#endif  // DIRECTIVES_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/src/emit.cpp b/contrib/libs/yaml-cpp/src/emit.cpp
index 01a41e11b71..51bc791533d 100644
--- a/contrib/libs/yaml-cpp/src/emit.cpp
+++ b/contrib/libs/yaml-cpp/src/emit.cpp
@@ -1,25 +1,25 @@
-#include "yaml-cpp/node/emit.h" 
-#include "yaml-cpp/emitfromevents.h" 
-#include "yaml-cpp/emitter.h" 
-#include "nodeevents.h" 
- 
-namespace YAML { 
-Emitter& operator<<(Emitter& out, const Node& node) { 
-  EmitFromEvents emitFromEvents(out); 
-  NodeEvents events(node); 
-  events.Emit(emitFromEvents); 
-  return out; 
-} 
- 
-std::ostream& operator<<(std::ostream& out, const Node& node) { 
-  Emitter emitter(out); 
-  emitter << node; 
-  return out; 
-} 
- 
-std::string Dump(const Node& node) { 
-  Emitter emitter; 
-  emitter << node; 
-  return emitter.c_str(); 
-} 
+#include "yaml-cpp/node/emit.h"
+#include "yaml-cpp/emitfromevents.h"
+#include "yaml-cpp/emitter.h"
+#include "nodeevents.h"
+
+namespace YAML {
+Emitter& operator<<(Emitter& out, const Node& node) {
+  EmitFromEvents emitFromEvents(out);
+  NodeEvents events(node);
+  events.Emit(emitFromEvents);
+  return out;
+}
+
+std::ostream& operator<<(std::ostream& out, const Node& node) {
+  Emitter emitter(out);
+  emitter << node;
+  return out;
+}
+
+std::string Dump(const Node& node) {
+  Emitter emitter;
+  emitter << node;
+  return emitter.c_str();
+}
 }  // namespace YAML
diff --git a/contrib/libs/yaml-cpp/src/emitfromevents.cpp b/contrib/libs/yaml-cpp/src/emitfromevents.cpp
index edf7f53846b..4832649f3c7 100644
--- a/contrib/libs/yaml-cpp/src/emitfromevents.cpp
+++ b/contrib/libs/yaml-cpp/src/emitfromevents.cpp
@@ -1,119 +1,119 @@
-#include <cassert> 
-#include <sstream> 
- 
-#include "yaml-cpp/emitfromevents.h" 
-#include "yaml-cpp/emitter.h" 
-#include "yaml-cpp/emittermanip.h" 
-#include "yaml-cpp/null.h" 
- 
-namespace YAML { 
-struct Mark; 
-}  // namespace YAML 
- 
-namespace { 
-std::string ToString(YAML::anchor_t anchor) { 
-  std::stringstream stream; 
-  stream << anchor; 
-  return stream.str(); 
-} 
-} 
- 
-namespace YAML { 
-EmitFromEvents::EmitFromEvents(Emitter& emitter) : m_emitter(emitter) {} 
- 
-void EmitFromEvents::OnDocumentStart(const Mark&) {} 
- 
-void EmitFromEvents::OnDocumentEnd() {} 
- 
-void EmitFromEvents::OnNull(const Mark&, anchor_t anchor) { 
-  BeginNode(); 
-  EmitProps("", anchor); 
-  m_emitter << Null; 
-} 
- 
-void EmitFromEvents::OnAlias(const Mark&, anchor_t anchor) { 
-  BeginNode(); 
-  m_emitter << Alias(ToString(anchor)); 
-} 
- 
-void EmitFromEvents::OnScalar(const Mark&, const std::string& tag, 
-                              anchor_t anchor, const std::string& value) { 
-  BeginNode(); 
-  EmitProps(tag, anchor); 
-  m_emitter << value; 
-} 
- 
-void EmitFromEvents::OnSequenceStart(const Mark&, const std::string& tag, 
-                                     anchor_t anchor, 
-                                     EmitterStyle::value style) { 
-  BeginNode(); 
-  EmitProps(tag, anchor); 
-  switch (style) { 
-    case EmitterStyle::Block: 
-      m_emitter << Block; 
-      break; 
-    case EmitterStyle::Flow: 
-      m_emitter << Flow; 
-      break; 
-    default: 
-      break; 
-  } 
-  m_emitter << BeginSeq; 
-  m_stateStack.push(State::WaitingForSequenceEntry); 
-} 
- 
-void EmitFromEvents::OnSequenceEnd() { 
-  m_emitter << EndSeq; 
-  assert(m_stateStack.top() == State::WaitingForSequenceEntry); 
-  m_stateStack.pop(); 
-} 
- 
-void EmitFromEvents::OnMapStart(const Mark&, const std::string& tag, 
-                                anchor_t anchor, EmitterStyle::value style) { 
-  BeginNode(); 
-  EmitProps(tag, anchor); 
-  switch (style) { 
-    case EmitterStyle::Block: 
-      m_emitter << Block; 
-      break; 
-    case EmitterStyle::Flow: 
-      m_emitter << Flow; 
-      break; 
-    default: 
-      break; 
-  } 
-  m_emitter << BeginMap; 
-  m_stateStack.push(State::WaitingForKey); 
-} 
- 
-void EmitFromEvents::OnMapEnd() { 
-  m_emitter << EndMap; 
-  assert(m_stateStack.top() == State::WaitingForKey); 
-  m_stateStack.pop(); 
-} 
- 
-void EmitFromEvents::BeginNode() { 
-  if (m_stateStack.empty()) 
-    return; 
- 
-  switch (m_stateStack.top()) { 
-    case State::WaitingForKey: 
-      m_emitter << Key; 
-      m_stateStack.top() = State::WaitingForValue; 
-      break; 
-    case State::WaitingForValue: 
-      m_emitter << Value; 
-      m_stateStack.top() = State::WaitingForKey; 
-      break; 
-    default: 
-      break; 
-  } 
-} 
- 
-void EmitFromEvents::EmitProps(const std::string& tag, anchor_t anchor) { 
+#include <cassert>
+#include <sstream>
+
+#include "yaml-cpp/emitfromevents.h"
+#include "yaml-cpp/emitter.h"
+#include "yaml-cpp/emittermanip.h"
+#include "yaml-cpp/null.h"
+
+namespace YAML {
+struct Mark;
+}  // namespace YAML
+
+namespace {
+std::string ToString(YAML::anchor_t anchor) {
+  std::stringstream stream;
+  stream << anchor;
+  return stream.str();
+}
+}
+
+namespace YAML {
+EmitFromEvents::EmitFromEvents(Emitter& emitter) : m_emitter(emitter) {}
+
+void EmitFromEvents::OnDocumentStart(const Mark&) {}
+
+void EmitFromEvents::OnDocumentEnd() {}
+
+void EmitFromEvents::OnNull(const Mark&, anchor_t anchor) {
+  BeginNode();
+  EmitProps("", anchor);
+  m_emitter << Null;
+}
+
+void EmitFromEvents::OnAlias(const Mark&, anchor_t anchor) {
+  BeginNode();
+  m_emitter << Alias(ToString(anchor));
+}
+
+void EmitFromEvents::OnScalar(const Mark&, const std::string& tag,
+                              anchor_t anchor, const std::string& value) {
+  BeginNode();
+  EmitProps(tag, anchor);
+  m_emitter << value;
+}
+
+void EmitFromEvents::OnSequenceStart(const Mark&, const std::string& tag,
+                                     anchor_t anchor,
+                                     EmitterStyle::value style) {
+  BeginNode();
+  EmitProps(tag, anchor);
+  switch (style) {
+    case EmitterStyle::Block:
+      m_emitter << Block;
+      break;
+    case EmitterStyle::Flow:
+      m_emitter << Flow;
+      break;
+    default:
+      break;
+  }
+  m_emitter << BeginSeq;
+  m_stateStack.push(State::WaitingForSequenceEntry);
+}
+
+void EmitFromEvents::OnSequenceEnd() {
+  m_emitter << EndSeq;
+  assert(m_stateStack.top() == State::WaitingForSequenceEntry);
+  m_stateStack.pop();
+}
+
+void EmitFromEvents::OnMapStart(const Mark&, const std::string& tag,
+                                anchor_t anchor, EmitterStyle::value style) {
+  BeginNode();
+  EmitProps(tag, anchor);
+  switch (style) {
+    case EmitterStyle::Block:
+      m_emitter << Block;
+      break;
+    case EmitterStyle::Flow:
+      m_emitter << Flow;
+      break;
+    default:
+      break;
+  }
+  m_emitter << BeginMap;
+  m_stateStack.push(State::WaitingForKey);
+}
+
+void EmitFromEvents::OnMapEnd() {
+  m_emitter << EndMap;
+  assert(m_stateStack.top() == State::WaitingForKey);
+  m_stateStack.pop();
+}
+
+void EmitFromEvents::BeginNode() {
+  if (m_stateStack.empty())
+    return;
+
+  switch (m_stateStack.top()) {
+    case State::WaitingForKey:
+      m_emitter << Key;
+      m_stateStack.top() = State::WaitingForValue;
+      break;
+    case State::WaitingForValue:
+      m_emitter << Value;
+      m_stateStack.top() = State::WaitingForKey;
+      break;
+    default:
+      break;
+  }
+}
+
+void EmitFromEvents::EmitProps(const std::string& tag, anchor_t anchor) {
   if (!tag.empty() && tag != "?" && tag != "!")
-    m_emitter << VerbatimTag(tag); 
-  if (anchor) 
-    m_emitter << Anchor(ToString(anchor)); 
-} 
-} 
+    m_emitter << VerbatimTag(tag);
+  if (anchor)
+    m_emitter << Anchor(ToString(anchor));
+}
+}
diff --git a/contrib/libs/yaml-cpp/src/emitter.cpp b/contrib/libs/yaml-cpp/src/emitter.cpp
index 76ab6194d5d..ebeb059554e 100644
--- a/contrib/libs/yaml-cpp/src/emitter.cpp
+++ b/contrib/libs/yaml-cpp/src/emitter.cpp
@@ -1,911 +1,911 @@
-#include <sstream> 
- 
-#include "emitterutils.h" 
-#include "indentation.h"  // IWYU pragma: keep 
-#include "yaml-cpp/emitter.h" 
-#include "yaml-cpp/emitterdef.h" 
-#include "yaml-cpp/emittermanip.h" 
-#include "yaml-cpp/exceptions.h"  // IWYU pragma: keep 
- 
-namespace YAML { 
-class Binary; 
-struct _Null; 
- 
-Emitter::Emitter() : m_pState(new EmitterState) {} 
- 
-Emitter::Emitter(std::ostream& stream) 
-    : m_pState(new EmitterState), m_stream(stream) {} 
- 
-Emitter::~Emitter() {} 
- 
-const char* Emitter::c_str() const { return m_stream.str(); } 
- 
-std::size_t Emitter::size() const { return m_stream.pos(); } 
- 
-// state checking 
-bool Emitter::good() const { return m_pState->good(); } 
- 
-const std::string Emitter::GetLastError() const { 
-  return m_pState->GetLastError(); 
-} 
- 
-// global setters 
-bool Emitter::SetOutputCharset(EMITTER_MANIP value) { 
-  return m_pState->SetOutputCharset(value, FmtScope::Global); 
-} 
- 
-bool Emitter::SetStringFormat(EMITTER_MANIP value) { 
-  return m_pState->SetStringFormat(value, FmtScope::Global); 
-} 
- 
-bool Emitter::SetBoolFormat(EMITTER_MANIP value) { 
-  bool ok = false; 
-  if (m_pState->SetBoolFormat(value, FmtScope::Global)) 
-    ok = true; 
-  if (m_pState->SetBoolCaseFormat(value, FmtScope::Global)) 
-    ok = true; 
-  if (m_pState->SetBoolLengthFormat(value, FmtScope::Global)) 
-    ok = true; 
-  return ok; 
-} 
- 
-bool Emitter::SetIntBase(EMITTER_MANIP value) { 
-  return m_pState->SetIntFormat(value, FmtScope::Global); 
-} 
- 
-bool Emitter::SetSeqFormat(EMITTER_MANIP value) { 
-  return m_pState->SetFlowType(GroupType::Seq, value, FmtScope::Global); 
-} 
- 
-bool Emitter::SetMapFormat(EMITTER_MANIP value) { 
-  bool ok = false; 
-  if (m_pState->SetFlowType(GroupType::Map, value, FmtScope::Global)) 
-    ok = true; 
-  if (m_pState->SetMapKeyFormat(value, FmtScope::Global)) 
-    ok = true; 
-  return ok; 
-} 
- 
-bool Emitter::SetIndent(std::size_t n) { 
-  return m_pState->SetIndent(n, FmtScope::Global); 
-} 
- 
-bool Emitter::SetPreCommentIndent(std::size_t n) { 
-  return m_pState->SetPreCommentIndent(n, FmtScope::Global); 
-} 
- 
-bool Emitter::SetPostCommentIndent(std::size_t n) { 
-  return m_pState->SetPostCommentIndent(n, FmtScope::Global); 
-} 
- 
-bool Emitter::SetFloatPrecision(std::size_t n) { 
-  return m_pState->SetFloatPrecision(n, FmtScope::Global); 
-} 
- 
-bool Emitter::SetDoublePrecision(std::size_t n) { 
-  return m_pState->SetDoublePrecision(n, FmtScope::Global); 
-} 
- 
-// SetLocalValue 
-// . Either start/end a group, or set a modifier locally 
-Emitter& Emitter::SetLocalValue(EMITTER_MANIP value) { 
-  if (!good()) 
-    return *this; 
- 
-  switch (value) { 
-    case BeginDoc: 
-      EmitBeginDoc(); 
-      break; 
-    case EndDoc: 
-      EmitEndDoc(); 
-      break; 
-    case BeginSeq: 
-      EmitBeginSeq(); 
-      break; 
-    case EndSeq: 
-      EmitEndSeq(); 
-      break; 
-    case BeginMap: 
-      EmitBeginMap(); 
-      break; 
-    case EndMap: 
-      EmitEndMap(); 
-      break; 
-    case Key: 
-    case Value: 
-      // deprecated (these can be deduced by the parity of nodes in a map) 
-      break; 
-    case TagByKind: 
-      EmitKindTag(); 
-      break; 
-    case Newline: 
-      EmitNewline(); 
-      break; 
-    default: 
-      m_pState->SetLocalValue(value); 
-      break; 
-  } 
-  return *this; 
-} 
- 
-Emitter& Emitter::SetLocalIndent(const _Indent& indent) { 
-  m_pState->SetIndent(indent.value, FmtScope::Local); 
-  return *this; 
-} 
- 
-Emitter& Emitter::SetLocalPrecision(const _Precision& precision) { 
-  if (precision.floatPrecision >= 0) 
-    m_pState->SetFloatPrecision(precision.floatPrecision, FmtScope::Local); 
-  if (precision.doublePrecision >= 0) 
-    m_pState->SetDoublePrecision(precision.doublePrecision, FmtScope::Local); 
-  return *this; 
-} 
- 
-// EmitBeginDoc 
-void Emitter::EmitBeginDoc() { 
-  if (!good()) 
-    return; 
- 
-  if (m_pState->CurGroupType() != GroupType::NoType) { 
-    m_pState->SetError("Unexpected begin document"); 
-    return; 
-  } 
- 
-  if (m_pState->HasAnchor() || m_pState->HasTag()) { 
-    m_pState->SetError("Unexpected begin document"); 
-    return; 
-  } 
- 
-  if (m_stream.col() > 0) 
-    m_stream << "\n"; 
-  m_stream << "---\n"; 
- 
-  m_pState->StartedDoc(); 
-} 
- 
-// EmitEndDoc 
-void Emitter::EmitEndDoc() { 
-  if (!good()) 
-    return; 
- 
-  if (m_pState->CurGroupType() != GroupType::NoType) { 
-    m_pState->SetError("Unexpected begin document"); 
-    return; 
-  } 
- 
-  if (m_pState->HasAnchor() || m_pState->HasTag()) { 
-    m_pState->SetError("Unexpected begin document"); 
-    return; 
-  } 
- 
-  if (m_stream.col() > 0) 
-    m_stream << "\n"; 
-  m_stream << "...\n"; 
-} 
- 
-// EmitBeginSeq 
-void Emitter::EmitBeginSeq() { 
-  if (!good()) 
-    return; 
- 
-  PrepareNode(m_pState->NextGroupType(GroupType::Seq)); 
- 
-  m_pState->StartedGroup(GroupType::Seq); 
-} 
- 
-// EmitEndSeq 
-void Emitter::EmitEndSeq() { 
-  if (!good()) 
-    return; 
- 
-  if (m_pState->CurGroupChildCount() == 0) 
-    m_pState->ForceFlow(); 
- 
-  if (m_pState->CurGroupFlowType() == FlowType::Flow) { 
-    if (m_stream.comment()) 
-      m_stream << "\n"; 
-    m_stream << IndentTo(m_pState->CurIndent()); 
-    if (m_pState->CurGroupChildCount() == 0) 
-      m_stream << "["; 
-    m_stream << "]"; 
-  } 
- 
-  m_pState->EndedGroup(GroupType::Seq); 
-} 
- 
-// EmitBeginMap 
-void Emitter::EmitBeginMap() { 
-  if (!good()) 
-    return; 
- 
-  PrepareNode(m_pState->NextGroupType(GroupType::Map)); 
- 
-  m_pState->StartedGroup(GroupType::Map); 
-} 
- 
-// EmitEndMap 
-void Emitter::EmitEndMap() { 
-  if (!good()) 
-    return; 
- 
-  if (m_pState->CurGroupChildCount() == 0) 
-    m_pState->ForceFlow(); 
- 
-  if (m_pState->CurGroupFlowType() == FlowType::Flow) { 
-    if (m_stream.comment()) 
-      m_stream << "\n"; 
-    m_stream << IndentTo(m_pState->CurIndent()); 
-    if (m_pState->CurGroupChildCount() == 0) 
-      m_stream << "{"; 
-    m_stream << "}"; 
-  } 
- 
-  m_pState->EndedGroup(GroupType::Map); 
-} 
- 
-// EmitNewline 
-void Emitter::EmitNewline() { 
-  if (!good()) 
-    return; 
- 
-  PrepareNode(EmitterNodeType::NoType); 
-  m_stream << "\n"; 
-  m_pState->SetNonContent(); 
-} 
- 
-bool Emitter::CanEmitNewline() const { return true; } 
- 
-// Put the stream in a state so we can simply write the next node 
-// E.g., if we're in a sequence, write the "- " 
-void Emitter::PrepareNode(EmitterNodeType::value child) { 
-  switch (m_pState->CurGroupNodeType()) { 
-    case EmitterNodeType::NoType: 
-      PrepareTopNode(child); 
-      break; 
-    case EmitterNodeType::FlowSeq: 
-      FlowSeqPrepareNode(child); 
-      break; 
-    case EmitterNodeType::BlockSeq: 
-      BlockSeqPrepareNode(child); 
-      break; 
-    case EmitterNodeType::FlowMap: 
-      FlowMapPrepareNode(child); 
-      break; 
-    case EmitterNodeType::BlockMap: 
-      BlockMapPrepareNode(child); 
-      break; 
-    case EmitterNodeType::Property: 
-    case EmitterNodeType::Scalar: 
-      assert(false); 
-      break; 
-  } 
-} 
- 
-void Emitter::PrepareTopNode(EmitterNodeType::value child) { 
-  if (child == EmitterNodeType::NoType) 
-    return; 
- 
-  if (m_pState->CurGroupChildCount() > 0 && m_stream.col() > 0) { 
-    if (child != EmitterNodeType::NoType) 
-      EmitBeginDoc(); 
-  } 
- 
-  switch (child) { 
-    case EmitterNodeType::NoType: 
-      break; 
-    case EmitterNodeType::Property: 
-    case EmitterNodeType::Scalar: 
-    case EmitterNodeType::FlowSeq: 
-    case EmitterNodeType::FlowMap: 
-      // TODO: if we were writing null, and 
-      // we wanted it blank, we wouldn't want a space 
-      SpaceOrIndentTo(m_pState->HasBegunContent(), 0); 
-      break; 
-    case EmitterNodeType::BlockSeq: 
-    case EmitterNodeType::BlockMap: 
-      if (m_pState->HasBegunNode()) 
-        m_stream << "\n"; 
-      break; 
-  } 
-} 
- 
-void Emitter::FlowSeqPrepareNode(EmitterNodeType::value child) { 
-  const std::size_t lastIndent = m_pState->LastIndent(); 
- 
-  if (!m_pState->HasBegunNode()) { 
-    if (m_stream.comment()) 
-      m_stream << "\n"; 
-    m_stream << IndentTo(lastIndent); 
-    if (m_pState->CurGroupChildCount() == 0) 
-      m_stream << "["; 
-    else 
-      m_stream << ","; 
-  } 
- 
-  switch (child) { 
-    case EmitterNodeType::NoType: 
-      break; 
-    case EmitterNodeType::Property: 
-    case EmitterNodeType::Scalar: 
-    case EmitterNodeType::FlowSeq: 
-    case EmitterNodeType::FlowMap: 
-      SpaceOrIndentTo( 
-          m_pState->HasBegunContent() || m_pState->CurGroupChildCount() > 0, 
-          lastIndent); 
-      break; 
-    case EmitterNodeType::BlockSeq: 
-    case EmitterNodeType::BlockMap: 
-      assert(false); 
-      break; 
-  } 
-} 
- 
-void Emitter::BlockSeqPrepareNode(EmitterNodeType::value child) { 
-  const std::size_t curIndent = m_pState->CurIndent(); 
-  const std::size_t nextIndent = curIndent + m_pState->CurGroupIndent(); 
- 
-  if (child == EmitterNodeType::NoType) 
-    return; 
- 
-  if (!m_pState->HasBegunContent()) { 
-    if (m_pState->CurGroupChildCount() > 0 || m_stream.comment()) { 
-      m_stream << "\n"; 
-    } 
-    m_stream << IndentTo(curIndent); 
-    m_stream << "-"; 
-  } 
- 
-  switch (child) { 
-    case EmitterNodeType::NoType: 
-      break; 
-    case EmitterNodeType::Property: 
-    case EmitterNodeType::Scalar: 
-    case EmitterNodeType::FlowSeq: 
-    case EmitterNodeType::FlowMap: 
-      SpaceOrIndentTo(m_pState->HasBegunContent(), nextIndent); 
-      break; 
-    case EmitterNodeType::BlockSeq: 
-      m_stream << "\n"; 
-      break; 
-    case EmitterNodeType::BlockMap: 
-      if (m_pState->HasBegunContent() || m_stream.comment()) 
-        m_stream << "\n"; 
-      break; 
-  } 
-} 
- 
-void Emitter::FlowMapPrepareNode(EmitterNodeType::value child) { 
-  if (m_pState->CurGroupChildCount() % 2 == 0) { 
-    if (m_pState->GetMapKeyFormat() == LongKey) 
-      m_pState->SetLongKey(); 
- 
-    if (m_pState->CurGroupLongKey()) 
-      FlowMapPrepareLongKey(child); 
-    else 
-      FlowMapPrepareSimpleKey(child); 
-  } else { 
-    if (m_pState->CurGroupLongKey()) 
-      FlowMapPrepareLongKeyValue(child); 
-    else 
-      FlowMapPrepareSimpleKeyValue(child); 
-  } 
-} 
- 
-void Emitter::FlowMapPrepareLongKey(EmitterNodeType::value child) { 
-  const std::size_t lastIndent = m_pState->LastIndent(); 
- 
-  if (!m_pState->HasBegunNode()) { 
-    if (m_stream.comment()) 
-      m_stream << "\n"; 
-    m_stream << IndentTo(lastIndent); 
-    if (m_pState->CurGroupChildCount() == 0) 
-      m_stream << "{ ?"; 
-    else 
-      m_stream << ", ?"; 
-  } 
- 
-  switch (child) { 
-    case EmitterNodeType::NoType: 
-      break; 
-    case EmitterNodeType::Property: 
-    case EmitterNodeType::Scalar: 
-    case EmitterNodeType::FlowSeq: 
-    case EmitterNodeType::FlowMap: 
-      SpaceOrIndentTo( 
-          m_pState->HasBegunContent() || m_pState->CurGroupChildCount() > 0, 
-          lastIndent); 
-      break; 
-    case EmitterNodeType::BlockSeq: 
-    case EmitterNodeType::BlockMap: 
-      assert(false); 
-      break; 
-  } 
-} 
- 
-void Emitter::FlowMapPrepareLongKeyValue(EmitterNodeType::value child) { 
-  const std::size_t lastIndent = m_pState->LastIndent(); 
- 
-  if (!m_pState->HasBegunNode()) { 
-    if (m_stream.comment()) 
-      m_stream << "\n"; 
-    m_stream << IndentTo(lastIndent); 
-    m_stream << ":"; 
-  } 
- 
-  switch (child) { 
-    case EmitterNodeType::NoType: 
-      break; 
-    case EmitterNodeType::Property: 
-    case EmitterNodeType::Scalar: 
-    case EmitterNodeType::FlowSeq: 
-    case EmitterNodeType::FlowMap: 
-      SpaceOrIndentTo( 
-          m_pState->HasBegunContent() || m_pState->CurGroupChildCount() > 0, 
-          lastIndent); 
-      break; 
-    case EmitterNodeType::BlockSeq: 
-    case EmitterNodeType::BlockMap: 
-      assert(false); 
-      break; 
-  } 
-} 
- 
-void Emitter::FlowMapPrepareSimpleKey(EmitterNodeType::value child) { 
-  const std::size_t lastIndent = m_pState->LastIndent(); 
- 
-  if (!m_pState->HasBegunNode()) { 
-    if (m_stream.comment()) 
-      m_stream << "\n"; 
-    m_stream << IndentTo(lastIndent); 
-    if (m_pState->CurGroupChildCount() == 0) 
-      m_stream << "{"; 
-    else 
-      m_stream << ","; 
-  } 
- 
-  switch (child) { 
-    case EmitterNodeType::NoType: 
-      break; 
-    case EmitterNodeType::Property: 
-    case EmitterNodeType::Scalar: 
-    case EmitterNodeType::FlowSeq: 
-    case EmitterNodeType::FlowMap: 
-      SpaceOrIndentTo( 
-          m_pState->HasBegunContent() || m_pState->CurGroupChildCount() > 0, 
-          lastIndent); 
-      break; 
-    case EmitterNodeType::BlockSeq: 
-    case EmitterNodeType::BlockMap: 
-      assert(false); 
-      break; 
-  } 
-} 
- 
-void Emitter::FlowMapPrepareSimpleKeyValue(EmitterNodeType::value child) { 
-  const std::size_t lastIndent = m_pState->LastIndent(); 
- 
-  if (!m_pState->HasBegunNode()) { 
-    if (m_stream.comment()) 
-      m_stream << "\n"; 
-    m_stream << IndentTo(lastIndent); 
-    m_stream << ":"; 
-  } 
- 
-  switch (child) { 
-    case EmitterNodeType::NoType: 
-      break; 
-    case EmitterNodeType::Property: 
-    case EmitterNodeType::Scalar: 
-    case EmitterNodeType::FlowSeq: 
-    case EmitterNodeType::FlowMap: 
-      SpaceOrIndentTo( 
-          m_pState->HasBegunContent() || m_pState->CurGroupChildCount() > 0, 
-          lastIndent); 
-      break; 
-    case EmitterNodeType::BlockSeq: 
-    case EmitterNodeType::BlockMap: 
-      assert(false); 
-      break; 
-  } 
-} 
- 
-void Emitter::BlockMapPrepareNode(EmitterNodeType::value child) { 
-  if (m_pState->CurGroupChildCount() % 2 == 0) { 
-    if (m_pState->GetMapKeyFormat() == LongKey) 
-      m_pState->SetLongKey(); 
-    if (child == EmitterNodeType::BlockSeq || 
-        child == EmitterNodeType::BlockMap) 
-      m_pState->SetLongKey(); 
- 
-    if (m_pState->CurGroupLongKey()) 
-      BlockMapPrepareLongKey(child); 
-    else 
-      BlockMapPrepareSimpleKey(child); 
-  } else { 
-    if (m_pState->CurGroupLongKey()) 
-      BlockMapPrepareLongKeyValue(child); 
-    else 
-      BlockMapPrepareSimpleKeyValue(child); 
-  } 
-} 
- 
-void Emitter::BlockMapPrepareLongKey(EmitterNodeType::value child) { 
-  const std::size_t curIndent = m_pState->CurIndent(); 
-  const std::size_t childCount = m_pState->CurGroupChildCount(); 
- 
-  if (child == EmitterNodeType::NoType) 
-    return; 
- 
-  if (!m_pState->HasBegunContent()) { 
-    if (childCount > 0) { 
-      m_stream << "\n"; 
-    } 
-    if (m_stream.comment()) { 
-      m_stream << "\n"; 
-    } 
-    m_stream << IndentTo(curIndent); 
-    m_stream << "?"; 
-  } 
- 
-  switch (child) { 
-    case EmitterNodeType::NoType: 
-      break; 
-    case EmitterNodeType::Property: 
-    case EmitterNodeType::Scalar: 
-    case EmitterNodeType::FlowSeq: 
-    case EmitterNodeType::FlowMap: 
-      SpaceOrIndentTo(true, curIndent + 1); 
-      break; 
-    case EmitterNodeType::BlockSeq: 
-    case EmitterNodeType::BlockMap: 
-      break; 
-  } 
-} 
- 
-void Emitter::BlockMapPrepareLongKeyValue(EmitterNodeType::value child) { 
-  const std::size_t curIndent = m_pState->CurIndent(); 
- 
-  if (child == EmitterNodeType::NoType) 
-    return; 
- 
-  if (!m_pState->HasBegunContent()) { 
-    m_stream << "\n"; 
-    m_stream << IndentTo(curIndent); 
-    m_stream << ":"; 
-  } 
- 
-  switch (child) { 
-    case EmitterNodeType::NoType: 
-      break; 
-    case EmitterNodeType::Property: 
-    case EmitterNodeType::Scalar: 
-    case EmitterNodeType::FlowSeq: 
-    case EmitterNodeType::FlowMap: 
-    case EmitterNodeType::BlockSeq: 
-    case EmitterNodeType::BlockMap: 
-      SpaceOrIndentTo(true, curIndent + 1); 
-      break; 
-  } 
-} 
- 
-void Emitter::BlockMapPrepareSimpleKey(EmitterNodeType::value child) { 
-  const std::size_t curIndent = m_pState->CurIndent(); 
-  const std::size_t childCount = m_pState->CurGroupChildCount(); 
- 
-  if (child == EmitterNodeType::NoType) 
-    return; 
- 
-  if (!m_pState->HasBegunNode()) { 
-    if (childCount > 0) { 
-      m_stream << "\n"; 
-    } 
-  } 
- 
-  switch (child) { 
-    case EmitterNodeType::NoType: 
-      break; 
-    case EmitterNodeType::Property: 
-    case EmitterNodeType::Scalar: 
-    case EmitterNodeType::FlowSeq: 
-    case EmitterNodeType::FlowMap: 
-      SpaceOrIndentTo(m_pState->HasBegunContent(), curIndent); 
-      break; 
-    case EmitterNodeType::BlockSeq: 
-    case EmitterNodeType::BlockMap: 
-      break; 
-  } 
-} 
- 
-void Emitter::BlockMapPrepareSimpleKeyValue(EmitterNodeType::value child) { 
-  const std::size_t curIndent = m_pState->CurIndent(); 
-  const std::size_t nextIndent = curIndent + m_pState->CurGroupIndent(); 
- 
-  if (!m_pState->HasBegunNode()) { 
-    m_stream << ":"; 
-  } 
- 
-  switch (child) { 
-    case EmitterNodeType::NoType: 
-      break; 
-    case EmitterNodeType::Property: 
-    case EmitterNodeType::Scalar: 
-    case EmitterNodeType::FlowSeq: 
-    case EmitterNodeType::FlowMap: 
-      SpaceOrIndentTo(true, nextIndent); 
-      break; 
-    case EmitterNodeType::BlockSeq: 
-    case EmitterNodeType::BlockMap: 
-      m_stream << "\n"; 
-      break; 
-  } 
-} 
- 
-// SpaceOrIndentTo 
-// . Prepares for some more content by proper spacing 
-void Emitter::SpaceOrIndentTo(bool requireSpace, std::size_t indent) { 
-  if (m_stream.comment()) 
-    m_stream << "\n"; 
-  if (m_stream.col() > 0 && requireSpace) 
-    m_stream << " "; 
-  m_stream << IndentTo(indent); 
-} 
- 
-void Emitter::PrepareIntegralStream(std::stringstream& stream) const { 
- 
-  switch (m_pState->GetIntFormat()) { 
-    case Dec: 
-      stream << std::dec; 
-      break; 
-    case Hex: 
-      stream << "0x"; 
-      stream << std::hex; 
-      break; 
-    case Oct: 
-      stream << "0"; 
-      stream << std::oct; 
-      break; 
-    default: 
-      assert(false); 
-  } 
-} 
- 
-void Emitter::StartedScalar() { m_pState->StartedScalar(); } 
- 
-// ******************************************************************************************* 
-// overloads of Write 
- 
-Emitter& Emitter::Write(const std::string& str) { 
-  if (!good()) 
-    return *this; 
- 
-  const bool escapeNonAscii = m_pState->GetOutputCharset() == EscapeNonAscii; 
-  const StringFormat::value strFormat = 
-      Utils::ComputeStringFormat(str, m_pState->GetStringFormat(), 
-                                 m_pState->CurGroupFlowType(), escapeNonAscii); 
- 
-  if (strFormat == StringFormat::Literal) 
-    m_pState->SetMapKeyFormat(YAML::LongKey, FmtScope::Local); 
- 
-  PrepareNode(EmitterNodeType::Scalar); 
- 
-  switch (strFormat) { 
-    case StringFormat::Plain: 
-      m_stream << str; 
-      break; 
-    case StringFormat::SingleQuoted: 
-      Utils::WriteSingleQuotedString(m_stream, str); 
-      break; 
-    case StringFormat::DoubleQuoted: 
-      Utils::WriteDoubleQuotedString(m_stream, str, escapeNonAscii); 
-      break; 
-    case StringFormat::Literal: 
-      Utils::WriteLiteralString(m_stream, str, 
-                                m_pState->CurIndent() + m_pState->GetIndent()); 
-      break; 
-  } 
- 
-  StartedScalar(); 
- 
-  return *this; 
-} 
- 
-std::size_t Emitter::GetFloatPrecision() const { 
-  return m_pState->GetFloatPrecision(); 
-} 
- 
-std::size_t Emitter::GetDoublePrecision() const { 
-  return m_pState->GetDoublePrecision(); 
-} 
- 
-const char* Emitter::ComputeFullBoolName(bool b) const { 
-  const EMITTER_MANIP mainFmt = (m_pState->GetBoolLengthFormat() == ShortBool 
-                                     ? YesNoBool 
-                                     : m_pState->GetBoolFormat()); 
-  const EMITTER_MANIP caseFmt = m_pState->GetBoolCaseFormat(); 
-  switch (mainFmt) { 
-    case YesNoBool: 
-      switch (caseFmt) { 
-        case UpperCase: 
-          return b ? "YES" : "NO"; 
-        case CamelCase: 
-          return b ? "Yes" : "No"; 
-        case LowerCase: 
-          return b ? "yes" : "no"; 
-        default: 
-          break; 
-      } 
-      break; 
-    case OnOffBool: 
-      switch (caseFmt) { 
-        case UpperCase: 
-          return b ? "ON" : "OFF"; 
-        case CamelCase: 
-          return b ? "On" : "Off"; 
-        case LowerCase: 
-          return b ? "on" : "off"; 
-        default: 
-          break; 
-      } 
-      break; 
-    case TrueFalseBool: 
-      switch (caseFmt) { 
-        case UpperCase: 
-          return b ? "TRUE" : "FALSE"; 
-        case CamelCase: 
-          return b ? "True" : "False"; 
-        case LowerCase: 
-          return b ? "true" : "false"; 
-        default: 
-          break; 
-      } 
-      break; 
-    default: 
-      break; 
-  } 
-  return b ? "y" : "n";  // should never get here, but it can't hurt to give 
-                         // these answers 
-} 
- 
-Emitter& Emitter::Write(bool b) { 
-  if (!good()) 
-    return *this; 
- 
-  PrepareNode(EmitterNodeType::Scalar); 
- 
-  const char* name = ComputeFullBoolName(b); 
-  if (m_pState->GetBoolLengthFormat() == ShortBool) 
-    m_stream << name[0]; 
-  else 
-    m_stream << name; 
- 
-  StartedScalar(); 
- 
-  return *this; 
-} 
- 
-Emitter& Emitter::Write(char ch) { 
-  if (!good()) 
-    return *this; 
- 
-  PrepareNode(EmitterNodeType::Scalar); 
-  Utils::WriteChar(m_stream, ch); 
-  StartedScalar(); 
- 
-  return *this; 
-} 
- 
-Emitter& Emitter::Write(const _Alias& alias) { 
-  if (!good()) 
-    return *this; 
- 
-  if (m_pState->HasAnchor() || m_pState->HasTag()) { 
-    m_pState->SetError(ErrorMsg::INVALID_ALIAS); 
-    return *this; 
-  } 
- 
-  PrepareNode(EmitterNodeType::Scalar); 
- 
-  if (!Utils::WriteAlias(m_stream, alias.content)) { 
-    m_pState->SetError(ErrorMsg::INVALID_ALIAS); 
-    return *this; 
-  } 
- 
-  StartedScalar(); 
- 
-  return *this; 
-} 
- 
-Emitter& Emitter::Write(const _Anchor& anchor) { 
-  if (!good()) 
-    return *this; 
- 
-  if (m_pState->HasAnchor()) { 
-    m_pState->SetError(ErrorMsg::INVALID_ANCHOR); 
-    return *this; 
-  } 
- 
-  PrepareNode(EmitterNodeType::Property); 
- 
-  if (!Utils::WriteAnchor(m_stream, anchor.content)) { 
-    m_pState->SetError(ErrorMsg::INVALID_ANCHOR); 
-    return *this; 
-  } 
- 
-  m_pState->SetAnchor(); 
- 
-  return *this; 
-} 
- 
-Emitter& Emitter::Write(const _Tag& tag) { 
-  if (!good()) 
-    return *this; 
- 
-  if (m_pState->HasTag()) { 
-    m_pState->SetError(ErrorMsg::INVALID_TAG); 
-    return *this; 
-  } 
- 
-  PrepareNode(EmitterNodeType::Property); 
- 
-  bool success = false; 
-  if (tag.type == _Tag::Type::Verbatim) 
-    success = Utils::WriteTag(m_stream, tag.content, true); 
-  else if (tag.type == _Tag::Type::PrimaryHandle) 
-    success = Utils::WriteTag(m_stream, tag.content, false); 
-  else 
-    success = Utils::WriteTagWithPrefix(m_stream, tag.prefix, tag.content); 
- 
-  if (!success) { 
-    m_pState->SetError(ErrorMsg::INVALID_TAG); 
-    return *this; 
-  } 
- 
-  m_pState->SetTag(); 
- 
-  return *this; 
-} 
- 
-void Emitter::EmitKindTag() { Write(LocalTag("")); } 
- 
-Emitter& Emitter::Write(const _Comment& comment) { 
-  if (!good()) 
-    return *this; 
- 
-  PrepareNode(EmitterNodeType::NoType); 
- 
-  if (m_stream.col() > 0) 
-    m_stream << Indentation(m_pState->GetPreCommentIndent()); 
-  Utils::WriteComment(m_stream, comment.content, 
-                      m_pState->GetPostCommentIndent()); 
- 
-  m_pState->SetNonContent(); 
- 
-  return *this; 
-} 
- 
-Emitter& Emitter::Write(const _Null& /*null*/) { 
-  if (!good()) 
-    return *this; 
- 
-  PrepareNode(EmitterNodeType::Scalar); 
- 
-  m_stream << "~"; 
- 
-  StartedScalar(); 
- 
-  return *this; 
-} 
- 
-Emitter& Emitter::Write(const Binary& binary) { 
-  Write(SecondaryTag("binary")); 
- 
-  if (!good()) 
-    return *this; 
- 
-  PrepareNode(EmitterNodeType::Scalar); 
-  Utils::WriteBinary(m_stream, binary); 
-  StartedScalar(); 
- 
-  return *this; 
-} 
-} 
+#include <sstream>
+
+#include "emitterutils.h"
+#include "indentation.h"  // IWYU pragma: keep
+#include "yaml-cpp/emitter.h"
+#include "yaml-cpp/emitterdef.h"
+#include "yaml-cpp/emittermanip.h"
+#include "yaml-cpp/exceptions.h"  // IWYU pragma: keep
+
+namespace YAML {
+class Binary;
+struct _Null;
+
+Emitter::Emitter() : m_pState(new EmitterState) {}
+
+Emitter::Emitter(std::ostream& stream)
+    : m_pState(new EmitterState), m_stream(stream) {}
+
+Emitter::~Emitter() {}
+
+const char* Emitter::c_str() const { return m_stream.str(); }
+
+std::size_t Emitter::size() const { return m_stream.pos(); }
+
+// state checking
+bool Emitter::good() const { return m_pState->good(); }
+
+const std::string Emitter::GetLastError() const {
+  return m_pState->GetLastError();
+}
+
+// global setters
+bool Emitter::SetOutputCharset(EMITTER_MANIP value) {
+  return m_pState->SetOutputCharset(value, FmtScope::Global);
+}
+
+bool Emitter::SetStringFormat(EMITTER_MANIP value) {
+  return m_pState->SetStringFormat(value, FmtScope::Global);
+}
+
+bool Emitter::SetBoolFormat(EMITTER_MANIP value) {
+  bool ok = false;
+  if (m_pState->SetBoolFormat(value, FmtScope::Global))
+    ok = true;
+  if (m_pState->SetBoolCaseFormat(value, FmtScope::Global))
+    ok = true;
+  if (m_pState->SetBoolLengthFormat(value, FmtScope::Global))
+    ok = true;
+  return ok;
+}
+
+bool Emitter::SetIntBase(EMITTER_MANIP value) {
+  return m_pState->SetIntFormat(value, FmtScope::Global);
+}
+
+bool Emitter::SetSeqFormat(EMITTER_MANIP value) {
+  return m_pState->SetFlowType(GroupType::Seq, value, FmtScope::Global);
+}
+
+bool Emitter::SetMapFormat(EMITTER_MANIP value) {
+  bool ok = false;
+  if (m_pState->SetFlowType(GroupType::Map, value, FmtScope::Global))
+    ok = true;
+  if (m_pState->SetMapKeyFormat(value, FmtScope::Global))
+    ok = true;
+  return ok;
+}
+
+bool Emitter::SetIndent(std::size_t n) {
+  return m_pState->SetIndent(n, FmtScope::Global);
+}
+
+bool Emitter::SetPreCommentIndent(std::size_t n) {
+  return m_pState->SetPreCommentIndent(n, FmtScope::Global);
+}
+
+bool Emitter::SetPostCommentIndent(std::size_t n) {
+  return m_pState->SetPostCommentIndent(n, FmtScope::Global);
+}
+
+bool Emitter::SetFloatPrecision(std::size_t n) {
+  return m_pState->SetFloatPrecision(n, FmtScope::Global);
+}
+
+bool Emitter::SetDoublePrecision(std::size_t n) {
+  return m_pState->SetDoublePrecision(n, FmtScope::Global);
+}
+
+// SetLocalValue
+// . Either start/end a group, or set a modifier locally
+Emitter& Emitter::SetLocalValue(EMITTER_MANIP value) {
+  if (!good())
+    return *this;
+
+  switch (value) {
+    case BeginDoc:
+      EmitBeginDoc();
+      break;
+    case EndDoc:
+      EmitEndDoc();
+      break;
+    case BeginSeq:
+      EmitBeginSeq();
+      break;
+    case EndSeq:
+      EmitEndSeq();
+      break;
+    case BeginMap:
+      EmitBeginMap();
+      break;
+    case EndMap:
+      EmitEndMap();
+      break;
+    case Key:
+    case Value:
+      // deprecated (these can be deduced by the parity of nodes in a map)
+      break;
+    case TagByKind:
+      EmitKindTag();
+      break;
+    case Newline:
+      EmitNewline();
+      break;
+    default:
+      m_pState->SetLocalValue(value);
+      break;
+  }
+  return *this;
+}
+
+Emitter& Emitter::SetLocalIndent(const _Indent& indent) {
+  m_pState->SetIndent(indent.value, FmtScope::Local);
+  return *this;
+}
+
+Emitter& Emitter::SetLocalPrecision(const _Precision& precision) {
+  if (precision.floatPrecision >= 0)
+    m_pState->SetFloatPrecision(precision.floatPrecision, FmtScope::Local);
+  if (precision.doublePrecision >= 0)
+    m_pState->SetDoublePrecision(precision.doublePrecision, FmtScope::Local);
+  return *this;
+}
+
+// EmitBeginDoc
+void Emitter::EmitBeginDoc() {
+  if (!good())
+    return;
+
+  if (m_pState->CurGroupType() != GroupType::NoType) {
+    m_pState->SetError("Unexpected begin document");
+    return;
+  }
+
+  if (m_pState->HasAnchor() || m_pState->HasTag()) {
+    m_pState->SetError("Unexpected begin document");
+    return;
+  }
+
+  if (m_stream.col() > 0)
+    m_stream << "\n";
+  m_stream << "---\n";
+
+  m_pState->StartedDoc();
+}
+
+// EmitEndDoc
+void Emitter::EmitEndDoc() {
+  if (!good())
+    return;
+
+  if (m_pState->CurGroupType() != GroupType::NoType) {
+    m_pState->SetError("Unexpected begin document");
+    return;
+  }
+
+  if (m_pState->HasAnchor() || m_pState->HasTag()) {
+    m_pState->SetError("Unexpected begin document");
+    return;
+  }
+
+  if (m_stream.col() > 0)
+    m_stream << "\n";
+  m_stream << "...\n";
+}
+
+// EmitBeginSeq
+void Emitter::EmitBeginSeq() {
+  if (!good())
+    return;
+
+  PrepareNode(m_pState->NextGroupType(GroupType::Seq));
+
+  m_pState->StartedGroup(GroupType::Seq);
+}
+
+// EmitEndSeq
+void Emitter::EmitEndSeq() {
+  if (!good())
+    return;
+
+  if (m_pState->CurGroupChildCount() == 0)
+    m_pState->ForceFlow();
+
+  if (m_pState->CurGroupFlowType() == FlowType::Flow) {
+    if (m_stream.comment())
+      m_stream << "\n";
+    m_stream << IndentTo(m_pState->CurIndent());
+    if (m_pState->CurGroupChildCount() == 0)
+      m_stream << "[";
+    m_stream << "]";
+  }
+
+  m_pState->EndedGroup(GroupType::Seq);
+}
+
+// EmitBeginMap
+void Emitter::EmitBeginMap() {
+  if (!good())
+    return;
+
+  PrepareNode(m_pState->NextGroupType(GroupType::Map));
+
+  m_pState->StartedGroup(GroupType::Map);
+}
+
+// EmitEndMap
+void Emitter::EmitEndMap() {
+  if (!good())
+    return;
+
+  if (m_pState->CurGroupChildCount() == 0)
+    m_pState->ForceFlow();
+
+  if (m_pState->CurGroupFlowType() == FlowType::Flow) {
+    if (m_stream.comment())
+      m_stream << "\n";
+    m_stream << IndentTo(m_pState->CurIndent());
+    if (m_pState->CurGroupChildCount() == 0)
+      m_stream << "{";
+    m_stream << "}";
+  }
+
+  m_pState->EndedGroup(GroupType::Map);
+}
+
+// EmitNewline
+void Emitter::EmitNewline() {
+  if (!good())
+    return;
+
+  PrepareNode(EmitterNodeType::NoType);
+  m_stream << "\n";
+  m_pState->SetNonContent();
+}
+
+bool Emitter::CanEmitNewline() const { return true; }
+
+// Put the stream in a state so we can simply write the next node
+// E.g., if we're in a sequence, write the "- "
+void Emitter::PrepareNode(EmitterNodeType::value child) {
+  switch (m_pState->CurGroupNodeType()) {
+    case EmitterNodeType::NoType:
+      PrepareTopNode(child);
+      break;
+    case EmitterNodeType::FlowSeq:
+      FlowSeqPrepareNode(child);
+      break;
+    case EmitterNodeType::BlockSeq:
+      BlockSeqPrepareNode(child);
+      break;
+    case EmitterNodeType::FlowMap:
+      FlowMapPrepareNode(child);
+      break;
+    case EmitterNodeType::BlockMap:
+      BlockMapPrepareNode(child);
+      break;
+    case EmitterNodeType::Property:
+    case EmitterNodeType::Scalar:
+      assert(false);
+      break;
+  }
+}
+
+void Emitter::PrepareTopNode(EmitterNodeType::value child) {
+  if (child == EmitterNodeType::NoType)
+    return;
+
+  if (m_pState->CurGroupChildCount() > 0 && m_stream.col() > 0) {
+    if (child != EmitterNodeType::NoType)
+      EmitBeginDoc();
+  }
+
+  switch (child) {
+    case EmitterNodeType::NoType:
+      break;
+    case EmitterNodeType::Property:
+    case EmitterNodeType::Scalar:
+    case EmitterNodeType::FlowSeq:
+    case EmitterNodeType::FlowMap:
+      // TODO: if we were writing null, and
+      // we wanted it blank, we wouldn't want a space
+      SpaceOrIndentTo(m_pState->HasBegunContent(), 0);
+      break;
+    case EmitterNodeType::BlockSeq:
+    case EmitterNodeType::BlockMap:
+      if (m_pState->HasBegunNode())
+        m_stream << "\n";
+      break;
+  }
+}
+
+void Emitter::FlowSeqPrepareNode(EmitterNodeType::value child) {
+  const std::size_t lastIndent = m_pState->LastIndent();
+
+  if (!m_pState->HasBegunNode()) {
+    if (m_stream.comment())
+      m_stream << "\n";
+    m_stream << IndentTo(lastIndent);
+    if (m_pState->CurGroupChildCount() == 0)
+      m_stream << "[";
+    else
+      m_stream << ",";
+  }
+
+  switch (child) {
+    case EmitterNodeType::NoType:
+      break;
+    case EmitterNodeType::Property:
+    case EmitterNodeType::Scalar:
+    case EmitterNodeType::FlowSeq:
+    case EmitterNodeType::FlowMap:
+      SpaceOrIndentTo(
+          m_pState->HasBegunContent() || m_pState->CurGroupChildCount() > 0,
+          lastIndent);
+      break;
+    case EmitterNodeType::BlockSeq:
+    case EmitterNodeType::BlockMap:
+      assert(false);
+      break;
+  }
+}
+
+void Emitter::BlockSeqPrepareNode(EmitterNodeType::value child) {
+  const std::size_t curIndent = m_pState->CurIndent();
+  const std::size_t nextIndent = curIndent + m_pState->CurGroupIndent();
+
+  if (child == EmitterNodeType::NoType)
+    return;
+
+  if (!m_pState->HasBegunContent()) {
+    if (m_pState->CurGroupChildCount() > 0 || m_stream.comment()) {
+      m_stream << "\n";
+    }
+    m_stream << IndentTo(curIndent);
+    m_stream << "-";
+  }
+
+  switch (child) {
+    case EmitterNodeType::NoType:
+      break;
+    case EmitterNodeType::Property:
+    case EmitterNodeType::Scalar:
+    case EmitterNodeType::FlowSeq:
+    case EmitterNodeType::FlowMap:
+      SpaceOrIndentTo(m_pState->HasBegunContent(), nextIndent);
+      break;
+    case EmitterNodeType::BlockSeq:
+      m_stream << "\n";
+      break;
+    case EmitterNodeType::BlockMap:
+      if (m_pState->HasBegunContent() || m_stream.comment())
+        m_stream << "\n";
+      break;
+  }
+}
+
+void Emitter::FlowMapPrepareNode(EmitterNodeType::value child) {
+  if (m_pState->CurGroupChildCount() % 2 == 0) {
+    if (m_pState->GetMapKeyFormat() == LongKey)
+      m_pState->SetLongKey();
+
+    if (m_pState->CurGroupLongKey())
+      FlowMapPrepareLongKey(child);
+    else
+      FlowMapPrepareSimpleKey(child);
+  } else {
+    if (m_pState->CurGroupLongKey())
+      FlowMapPrepareLongKeyValue(child);
+    else
+      FlowMapPrepareSimpleKeyValue(child);
+  }
+}
+
+void Emitter::FlowMapPrepareLongKey(EmitterNodeType::value child) {
+  const std::size_t lastIndent = m_pState->LastIndent();
+
+  if (!m_pState->HasBegunNode()) {
+    if (m_stream.comment())
+      m_stream << "\n";
+    m_stream << IndentTo(lastIndent);
+    if (m_pState->CurGroupChildCount() == 0)
+      m_stream << "{ ?";
+    else
+      m_stream << ", ?";
+  }
+
+  switch (child) {
+    case EmitterNodeType::NoType:
+      break;
+    case EmitterNodeType::Property:
+    case EmitterNodeType::Scalar:
+    case EmitterNodeType::FlowSeq:
+    case EmitterNodeType::FlowMap:
+      SpaceOrIndentTo(
+          m_pState->HasBegunContent() || m_pState->CurGroupChildCount() > 0,
+          lastIndent);
+      break;
+    case EmitterNodeType::BlockSeq:
+    case EmitterNodeType::BlockMap:
+      assert(false);
+      break;
+  }
+}
+
+void Emitter::FlowMapPrepareLongKeyValue(EmitterNodeType::value child) {
+  const std::size_t lastIndent = m_pState->LastIndent();
+
+  if (!m_pState->HasBegunNode()) {
+    if (m_stream.comment())
+      m_stream << "\n";
+    m_stream << IndentTo(lastIndent);
+    m_stream << ":";
+  }
+
+  switch (child) {
+    case EmitterNodeType::NoType:
+      break;
+    case EmitterNodeType::Property:
+    case EmitterNodeType::Scalar:
+    case EmitterNodeType::FlowSeq:
+    case EmitterNodeType::FlowMap:
+      SpaceOrIndentTo(
+          m_pState->HasBegunContent() || m_pState->CurGroupChildCount() > 0,
+          lastIndent);
+      break;
+    case EmitterNodeType::BlockSeq:
+    case EmitterNodeType::BlockMap:
+      assert(false);
+      break;
+  }
+}
+
+void Emitter::FlowMapPrepareSimpleKey(EmitterNodeType::value child) {
+  const std::size_t lastIndent = m_pState->LastIndent();
+
+  if (!m_pState->HasBegunNode()) {
+    if (m_stream.comment())
+      m_stream << "\n";
+    m_stream << IndentTo(lastIndent);
+    if (m_pState->CurGroupChildCount() == 0)
+      m_stream << "{";
+    else
+      m_stream << ",";
+  }
+
+  switch (child) {
+    case EmitterNodeType::NoType:
+      break;
+    case EmitterNodeType::Property:
+    case EmitterNodeType::Scalar:
+    case EmitterNodeType::FlowSeq:
+    case EmitterNodeType::FlowMap:
+      SpaceOrIndentTo(
+          m_pState->HasBegunContent() || m_pState->CurGroupChildCount() > 0,
+          lastIndent);
+      break;
+    case EmitterNodeType::BlockSeq:
+    case EmitterNodeType::BlockMap:
+      assert(false);
+      break;
+  }
+}
+
+void Emitter::FlowMapPrepareSimpleKeyValue(EmitterNodeType::value child) {
+  const std::size_t lastIndent = m_pState->LastIndent();
+
+  if (!m_pState->HasBegunNode()) {
+    if (m_stream.comment())
+      m_stream << "\n";
+    m_stream << IndentTo(lastIndent);
+    m_stream << ":";
+  }
+
+  switch (child) {
+    case EmitterNodeType::NoType:
+      break;
+    case EmitterNodeType::Property:
+    case EmitterNodeType::Scalar:
+    case EmitterNodeType::FlowSeq:
+    case EmitterNodeType::FlowMap:
+      SpaceOrIndentTo(
+          m_pState->HasBegunContent() || m_pState->CurGroupChildCount() > 0,
+          lastIndent);
+      break;
+    case EmitterNodeType::BlockSeq:
+    case EmitterNodeType::BlockMap:
+      assert(false);
+      break;
+  }
+}
+
+void Emitter::BlockMapPrepareNode(EmitterNodeType::value child) {
+  if (m_pState->CurGroupChildCount() % 2 == 0) {
+    if (m_pState->GetMapKeyFormat() == LongKey)
+      m_pState->SetLongKey();
+    if (child == EmitterNodeType::BlockSeq ||
+        child == EmitterNodeType::BlockMap)
+      m_pState->SetLongKey();
+
+    if (m_pState->CurGroupLongKey())
+      BlockMapPrepareLongKey(child);
+    else
+      BlockMapPrepareSimpleKey(child);
+  } else {
+    if (m_pState->CurGroupLongKey())
+      BlockMapPrepareLongKeyValue(child);
+    else
+      BlockMapPrepareSimpleKeyValue(child);
+  }
+}
+
+void Emitter::BlockMapPrepareLongKey(EmitterNodeType::value child) {
+  const std::size_t curIndent = m_pState->CurIndent();
+  const std::size_t childCount = m_pState->CurGroupChildCount();
+
+  if (child == EmitterNodeType::NoType)
+    return;
+
+  if (!m_pState->HasBegunContent()) {
+    if (childCount > 0) {
+      m_stream << "\n";
+    }
+    if (m_stream.comment()) {
+      m_stream << "\n";
+    }
+    m_stream << IndentTo(curIndent);
+    m_stream << "?";
+  }
+
+  switch (child) {
+    case EmitterNodeType::NoType:
+      break;
+    case EmitterNodeType::Property:
+    case EmitterNodeType::Scalar:
+    case EmitterNodeType::FlowSeq:
+    case EmitterNodeType::FlowMap:
+      SpaceOrIndentTo(true, curIndent + 1);
+      break;
+    case EmitterNodeType::BlockSeq:
+    case EmitterNodeType::BlockMap:
+      break;
+  }
+}
+
+void Emitter::BlockMapPrepareLongKeyValue(EmitterNodeType::value child) {
+  const std::size_t curIndent = m_pState->CurIndent();
+
+  if (child == EmitterNodeType::NoType)
+    return;
+
+  if (!m_pState->HasBegunContent()) {
+    m_stream << "\n";
+    m_stream << IndentTo(curIndent);
+    m_stream << ":";
+  }
+
+  switch (child) {
+    case EmitterNodeType::NoType:
+      break;
+    case EmitterNodeType::Property:
+    case EmitterNodeType::Scalar:
+    case EmitterNodeType::FlowSeq:
+    case EmitterNodeType::FlowMap:
+    case EmitterNodeType::BlockSeq:
+    case EmitterNodeType::BlockMap:
+      SpaceOrIndentTo(true, curIndent + 1);
+      break;
+  }
+}
+
+void Emitter::BlockMapPrepareSimpleKey(EmitterNodeType::value child) {
+  const std::size_t curIndent = m_pState->CurIndent();
+  const std::size_t childCount = m_pState->CurGroupChildCount();
+
+  if (child == EmitterNodeType::NoType)
+    return;
+
+  if (!m_pState->HasBegunNode()) {
+    if (childCount > 0) {
+      m_stream << "\n";
+    }
+  }
+
+  switch (child) {
+    case EmitterNodeType::NoType:
+      break;
+    case EmitterNodeType::Property:
+    case EmitterNodeType::Scalar:
+    case EmitterNodeType::FlowSeq:
+    case EmitterNodeType::FlowMap:
+      SpaceOrIndentTo(m_pState->HasBegunContent(), curIndent);
+      break;
+    case EmitterNodeType::BlockSeq:
+    case EmitterNodeType::BlockMap:
+      break;
+  }
+}
+
+void Emitter::BlockMapPrepareSimpleKeyValue(EmitterNodeType::value child) {
+  const std::size_t curIndent = m_pState->CurIndent();
+  const std::size_t nextIndent = curIndent + m_pState->CurGroupIndent();
+
+  if (!m_pState->HasBegunNode()) {
+    m_stream << ":";
+  }
+
+  switch (child) {
+    case EmitterNodeType::NoType:
+      break;
+    case EmitterNodeType::Property:
+    case EmitterNodeType::Scalar:
+    case EmitterNodeType::FlowSeq:
+    case EmitterNodeType::FlowMap:
+      SpaceOrIndentTo(true, nextIndent);
+      break;
+    case EmitterNodeType::BlockSeq:
+    case EmitterNodeType::BlockMap:
+      m_stream << "\n";
+      break;
+  }
+}
+
+// SpaceOrIndentTo
+// . Prepares for some more content by proper spacing
+void Emitter::SpaceOrIndentTo(bool requireSpace, std::size_t indent) {
+  if (m_stream.comment())
+    m_stream << "\n";
+  if (m_stream.col() > 0 && requireSpace)
+    m_stream << " ";
+  m_stream << IndentTo(indent);
+}
+
+void Emitter::PrepareIntegralStream(std::stringstream& stream) const {
+
+  switch (m_pState->GetIntFormat()) {
+    case Dec:
+      stream << std::dec;
+      break;
+    case Hex:
+      stream << "0x";
+      stream << std::hex;
+      break;
+    case Oct:
+      stream << "0";
+      stream << std::oct;
+      break;
+    default:
+      assert(false);
+  }
+}
+
+void Emitter::StartedScalar() { m_pState->StartedScalar(); }
+
+// *******************************************************************************************
+// overloads of Write
+
+Emitter& Emitter::Write(const std::string& str) {
+  if (!good())
+    return *this;
+
+  const bool escapeNonAscii = m_pState->GetOutputCharset() == EscapeNonAscii;
+  const StringFormat::value strFormat =
+      Utils::ComputeStringFormat(str, m_pState->GetStringFormat(),
+                                 m_pState->CurGroupFlowType(), escapeNonAscii);
+
+  if (strFormat == StringFormat::Literal)
+    m_pState->SetMapKeyFormat(YAML::LongKey, FmtScope::Local);
+
+  PrepareNode(EmitterNodeType::Scalar);
+
+  switch (strFormat) {
+    case StringFormat::Plain:
+      m_stream << str;
+      break;
+    case StringFormat::SingleQuoted:
+      Utils::WriteSingleQuotedString(m_stream, str);
+      break;
+    case StringFormat::DoubleQuoted:
+      Utils::WriteDoubleQuotedString(m_stream, str, escapeNonAscii);
+      break;
+    case StringFormat::Literal:
+      Utils::WriteLiteralString(m_stream, str,
+                                m_pState->CurIndent() + m_pState->GetIndent());
+      break;
+  }
+
+  StartedScalar();
+
+  return *this;
+}
+
+std::size_t Emitter::GetFloatPrecision() const {
+  return m_pState->GetFloatPrecision();
+}
+
+std::size_t Emitter::GetDoublePrecision() const {
+  return m_pState->GetDoublePrecision();
+}
+
+const char* Emitter::ComputeFullBoolName(bool b) const {
+  const EMITTER_MANIP mainFmt = (m_pState->GetBoolLengthFormat() == ShortBool
+                                     ? YesNoBool
+                                     : m_pState->GetBoolFormat());
+  const EMITTER_MANIP caseFmt = m_pState->GetBoolCaseFormat();
+  switch (mainFmt) {
+    case YesNoBool:
+      switch (caseFmt) {
+        case UpperCase:
+          return b ? "YES" : "NO";
+        case CamelCase:
+          return b ? "Yes" : "No";
+        case LowerCase:
+          return b ? "yes" : "no";
+        default:
+          break;
+      }
+      break;
+    case OnOffBool:
+      switch (caseFmt) {
+        case UpperCase:
+          return b ? "ON" : "OFF";
+        case CamelCase:
+          return b ? "On" : "Off";
+        case LowerCase:
+          return b ? "on" : "off";
+        default:
+          break;
+      }
+      break;
+    case TrueFalseBool:
+      switch (caseFmt) {
+        case UpperCase:
+          return b ? "TRUE" : "FALSE";
+        case CamelCase:
+          return b ? "True" : "False";
+        case LowerCase:
+          return b ? "true" : "false";
+        default:
+          break;
+      }
+      break;
+    default:
+      break;
+  }
+  return b ? "y" : "n";  // should never get here, but it can't hurt to give
+                         // these answers
+}
+
+Emitter& Emitter::Write(bool b) {
+  if (!good())
+    return *this;
+
+  PrepareNode(EmitterNodeType::Scalar);
+
+  const char* name = ComputeFullBoolName(b);
+  if (m_pState->GetBoolLengthFormat() == ShortBool)
+    m_stream << name[0];
+  else
+    m_stream << name;
+
+  StartedScalar();
+
+  return *this;
+}
+
+Emitter& Emitter::Write(char ch) {
+  if (!good())
+    return *this;
+
+  PrepareNode(EmitterNodeType::Scalar);
+  Utils::WriteChar(m_stream, ch);
+  StartedScalar();
+
+  return *this;
+}
+
+Emitter& Emitter::Write(const _Alias& alias) {
+  if (!good())
+    return *this;
+
+  if (m_pState->HasAnchor() || m_pState->HasTag()) {
+    m_pState->SetError(ErrorMsg::INVALID_ALIAS);
+    return *this;
+  }
+
+  PrepareNode(EmitterNodeType::Scalar);
+
+  if (!Utils::WriteAlias(m_stream, alias.content)) {
+    m_pState->SetError(ErrorMsg::INVALID_ALIAS);
+    return *this;
+  }
+
+  StartedScalar();
+
+  return *this;
+}
+
+Emitter& Emitter::Write(const _Anchor& anchor) {
+  if (!good())
+    return *this;
+
+  if (m_pState->HasAnchor()) {
+    m_pState->SetError(ErrorMsg::INVALID_ANCHOR);
+    return *this;
+  }
+
+  PrepareNode(EmitterNodeType::Property);
+
+  if (!Utils::WriteAnchor(m_stream, anchor.content)) {
+    m_pState->SetError(ErrorMsg::INVALID_ANCHOR);
+    return *this;
+  }
+
+  m_pState->SetAnchor();
+
+  return *this;
+}
+
+Emitter& Emitter::Write(const _Tag& tag) {
+  if (!good())
+    return *this;
+
+  if (m_pState->HasTag()) {
+    m_pState->SetError(ErrorMsg::INVALID_TAG);
+    return *this;
+  }
+
+  PrepareNode(EmitterNodeType::Property);
+
+  bool success = false;
+  if (tag.type == _Tag::Type::Verbatim)
+    success = Utils::WriteTag(m_stream, tag.content, true);
+  else if (tag.type == _Tag::Type::PrimaryHandle)
+    success = Utils::WriteTag(m_stream, tag.content, false);
+  else
+    success = Utils::WriteTagWithPrefix(m_stream, tag.prefix, tag.content);
+
+  if (!success) {
+    m_pState->SetError(ErrorMsg::INVALID_TAG);
+    return *this;
+  }
+
+  m_pState->SetTag();
+
+  return *this;
+}
+
+void Emitter::EmitKindTag() { Write(LocalTag("")); }
+
+Emitter& Emitter::Write(const _Comment& comment) {
+  if (!good())
+    return *this;
+
+  PrepareNode(EmitterNodeType::NoType);
+
+  if (m_stream.col() > 0)
+    m_stream << Indentation(m_pState->GetPreCommentIndent());
+  Utils::WriteComment(m_stream, comment.content,
+                      m_pState->GetPostCommentIndent());
+
+  m_pState->SetNonContent();
+
+  return *this;
+}
+
+Emitter& Emitter::Write(const _Null& /*null*/) {
+  if (!good())
+    return *this;
+
+  PrepareNode(EmitterNodeType::Scalar);
+
+  m_stream << "~";
+
+  StartedScalar();
+
+  return *this;
+}
+
+Emitter& Emitter::Write(const Binary& binary) {
+  Write(SecondaryTag("binary"));
+
+  if (!good())
+    return *this;
+
+  PrepareNode(EmitterNodeType::Scalar);
+  Utils::WriteBinary(m_stream, binary);
+  StartedScalar();
+
+  return *this;
+}
+}
diff --git a/contrib/libs/yaml-cpp/src/emitterstate.cpp b/contrib/libs/yaml-cpp/src/emitterstate.cpp
index f32ede28d02..3542aaf5071 100644
--- a/contrib/libs/yaml-cpp/src/emitterstate.cpp
+++ b/contrib/libs/yaml-cpp/src/emitterstate.cpp
@@ -1,365 +1,365 @@
-#include <limits> 
- 
-#include "emitterstate.h" 
-#include "yaml-cpp/exceptions.h"  // IWYU pragma: keep 
- 
-namespace YAML { 
-EmitterState::EmitterState() 
-    : m_isGood(true), 
-      m_curIndent(0), 
-      m_hasAnchor(false), 
-      m_hasTag(false), 
-      m_hasNonContent(false), 
-      m_docCount(0) { 
-  // set default global manipulators 
-  m_charset.set(EmitNonAscii); 
-  m_strFmt.set(Auto); 
-  m_boolFmt.set(TrueFalseBool); 
-  m_boolLengthFmt.set(LongBool); 
-  m_boolCaseFmt.set(LowerCase); 
-  m_intFmt.set(Dec); 
-  m_indent.set(2); 
-  m_preCommentIndent.set(2); 
-  m_postCommentIndent.set(1); 
-  m_seqFmt.set(Block); 
-  m_mapFmt.set(Block); 
-  m_mapKeyFmt.set(Auto); 
-  m_floatPrecision.set(std::numeric_limits<float>::digits10 + 1); 
-  m_doublePrecision.set(std::numeric_limits<double>::digits10 + 1); 
-} 
- 
-EmitterState::~EmitterState() {} 
- 
-// SetLocalValue 
-// . We blindly tries to set all possible formatters to this value 
-// . Only the ones that make sense will be accepted 
-void EmitterState::SetLocalValue(EMITTER_MANIP value) { 
-  SetOutputCharset(value, FmtScope::Local); 
-  SetStringFormat(value, FmtScope::Local); 
-  SetBoolFormat(value, FmtScope::Local); 
-  SetBoolCaseFormat(value, FmtScope::Local); 
-  SetBoolLengthFormat(value, FmtScope::Local); 
-  SetIntFormat(value, FmtScope::Local); 
-  SetFlowType(GroupType::Seq, value, FmtScope::Local); 
-  SetFlowType(GroupType::Map, value, FmtScope::Local); 
-  SetMapKeyFormat(value, FmtScope::Local); 
-} 
- 
-void EmitterState::SetAnchor() { m_hasAnchor = true; } 
- 
-void EmitterState::SetTag() { m_hasTag = true; } 
- 
-void EmitterState::SetNonContent() { m_hasNonContent = true; } 
- 
-void EmitterState::SetLongKey() { 
-  assert(!m_groups.empty()); 
+#include <limits>
+
+#include "emitterstate.h"
+#include "yaml-cpp/exceptions.h"  // IWYU pragma: keep
+
+namespace YAML {
+EmitterState::EmitterState()
+    : m_isGood(true),
+      m_curIndent(0),
+      m_hasAnchor(false),
+      m_hasTag(false),
+      m_hasNonContent(false),
+      m_docCount(0) {
+  // set default global manipulators
+  m_charset.set(EmitNonAscii);
+  m_strFmt.set(Auto);
+  m_boolFmt.set(TrueFalseBool);
+  m_boolLengthFmt.set(LongBool);
+  m_boolCaseFmt.set(LowerCase);
+  m_intFmt.set(Dec);
+  m_indent.set(2);
+  m_preCommentIndent.set(2);
+  m_postCommentIndent.set(1);
+  m_seqFmt.set(Block);
+  m_mapFmt.set(Block);
+  m_mapKeyFmt.set(Auto);
+  m_floatPrecision.set(std::numeric_limits<float>::digits10 + 1);
+  m_doublePrecision.set(std::numeric_limits<double>::digits10 + 1);
+}
+
+EmitterState::~EmitterState() {}
+
+// SetLocalValue
+// . We blindly tries to set all possible formatters to this value
+// . Only the ones that make sense will be accepted
+void EmitterState::SetLocalValue(EMITTER_MANIP value) {
+  SetOutputCharset(value, FmtScope::Local);
+  SetStringFormat(value, FmtScope::Local);
+  SetBoolFormat(value, FmtScope::Local);
+  SetBoolCaseFormat(value, FmtScope::Local);
+  SetBoolLengthFormat(value, FmtScope::Local);
+  SetIntFormat(value, FmtScope::Local);
+  SetFlowType(GroupType::Seq, value, FmtScope::Local);
+  SetFlowType(GroupType::Map, value, FmtScope::Local);
+  SetMapKeyFormat(value, FmtScope::Local);
+}
+
+void EmitterState::SetAnchor() { m_hasAnchor = true; }
+
+void EmitterState::SetTag() { m_hasTag = true; }
+
+void EmitterState::SetNonContent() { m_hasNonContent = true; }
+
+void EmitterState::SetLongKey() {
+  assert(!m_groups.empty());
   if (m_groups.empty()) {
-    return; 
+    return;
   }
- 
+
   assert(m_groups.back()->type == GroupType::Map);
   m_groups.back()->longKey = true;
-} 
- 
-void EmitterState::ForceFlow() { 
-  assert(!m_groups.empty()); 
+}
+
+void EmitterState::ForceFlow() {
+  assert(!m_groups.empty());
   if (m_groups.empty()) {
-    return; 
+    return;
   }
- 
+
   m_groups.back()->flowType = FlowType::Flow;
-} 
- 
-void EmitterState::StartedNode() { 
-  if (m_groups.empty()) { 
-    m_docCount++; 
-  } else { 
+}
+
+void EmitterState::StartedNode() {
+  if (m_groups.empty()) {
+    m_docCount++;
+  } else {
     m_groups.back()->childCount++;
     if (m_groups.back()->childCount % 2 == 0) {
       m_groups.back()->longKey = false;
     }
-  } 
- 
-  m_hasAnchor = false; 
-  m_hasTag = false; 
-  m_hasNonContent = false; 
-} 
- 
-EmitterNodeType::value EmitterState::NextGroupType( 
-    GroupType::value type) const { 
-  if (type == GroupType::Seq) { 
-    if (GetFlowType(type) == Block) 
-      return EmitterNodeType::BlockSeq; 
-    else 
-      return EmitterNodeType::FlowSeq; 
-  } else { 
-    if (GetFlowType(type) == Block) 
-      return EmitterNodeType::BlockMap; 
-    else 
-      return EmitterNodeType::FlowMap; 
-  } 
- 
-  // can't happen 
-  assert(false); 
-  return EmitterNodeType::NoType; 
-} 
- 
-void EmitterState::StartedDoc() { 
-  m_hasAnchor = false; 
-  m_hasTag = false; 
-  m_hasNonContent = false; 
-} 
- 
-void EmitterState::EndedDoc() { 
-  m_hasAnchor = false; 
-  m_hasTag = false; 
-  m_hasNonContent = false; 
-} 
- 
-void EmitterState::StartedScalar() { 
-  StartedNode(); 
-  ClearModifiedSettings(); 
-} 
- 
-void EmitterState::StartedGroup(GroupType::value type) { 
-  StartedNode(); 
- 
+  }
+
+  m_hasAnchor = false;
+  m_hasTag = false;
+  m_hasNonContent = false;
+}
+
+EmitterNodeType::value EmitterState::NextGroupType(
+    GroupType::value type) const {
+  if (type == GroupType::Seq) {
+    if (GetFlowType(type) == Block)
+      return EmitterNodeType::BlockSeq;
+    else
+      return EmitterNodeType::FlowSeq;
+  } else {
+    if (GetFlowType(type) == Block)
+      return EmitterNodeType::BlockMap;
+    else
+      return EmitterNodeType::FlowMap;
+  }
+
+  // can't happen
+  assert(false);
+  return EmitterNodeType::NoType;
+}
+
+void EmitterState::StartedDoc() {
+  m_hasAnchor = false;
+  m_hasTag = false;
+  m_hasNonContent = false;
+}
+
+void EmitterState::EndedDoc() {
+  m_hasAnchor = false;
+  m_hasTag = false;
+  m_hasNonContent = false;
+}
+
+void EmitterState::StartedScalar() {
+  StartedNode();
+  ClearModifiedSettings();
+}
+
+void EmitterState::StartedGroup(GroupType::value type) {
+  StartedNode();
+
   const std::size_t lastGroupIndent =
       (m_groups.empty() ? 0 : m_groups.back()->indent);
-  m_curIndent += lastGroupIndent; 
- 
+  m_curIndent += lastGroupIndent;
+
   // TODO: Create move constructors for settings types to simplify transfer
   std::unique_ptr<Group> pGroup(new Group(type));
- 
-  // transfer settings (which last until this group is done) 
+
+  // transfer settings (which last until this group is done)
   //
   // NB: if pGroup->modifiedSettings == m_modifiedSettings,
   // m_modifiedSettings is not changed!
   pGroup->modifiedSettings = std::move(m_modifiedSettings);
- 
-  // set up group 
+
+  // set up group
   if (GetFlowType(type) == Block) {
-    pGroup->flowType = FlowType::Block; 
+    pGroup->flowType = FlowType::Block;
   } else {
-    pGroup->flowType = FlowType::Flow; 
+    pGroup->flowType = FlowType::Flow;
   }
-  pGroup->indent = GetIndent(); 
- 
+  pGroup->indent = GetIndent();
+
   m_groups.push_back(std::move(pGroup));
-} 
- 
-void EmitterState::EndedGroup(GroupType::value type) { 
-  if (m_groups.empty()) { 
+}
+
+void EmitterState::EndedGroup(GroupType::value type) {
+  if (m_groups.empty()) {
     if (type == GroupType::Seq) {
-      return SetError(ErrorMsg::UNEXPECTED_END_SEQ); 
+      return SetError(ErrorMsg::UNEXPECTED_END_SEQ);
     } else {
-      return SetError(ErrorMsg::UNEXPECTED_END_MAP); 
+      return SetError(ErrorMsg::UNEXPECTED_END_MAP);
     }
-  } 
- 
-  // get rid of the current group 
-  { 
+  }
+
+  // get rid of the current group
+  {
     std::unique_ptr<Group> pFinishedGroup = std::move(m_groups.back());
     m_groups.pop_back();
     if (pFinishedGroup->type != type) {
-      return SetError(ErrorMsg::UNMATCHED_GROUP_TAG); 
+      return SetError(ErrorMsg::UNMATCHED_GROUP_TAG);
     }
-  } 
- 
-  // reset old settings 
+  }
+
+  // reset old settings
   std::size_t lastIndent = (m_groups.empty() ? 0 : m_groups.back()->indent);
-  assert(m_curIndent >= lastIndent); 
-  m_curIndent -= lastIndent; 
- 
-  // some global settings that we changed may have been overridden 
-  // by a local setting we just popped, so we need to restore them 
-  m_globalModifiedSettings.restore(); 
- 
-  ClearModifiedSettings(); 
-} 
- 
-EmitterNodeType::value EmitterState::CurGroupNodeType() const { 
+  assert(m_curIndent >= lastIndent);
+  m_curIndent -= lastIndent;
+
+  // some global settings that we changed may have been overridden
+  // by a local setting we just popped, so we need to restore them
+  m_globalModifiedSettings.restore();
+
+  ClearModifiedSettings();
+}
+
+EmitterNodeType::value EmitterState::CurGroupNodeType() const {
   if (m_groups.empty()) {
-    return EmitterNodeType::NoType; 
+    return EmitterNodeType::NoType;
   }
- 
+
   return m_groups.back()->NodeType();
-} 
- 
-GroupType::value EmitterState::CurGroupType() const { 
+}
+
+GroupType::value EmitterState::CurGroupType() const {
   return m_groups.empty() ? GroupType::NoType : m_groups.back()->type;
-} 
- 
-FlowType::value EmitterState::CurGroupFlowType() const { 
+}
+
+FlowType::value EmitterState::CurGroupFlowType() const {
   return m_groups.empty() ? FlowType::NoType : m_groups.back()->flowType;
-} 
- 
+}
+
 std::size_t EmitterState::CurGroupIndent() const {
   return m_groups.empty() ? 0 : m_groups.back()->indent;
-} 
- 
-std::size_t EmitterState::CurGroupChildCount() const { 
+}
+
+std::size_t EmitterState::CurGroupChildCount() const {
   return m_groups.empty() ? m_docCount : m_groups.back()->childCount;
-} 
- 
-bool EmitterState::CurGroupLongKey() const { 
+}
+
+bool EmitterState::CurGroupLongKey() const {
   return m_groups.empty() ? false : m_groups.back()->longKey;
-} 
- 
+}
+
 std::size_t EmitterState::LastIndent() const {
   if (m_groups.size() <= 1) {
-    return 0; 
+    return 0;
   }
- 
+
   return m_curIndent - m_groups[m_groups.size() - 2]->indent;
-} 
- 
-void EmitterState::ClearModifiedSettings() { m_modifiedSettings.clear(); } 
- 
-bool EmitterState::SetOutputCharset(EMITTER_MANIP value, 
-                                    FmtScope::value scope) { 
-  switch (value) { 
-    case EmitNonAscii: 
-    case EscapeNonAscii: 
-      _Set(m_charset, value, scope); 
-      return true; 
-    default: 
-      return false; 
-  } 
-} 
- 
-bool EmitterState::SetStringFormat(EMITTER_MANIP value, FmtScope::value scope) { 
-  switch (value) { 
-    case Auto: 
-    case SingleQuoted: 
-    case DoubleQuoted: 
-    case Literal: 
-      _Set(m_strFmt, value, scope); 
-      return true; 
-    default: 
-      return false; 
-  } 
-} 
- 
-bool EmitterState::SetBoolFormat(EMITTER_MANIP value, FmtScope::value scope) { 
-  switch (value) { 
-    case OnOffBool: 
-    case TrueFalseBool: 
-    case YesNoBool: 
-      _Set(m_boolFmt, value, scope); 
-      return true; 
-    default: 
-      return false; 
-  } 
-} 
- 
-bool EmitterState::SetBoolLengthFormat(EMITTER_MANIP value, 
-                                       FmtScope::value scope) { 
-  switch (value) { 
-    case LongBool: 
-    case ShortBool: 
-      _Set(m_boolLengthFmt, value, scope); 
-      return true; 
-    default: 
-      return false; 
-  } 
-} 
- 
-bool EmitterState::SetBoolCaseFormat(EMITTER_MANIP value, 
-                                     FmtScope::value scope) { 
-  switch (value) { 
-    case UpperCase: 
-    case LowerCase: 
-    case CamelCase: 
-      _Set(m_boolCaseFmt, value, scope); 
-      return true; 
-    default: 
-      return false; 
-  } 
-} 
- 
-bool EmitterState::SetIntFormat(EMITTER_MANIP value, FmtScope::value scope) { 
-  switch (value) { 
-    case Dec: 
-    case Hex: 
-    case Oct: 
-      _Set(m_intFmt, value, scope); 
-      return true; 
-    default: 
-      return false; 
-  } 
-} 
- 
-bool EmitterState::SetIndent(std::size_t value, FmtScope::value scope) { 
-  if (value <= 1) 
-    return false; 
- 
-  _Set(m_indent, value, scope); 
-  return true; 
-} 
- 
-bool EmitterState::SetPreCommentIndent(std::size_t value, 
-                                       FmtScope::value scope) { 
-  if (value == 0) 
-    return false; 
- 
-  _Set(m_preCommentIndent, value, scope); 
-  return true; 
-} 
- 
-bool EmitterState::SetPostCommentIndent(std::size_t value, 
-                                        FmtScope::value scope) { 
-  if (value == 0) 
-    return false; 
- 
-  _Set(m_postCommentIndent, value, scope); 
-  return true; 
-} 
- 
-bool EmitterState::SetFlowType(GroupType::value groupType, EMITTER_MANIP value, 
-                               FmtScope::value scope) { 
-  switch (value) { 
-    case Block: 
-    case Flow: 
-      _Set(groupType == GroupType::Seq ? m_seqFmt : m_mapFmt, value, scope); 
-      return true; 
-    default: 
-      return false; 
-  } 
-} 
- 
-EMITTER_MANIP EmitterState::GetFlowType(GroupType::value groupType) const { 
-  // force flow style if we're currently in a flow 
-  if (CurGroupFlowType() == FlowType::Flow) 
-    return Flow; 
- 
-  // otherwise, go with what's asked of us 
-  return (groupType == GroupType::Seq ? m_seqFmt.get() : m_mapFmt.get()); 
-} 
- 
-bool EmitterState::SetMapKeyFormat(EMITTER_MANIP value, FmtScope::value scope) { 
-  switch (value) { 
-    case Auto: 
-    case LongKey: 
-      _Set(m_mapKeyFmt, value, scope); 
-      return true; 
-    default: 
-      return false; 
-  } 
-} 
- 
+}
+
+void EmitterState::ClearModifiedSettings() { m_modifiedSettings.clear(); }
+
+bool EmitterState::SetOutputCharset(EMITTER_MANIP value,
+                                    FmtScope::value scope) {
+  switch (value) {
+    case EmitNonAscii:
+    case EscapeNonAscii:
+      _Set(m_charset, value, scope);
+      return true;
+    default:
+      return false;
+  }
+}
+
+bool EmitterState::SetStringFormat(EMITTER_MANIP value, FmtScope::value scope) {
+  switch (value) {
+    case Auto:
+    case SingleQuoted:
+    case DoubleQuoted:
+    case Literal:
+      _Set(m_strFmt, value, scope);
+      return true;
+    default:
+      return false;
+  }
+}
+
+bool EmitterState::SetBoolFormat(EMITTER_MANIP value, FmtScope::value scope) {
+  switch (value) {
+    case OnOffBool:
+    case TrueFalseBool:
+    case YesNoBool:
+      _Set(m_boolFmt, value, scope);
+      return true;
+    default:
+      return false;
+  }
+}
+
+bool EmitterState::SetBoolLengthFormat(EMITTER_MANIP value,
+                                       FmtScope::value scope) {
+  switch (value) {
+    case LongBool:
+    case ShortBool:
+      _Set(m_boolLengthFmt, value, scope);
+      return true;
+    default:
+      return false;
+  }
+}
+
+bool EmitterState::SetBoolCaseFormat(EMITTER_MANIP value,
+                                     FmtScope::value scope) {
+  switch (value) {
+    case UpperCase:
+    case LowerCase:
+    case CamelCase:
+      _Set(m_boolCaseFmt, value, scope);
+      return true;
+    default:
+      return false;
+  }
+}
+
+bool EmitterState::SetIntFormat(EMITTER_MANIP value, FmtScope::value scope) {
+  switch (value) {
+    case Dec:
+    case Hex:
+    case Oct:
+      _Set(m_intFmt, value, scope);
+      return true;
+    default:
+      return false;
+  }
+}
+
+bool EmitterState::SetIndent(std::size_t value, FmtScope::value scope) {
+  if (value <= 1)
+    return false;
+
+  _Set(m_indent, value, scope);
+  return true;
+}
+
+bool EmitterState::SetPreCommentIndent(std::size_t value,
+                                       FmtScope::value scope) {
+  if (value == 0)
+    return false;
+
+  _Set(m_preCommentIndent, value, scope);
+  return true;
+}
+
+bool EmitterState::SetPostCommentIndent(std::size_t value,
+                                        FmtScope::value scope) {
+  if (value == 0)
+    return false;
+
+  _Set(m_postCommentIndent, value, scope);
+  return true;
+}
+
+bool EmitterState::SetFlowType(GroupType::value groupType, EMITTER_MANIP value,
+                               FmtScope::value scope) {
+  switch (value) {
+    case Block:
+    case Flow:
+      _Set(groupType == GroupType::Seq ? m_seqFmt : m_mapFmt, value, scope);
+      return true;
+    default:
+      return false;
+  }
+}
+
+EMITTER_MANIP EmitterState::GetFlowType(GroupType::value groupType) const {
+  // force flow style if we're currently in a flow
+  if (CurGroupFlowType() == FlowType::Flow)
+    return Flow;
+
+  // otherwise, go with what's asked of us
+  return (groupType == GroupType::Seq ? m_seqFmt.get() : m_mapFmt.get());
+}
+
+bool EmitterState::SetMapKeyFormat(EMITTER_MANIP value, FmtScope::value scope) {
+  switch (value) {
+    case Auto:
+    case LongKey:
+      _Set(m_mapKeyFmt, value, scope);
+      return true;
+    default:
+      return false;
+  }
+}
+
 bool EmitterState::SetFloatPrecision(std::size_t value, FmtScope::value scope) {
   if (value > std::numeric_limits<float>::digits10 + 1)
-    return false; 
-  _Set(m_floatPrecision, value, scope); 
-  return true; 
-} 
- 
+    return false;
+  _Set(m_floatPrecision, value, scope);
+  return true;
+}
+
 bool EmitterState::SetDoublePrecision(std::size_t value,
                                       FmtScope::value scope) {
   if (value > std::numeric_limits<double>::digits10 + 1)
-    return false; 
-  _Set(m_doublePrecision, value, scope); 
-  return true; 
-} 
-} 
+    return false;
+  _Set(m_doublePrecision, value, scope);
+  return true;
+}
+}
diff --git a/contrib/libs/yaml-cpp/src/emitterstate.h b/contrib/libs/yaml-cpp/src/emitterstate.h
index 719fcfd5eff..0937f000d9f 100644
--- a/contrib/libs/yaml-cpp/src/emitterstate.h
+++ b/contrib/libs/yaml-cpp/src/emitterstate.h
@@ -1,203 +1,203 @@
-#ifndef EMITTERSTATE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define EMITTERSTATE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include "setting.h" 
-#include "yaml-cpp/emitterdef.h" 
-#include "yaml-cpp/emittermanip.h" 
-
-#include <cassert> 
+#ifndef EMITTERSTATE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define EMITTERSTATE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "setting.h"
+#include "yaml-cpp/emitterdef.h"
+#include "yaml-cpp/emittermanip.h"
+
+#include <cassert>
 #include <memory>
-#include <stack> 
-#include <stdexcept> 
+#include <stack>
+#include <stdexcept>
 #include <vector>
- 
-namespace YAML { 
-struct FmtScope { 
-  enum value { Local, Global }; 
-}; 
-struct GroupType { 
-  enum value { NoType, Seq, Map }; 
-}; 
-struct FlowType { 
-  enum value { NoType, Flow, Block }; 
-}; 
- 
-class EmitterState { 
- public: 
-  EmitterState(); 
-  ~EmitterState(); 
- 
-  // basic state checking 
-  bool good() const { return m_isGood; } 
-  const std::string GetLastError() const { return m_lastError; } 
-  void SetError(const std::string& error) { 
-    m_isGood = false; 
-    m_lastError = error; 
-  } 
- 
-  // node handling 
-  void SetAnchor(); 
-  void SetTag(); 
-  void SetNonContent(); 
-  void SetLongKey(); 
-  void ForceFlow(); 
-  void StartedDoc(); 
-  void EndedDoc(); 
-  void StartedScalar(); 
-  void StartedGroup(GroupType::value type); 
-  void EndedGroup(GroupType::value type); 
- 
-  EmitterNodeType::value NextGroupType(GroupType::value type) const; 
-  EmitterNodeType::value CurGroupNodeType() const; 
- 
-  GroupType::value CurGroupType() const; 
-  FlowType::value CurGroupFlowType() const; 
+
+namespace YAML {
+struct FmtScope {
+  enum value { Local, Global };
+};
+struct GroupType {
+  enum value { NoType, Seq, Map };
+};
+struct FlowType {
+  enum value { NoType, Flow, Block };
+};
+
+class EmitterState {
+ public:
+  EmitterState();
+  ~EmitterState();
+
+  // basic state checking
+  bool good() const { return m_isGood; }
+  const std::string GetLastError() const { return m_lastError; }
+  void SetError(const std::string& error) {
+    m_isGood = false;
+    m_lastError = error;
+  }
+
+  // node handling
+  void SetAnchor();
+  void SetTag();
+  void SetNonContent();
+  void SetLongKey();
+  void ForceFlow();
+  void StartedDoc();
+  void EndedDoc();
+  void StartedScalar();
+  void StartedGroup(GroupType::value type);
+  void EndedGroup(GroupType::value type);
+
+  EmitterNodeType::value NextGroupType(GroupType::value type) const;
+  EmitterNodeType::value CurGroupNodeType() const;
+
+  GroupType::value CurGroupType() const;
+  FlowType::value CurGroupFlowType() const;
   std::size_t CurGroupIndent() const;
-  std::size_t CurGroupChildCount() const; 
-  bool CurGroupLongKey() const; 
- 
+  std::size_t CurGroupChildCount() const;
+  bool CurGroupLongKey() const;
+
   std::size_t LastIndent() const;
   std::size_t CurIndent() const { return m_curIndent; }
-  bool HasAnchor() const { return m_hasAnchor; } 
-  bool HasTag() const { return m_hasTag; } 
-  bool HasBegunNode() const { 
-    return m_hasAnchor || m_hasTag || m_hasNonContent; 
-  } 
-  bool HasBegunContent() const { return m_hasAnchor || m_hasTag; } 
- 
-  void ClearModifiedSettings(); 
- 
-  // formatters 
-  void SetLocalValue(EMITTER_MANIP value); 
- 
-  bool SetOutputCharset(EMITTER_MANIP value, FmtScope::value scope); 
-  EMITTER_MANIP GetOutputCharset() const { return m_charset.get(); } 
- 
-  bool SetStringFormat(EMITTER_MANIP value, FmtScope::value scope); 
-  EMITTER_MANIP GetStringFormat() const { return m_strFmt.get(); } 
- 
-  bool SetBoolFormat(EMITTER_MANIP value, FmtScope::value scope); 
-  EMITTER_MANIP GetBoolFormat() const { return m_boolFmt.get(); } 
- 
-  bool SetBoolLengthFormat(EMITTER_MANIP value, FmtScope::value scope); 
-  EMITTER_MANIP GetBoolLengthFormat() const { return m_boolLengthFmt.get(); } 
- 
-  bool SetBoolCaseFormat(EMITTER_MANIP value, FmtScope::value scope); 
-  EMITTER_MANIP GetBoolCaseFormat() const { return m_boolCaseFmt.get(); } 
- 
-  bool SetIntFormat(EMITTER_MANIP value, FmtScope::value scope); 
-  EMITTER_MANIP GetIntFormat() const { return m_intFmt.get(); } 
- 
-  bool SetIndent(std::size_t value, FmtScope::value scope); 
+  bool HasAnchor() const { return m_hasAnchor; }
+  bool HasTag() const { return m_hasTag; }
+  bool HasBegunNode() const {
+    return m_hasAnchor || m_hasTag || m_hasNonContent;
+  }
+  bool HasBegunContent() const { return m_hasAnchor || m_hasTag; }
+
+  void ClearModifiedSettings();
+
+  // formatters
+  void SetLocalValue(EMITTER_MANIP value);
+
+  bool SetOutputCharset(EMITTER_MANIP value, FmtScope::value scope);
+  EMITTER_MANIP GetOutputCharset() const { return m_charset.get(); }
+
+  bool SetStringFormat(EMITTER_MANIP value, FmtScope::value scope);
+  EMITTER_MANIP GetStringFormat() const { return m_strFmt.get(); }
+
+  bool SetBoolFormat(EMITTER_MANIP value, FmtScope::value scope);
+  EMITTER_MANIP GetBoolFormat() const { return m_boolFmt.get(); }
+
+  bool SetBoolLengthFormat(EMITTER_MANIP value, FmtScope::value scope);
+  EMITTER_MANIP GetBoolLengthFormat() const { return m_boolLengthFmt.get(); }
+
+  bool SetBoolCaseFormat(EMITTER_MANIP value, FmtScope::value scope);
+  EMITTER_MANIP GetBoolCaseFormat() const { return m_boolCaseFmt.get(); }
+
+  bool SetIntFormat(EMITTER_MANIP value, FmtScope::value scope);
+  EMITTER_MANIP GetIntFormat() const { return m_intFmt.get(); }
+
+  bool SetIndent(std::size_t value, FmtScope::value scope);
   std::size_t GetIndent() const { return m_indent.get(); }
- 
-  bool SetPreCommentIndent(std::size_t value, FmtScope::value scope); 
+
+  bool SetPreCommentIndent(std::size_t value, FmtScope::value scope);
   std::size_t GetPreCommentIndent() const { return m_preCommentIndent.get(); }
-  bool SetPostCommentIndent(std::size_t value, FmtScope::value scope); 
+  bool SetPostCommentIndent(std::size_t value, FmtScope::value scope);
   std::size_t GetPostCommentIndent() const { return m_postCommentIndent.get(); }
- 
-  bool SetFlowType(GroupType::value groupType, EMITTER_MANIP value, 
-                   FmtScope::value scope); 
-  EMITTER_MANIP GetFlowType(GroupType::value groupType) const; 
- 
-  bool SetMapKeyFormat(EMITTER_MANIP value, FmtScope::value scope); 
-  EMITTER_MANIP GetMapKeyFormat() const { return m_mapKeyFmt.get(); } 
- 
+
+  bool SetFlowType(GroupType::value groupType, EMITTER_MANIP value,
+                   FmtScope::value scope);
+  EMITTER_MANIP GetFlowType(GroupType::value groupType) const;
+
+  bool SetMapKeyFormat(EMITTER_MANIP value, FmtScope::value scope);
+  EMITTER_MANIP GetMapKeyFormat() const { return m_mapKeyFmt.get(); }
+
   bool SetFloatPrecision(std::size_t value, FmtScope::value scope);
-  std::size_t GetFloatPrecision() const { return m_floatPrecision.get(); } 
+  std::size_t GetFloatPrecision() const { return m_floatPrecision.get(); }
   bool SetDoublePrecision(std::size_t value, FmtScope::value scope);
-  std::size_t GetDoublePrecision() const { return m_doublePrecision.get(); } 
- 
- private: 
-  template <typename T> 
-  void _Set(Setting<T>& fmt, T value, FmtScope::value scope); 
- 
-  void StartedNode(); 
- 
- private: 
-  // basic state ok? 
-  bool m_isGood; 
-  std::string m_lastError; 
- 
-  // other state 
-  Setting<EMITTER_MANIP> m_charset; 
-  Setting<EMITTER_MANIP> m_strFmt; 
-  Setting<EMITTER_MANIP> m_boolFmt; 
-  Setting<EMITTER_MANIP> m_boolLengthFmt; 
-  Setting<EMITTER_MANIP> m_boolCaseFmt; 
-  Setting<EMITTER_MANIP> m_intFmt; 
-  Setting<std::size_t> m_indent; 
-  Setting<std::size_t> m_preCommentIndent, m_postCommentIndent; 
-  Setting<EMITTER_MANIP> m_seqFmt; 
-  Setting<EMITTER_MANIP> m_mapFmt; 
-  Setting<EMITTER_MANIP> m_mapKeyFmt; 
+  std::size_t GetDoublePrecision() const { return m_doublePrecision.get(); }
+
+ private:
+  template <typename T>
+  void _Set(Setting<T>& fmt, T value, FmtScope::value scope);
+
+  void StartedNode();
+
+ private:
+  // basic state ok?
+  bool m_isGood;
+  std::string m_lastError;
+
+  // other state
+  Setting<EMITTER_MANIP> m_charset;
+  Setting<EMITTER_MANIP> m_strFmt;
+  Setting<EMITTER_MANIP> m_boolFmt;
+  Setting<EMITTER_MANIP> m_boolLengthFmt;
+  Setting<EMITTER_MANIP> m_boolCaseFmt;
+  Setting<EMITTER_MANIP> m_intFmt;
+  Setting<std::size_t> m_indent;
+  Setting<std::size_t> m_preCommentIndent, m_postCommentIndent;
+  Setting<EMITTER_MANIP> m_seqFmt;
+  Setting<EMITTER_MANIP> m_mapFmt;
+  Setting<EMITTER_MANIP> m_mapKeyFmt;
   Setting<std::size_t> m_floatPrecision;
   Setting<std::size_t> m_doublePrecision;
- 
-  SettingChanges m_modifiedSettings; 
-  SettingChanges m_globalModifiedSettings; 
- 
-  struct Group { 
-    explicit Group(GroupType::value type_) 
-        : type(type_), indent(0), childCount(0), longKey(false) {} 
- 
-    GroupType::value type; 
-    FlowType::value flowType; 
+
+  SettingChanges m_modifiedSettings;
+  SettingChanges m_globalModifiedSettings;
+
+  struct Group {
+    explicit Group(GroupType::value type_)
+        : type(type_), indent(0), childCount(0), longKey(false) {}
+
+    GroupType::value type;
+    FlowType::value flowType;
     std::size_t indent;
-    std::size_t childCount; 
-    bool longKey; 
- 
-    SettingChanges modifiedSettings; 
- 
-    EmitterNodeType::value NodeType() const { 
-      if (type == GroupType::Seq) { 
-        if (flowType == FlowType::Flow) 
-          return EmitterNodeType::FlowSeq; 
-        else 
-          return EmitterNodeType::BlockSeq; 
-      } else { 
-        if (flowType == FlowType::Flow) 
-          return EmitterNodeType::FlowMap; 
-        else 
-          return EmitterNodeType::BlockMap; 
-      } 
- 
-      // can't get here 
-      assert(false); 
-      return EmitterNodeType::NoType; 
-    } 
-  }; 
- 
+    std::size_t childCount;
+    bool longKey;
+
+    SettingChanges modifiedSettings;
+
+    EmitterNodeType::value NodeType() const {
+      if (type == GroupType::Seq) {
+        if (flowType == FlowType::Flow)
+          return EmitterNodeType::FlowSeq;
+        else
+          return EmitterNodeType::BlockSeq;
+      } else {
+        if (flowType == FlowType::Flow)
+          return EmitterNodeType::FlowMap;
+        else
+          return EmitterNodeType::BlockMap;
+      }
+
+      // can't get here
+      assert(false);
+      return EmitterNodeType::NoType;
+    }
+  };
+
   std::vector<std::unique_ptr<Group>> m_groups;
-  std::size_t m_curIndent; 
-  bool m_hasAnchor; 
-  bool m_hasTag; 
-  bool m_hasNonContent; 
-  std::size_t m_docCount; 
-}; 
- 
-template <typename T> 
-void EmitterState::_Set(Setting<T>& fmt, T value, FmtScope::value scope) { 
-  switch (scope) { 
-    case FmtScope::Local: 
-      m_modifiedSettings.push(fmt.set(value)); 
-      break; 
-    case FmtScope::Global: 
-      fmt.set(value); 
-      m_globalModifiedSettings.push( 
-          fmt.set(value));  // this pushes an identity set, so when we restore, 
-      // it restores to the value here, and not the previous one 
-      break; 
-    default: 
-      assert(false); 
-  } 
-} 
-} 
- 
-#endif  // EMITTERSTATE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+  std::size_t m_curIndent;
+  bool m_hasAnchor;
+  bool m_hasTag;
+  bool m_hasNonContent;
+  std::size_t m_docCount;
+};
+
+template <typename T>
+void EmitterState::_Set(Setting<T>& fmt, T value, FmtScope::value scope) {
+  switch (scope) {
+    case FmtScope::Local:
+      m_modifiedSettings.push(fmt.set(value));
+      break;
+    case FmtScope::Global:
+      fmt.set(value);
+      m_globalModifiedSettings.push(
+          fmt.set(value));  // this pushes an identity set, so when we restore,
+      // it restores to the value here, and not the previous one
+      break;
+    default:
+      assert(false);
+  }
+}
+}
+
+#endif  // EMITTERSTATE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/src/emitterutils.cpp b/contrib/libs/yaml-cpp/src/emitterutils.cpp
index 244d2ff65f0..147738ad8a1 100644
--- a/contrib/libs/yaml-cpp/src/emitterutils.cpp
+++ b/contrib/libs/yaml-cpp/src/emitterutils.cpp
@@ -1,483 +1,483 @@
-#include <iomanip> 
-#include <sstream> 
- 
-#include "emitterutils.h" 
-#include "exp.h" 
-#include "indentation.h" 
-#include "regex_yaml.h" 
-#include "regeximpl.h" 
-#include "stringsource.h" 
-#include "yaml-cpp/binary.h"  // IWYU pragma: keep 
-#include "yaml-cpp/ostream_wrapper.h" 
+#include <iomanip>
+#include <sstream>
+
+#include "emitterutils.h"
+#include "exp.h"
+#include "indentation.h"
+#include "regex_yaml.h"
+#include "regeximpl.h"
+#include "stringsource.h"
+#include "yaml-cpp/binary.h"  // IWYU pragma: keep
+#include "yaml-cpp/ostream_wrapper.h"
 #include "yaml-cpp/null.h"
- 
-namespace YAML { 
-namespace Utils { 
-namespace { 
-enum { REPLACEMENT_CHARACTER = 0xFFFD }; 
- 
-bool IsAnchorChar(int ch) {  // test for ns-anchor-char 
-  switch (ch) { 
-    case ',': 
-    case '[': 
-    case ']': 
-    case '{': 
-    case '}':  // c-flow-indicator 
-    case ' ': 
-    case '\t':    // s-white 
-    case 0xFEFF:  // c-byte-order-mark 
-    case 0xA: 
-    case 0xD:  // b-char 
-      return false; 
-    case 0x85: 
-      return true; 
-  } 
- 
-  if (ch < 0x20) { 
-    return false; 
-  } 
- 
-  if (ch < 0x7E) { 
-    return true; 
-  } 
- 
-  if (ch < 0xA0) { 
-    return false; 
-  } 
-  if (ch >= 0xD800 && ch <= 0xDFFF) { 
-    return false; 
-  } 
-  if ((ch & 0xFFFE) == 0xFFFE) { 
-    return false; 
-  } 
-  if ((ch >= 0xFDD0) && (ch <= 0xFDEF)) { 
-    return false; 
-  } 
-  if (ch > 0x10FFFF) { 
-    return false; 
-  } 
- 
-  return true; 
-} 
- 
-int Utf8BytesIndicated(char ch) { 
-  int byteVal = static_cast<unsigned char>(ch); 
-  switch (byteVal >> 4) { 
-    case 0: 
-    case 1: 
-    case 2: 
-    case 3: 
-    case 4: 
-    case 5: 
-    case 6: 
-    case 7: 
-      return 1; 
-    case 12: 
-    case 13: 
-      return 2; 
-    case 14: 
-      return 3; 
-    case 15: 
-      return 4; 
-    default: 
-      return -1; 
-  } 
-} 
- 
-bool IsTrailingByte(char ch) { return (ch & 0xC0) == 0x80; } 
- 
-bool GetNextCodePointAndAdvance(int& codePoint, 
-                                std::string::const_iterator& first, 
-                                std::string::const_iterator last) { 
-  if (first == last) 
-    return false; 
- 
-  int nBytes = Utf8BytesIndicated(*first); 
-  if (nBytes < 1) { 
-    // Bad lead byte 
-    ++first; 
-    codePoint = REPLACEMENT_CHARACTER; 
-    return true; 
-  } 
- 
-  if (nBytes == 1) { 
-    codePoint = *first++; 
-    return true; 
-  } 
- 
-  // Gather bits from trailing bytes 
-  codePoint = static_cast<unsigned char>(*first) & ~(0xFF << (7 - nBytes)); 
-  ++first; 
-  --nBytes; 
-  for (; nBytes > 0; ++first, --nBytes) { 
-    if ((first == last) || !IsTrailingByte(*first)) { 
-      codePoint = REPLACEMENT_CHARACTER; 
-      break; 
-    } 
-    codePoint <<= 6; 
-    codePoint |= *first & 0x3F; 
-  } 
- 
-  // Check for illegal code points 
-  if (codePoint > 0x10FFFF) 
-    codePoint = REPLACEMENT_CHARACTER; 
-  else if (codePoint >= 0xD800 && codePoint <= 0xDFFF) 
-    codePoint = REPLACEMENT_CHARACTER; 
-  else if ((codePoint & 0xFFFE) == 0xFFFE) 
-    codePoint = REPLACEMENT_CHARACTER; 
-  else if (codePoint >= 0xFDD0 && codePoint <= 0xFDEF) 
-    codePoint = REPLACEMENT_CHARACTER; 
-  return true; 
-} 
- 
-void WriteCodePoint(ostream_wrapper& out, int codePoint) { 
-  if (codePoint < 0 || codePoint > 0x10FFFF) { 
-    codePoint = REPLACEMENT_CHARACTER; 
-  } 
-  if (codePoint < 0x7F) { 
-    out << static_cast<char>(codePoint); 
-  } else if (codePoint < 0x7FF) { 
-    out << static_cast<char>(0xC0 | (codePoint >> 6)) 
-        << static_cast<char>(0x80 | (codePoint & 0x3F)); 
-  } else if (codePoint < 0xFFFF) { 
-    out << static_cast<char>(0xE0 | (codePoint >> 12)) 
-        << static_cast<char>(0x80 | ((codePoint >> 6) & 0x3F)) 
-        << static_cast<char>(0x80 | (codePoint & 0x3F)); 
-  } else { 
-    out << static_cast<char>(0xF0 | (codePoint >> 18)) 
-        << static_cast<char>(0x80 | ((codePoint >> 12) & 0x3F)) 
-        << static_cast<char>(0x80 | ((codePoint >> 6) & 0x3F)) 
-        << static_cast<char>(0x80 | (codePoint & 0x3F)); 
-  } 
-} 
- 
-bool IsValidPlainScalar(const std::string& str, FlowType::value flowType, 
-                        bool allowOnlyAscii) { 
-  // check against null 
+
+namespace YAML {
+namespace Utils {
+namespace {
+enum { REPLACEMENT_CHARACTER = 0xFFFD };
+
+bool IsAnchorChar(int ch) {  // test for ns-anchor-char
+  switch (ch) {
+    case ',':
+    case '[':
+    case ']':
+    case '{':
+    case '}':  // c-flow-indicator
+    case ' ':
+    case '\t':    // s-white
+    case 0xFEFF:  // c-byte-order-mark
+    case 0xA:
+    case 0xD:  // b-char
+      return false;
+    case 0x85:
+      return true;
+  }
+
+  if (ch < 0x20) {
+    return false;
+  }
+
+  if (ch < 0x7E) {
+    return true;
+  }
+
+  if (ch < 0xA0) {
+    return false;
+  }
+  if (ch >= 0xD800 && ch <= 0xDFFF) {
+    return false;
+  }
+  if ((ch & 0xFFFE) == 0xFFFE) {
+    return false;
+  }
+  if ((ch >= 0xFDD0) && (ch <= 0xFDEF)) {
+    return false;
+  }
+  if (ch > 0x10FFFF) {
+    return false;
+  }
+
+  return true;
+}
+
+int Utf8BytesIndicated(char ch) {
+  int byteVal = static_cast<unsigned char>(ch);
+  switch (byteVal >> 4) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+    case 6:
+    case 7:
+      return 1;
+    case 12:
+    case 13:
+      return 2;
+    case 14:
+      return 3;
+    case 15:
+      return 4;
+    default:
+      return -1;
+  }
+}
+
+bool IsTrailingByte(char ch) { return (ch & 0xC0) == 0x80; }
+
+bool GetNextCodePointAndAdvance(int& codePoint,
+                                std::string::const_iterator& first,
+                                std::string::const_iterator last) {
+  if (first == last)
+    return false;
+
+  int nBytes = Utf8BytesIndicated(*first);
+  if (nBytes < 1) {
+    // Bad lead byte
+    ++first;
+    codePoint = REPLACEMENT_CHARACTER;
+    return true;
+  }
+
+  if (nBytes == 1) {
+    codePoint = *first++;
+    return true;
+  }
+
+  // Gather bits from trailing bytes
+  codePoint = static_cast<unsigned char>(*first) & ~(0xFF << (7 - nBytes));
+  ++first;
+  --nBytes;
+  for (; nBytes > 0; ++first, --nBytes) {
+    if ((first == last) || !IsTrailingByte(*first)) {
+      codePoint = REPLACEMENT_CHARACTER;
+      break;
+    }
+    codePoint <<= 6;
+    codePoint |= *first & 0x3F;
+  }
+
+  // Check for illegal code points
+  if (codePoint > 0x10FFFF)
+    codePoint = REPLACEMENT_CHARACTER;
+  else if (codePoint >= 0xD800 && codePoint <= 0xDFFF)
+    codePoint = REPLACEMENT_CHARACTER;
+  else if ((codePoint & 0xFFFE) == 0xFFFE)
+    codePoint = REPLACEMENT_CHARACTER;
+  else if (codePoint >= 0xFDD0 && codePoint <= 0xFDEF)
+    codePoint = REPLACEMENT_CHARACTER;
+  return true;
+}
+
+void WriteCodePoint(ostream_wrapper& out, int codePoint) {
+  if (codePoint < 0 || codePoint > 0x10FFFF) {
+    codePoint = REPLACEMENT_CHARACTER;
+  }
+  if (codePoint < 0x7F) {
+    out << static_cast<char>(codePoint);
+  } else if (codePoint < 0x7FF) {
+    out << static_cast<char>(0xC0 | (codePoint >> 6))
+        << static_cast<char>(0x80 | (codePoint & 0x3F));
+  } else if (codePoint < 0xFFFF) {
+    out << static_cast<char>(0xE0 | (codePoint >> 12))
+        << static_cast<char>(0x80 | ((codePoint >> 6) & 0x3F))
+        << static_cast<char>(0x80 | (codePoint & 0x3F));
+  } else {
+    out << static_cast<char>(0xF0 | (codePoint >> 18))
+        << static_cast<char>(0x80 | ((codePoint >> 12) & 0x3F))
+        << static_cast<char>(0x80 | ((codePoint >> 6) & 0x3F))
+        << static_cast<char>(0x80 | (codePoint & 0x3F));
+  }
+}
+
+bool IsValidPlainScalar(const std::string& str, FlowType::value flowType,
+                        bool allowOnlyAscii) {
+  // check against null
   if (IsNullString(str)) {
-    return false; 
-  } 
- 
-  // check the start 
-  const RegEx& start = (flowType == FlowType::Flow ? Exp::PlainScalarInFlow() 
-                                                   : Exp::PlainScalar()); 
-  if (!start.Matches(str)) { 
-    return false; 
-  } 
- 
-  // and check the end for plain whitespace (which can't be faithfully kept in a 
-  // plain scalar) 
-  if (!str.empty() && *str.rbegin() == ' ') { 
-    return false; 
-  } 
- 
-  // then check until something is disallowed 
-  static const RegEx& disallowed_flow = 
-      Exp::EndScalarInFlow() || (Exp::BlankOrBreak() + Exp::Comment()) || 
-      Exp::NotPrintable() || Exp::Utf8_ByteOrderMark() || Exp::Break() || 
-      Exp::Tab(); 
-  static const RegEx& disallowed_block = 
-      Exp::EndScalar() || (Exp::BlankOrBreak() + Exp::Comment()) || 
-      Exp::NotPrintable() || Exp::Utf8_ByteOrderMark() || Exp::Break() || 
-      Exp::Tab(); 
-  const RegEx& disallowed = 
-      flowType == FlowType::Flow ? disallowed_flow : disallowed_block; 
- 
-  StringCharSource buffer(str.c_str(), str.size()); 
-  while (buffer) { 
-    if (disallowed.Matches(buffer)) { 
-      return false; 
-    } 
-    if (allowOnlyAscii && (0x80 <= static_cast<unsigned char>(buffer[0]))) { 
-      return false; 
-    } 
-    ++buffer; 
-  } 
- 
-  return true; 
-} 
- 
-bool IsValidSingleQuotedScalar(const std::string& str, bool escapeNonAscii) { 
-  // TODO: check for non-printable characters? 
-  for (std::size_t i = 0; i < str.size(); i++) { 
-    if (escapeNonAscii && (0x80 <= static_cast<unsigned char>(str[i]))) { 
-      return false; 
-    } 
-    if (str[i] == '\n') { 
-      return false; 
-    } 
-  } 
-  return true; 
-} 
- 
-bool IsValidLiteralScalar(const std::string& str, FlowType::value flowType, 
-                          bool escapeNonAscii) { 
-  if (flowType == FlowType::Flow) { 
-    return false; 
-  } 
- 
-  // TODO: check for non-printable characters? 
-  for (std::size_t i = 0; i < str.size(); i++) { 
-    if (escapeNonAscii && (0x80 <= static_cast<unsigned char>(str[i]))) { 
-      return false; 
-    } 
-  } 
-  return true; 
-} 
- 
-void WriteDoubleQuoteEscapeSequence(ostream_wrapper& out, int codePoint) { 
-  static const char hexDigits[] = "0123456789abcdef"; 
- 
-  out << "\\"; 
-  int digits = 8; 
-  if (codePoint < 0xFF) { 
-    out << "x"; 
-    digits = 2; 
-  } else if (codePoint < 0xFFFF) { 
-    out << "u"; 
-    digits = 4; 
-  } else { 
-    out << "U"; 
-    digits = 8; 
-  } 
- 
-  // Write digits into the escape sequence 
-  for (; digits > 0; --digits) 
-    out << hexDigits[(codePoint >> (4 * (digits - 1))) & 0xF]; 
-} 
- 
-bool WriteAliasName(ostream_wrapper& out, const std::string& str) { 
-  int codePoint; 
-  for (std::string::const_iterator i = str.begin(); 
-       GetNextCodePointAndAdvance(codePoint, i, str.end());) { 
-    if (!IsAnchorChar(codePoint)) { 
-      return false; 
-    } 
- 
-    WriteCodePoint(out, codePoint); 
-  } 
-  return true; 
-} 
-} 
- 
-StringFormat::value ComputeStringFormat(const std::string& str, 
-                                        EMITTER_MANIP strFormat, 
-                                        FlowType::value flowType, 
-                                        bool escapeNonAscii) { 
-  switch (strFormat) { 
-    case Auto: 
-      if (IsValidPlainScalar(str, flowType, escapeNonAscii)) { 
-        return StringFormat::Plain; 
-      } 
-      return StringFormat::DoubleQuoted; 
-    case SingleQuoted: 
-      if (IsValidSingleQuotedScalar(str, escapeNonAscii)) { 
-        return StringFormat::SingleQuoted; 
-      } 
-      return StringFormat::DoubleQuoted; 
-    case DoubleQuoted: 
-      return StringFormat::DoubleQuoted; 
-    case Literal: 
-      if (IsValidLiteralScalar(str, flowType, escapeNonAscii)) { 
-        return StringFormat::Literal; 
-      } 
-      return StringFormat::DoubleQuoted; 
-    default: 
-      break; 
-  } 
- 
-  return StringFormat::DoubleQuoted; 
-} 
- 
-bool WriteSingleQuotedString(ostream_wrapper& out, const std::string& str) { 
-  out << "'"; 
-  int codePoint; 
-  for (std::string::const_iterator i = str.begin(); 
-       GetNextCodePointAndAdvance(codePoint, i, str.end());) { 
-    if (codePoint == '\n') { 
-      return false;  // We can't handle a new line and the attendant indentation 
-                     // yet 
-    } 
- 
-    if (codePoint == '\'') { 
-      out << "''"; 
-    } else { 
-      WriteCodePoint(out, codePoint); 
-    } 
-  } 
-  out << "'"; 
-  return true; 
-} 
- 
-bool WriteDoubleQuotedString(ostream_wrapper& out, const std::string& str, 
-                             bool escapeNonAscii) { 
-  out << "\""; 
-  int codePoint; 
-  for (std::string::const_iterator i = str.begin(); 
-       GetNextCodePointAndAdvance(codePoint, i, str.end());) { 
-    switch (codePoint) { 
-      case '\"': 
-        out << "\\\""; 
-        break; 
-      case '\\': 
-        out << "\\\\"; 
-        break; 
-      case '\n': 
-        out << "\\n"; 
-        break; 
-      case '\t': 
-        out << "\\t"; 
-        break; 
-      case '\r': 
-        out << "\\r"; 
-        break; 
-      case '\b': 
-        out << "\\b"; 
-        break; 
-      default: 
-        if (codePoint < 0x20 || 
-            (codePoint >= 0x80 && 
-             codePoint <= 0xA0)) {  // Control characters and non-breaking space 
-          WriteDoubleQuoteEscapeSequence(out, codePoint); 
-        } else if (codePoint == 0xFEFF) {  // Byte order marks (ZWNS) should be 
-                                           // escaped (YAML 1.2, sec. 5.2) 
-          WriteDoubleQuoteEscapeSequence(out, codePoint); 
-        } else if (escapeNonAscii && codePoint > 0x7E) { 
-          WriteDoubleQuoteEscapeSequence(out, codePoint); 
-        } else { 
-          WriteCodePoint(out, codePoint); 
-        } 
-    } 
-  } 
-  out << "\""; 
-  return true; 
-} 
- 
-bool WriteLiteralString(ostream_wrapper& out, const std::string& str, 
+    return false;
+  }
+
+  // check the start
+  const RegEx& start = (flowType == FlowType::Flow ? Exp::PlainScalarInFlow()
+                                                   : Exp::PlainScalar());
+  if (!start.Matches(str)) {
+    return false;
+  }
+
+  // and check the end for plain whitespace (which can't be faithfully kept in a
+  // plain scalar)
+  if (!str.empty() && *str.rbegin() == ' ') {
+    return false;
+  }
+
+  // then check until something is disallowed
+  static const RegEx& disallowed_flow =
+      Exp::EndScalarInFlow() || (Exp::BlankOrBreak() + Exp::Comment()) ||
+      Exp::NotPrintable() || Exp::Utf8_ByteOrderMark() || Exp::Break() ||
+      Exp::Tab();
+  static const RegEx& disallowed_block =
+      Exp::EndScalar() || (Exp::BlankOrBreak() + Exp::Comment()) ||
+      Exp::NotPrintable() || Exp::Utf8_ByteOrderMark() || Exp::Break() ||
+      Exp::Tab();
+  const RegEx& disallowed =
+      flowType == FlowType::Flow ? disallowed_flow : disallowed_block;
+
+  StringCharSource buffer(str.c_str(), str.size());
+  while (buffer) {
+    if (disallowed.Matches(buffer)) {
+      return false;
+    }
+    if (allowOnlyAscii && (0x80 <= static_cast<unsigned char>(buffer[0]))) {
+      return false;
+    }
+    ++buffer;
+  }
+
+  return true;
+}
+
+bool IsValidSingleQuotedScalar(const std::string& str, bool escapeNonAscii) {
+  // TODO: check for non-printable characters?
+  for (std::size_t i = 0; i < str.size(); i++) {
+    if (escapeNonAscii && (0x80 <= static_cast<unsigned char>(str[i]))) {
+      return false;
+    }
+    if (str[i] == '\n') {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool IsValidLiteralScalar(const std::string& str, FlowType::value flowType,
+                          bool escapeNonAscii) {
+  if (flowType == FlowType::Flow) {
+    return false;
+  }
+
+  // TODO: check for non-printable characters?
+  for (std::size_t i = 0; i < str.size(); i++) {
+    if (escapeNonAscii && (0x80 <= static_cast<unsigned char>(str[i]))) {
+      return false;
+    }
+  }
+  return true;
+}
+
+void WriteDoubleQuoteEscapeSequence(ostream_wrapper& out, int codePoint) {
+  static const char hexDigits[] = "0123456789abcdef";
+
+  out << "\\";
+  int digits = 8;
+  if (codePoint < 0xFF) {
+    out << "x";
+    digits = 2;
+  } else if (codePoint < 0xFFFF) {
+    out << "u";
+    digits = 4;
+  } else {
+    out << "U";
+    digits = 8;
+  }
+
+  // Write digits into the escape sequence
+  for (; digits > 0; --digits)
+    out << hexDigits[(codePoint >> (4 * (digits - 1))) & 0xF];
+}
+
+bool WriteAliasName(ostream_wrapper& out, const std::string& str) {
+  int codePoint;
+  for (std::string::const_iterator i = str.begin();
+       GetNextCodePointAndAdvance(codePoint, i, str.end());) {
+    if (!IsAnchorChar(codePoint)) {
+      return false;
+    }
+
+    WriteCodePoint(out, codePoint);
+  }
+  return true;
+}
+}
+
+StringFormat::value ComputeStringFormat(const std::string& str,
+                                        EMITTER_MANIP strFormat,
+                                        FlowType::value flowType,
+                                        bool escapeNonAscii) {
+  switch (strFormat) {
+    case Auto:
+      if (IsValidPlainScalar(str, flowType, escapeNonAscii)) {
+        return StringFormat::Plain;
+      }
+      return StringFormat::DoubleQuoted;
+    case SingleQuoted:
+      if (IsValidSingleQuotedScalar(str, escapeNonAscii)) {
+        return StringFormat::SingleQuoted;
+      }
+      return StringFormat::DoubleQuoted;
+    case DoubleQuoted:
+      return StringFormat::DoubleQuoted;
+    case Literal:
+      if (IsValidLiteralScalar(str, flowType, escapeNonAscii)) {
+        return StringFormat::Literal;
+      }
+      return StringFormat::DoubleQuoted;
+    default:
+      break;
+  }
+
+  return StringFormat::DoubleQuoted;
+}
+
+bool WriteSingleQuotedString(ostream_wrapper& out, const std::string& str) {
+  out << "'";
+  int codePoint;
+  for (std::string::const_iterator i = str.begin();
+       GetNextCodePointAndAdvance(codePoint, i, str.end());) {
+    if (codePoint == '\n') {
+      return false;  // We can't handle a new line and the attendant indentation
+                     // yet
+    }
+
+    if (codePoint == '\'') {
+      out << "''";
+    } else {
+      WriteCodePoint(out, codePoint);
+    }
+  }
+  out << "'";
+  return true;
+}
+
+bool WriteDoubleQuotedString(ostream_wrapper& out, const std::string& str,
+                             bool escapeNonAscii) {
+  out << "\"";
+  int codePoint;
+  for (std::string::const_iterator i = str.begin();
+       GetNextCodePointAndAdvance(codePoint, i, str.end());) {
+    switch (codePoint) {
+      case '\"':
+        out << "\\\"";
+        break;
+      case '\\':
+        out << "\\\\";
+        break;
+      case '\n':
+        out << "\\n";
+        break;
+      case '\t':
+        out << "\\t";
+        break;
+      case '\r':
+        out << "\\r";
+        break;
+      case '\b':
+        out << "\\b";
+        break;
+      default:
+        if (codePoint < 0x20 ||
+            (codePoint >= 0x80 &&
+             codePoint <= 0xA0)) {  // Control characters and non-breaking space
+          WriteDoubleQuoteEscapeSequence(out, codePoint);
+        } else if (codePoint == 0xFEFF) {  // Byte order marks (ZWNS) should be
+                                           // escaped (YAML 1.2, sec. 5.2)
+          WriteDoubleQuoteEscapeSequence(out, codePoint);
+        } else if (escapeNonAscii && codePoint > 0x7E) {
+          WriteDoubleQuoteEscapeSequence(out, codePoint);
+        } else {
+          WriteCodePoint(out, codePoint);
+        }
+    }
+  }
+  out << "\"";
+  return true;
+}
+
+bool WriteLiteralString(ostream_wrapper& out, const std::string& str,
                         std::size_t indent) {
-  out << "|\n"; 
-  out << IndentTo(indent); 
-  int codePoint; 
-  for (std::string::const_iterator i = str.begin(); 
-       GetNextCodePointAndAdvance(codePoint, i, str.end());) { 
-    if (codePoint == '\n') { 
-      out << "\n" << IndentTo(indent); 
-    } else { 
-      WriteCodePoint(out, codePoint); 
-    } 
-  } 
-  return true; 
-} 
- 
-bool WriteChar(ostream_wrapper& out, char ch) { 
-  if (('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z')) { 
-    out << ch; 
-  } else if (ch == '\"') { 
-    out << "\"\\\"\""; 
-  } else if (ch == '\t') { 
-    out << "\"\\t\""; 
-  } else if (ch == '\n') { 
-    out << "\"\\n\""; 
-  } else if (ch == '\b') { 
-    out << "\"\\b\""; 
+  out << "|\n";
+  out << IndentTo(indent);
+  int codePoint;
+  for (std::string::const_iterator i = str.begin();
+       GetNextCodePointAndAdvance(codePoint, i, str.end());) {
+    if (codePoint == '\n') {
+      out << "\n" << IndentTo(indent);
+    } else {
+      WriteCodePoint(out, codePoint);
+    }
+  }
+  return true;
+}
+
+bool WriteChar(ostream_wrapper& out, char ch) {
+  if (('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z')) {
+    out << ch;
+  } else if (ch == '\"') {
+    out << "\"\\\"\"";
+  } else if (ch == '\t') {
+    out << "\"\\t\"";
+  } else if (ch == '\n') {
+    out << "\"\\n\"";
+  } else if (ch == '\b') {
+    out << "\"\\b\"";
   } else if (ch == '\\') {
     out << "\"\\\\\"";
-  } else if ((0x20 <= ch && ch <= 0x7e) || ch == ' ') { 
-    out << "\"" << ch << "\""; 
-  } else { 
-    out << "\""; 
-    WriteDoubleQuoteEscapeSequence(out, ch); 
-    out << "\""; 
-  } 
-  return true; 
-} 
- 
-bool WriteComment(ostream_wrapper& out, const std::string& str, 
+  } else if ((0x20 <= ch && ch <= 0x7e) || ch == ' ') {
+    out << "\"" << ch << "\"";
+  } else {
+    out << "\"";
+    WriteDoubleQuoteEscapeSequence(out, ch);
+    out << "\"";
+  }
+  return true;
+}
+
+bool WriteComment(ostream_wrapper& out, const std::string& str,
                   std::size_t postCommentIndent) {
-  const std::size_t curIndent = out.col(); 
-  out << "#" << Indentation(postCommentIndent); 
-  out.set_comment(); 
-  int codePoint; 
-  for (std::string::const_iterator i = str.begin(); 
-       GetNextCodePointAndAdvance(codePoint, i, str.end());) { 
-    if (codePoint == '\n') { 
-      out << "\n" << IndentTo(curIndent) << "#" 
-          << Indentation(postCommentIndent); 
-      out.set_comment(); 
-    } else { 
-      WriteCodePoint(out, codePoint); 
-    } 
-  } 
-  return true; 
-} 
- 
-bool WriteAlias(ostream_wrapper& out, const std::string& str) { 
-  out << "*"; 
-  return WriteAliasName(out, str); 
-} 
- 
-bool WriteAnchor(ostream_wrapper& out, const std::string& str) { 
-  out << "&"; 
-  return WriteAliasName(out, str); 
-} 
- 
-bool WriteTag(ostream_wrapper& out, const std::string& str, bool verbatim) { 
-  out << (verbatim ? "!<" : "!"); 
-  StringCharSource buffer(str.c_str(), str.size()); 
-  const RegEx& reValid = verbatim ? Exp::URI() : Exp::Tag(); 
-  while (buffer) { 
-    int n = reValid.Match(buffer); 
-    if (n <= 0) { 
-      return false; 
-    } 
- 
-    while (--n >= 0) { 
-      out << buffer[0]; 
-      ++buffer; 
-    } 
-  } 
-  if (verbatim) { 
-    out << ">"; 
-  } 
-  return true; 
-} 
- 
-bool WriteTagWithPrefix(ostream_wrapper& out, const std::string& prefix, 
-                        const std::string& tag) { 
-  out << "!"; 
-  StringCharSource prefixBuffer(prefix.c_str(), prefix.size()); 
-  while (prefixBuffer) { 
-    int n = Exp::URI().Match(prefixBuffer); 
-    if (n <= 0) { 
-      return false; 
-    } 
- 
-    while (--n >= 0) { 
-      out << prefixBuffer[0]; 
-      ++prefixBuffer; 
-    } 
-  } 
- 
-  out << "!"; 
-  StringCharSource tagBuffer(tag.c_str(), tag.size()); 
-  while (tagBuffer) { 
-    int n = Exp::Tag().Match(tagBuffer); 
-    if (n <= 0) { 
-      return false; 
-    } 
- 
-    while (--n >= 0) { 
-      out << tagBuffer[0]; 
-      ++tagBuffer; 
-    } 
-  } 
-  return true; 
-} 
- 
-bool WriteBinary(ostream_wrapper& out, const Binary& binary) { 
-  WriteDoubleQuotedString(out, EncodeBase64(binary.data(), binary.size()), 
-                          false); 
-  return true; 
-} 
-} 
-} 
+  const std::size_t curIndent = out.col();
+  out << "#" << Indentation(postCommentIndent);
+  out.set_comment();
+  int codePoint;
+  for (std::string::const_iterator i = str.begin();
+       GetNextCodePointAndAdvance(codePoint, i, str.end());) {
+    if (codePoint == '\n') {
+      out << "\n" << IndentTo(curIndent) << "#"
+          << Indentation(postCommentIndent);
+      out.set_comment();
+    } else {
+      WriteCodePoint(out, codePoint);
+    }
+  }
+  return true;
+}
+
+bool WriteAlias(ostream_wrapper& out, const std::string& str) {
+  out << "*";
+  return WriteAliasName(out, str);
+}
+
+bool WriteAnchor(ostream_wrapper& out, const std::string& str) {
+  out << "&";
+  return WriteAliasName(out, str);
+}
+
+bool WriteTag(ostream_wrapper& out, const std::string& str, bool verbatim) {
+  out << (verbatim ? "!<" : "!");
+  StringCharSource buffer(str.c_str(), str.size());
+  const RegEx& reValid = verbatim ? Exp::URI() : Exp::Tag();
+  while (buffer) {
+    int n = reValid.Match(buffer);
+    if (n <= 0) {
+      return false;
+    }
+
+    while (--n >= 0) {
+      out << buffer[0];
+      ++buffer;
+    }
+  }
+  if (verbatim) {
+    out << ">";
+  }
+  return true;
+}
+
+bool WriteTagWithPrefix(ostream_wrapper& out, const std::string& prefix,
+                        const std::string& tag) {
+  out << "!";
+  StringCharSource prefixBuffer(prefix.c_str(), prefix.size());
+  while (prefixBuffer) {
+    int n = Exp::URI().Match(prefixBuffer);
+    if (n <= 0) {
+      return false;
+    }
+
+    while (--n >= 0) {
+      out << prefixBuffer[0];
+      ++prefixBuffer;
+    }
+  }
+
+  out << "!";
+  StringCharSource tagBuffer(tag.c_str(), tag.size());
+  while (tagBuffer) {
+    int n = Exp::Tag().Match(tagBuffer);
+    if (n <= 0) {
+      return false;
+    }
+
+    while (--n >= 0) {
+      out << tagBuffer[0];
+      ++tagBuffer;
+    }
+  }
+  return true;
+}
+
+bool WriteBinary(ostream_wrapper& out, const Binary& binary) {
+  WriteDoubleQuotedString(out, EncodeBase64(binary.data(), binary.size()),
+                          false);
+  return true;
+}
+}
+}
diff --git a/contrib/libs/yaml-cpp/src/emitterutils.h b/contrib/libs/yaml-cpp/src/emitterutils.h
index 1a668a524c4..6cc73191476 100644
--- a/contrib/libs/yaml-cpp/src/emitterutils.h
+++ b/contrib/libs/yaml-cpp/src/emitterutils.h
@@ -1,50 +1,50 @@
-#ifndef EMITTERUTILS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define EMITTERUTILS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include <string> 
- 
-#include "emitterstate.h" 
-#include "yaml-cpp/emittermanip.h" 
-#include "yaml-cpp/ostream_wrapper.h" 
- 
-namespace YAML { 
-class ostream_wrapper; 
-}  // namespace YAML 
- 
-namespace YAML { 
-class Binary; 
- 
-struct StringFormat { 
-  enum value { Plain, SingleQuoted, DoubleQuoted, Literal }; 
-}; 
- 
-namespace Utils { 
-StringFormat::value ComputeStringFormat(const std::string& str, 
-                                        EMITTER_MANIP strFormat, 
-                                        FlowType::value flowType, 
-                                        bool escapeNonAscii); 
- 
-bool WriteSingleQuotedString(ostream_wrapper& out, const std::string& str); 
-bool WriteDoubleQuotedString(ostream_wrapper& out, const std::string& str, 
-                             bool escapeNonAscii); 
-bool WriteLiteralString(ostream_wrapper& out, const std::string& str, 
+#ifndef EMITTERUTILS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define EMITTERUTILS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <string>
+
+#include "emitterstate.h"
+#include "yaml-cpp/emittermanip.h"
+#include "yaml-cpp/ostream_wrapper.h"
+
+namespace YAML {
+class ostream_wrapper;
+}  // namespace YAML
+
+namespace YAML {
+class Binary;
+
+struct StringFormat {
+  enum value { Plain, SingleQuoted, DoubleQuoted, Literal };
+};
+
+namespace Utils {
+StringFormat::value ComputeStringFormat(const std::string& str,
+                                        EMITTER_MANIP strFormat,
+                                        FlowType::value flowType,
+                                        bool escapeNonAscii);
+
+bool WriteSingleQuotedString(ostream_wrapper& out, const std::string& str);
+bool WriteDoubleQuotedString(ostream_wrapper& out, const std::string& str,
+                             bool escapeNonAscii);
+bool WriteLiteralString(ostream_wrapper& out, const std::string& str,
                         std::size_t indent);
-bool WriteChar(ostream_wrapper& out, char ch); 
-bool WriteComment(ostream_wrapper& out, const std::string& str, 
+bool WriteChar(ostream_wrapper& out, char ch);
+bool WriteComment(ostream_wrapper& out, const std::string& str,
                   std::size_t postCommentIndent);
-bool WriteAlias(ostream_wrapper& out, const std::string& str); 
-bool WriteAnchor(ostream_wrapper& out, const std::string& str); 
-bool WriteTag(ostream_wrapper& out, const std::string& str, bool verbatim); 
-bool WriteTagWithPrefix(ostream_wrapper& out, const std::string& prefix, 
-                        const std::string& tag); 
-bool WriteBinary(ostream_wrapper& out, const Binary& binary); 
-} 
-} 
- 
-#endif  // EMITTERUTILS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+bool WriteAlias(ostream_wrapper& out, const std::string& str);
+bool WriteAnchor(ostream_wrapper& out, const std::string& str);
+bool WriteTag(ostream_wrapper& out, const std::string& str, bool verbatim);
+bool WriteTagWithPrefix(ostream_wrapper& out, const std::string& prefix,
+                        const std::string& tag);
+bool WriteBinary(ostream_wrapper& out, const Binary& binary);
+}
+}
+
+#endif  // EMITTERUTILS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/src/exp.cpp b/contrib/libs/yaml-cpp/src/exp.cpp
index 01a6ed0c4c8..695440aec0e 100644
--- a/contrib/libs/yaml-cpp/src/exp.cpp
+++ b/contrib/libs/yaml-cpp/src/exp.cpp
@@ -1,136 +1,136 @@
-#include <sstream> 
- 
-#include "exp.h" 
-#include "stream.h" 
-#include "yaml-cpp/exceptions.h"  // IWYU pragma: keep 
- 
-namespace YAML { 
-struct Mark; 
-}  // namespace YAML 
- 
-namespace YAML { 
-namespace Exp { 
-unsigned ParseHex(const std::string& str, const Mark& mark) { 
-  unsigned value = 0; 
-  for (std::size_t i = 0; i < str.size(); i++) { 
-    char ch = str[i]; 
-    int digit = 0; 
-    if ('a' <= ch && ch <= 'f') 
-      digit = ch - 'a' + 10; 
-    else if ('A' <= ch && ch <= 'F') 
-      digit = ch - 'A' + 10; 
-    else if ('0' <= ch && ch <= '9') 
-      digit = ch - '0'; 
-    else 
-      throw ParserException(mark, ErrorMsg::INVALID_HEX); 
- 
-    value = (value << 4) + digit; 
-  } 
- 
-  return value; 
-} 
- 
-std::string Str(unsigned ch) { return std::string(1, static_cast<char>(ch)); } 
- 
-// Escape 
-// . Translates the next 'codeLength' characters into a hex number and returns 
-// the result. 
-// . Throws if it's not actually hex. 
-std::string Escape(Stream& in, int codeLength) { 
-  // grab string 
-  std::string str; 
-  for (int i = 0; i < codeLength; i++) 
-    str += in.get(); 
- 
-  // get the value 
-  unsigned value = ParseHex(str, in.mark()); 
- 
-  // legal unicode? 
-  if ((value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF) { 
-    std::stringstream msg; 
-    msg << ErrorMsg::INVALID_UNICODE << value; 
-    throw ParserException(in.mark(), msg.str()); 
-  } 
- 
-  // now break it up into chars 
-  if (value <= 0x7F) 
-    return Str(value); 
-  else if (value <= 0x7FF) 
-    return Str(0xC0 + (value >> 6)) + Str(0x80 + (value & 0x3F)); 
-  else if (value <= 0xFFFF) 
-    return Str(0xE0 + (value >> 12)) + Str(0x80 + ((value >> 6) & 0x3F)) + 
-           Str(0x80 + (value & 0x3F)); 
-  else 
-    return Str(0xF0 + (value >> 18)) + Str(0x80 + ((value >> 12) & 0x3F)) + 
-           Str(0x80 + ((value >> 6) & 0x3F)) + Str(0x80 + (value & 0x3F)); 
-} 
- 
-// Escape 
-// . Escapes the sequence starting 'in' (it must begin with a '\' or single 
-// quote) 
-//   and returns the result. 
-// . Throws if it's an unknown escape character. 
-std::string Escape(Stream& in) { 
-  // eat slash 
-  char escape = in.get(); 
- 
-  // switch on escape character 
-  char ch = in.get(); 
- 
-  // first do single quote, since it's easier 
-  if (escape == '\'' && ch == '\'') 
-    return "\'"; 
- 
-  // now do the slash (we're not gonna check if it's a slash - you better pass 
-  // one!) 
-  switch (ch) { 
-    case '0': 
-      return std::string(1, '\x00'); 
-    case 'a': 
-      return "\x07"; 
-    case 'b': 
-      return "\x08"; 
-    case 't': 
-    case '\t': 
-      return "\x09"; 
-    case 'n': 
-      return "\x0A"; 
-    case 'v': 
-      return "\x0B"; 
-    case 'f': 
-      return "\x0C"; 
-    case 'r': 
-      return "\x0D"; 
-    case 'e': 
-      return "\x1B"; 
-    case ' ': 
-      return "\x20"; 
-    case '\"': 
-      return "\""; 
-    case '\'': 
-      return "\'"; 
-    case '\\': 
-      return "\\"; 
-    case '/': 
-      return "/"; 
-    case 'N': 
-      return "\x85"; 
-    case '_': 
-      return "\xA0"; 
-    case 'L': 
-      return "\xE2\x80\xA8";  // LS (#x2028) 
-    case 'P': 
-      return "\xE2\x80\xA9";  // PS (#x2029) 
-    case 'x': 
-      return Escape(in, 2); 
-    case 'u': 
-      return Escape(in, 4); 
-    case 'U': 
-      return Escape(in, 8); 
-  } 
- 
-  std::stringstream msg; 
-  throw ParserException(in.mark(), std::string(ErrorMsg::INVALID_ESCAPE) + ch); 
-} 
-} 
-} 
+#include <sstream>
+
+#include "exp.h"
+#include "stream.h"
+#include "yaml-cpp/exceptions.h"  // IWYU pragma: keep
+
+namespace YAML {
+struct Mark;
+}  // namespace YAML
+
+namespace YAML {
+namespace Exp {
+unsigned ParseHex(const std::string& str, const Mark& mark) {
+  unsigned value = 0;
+  for (std::size_t i = 0; i < str.size(); i++) {
+    char ch = str[i];
+    int digit = 0;
+    if ('a' <= ch && ch <= 'f')
+      digit = ch - 'a' + 10;
+    else if ('A' <= ch && ch <= 'F')
+      digit = ch - 'A' + 10;
+    else if ('0' <= ch && ch <= '9')
+      digit = ch - '0';
+    else
+      throw ParserException(mark, ErrorMsg::INVALID_HEX);
+
+    value = (value << 4) + digit;
+  }
+
+  return value;
+}
+
+std::string Str(unsigned ch) { return std::string(1, static_cast<char>(ch)); }
+
+// Escape
+// . Translates the next 'codeLength' characters into a hex number and returns
+// the result.
+// . Throws if it's not actually hex.
+std::string Escape(Stream& in, int codeLength) {
+  // grab string
+  std::string str;
+  for (int i = 0; i < codeLength; i++)
+    str += in.get();
+
+  // get the value
+  unsigned value = ParseHex(str, in.mark());
+
+  // legal unicode?
+  if ((value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF) {
+    std::stringstream msg;
+    msg << ErrorMsg::INVALID_UNICODE << value;
+    throw ParserException(in.mark(), msg.str());
+  }
+
+  // now break it up into chars
+  if (value <= 0x7F)
+    return Str(value);
+  else if (value <= 0x7FF)
+    return Str(0xC0 + (value >> 6)) + Str(0x80 + (value & 0x3F));
+  else if (value <= 0xFFFF)
+    return Str(0xE0 + (value >> 12)) + Str(0x80 + ((value >> 6) & 0x3F)) +
+           Str(0x80 + (value & 0x3F));
+  else
+    return Str(0xF0 + (value >> 18)) + Str(0x80 + ((value >> 12) & 0x3F)) +
+           Str(0x80 + ((value >> 6) & 0x3F)) + Str(0x80 + (value & 0x3F));
+}
+
+// Escape
+// . Escapes the sequence starting 'in' (it must begin with a '\' or single
+// quote)
+//   and returns the result.
+// . Throws if it's an unknown escape character.
+std::string Escape(Stream& in) {
+  // eat slash
+  char escape = in.get();
+
+  // switch on escape character
+  char ch = in.get();
+
+  // first do single quote, since it's easier
+  if (escape == '\'' && ch == '\'')
+    return "\'";
+
+  // now do the slash (we're not gonna check if it's a slash - you better pass
+  // one!)
+  switch (ch) {
+    case '0':
+      return std::string(1, '\x00');
+    case 'a':
+      return "\x07";
+    case 'b':
+      return "\x08";
+    case 't':
+    case '\t':
+      return "\x09";
+    case 'n':
+      return "\x0A";
+    case 'v':
+      return "\x0B";
+    case 'f':
+      return "\x0C";
+    case 'r':
+      return "\x0D";
+    case 'e':
+      return "\x1B";
+    case ' ':
+      return "\x20";
+    case '\"':
+      return "\"";
+    case '\'':
+      return "\'";
+    case '\\':
+      return "\\";
+    case '/':
+      return "/";
+    case 'N':
+      return "\x85";
+    case '_':
+      return "\xA0";
+    case 'L':
+      return "\xE2\x80\xA8";  // LS (#x2028)
+    case 'P':
+      return "\xE2\x80\xA9";  // PS (#x2029)
+    case 'x':
+      return Escape(in, 2);
+    case 'u':
+      return Escape(in, 4);
+    case 'U':
+      return Escape(in, 8);
+  }
+
+  std::stringstream msg;
+  throw ParserException(in.mark(), std::string(ErrorMsg::INVALID_ESCAPE) + ch);
+}
+}
+}
diff --git a/contrib/libs/yaml-cpp/src/exp.h b/contrib/libs/yaml-cpp/src/exp.h
index 1bd50b7ab1f..50b0220b811 100644
--- a/contrib/libs/yaml-cpp/src/exp.h
+++ b/contrib/libs/yaml-cpp/src/exp.h
@@ -1,174 +1,174 @@
-#ifndef EXP_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define EXP_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include <ios> 
-#include <string> 
- 
-#include "regex_yaml.h" 
-#include "stream.h" 
- 
-namespace YAML { 
-//////////////////////////////////////////////////////////////////////////////// 
-// Here we store a bunch of expressions for matching different parts of the 
-// file. 
- 
-namespace Exp { 
-// misc 
+#ifndef EXP_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define EXP_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <ios>
+#include <string>
+
+#include "regex_yaml.h"
+#include "stream.h"
+
+namespace YAML {
+////////////////////////////////////////////////////////////////////////////////
+// Here we store a bunch of expressions for matching different parts of the
+// file.
+
+namespace Exp {
+// misc
 inline const RegEx& Empty() {
   static const RegEx e;
   return e;
 }
-inline const RegEx& Space() { 
-  static const RegEx e = RegEx(' '); 
-  return e; 
-} 
-inline const RegEx& Tab() { 
-  static const RegEx e = RegEx('\t'); 
-  return e; 
-} 
-inline const RegEx& Blank() { 
-  static const RegEx e = Space() || Tab(); 
-  return e; 
-} 
-inline const RegEx& Break() { 
-  static const RegEx e = RegEx('\n') || RegEx("\r\n"); 
-  return e; 
-} 
-inline const RegEx& BlankOrBreak() { 
-  static const RegEx e = Blank() || Break(); 
-  return e; 
-} 
-inline const RegEx& Digit() { 
-  static const RegEx e = RegEx('0', '9'); 
-  return e; 
-} 
-inline const RegEx& Alpha() { 
-  static const RegEx e = RegEx('a', 'z') || RegEx('A', 'Z'); 
-  return e; 
-} 
-inline const RegEx& AlphaNumeric() { 
-  static const RegEx e = Alpha() || Digit(); 
-  return e; 
-} 
-inline const RegEx& Word() { 
-  static const RegEx e = AlphaNumeric() || RegEx('-'); 
-  return e; 
-} 
-inline const RegEx& Hex() { 
-  static const RegEx e = Digit() || RegEx('A', 'F') || RegEx('a', 'f'); 
-  return e; 
-} 
-// Valid Unicode code points that are not part of c-printable (YAML 1.2, sec. 
-// 5.1) 
-inline const RegEx& NotPrintable() { 
-  static const RegEx e = 
-      RegEx(0) || 
-      RegEx("\x01\x02\x03\x04\x05\x06\x07\x08\x0B\x0C\x7F", REGEX_OR) || 
-      RegEx(0x0E, 0x1F) || 
-      (RegEx('\xC2') + (RegEx('\x80', '\x84') || RegEx('\x86', '\x9F'))); 
-  return e; 
-} 
-inline const RegEx& Utf8_ByteOrderMark() { 
-  static const RegEx e = RegEx("\xEF\xBB\xBF"); 
-  return e; 
-} 
- 
-// actual tags 
- 
-inline const RegEx& DocStart() { 
-  static const RegEx e = RegEx("---") + (BlankOrBreak() || RegEx()); 
-  return e; 
-} 
-inline const RegEx& DocEnd() { 
-  static const RegEx e = RegEx("...") + (BlankOrBreak() || RegEx()); 
-  return e; 
-} 
-inline const RegEx& DocIndicator() { 
-  static const RegEx e = DocStart() || DocEnd(); 
-  return e; 
-} 
-inline const RegEx& BlockEntry() { 
-  static const RegEx e = RegEx('-') + (BlankOrBreak() || RegEx()); 
-  return e; 
-} 
-inline const RegEx& Key() { 
-  static const RegEx e = RegEx('?') + BlankOrBreak(); 
-  return e; 
-} 
-inline const RegEx& KeyInFlow() { 
-  static const RegEx e = RegEx('?') + BlankOrBreak(); 
-  return e; 
-} 
-inline const RegEx& Value() { 
-  static const RegEx e = RegEx(':') + (BlankOrBreak() || RegEx()); 
-  return e; 
-} 
-inline const RegEx& ValueInFlow() { 
-  static const RegEx e = RegEx(':') + (BlankOrBreak() || RegEx(",}", REGEX_OR)); 
-  return e; 
-} 
-inline const RegEx& ValueInJSONFlow() { 
-  static const RegEx e = RegEx(':'); 
-  return e; 
-} 
-inline const RegEx Comment() { 
-  static const RegEx e = RegEx('#'); 
-  return e; 
-} 
-inline const RegEx& Anchor() { 
-  static const RegEx e = !(RegEx("[]{},", REGEX_OR) || BlankOrBreak()); 
-  return e; 
-} 
-inline const RegEx& AnchorEnd() { 
-  static const RegEx e = RegEx("?:,]}%@`", REGEX_OR) || BlankOrBreak(); 
-  return e; 
-} 
-inline const RegEx& URI() { 
-  static const RegEx e = Word() || RegEx("#;/?:@&=+$,_.!~*'()[]", REGEX_OR) || 
-                         (RegEx('%') + Hex() + Hex()); 
-  return e; 
-} 
-inline const RegEx& Tag() { 
-  static const RegEx e = Word() || RegEx("#;/?:@&=+$_.~*'", REGEX_OR) || 
-                         (RegEx('%') + Hex() + Hex()); 
-  return e; 
-} 
- 
-// Plain scalar rules: 
-// . Cannot start with a blank. 
-// . Can never start with any of , [ ] { } # & * ! | > \' \" % @ ` 
-// . In the block context - ? : must be not be followed with a space. 
-// . In the flow context ? is illegal and : and - must not be followed with a 
-// space. 
-inline const RegEx& PlainScalar() { 
-  static const RegEx e = 
-      !(BlankOrBreak() || RegEx(",[]{}#&*!|>\'\"%@`", REGEX_OR) || 
-        (RegEx("-?:", REGEX_OR) + (BlankOrBreak() || RegEx()))); 
-  return e; 
-} 
-inline const RegEx& PlainScalarInFlow() { 
-  static const RegEx e = 
-      !(BlankOrBreak() || RegEx("?,[]{}#&*!|>\'\"%@`", REGEX_OR) || 
-        (RegEx("-:", REGEX_OR) + Blank())); 
-  return e; 
-} 
-inline const RegEx& EndScalar() { 
-  static const RegEx e = RegEx(':') + (BlankOrBreak() || RegEx()); 
-  return e; 
-} 
-inline const RegEx& EndScalarInFlow() { 
-  static const RegEx e = 
-      (RegEx(':') + (BlankOrBreak() || RegEx() || RegEx(",]}", REGEX_OR))) || 
-      RegEx(",?[]{}", REGEX_OR); 
-  return e; 
-} 
- 
+inline const RegEx& Space() {
+  static const RegEx e = RegEx(' ');
+  return e;
+}
+inline const RegEx& Tab() {
+  static const RegEx e = RegEx('\t');
+  return e;
+}
+inline const RegEx& Blank() {
+  static const RegEx e = Space() || Tab();
+  return e;
+}
+inline const RegEx& Break() {
+  static const RegEx e = RegEx('\n') || RegEx("\r\n");
+  return e;
+}
+inline const RegEx& BlankOrBreak() {
+  static const RegEx e = Blank() || Break();
+  return e;
+}
+inline const RegEx& Digit() {
+  static const RegEx e = RegEx('0', '9');
+  return e;
+}
+inline const RegEx& Alpha() {
+  static const RegEx e = RegEx('a', 'z') || RegEx('A', 'Z');
+  return e;
+}
+inline const RegEx& AlphaNumeric() {
+  static const RegEx e = Alpha() || Digit();
+  return e;
+}
+inline const RegEx& Word() {
+  static const RegEx e = AlphaNumeric() || RegEx('-');
+  return e;
+}
+inline const RegEx& Hex() {
+  static const RegEx e = Digit() || RegEx('A', 'F') || RegEx('a', 'f');
+  return e;
+}
+// Valid Unicode code points that are not part of c-printable (YAML 1.2, sec.
+// 5.1)
+inline const RegEx& NotPrintable() {
+  static const RegEx e =
+      RegEx(0) ||
+      RegEx("\x01\x02\x03\x04\x05\x06\x07\x08\x0B\x0C\x7F", REGEX_OR) ||
+      RegEx(0x0E, 0x1F) ||
+      (RegEx('\xC2') + (RegEx('\x80', '\x84') || RegEx('\x86', '\x9F')));
+  return e;
+}
+inline const RegEx& Utf8_ByteOrderMark() {
+  static const RegEx e = RegEx("\xEF\xBB\xBF");
+  return e;
+}
+
+// actual tags
+
+inline const RegEx& DocStart() {
+  static const RegEx e = RegEx("---") + (BlankOrBreak() || RegEx());
+  return e;
+}
+inline const RegEx& DocEnd() {
+  static const RegEx e = RegEx("...") + (BlankOrBreak() || RegEx());
+  return e;
+}
+inline const RegEx& DocIndicator() {
+  static const RegEx e = DocStart() || DocEnd();
+  return e;
+}
+inline const RegEx& BlockEntry() {
+  static const RegEx e = RegEx('-') + (BlankOrBreak() || RegEx());
+  return e;
+}
+inline const RegEx& Key() {
+  static const RegEx e = RegEx('?') + BlankOrBreak();
+  return e;
+}
+inline const RegEx& KeyInFlow() {
+  static const RegEx e = RegEx('?') + BlankOrBreak();
+  return e;
+}
+inline const RegEx& Value() {
+  static const RegEx e = RegEx(':') + (BlankOrBreak() || RegEx());
+  return e;
+}
+inline const RegEx& ValueInFlow() {
+  static const RegEx e = RegEx(':') + (BlankOrBreak() || RegEx(",}", REGEX_OR));
+  return e;
+}
+inline const RegEx& ValueInJSONFlow() {
+  static const RegEx e = RegEx(':');
+  return e;
+}
+inline const RegEx Comment() {
+  static const RegEx e = RegEx('#');
+  return e;
+}
+inline const RegEx& Anchor() {
+  static const RegEx e = !(RegEx("[]{},", REGEX_OR) || BlankOrBreak());
+  return e;
+}
+inline const RegEx& AnchorEnd() {
+  static const RegEx e = RegEx("?:,]}%@`", REGEX_OR) || BlankOrBreak();
+  return e;
+}
+inline const RegEx& URI() {
+  static const RegEx e = Word() || RegEx("#;/?:@&=+$,_.!~*'()[]", REGEX_OR) ||
+                         (RegEx('%') + Hex() + Hex());
+  return e;
+}
+inline const RegEx& Tag() {
+  static const RegEx e = Word() || RegEx("#;/?:@&=+$_.~*'", REGEX_OR) ||
+                         (RegEx('%') + Hex() + Hex());
+  return e;
+}
+
+// Plain scalar rules:
+// . Cannot start with a blank.
+// . Can never start with any of , [ ] { } # & * ! | > \' \" % @ `
+// . In the block context - ? : must be not be followed with a space.
+// . In the flow context ? is illegal and : and - must not be followed with a
+// space.
+inline const RegEx& PlainScalar() {
+  static const RegEx e =
+      !(BlankOrBreak() || RegEx(",[]{}#&*!|>\'\"%@`", REGEX_OR) ||
+        (RegEx("-?:", REGEX_OR) + (BlankOrBreak() || RegEx())));
+  return e;
+}
+inline const RegEx& PlainScalarInFlow() {
+  static const RegEx e =
+      !(BlankOrBreak() || RegEx("?,[]{}#&*!|>\'\"%@`", REGEX_OR) ||
+        (RegEx("-:", REGEX_OR) + Blank()));
+  return e;
+}
+inline const RegEx& EndScalar() {
+  static const RegEx e = RegEx(':') + (BlankOrBreak() || RegEx());
+  return e;
+}
+inline const RegEx& EndScalarInFlow() {
+  static const RegEx e =
+      (RegEx(':') + (BlankOrBreak() || RegEx() || RegEx(",]}", REGEX_OR))) ||
+      RegEx(",?[]{}", REGEX_OR);
+  return e;
+}
+
 inline const RegEx& ScanScalarEndInFlow() {
   static const RegEx e = (EndScalarInFlow() || (BlankOrBreak() + Comment()));
   return e;
@@ -178,45 +178,45 @@ inline const RegEx& ScanScalarEnd() {
   static const RegEx e = EndScalar() || (BlankOrBreak() + Comment());
   return e;
 }
-inline const RegEx& EscSingleQuote() { 
-  static const RegEx e = RegEx("\'\'"); 
-  return e; 
-} 
-inline const RegEx& EscBreak() { 
-  static const RegEx e = RegEx('\\') + Break(); 
-  return e; 
-} 
- 
-inline const RegEx& ChompIndicator() { 
-  static const RegEx e = RegEx("+-", REGEX_OR); 
-  return e; 
-} 
-inline const RegEx& Chomp() { 
-  static const RegEx e = (ChompIndicator() + Digit()) || 
-                         (Digit() + ChompIndicator()) || ChompIndicator() || 
-                         Digit(); 
-  return e; 
-} 
- 
-// and some functions 
-std::string Escape(Stream& in); 
-} 
- 
-namespace Keys { 
-const char Directive = '%'; 
-const char FlowSeqStart = '['; 
-const char FlowSeqEnd = ']'; 
-const char FlowMapStart = '{'; 
-const char FlowMapEnd = '}'; 
-const char FlowEntry = ','; 
-const char Alias = '*'; 
-const char Anchor = '&'; 
-const char Tag = '!'; 
-const char LiteralScalar = '|'; 
-const char FoldedScalar = '>'; 
-const char VerbatimTagStart = '<'; 
-const char VerbatimTagEnd = '>'; 
-} 
-} 
- 
-#endif  // EXP_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+inline const RegEx& EscSingleQuote() {
+  static const RegEx e = RegEx("\'\'");
+  return e;
+}
+inline const RegEx& EscBreak() {
+  static const RegEx e = RegEx('\\') + Break();
+  return e;
+}
+
+inline const RegEx& ChompIndicator() {
+  static const RegEx e = RegEx("+-", REGEX_OR);
+  return e;
+}
+inline const RegEx& Chomp() {
+  static const RegEx e = (ChompIndicator() + Digit()) ||
+                         (Digit() + ChompIndicator()) || ChompIndicator() ||
+                         Digit();
+  return e;
+}
+
+// and some functions
+std::string Escape(Stream& in);
+}
+
+namespace Keys {
+const char Directive = '%';
+const char FlowSeqStart = '[';
+const char FlowSeqEnd = ']';
+const char FlowMapStart = '{';
+const char FlowMapEnd = '}';
+const char FlowEntry = ',';
+const char Alias = '*';
+const char Anchor = '&';
+const char Tag = '!';
+const char LiteralScalar = '|';
+const char FoldedScalar = '>';
+const char VerbatimTagStart = '<';
+const char VerbatimTagEnd = '>';
+}
+}
+
+#endif  // EXP_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/src/indentation.h b/contrib/libs/yaml-cpp/src/indentation.h
index d6b1ce62cd8..1a2ccaea2e1 100644
--- a/contrib/libs/yaml-cpp/src/indentation.h
+++ b/contrib/libs/yaml-cpp/src/indentation.h
@@ -1,41 +1,41 @@
-#ifndef INDENTATION_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define INDENTATION_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include <iostream> 
-#include <cstddef> 
- 
-#include "yaml-cpp/ostream_wrapper.h" 
- 
-namespace YAML { 
-struct Indentation { 
-  Indentation(std::size_t n_) : n(n_) {} 
-  std::size_t n; 
-}; 
- 
-inline ostream_wrapper& operator<<(ostream_wrapper& out, 
-                                   const Indentation& indent) { 
-  for (std::size_t i = 0; i < indent.n; i++) 
-    out << ' '; 
-  return out; 
-} 
- 
-struct IndentTo { 
-  IndentTo(std::size_t n_) : n(n_) {} 
-  std::size_t n; 
-}; 
- 
-inline ostream_wrapper& operator<<(ostream_wrapper& out, 
-                                   const IndentTo& indent) { 
-  while (out.col() < indent.n) 
-    out << ' '; 
-  return out; 
-} 
-} 
- 
-#endif  // INDENTATION_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+#ifndef INDENTATION_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define INDENTATION_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <iostream>
+#include <cstddef>
+
+#include "yaml-cpp/ostream_wrapper.h"
+
+namespace YAML {
+struct Indentation {
+  Indentation(std::size_t n_) : n(n_) {}
+  std::size_t n;
+};
+
+inline ostream_wrapper& operator<<(ostream_wrapper& out,
+                                   const Indentation& indent) {
+  for (std::size_t i = 0; i < indent.n; i++)
+    out << ' ';
+  return out;
+}
+
+struct IndentTo {
+  IndentTo(std::size_t n_) : n(n_) {}
+  std::size_t n;
+};
+
+inline ostream_wrapper& operator<<(ostream_wrapper& out,
+                                   const IndentTo& indent) {
+  while (out.col() < indent.n)
+    out << ' ';
+  return out;
+}
+}
+
+#endif  // INDENTATION_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/src/memory.cpp b/contrib/libs/yaml-cpp/src/memory.cpp
index 737f70526f4..e5f8a9d3f8c 100644
--- a/contrib/libs/yaml-cpp/src/memory.cpp
+++ b/contrib/libs/yaml-cpp/src/memory.cpp
@@ -1,26 +1,26 @@
-#include "yaml-cpp/node/detail/memory.h" 
-#include "yaml-cpp/node/detail/node.h"  // IWYU pragma: keep 
-#include "yaml-cpp/node/ptr.h" 
- 
-namespace YAML { 
-namespace detail { 
- 
-void memory_holder::merge(memory_holder& rhs) { 
-  if (m_pMemory == rhs.m_pMemory) 
-    return; 
- 
-  m_pMemory->merge(*rhs.m_pMemory); 
-  rhs.m_pMemory = m_pMemory; 
-} 
- 
-node& memory::create_node() { 
-  shared_node pNode(new node); 
-  m_nodes.insert(pNode); 
-  return *pNode; 
-} 
- 
-void memory::merge(const memory& rhs) { 
-  m_nodes.insert(rhs.m_nodes.begin(), rhs.m_nodes.end()); 
-} 
-} 
-} 
+#include "yaml-cpp/node/detail/memory.h"
+#include "yaml-cpp/node/detail/node.h"  // IWYU pragma: keep
+#include "yaml-cpp/node/ptr.h"
+
+namespace YAML {
+namespace detail {
+
+void memory_holder::merge(memory_holder& rhs) {
+  if (m_pMemory == rhs.m_pMemory)
+    return;
+
+  m_pMemory->merge(*rhs.m_pMemory);
+  rhs.m_pMemory = m_pMemory;
+}
+
+node& memory::create_node() {
+  shared_node pNode(new node);
+  m_nodes.insert(pNode);
+  return *pNode;
+}
+
+void memory::merge(const memory& rhs) {
+  m_nodes.insert(rhs.m_nodes.begin(), rhs.m_nodes.end());
+}
+}
+}
diff --git a/contrib/libs/yaml-cpp/src/node.cpp b/contrib/libs/yaml-cpp/src/node.cpp
index 34ccfa21776..2088e13c9ae 100644
--- a/contrib/libs/yaml-cpp/src/node.cpp
+++ b/contrib/libs/yaml-cpp/src/node.cpp
@@ -1,12 +1,12 @@
-#include "yaml-cpp/node/node.h" 
-#include "nodebuilder.h" 
-#include "nodeevents.h" 
- 
-namespace YAML { 
-Node Clone(const Node& node) { 
-  NodeEvents events(node); 
-  NodeBuilder builder; 
-  events.Emit(builder); 
-  return builder.Root(); 
-} 
-} 
+#include "yaml-cpp/node/node.h"
+#include "nodebuilder.h"
+#include "nodeevents.h"
+
+namespace YAML {
+Node Clone(const Node& node) {
+  NodeEvents events(node);
+  NodeBuilder builder;
+  events.Emit(builder);
+  return builder.Root();
+}
+}
diff --git a/contrib/libs/yaml-cpp/src/node_data.cpp b/contrib/libs/yaml-cpp/src/node_data.cpp
index bfe4fec44f1..77cd4657806 100644
--- a/contrib/libs/yaml-cpp/src/node_data.cpp
+++ b/contrib/libs/yaml-cpp/src/node_data.cpp
@@ -1,300 +1,300 @@
-#include <assert.h> 
+#include <assert.h>
 #include <iterator>
-#include <sstream> 
- 
-#include "yaml-cpp/exceptions.h" 
-#include "yaml-cpp/node/detail/memory.h" 
-#include "yaml-cpp/node/detail/node.h"  // IWYU pragma: keep 
-#include "yaml-cpp/node/detail/node_data.h" 
-#include "yaml-cpp/node/detail/node_iterator.h" 
-#include "yaml-cpp/node/ptr.h" 
-#include "yaml-cpp/node/type.h" 
- 
-namespace YAML { 
-namespace detail { 
- 
-std::string node_data::empty_scalar; 
- 
-node_data::node_data() 
-    : m_isDefined(false), 
-      m_mark(Mark::null_mark()), 
-      m_type(NodeType::Null), 
-      m_style(EmitterStyle::Default), 
-      m_seqSize(0) {} 
- 
-void node_data::mark_defined() { 
-  if (m_type == NodeType::Undefined) 
-    m_type = NodeType::Null; 
-  m_isDefined = true; 
-} 
- 
+#include <sstream>
+
+#include "yaml-cpp/exceptions.h"
+#include "yaml-cpp/node/detail/memory.h"
+#include "yaml-cpp/node/detail/node.h"  // IWYU pragma: keep
+#include "yaml-cpp/node/detail/node_data.h"
+#include "yaml-cpp/node/detail/node_iterator.h"
+#include "yaml-cpp/node/ptr.h"
+#include "yaml-cpp/node/type.h"
+
+namespace YAML {
+namespace detail {
+
+std::string node_data::empty_scalar;
+
+node_data::node_data()
+    : m_isDefined(false),
+      m_mark(Mark::null_mark()),
+      m_type(NodeType::Null),
+      m_style(EmitterStyle::Default),
+      m_seqSize(0) {}
+
+void node_data::mark_defined() {
+  if (m_type == NodeType::Undefined)
+    m_type = NodeType::Null;
+  m_isDefined = true;
+}
+
 void node_data::set_mark(const Mark& mark) { m_mark = mark; }
- 
-void node_data::set_type(NodeType::value type) { 
-  if (type == NodeType::Undefined) { 
-    m_type = type; 
-    m_isDefined = false; 
-    return; 
-  } 
- 
-  m_isDefined = true; 
-  if (type == m_type) 
-    return; 
- 
-  m_type = type; 
- 
-  switch (m_type) { 
-    case NodeType::Null: 
-      break; 
-    case NodeType::Scalar: 
-      m_scalar.clear(); 
-      break; 
-    case NodeType::Sequence: 
-      reset_sequence(); 
-      break; 
-    case NodeType::Map: 
-      reset_map(); 
-      break; 
-    case NodeType::Undefined: 
-      assert(false); 
-      break; 
-  } 
-} 
- 
-void node_data::set_tag(const std::string& tag) { m_tag = tag; } 
- 
-void node_data::set_style(EmitterStyle::value style) { m_style = style; } 
- 
-void node_data::set_null() { 
-  m_isDefined = true; 
-  m_type = NodeType::Null; 
-} 
- 
-void node_data::set_scalar(const std::string& scalar) { 
-  m_isDefined = true; 
-  m_type = NodeType::Scalar; 
-  m_scalar = scalar; 
-} 
- 
-// size/iterator 
-std::size_t node_data::size() const { 
-  if (!m_isDefined) 
-    return 0; 
- 
-  switch (m_type) { 
-    case NodeType::Sequence: 
-      compute_seq_size(); 
-      return m_seqSize; 
-    case NodeType::Map: 
-      compute_map_size(); 
-      return m_map.size() - m_undefinedPairs.size(); 
-    default: 
-      return 0; 
-  } 
-  return 0; 
-} 
- 
-void node_data::compute_seq_size() const { 
-  while (m_seqSize < m_sequence.size() && m_sequence[m_seqSize]->is_defined()) 
-    m_seqSize++; 
-} 
- 
-void node_data::compute_map_size() const { 
-  kv_pairs::iterator it = m_undefinedPairs.begin(); 
-  while (it != m_undefinedPairs.end()) { 
+
+void node_data::set_type(NodeType::value type) {
+  if (type == NodeType::Undefined) {
+    m_type = type;
+    m_isDefined = false;
+    return;
+  }
+
+  m_isDefined = true;
+  if (type == m_type)
+    return;
+
+  m_type = type;
+
+  switch (m_type) {
+    case NodeType::Null:
+      break;
+    case NodeType::Scalar:
+      m_scalar.clear();
+      break;
+    case NodeType::Sequence:
+      reset_sequence();
+      break;
+    case NodeType::Map:
+      reset_map();
+      break;
+    case NodeType::Undefined:
+      assert(false);
+      break;
+  }
+}
+
+void node_data::set_tag(const std::string& tag) { m_tag = tag; }
+
+void node_data::set_style(EmitterStyle::value style) { m_style = style; }
+
+void node_data::set_null() {
+  m_isDefined = true;
+  m_type = NodeType::Null;
+}
+
+void node_data::set_scalar(const std::string& scalar) {
+  m_isDefined = true;
+  m_type = NodeType::Scalar;
+  m_scalar = scalar;
+}
+
+// size/iterator
+std::size_t node_data::size() const {
+  if (!m_isDefined)
+    return 0;
+
+  switch (m_type) {
+    case NodeType::Sequence:
+      compute_seq_size();
+      return m_seqSize;
+    case NodeType::Map:
+      compute_map_size();
+      return m_map.size() - m_undefinedPairs.size();
+    default:
+      return 0;
+  }
+  return 0;
+}
+
+void node_data::compute_seq_size() const {
+  while (m_seqSize < m_sequence.size() && m_sequence[m_seqSize]->is_defined())
+    m_seqSize++;
+}
+
+void node_data::compute_map_size() const {
+  kv_pairs::iterator it = m_undefinedPairs.begin();
+  while (it != m_undefinedPairs.end()) {
     kv_pairs::iterator jt = std::next(it);
-    if (it->first->is_defined() && it->second->is_defined()) 
-      m_undefinedPairs.erase(it); 
-    it = jt; 
-  } 
-} 
- 
-const_node_iterator node_data::begin() const { 
-  if (!m_isDefined) 
-    return const_node_iterator(); 
- 
-  switch (m_type) { 
-    case NodeType::Sequence: 
-      return const_node_iterator(m_sequence.begin()); 
-    case NodeType::Map: 
-      return const_node_iterator(m_map.begin(), m_map.end()); 
-    default: 
-      return const_node_iterator(); 
-  } 
-} 
- 
-node_iterator node_data::begin() { 
-  if (!m_isDefined) 
-    return node_iterator(); 
- 
-  switch (m_type) { 
-    case NodeType::Sequence: 
-      return node_iterator(m_sequence.begin()); 
-    case NodeType::Map: 
-      return node_iterator(m_map.begin(), m_map.end()); 
-    default: 
-      return node_iterator(); 
-  } 
-} 
- 
-const_node_iterator node_data::end() const { 
-  if (!m_isDefined) 
-    return const_node_iterator(); 
- 
-  switch (m_type) { 
-    case NodeType::Sequence: 
-      return const_node_iterator(m_sequence.end()); 
-    case NodeType::Map: 
-      return const_node_iterator(m_map.end(), m_map.end()); 
-    default: 
-      return const_node_iterator(); 
-  } 
-} 
- 
-node_iterator node_data::end() { 
-  if (!m_isDefined) 
-    return node_iterator(); 
- 
-  switch (m_type) { 
-    case NodeType::Sequence: 
-      return node_iterator(m_sequence.end()); 
-    case NodeType::Map: 
-      return node_iterator(m_map.end(), m_map.end()); 
-    default: 
-      return node_iterator(); 
-  } 
-} 
- 
-// sequence 
-void node_data::push_back(node& node, shared_memory_holder /* pMemory */) { 
-  if (m_type == NodeType::Undefined || m_type == NodeType::Null) { 
-    m_type = NodeType::Sequence; 
-    reset_sequence(); 
-  } 
- 
-  if (m_type != NodeType::Sequence) 
-    throw BadPushback(); 
- 
-  m_sequence.push_back(&node); 
-} 
- 
-void node_data::insert(node& key, node& value, shared_memory_holder pMemory) { 
-  switch (m_type) { 
-    case NodeType::Map: 
-      break; 
-    case NodeType::Undefined: 
-    case NodeType::Null: 
-    case NodeType::Sequence: 
-      convert_to_map(pMemory); 
-      break; 
-    case NodeType::Scalar: 
-      throw BadSubscript(); 
-  } 
- 
-  insert_map_pair(key, value); 
-} 
- 
-// indexing 
-node* node_data::get(node& key, shared_memory_holder /* pMemory */) const { 
-  if (m_type != NodeType::Map) { 
-    return NULL; 
-  } 
- 
-  for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) { 
-    if (it->first->is(key)) 
-      return it->second; 
-  } 
- 
-  return NULL; 
-} 
- 
-node& node_data::get(node& key, shared_memory_holder pMemory) { 
-  switch (m_type) { 
-    case NodeType::Map: 
-      break; 
-    case NodeType::Undefined: 
-    case NodeType::Null: 
-    case NodeType::Sequence: 
-      convert_to_map(pMemory); 
-      break; 
-    case NodeType::Scalar: 
-      throw BadSubscript(); 
-  } 
- 
-  for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) { 
-    if (it->first->is(key)) 
-      return *it->second; 
-  } 
- 
-  node& value = pMemory->create_node(); 
-  insert_map_pair(key, value); 
-  return value; 
-} 
- 
-bool node_data::remove(node& key, shared_memory_holder /* pMemory */) { 
-  if (m_type != NodeType::Map) 
-    return false; 
- 
-  for (node_map::iterator it = m_map.begin(); it != m_map.end(); ++it) { 
-    if (it->first->is(key)) { 
-      m_map.erase(it); 
-      return true; 
-    } 
-  } 
- 
-  return false; 
-} 
- 
-void node_data::reset_sequence() { 
-  m_sequence.clear(); 
-  m_seqSize = 0; 
-} 
- 
-void node_data::reset_map() { 
-  m_map.clear(); 
-  m_undefinedPairs.clear(); 
-} 
- 
-void node_data::insert_map_pair(node& key, node& value) { 
+    if (it->first->is_defined() && it->second->is_defined())
+      m_undefinedPairs.erase(it);
+    it = jt;
+  }
+}
+
+const_node_iterator node_data::begin() const {
+  if (!m_isDefined)
+    return const_node_iterator();
+
+  switch (m_type) {
+    case NodeType::Sequence:
+      return const_node_iterator(m_sequence.begin());
+    case NodeType::Map:
+      return const_node_iterator(m_map.begin(), m_map.end());
+    default:
+      return const_node_iterator();
+  }
+}
+
+node_iterator node_data::begin() {
+  if (!m_isDefined)
+    return node_iterator();
+
+  switch (m_type) {
+    case NodeType::Sequence:
+      return node_iterator(m_sequence.begin());
+    case NodeType::Map:
+      return node_iterator(m_map.begin(), m_map.end());
+    default:
+      return node_iterator();
+  }
+}
+
+const_node_iterator node_data::end() const {
+  if (!m_isDefined)
+    return const_node_iterator();
+
+  switch (m_type) {
+    case NodeType::Sequence:
+      return const_node_iterator(m_sequence.end());
+    case NodeType::Map:
+      return const_node_iterator(m_map.end(), m_map.end());
+    default:
+      return const_node_iterator();
+  }
+}
+
+node_iterator node_data::end() {
+  if (!m_isDefined)
+    return node_iterator();
+
+  switch (m_type) {
+    case NodeType::Sequence:
+      return node_iterator(m_sequence.end());
+    case NodeType::Map:
+      return node_iterator(m_map.end(), m_map.end());
+    default:
+      return node_iterator();
+  }
+}
+
+// sequence
+void node_data::push_back(node& node, shared_memory_holder /* pMemory */) {
+  if (m_type == NodeType::Undefined || m_type == NodeType::Null) {
+    m_type = NodeType::Sequence;
+    reset_sequence();
+  }
+
+  if (m_type != NodeType::Sequence)
+    throw BadPushback();
+
+  m_sequence.push_back(&node);
+}
+
+void node_data::insert(node& key, node& value, shared_memory_holder pMemory) {
+  switch (m_type) {
+    case NodeType::Map:
+      break;
+    case NodeType::Undefined:
+    case NodeType::Null:
+    case NodeType::Sequence:
+      convert_to_map(pMemory);
+      break;
+    case NodeType::Scalar:
+      throw BadSubscript();
+  }
+
+  insert_map_pair(key, value);
+}
+
+// indexing
+node* node_data::get(node& key, shared_memory_holder /* pMemory */) const {
+  if (m_type != NodeType::Map) {
+    return NULL;
+  }
+
+  for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) {
+    if (it->first->is(key))
+      return it->second;
+  }
+
+  return NULL;
+}
+
+node& node_data::get(node& key, shared_memory_holder pMemory) {
+  switch (m_type) {
+    case NodeType::Map:
+      break;
+    case NodeType::Undefined:
+    case NodeType::Null:
+    case NodeType::Sequence:
+      convert_to_map(pMemory);
+      break;
+    case NodeType::Scalar:
+      throw BadSubscript();
+  }
+
+  for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) {
+    if (it->first->is(key))
+      return *it->second;
+  }
+
+  node& value = pMemory->create_node();
+  insert_map_pair(key, value);
+  return value;
+}
+
+bool node_data::remove(node& key, shared_memory_holder /* pMemory */) {
+  if (m_type != NodeType::Map)
+    return false;
+
+  for (node_map::iterator it = m_map.begin(); it != m_map.end(); ++it) {
+    if (it->first->is(key)) {
+      m_map.erase(it);
+      return true;
+    }
+  }
+
+  return false;
+}
+
+void node_data::reset_sequence() {
+  m_sequence.clear();
+  m_seqSize = 0;
+}
+
+void node_data::reset_map() {
+  m_map.clear();
+  m_undefinedPairs.clear();
+}
+
+void node_data::insert_map_pair(node& key, node& value) {
   m_map.emplace_back(&key, &value);
 
-  if (!key.is_defined() || !value.is_defined()) 
+  if (!key.is_defined() || !value.is_defined())
     m_undefinedPairs.emplace_back(&key, &value);
-} 
- 
-void node_data::convert_to_map(shared_memory_holder pMemory) { 
-  switch (m_type) { 
-    case NodeType::Undefined: 
-    case NodeType::Null: 
-      reset_map(); 
-      m_type = NodeType::Map; 
-      break; 
-    case NodeType::Sequence: 
-      convert_sequence_to_map(pMemory); 
-      break; 
-    case NodeType::Map: 
-      break; 
-    case NodeType::Scalar: 
-      assert(false); 
-      break; 
-  } 
-} 
- 
-void node_data::convert_sequence_to_map(shared_memory_holder pMemory) { 
-  assert(m_type == NodeType::Sequence); 
- 
-  reset_map(); 
-  for (std::size_t i = 0; i < m_sequence.size(); i++) { 
-    std::stringstream stream; 
-    stream << i; 
- 
-    node& key = pMemory->create_node(); 
-    key.set_scalar(stream.str()); 
-    insert_map_pair(key, *m_sequence[i]); 
-  } 
- 
-  reset_sequence(); 
-  m_type = NodeType::Map; 
-} 
-} 
-} 
+}
+
+void node_data::convert_to_map(shared_memory_holder pMemory) {
+  switch (m_type) {
+    case NodeType::Undefined:
+    case NodeType::Null:
+      reset_map();
+      m_type = NodeType::Map;
+      break;
+    case NodeType::Sequence:
+      convert_sequence_to_map(pMemory);
+      break;
+    case NodeType::Map:
+      break;
+    case NodeType::Scalar:
+      assert(false);
+      break;
+  }
+}
+
+void node_data::convert_sequence_to_map(shared_memory_holder pMemory) {
+  assert(m_type == NodeType::Sequence);
+
+  reset_map();
+  for (std::size_t i = 0; i < m_sequence.size(); i++) {
+    std::stringstream stream;
+    stream << i;
+
+    node& key = pMemory->create_node();
+    key.set_scalar(stream.str());
+    insert_map_pair(key, *m_sequence[i]);
+  }
+
+  reset_sequence();
+  m_type = NodeType::Map;
+}
+}
+}
diff --git a/contrib/libs/yaml-cpp/src/nodebuilder.cpp b/contrib/libs/yaml-cpp/src/nodebuilder.cpp
index da09e7fd44c..093d2efeb77 100644
--- a/contrib/libs/yaml-cpp/src/nodebuilder.cpp
+++ b/contrib/libs/yaml-cpp/src/nodebuilder.cpp
@@ -1,130 +1,130 @@
-#include <assert.h> 
-#include <cassert> 
- 
-#include "nodebuilder.h" 
-#include "yaml-cpp/node/detail/node.h" 
-#include "yaml-cpp/node/impl.h" 
-#include "yaml-cpp/node/node.h" 
-#include "yaml-cpp/node/type.h" 
- 
-namespace YAML { 
-struct Mark; 
- 
-NodeBuilder::NodeBuilder() 
-    : m_pMemory(new detail::memory_holder), m_pRoot(0), m_mapDepth(0) { 
-  m_anchors.push_back(0);  // since the anchors start at 1 
-} 
- 
-NodeBuilder::~NodeBuilder() {} 
- 
-Node NodeBuilder::Root() { 
-  if (!m_pRoot) 
-    return Node(); 
- 
-  return Node(*m_pRoot, m_pMemory); 
-} 
- 
-void NodeBuilder::OnDocumentStart(const Mark&) {} 
- 
-void NodeBuilder::OnDocumentEnd() {} 
- 
-void NodeBuilder::OnNull(const Mark& mark, anchor_t anchor) { 
-  detail::node& node = Push(mark, anchor); 
-  node.set_null(); 
-  Pop(); 
-} 
- 
-void NodeBuilder::OnAlias(const Mark& /* mark */, anchor_t anchor) { 
-  detail::node& node = *m_anchors[anchor]; 
-  Push(node); 
-  Pop(); 
-} 
- 
-void NodeBuilder::OnScalar(const Mark& mark, const std::string& tag, 
-                           anchor_t anchor, const std::string& value) { 
-  detail::node& node = Push(mark, anchor); 
-  node.set_scalar(value); 
-  node.set_tag(tag); 
-  Pop(); 
-} 
- 
+#include <assert.h>
+#include <cassert>
+
+#include "nodebuilder.h"
+#include "yaml-cpp/node/detail/node.h"
+#include "yaml-cpp/node/impl.h"
+#include "yaml-cpp/node/node.h"
+#include "yaml-cpp/node/type.h"
+
+namespace YAML {
+struct Mark;
+
+NodeBuilder::NodeBuilder()
+    : m_pMemory(new detail::memory_holder), m_pRoot(0), m_mapDepth(0) {
+  m_anchors.push_back(0);  // since the anchors start at 1
+}
+
+NodeBuilder::~NodeBuilder() {}
+
+Node NodeBuilder::Root() {
+  if (!m_pRoot)
+    return Node();
+
+  return Node(*m_pRoot, m_pMemory);
+}
+
+void NodeBuilder::OnDocumentStart(const Mark&) {}
+
+void NodeBuilder::OnDocumentEnd() {}
+
+void NodeBuilder::OnNull(const Mark& mark, anchor_t anchor) {
+  detail::node& node = Push(mark, anchor);
+  node.set_null();
+  Pop();
+}
+
+void NodeBuilder::OnAlias(const Mark& /* mark */, anchor_t anchor) {
+  detail::node& node = *m_anchors[anchor];
+  Push(node);
+  Pop();
+}
+
+void NodeBuilder::OnScalar(const Mark& mark, const std::string& tag,
+                           anchor_t anchor, const std::string& value) {
+  detail::node& node = Push(mark, anchor);
+  node.set_scalar(value);
+  node.set_tag(tag);
+  Pop();
+}
+
 void NodeBuilder::OnSequenceStart(const Mark& mark, const std::string& tag,
                                   anchor_t anchor, EmitterStyle::value style) {
-  detail::node& node = Push(mark, anchor); 
-  node.set_tag(tag); 
-  node.set_type(NodeType::Sequence); 
-  node.set_style(style); 
-} 
- 
-void NodeBuilder::OnSequenceEnd() { Pop(); } 
- 
-void NodeBuilder::OnMapStart(const Mark& mark, const std::string& tag, 
-                             anchor_t anchor, EmitterStyle::value style) { 
-  detail::node& node = Push(mark, anchor); 
-  node.set_type(NodeType::Map); 
-  node.set_tag(tag); 
-  node.set_style(style); 
-  m_mapDepth++; 
-} 
- 
-void NodeBuilder::OnMapEnd() { 
-  assert(m_mapDepth > 0); 
-  m_mapDepth--; 
-  Pop(); 
-} 
- 
-detail::node& NodeBuilder::Push(const Mark& mark, anchor_t anchor) { 
-  detail::node& node = m_pMemory->create_node(); 
-  node.set_mark(mark); 
-  RegisterAnchor(anchor, node); 
-  Push(node); 
-  return node; 
-} 
- 
-void NodeBuilder::Push(detail::node& node) { 
-  const bool needsKey = 
-      (!m_stack.empty() && m_stack.back()->type() == NodeType::Map && 
-       m_keys.size() < m_mapDepth); 
- 
-  m_stack.push_back(&node); 
-  if (needsKey) 
-    m_keys.push_back(PushedKey(&node, false)); 
-} 
- 
-void NodeBuilder::Pop() { 
-  assert(!m_stack.empty()); 
-  if (m_stack.size() == 1) { 
-    m_pRoot = m_stack[0]; 
-    m_stack.pop_back(); 
-    return; 
-  } 
- 
-  detail::node& node = *m_stack.back(); 
-  m_stack.pop_back(); 
- 
-  detail::node& collection = *m_stack.back(); 
- 
-  if (collection.type() == NodeType::Sequence) { 
-    collection.push_back(node, m_pMemory); 
-  } else if (collection.type() == NodeType::Map) { 
-    assert(!m_keys.empty()); 
-    PushedKey& key = m_keys.back(); 
-    if (key.second) { 
-      collection.insert(*key.first, node, m_pMemory); 
-      m_keys.pop_back(); 
-    } else { 
-      key.second = true; 
-    } 
-  } else { 
-    assert(false); 
-    m_stack.clear(); 
-  } 
-} 
- 
-void NodeBuilder::RegisterAnchor(anchor_t anchor, detail::node& node) { 
-  if (anchor) { 
-    assert(anchor == m_anchors.size()); 
-    m_anchors.push_back(&node); 
-  } 
-} 
-} 
+  detail::node& node = Push(mark, anchor);
+  node.set_tag(tag);
+  node.set_type(NodeType::Sequence);
+  node.set_style(style);
+}
+
+void NodeBuilder::OnSequenceEnd() { Pop(); }
+
+void NodeBuilder::OnMapStart(const Mark& mark, const std::string& tag,
+                             anchor_t anchor, EmitterStyle::value style) {
+  detail::node& node = Push(mark, anchor);
+  node.set_type(NodeType::Map);
+  node.set_tag(tag);
+  node.set_style(style);
+  m_mapDepth++;
+}
+
+void NodeBuilder::OnMapEnd() {
+  assert(m_mapDepth > 0);
+  m_mapDepth--;
+  Pop();
+}
+
+detail::node& NodeBuilder::Push(const Mark& mark, anchor_t anchor) {
+  detail::node& node = m_pMemory->create_node();
+  node.set_mark(mark);
+  RegisterAnchor(anchor, node);
+  Push(node);
+  return node;
+}
+
+void NodeBuilder::Push(detail::node& node) {
+  const bool needsKey =
+      (!m_stack.empty() && m_stack.back()->type() == NodeType::Map &&
+       m_keys.size() < m_mapDepth);
+
+  m_stack.push_back(&node);
+  if (needsKey)
+    m_keys.push_back(PushedKey(&node, false));
+}
+
+void NodeBuilder::Pop() {
+  assert(!m_stack.empty());
+  if (m_stack.size() == 1) {
+    m_pRoot = m_stack[0];
+    m_stack.pop_back();
+    return;
+  }
+
+  detail::node& node = *m_stack.back();
+  m_stack.pop_back();
+
+  detail::node& collection = *m_stack.back();
+
+  if (collection.type() == NodeType::Sequence) {
+    collection.push_back(node, m_pMemory);
+  } else if (collection.type() == NodeType::Map) {
+    assert(!m_keys.empty());
+    PushedKey& key = m_keys.back();
+    if (key.second) {
+      collection.insert(*key.first, node, m_pMemory);
+      m_keys.pop_back();
+    } else {
+      key.second = true;
+    }
+  } else {
+    assert(false);
+    m_stack.clear();
+  }
+}
+
+void NodeBuilder::RegisterAnchor(anchor_t anchor, detail::node& node) {
+  if (anchor) {
+    assert(anchor == m_anchors.size());
+    m_anchors.push_back(&node);
+  }
+}
+}
diff --git a/contrib/libs/yaml-cpp/src/nodebuilder.h b/contrib/libs/yaml-cpp/src/nodebuilder.h
index 9d81488af5f..a6a47f007bb 100644
--- a/contrib/libs/yaml-cpp/src/nodebuilder.h
+++ b/contrib/libs/yaml-cpp/src/nodebuilder.h
@@ -1,70 +1,70 @@
-#ifndef NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include <vector> 
- 
-#include "yaml-cpp/anchor.h" 
-#include "yaml-cpp/emitterstyle.h" 
-#include "yaml-cpp/eventhandler.h" 
-#include "yaml-cpp/node/ptr.h" 
- 
-namespace YAML { 
-namespace detail { 
-class node; 
-}  // namespace detail 
-struct Mark; 
-}  // namespace YAML 
- 
-namespace YAML { 
-class Node; 
- 
-class NodeBuilder : public EventHandler { 
- public: 
-  NodeBuilder(); 
-  virtual ~NodeBuilder(); 
- 
-  Node Root(); 
- 
-  virtual void OnDocumentStart(const Mark& mark); 
-  virtual void OnDocumentEnd(); 
- 
-  virtual void OnNull(const Mark& mark, anchor_t anchor); 
-  virtual void OnAlias(const Mark& mark, anchor_t anchor); 
-  virtual void OnScalar(const Mark& mark, const std::string& tag, 
-                        anchor_t anchor, const std::string& value); 
- 
-  virtual void OnSequenceStart(const Mark& mark, const std::string& tag, 
-                               anchor_t anchor, EmitterStyle::value style); 
-  virtual void OnSequenceEnd(); 
- 
-  virtual void OnMapStart(const Mark& mark, const std::string& tag, 
-                          anchor_t anchor, EmitterStyle::value style); 
-  virtual void OnMapEnd(); 
- 
- private: 
-  detail::node& Push(const Mark& mark, anchor_t anchor); 
-  void Push(detail::node& node); 
-  void Pop(); 
-  void RegisterAnchor(anchor_t anchor, detail::node& node); 
- 
- private: 
-  detail::shared_memory_holder m_pMemory; 
-  detail::node* m_pRoot; 
- 
-  typedef std::vector<detail::node*> Nodes; 
-  Nodes m_stack; 
-  Nodes m_anchors; 
- 
-  typedef std::pair<detail::node*, bool> PushedKey; 
-  std::vector<PushedKey> m_keys; 
-  std::size_t m_mapDepth; 
-}; 
-} 
- 
-#endif  // NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+#ifndef NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <vector>
+
+#include "yaml-cpp/anchor.h"
+#include "yaml-cpp/emitterstyle.h"
+#include "yaml-cpp/eventhandler.h"
+#include "yaml-cpp/node/ptr.h"
+
+namespace YAML {
+namespace detail {
+class node;
+}  // namespace detail
+struct Mark;
+}  // namespace YAML
+
+namespace YAML {
+class Node;
+
+class NodeBuilder : public EventHandler {
+ public:
+  NodeBuilder();
+  virtual ~NodeBuilder();
+
+  Node Root();
+
+  virtual void OnDocumentStart(const Mark& mark);
+  virtual void OnDocumentEnd();
+
+  virtual void OnNull(const Mark& mark, anchor_t anchor);
+  virtual void OnAlias(const Mark& mark, anchor_t anchor);
+  virtual void OnScalar(const Mark& mark, const std::string& tag,
+                        anchor_t anchor, const std::string& value);
+
+  virtual void OnSequenceStart(const Mark& mark, const std::string& tag,
+                               anchor_t anchor, EmitterStyle::value style);
+  virtual void OnSequenceEnd();
+
+  virtual void OnMapStart(const Mark& mark, const std::string& tag,
+                          anchor_t anchor, EmitterStyle::value style);
+  virtual void OnMapEnd();
+
+ private:
+  detail::node& Push(const Mark& mark, anchor_t anchor);
+  void Push(detail::node& node);
+  void Pop();
+  void RegisterAnchor(anchor_t anchor, detail::node& node);
+
+ private:
+  detail::shared_memory_holder m_pMemory;
+  detail::node* m_pRoot;
+
+  typedef std::vector<detail::node*> Nodes;
+  Nodes m_stack;
+  Nodes m_anchors;
+
+  typedef std::pair<detail::node*, bool> PushedKey;
+  std::vector<PushedKey> m_keys;
+  std::size_t m_mapDepth;
+};
+}
+
+#endif  // NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/src/nodeevents.cpp b/contrib/libs/yaml-cpp/src/nodeevents.cpp
index 726fc13ae6c..82261feb058 100644
--- a/contrib/libs/yaml-cpp/src/nodeevents.cpp
+++ b/contrib/libs/yaml-cpp/src/nodeevents.cpp
@@ -1,101 +1,101 @@
-#include "nodeevents.h" 
-#include "yaml-cpp/eventhandler.h" 
-#include "yaml-cpp/mark.h" 
-#include "yaml-cpp/node/detail/node.h" 
-#include "yaml-cpp/node/detail/node_iterator.h" 
-#include "yaml-cpp/node/node.h" 
-#include "yaml-cpp/node/type.h" 
- 
-namespace YAML { 
-void NodeEvents::AliasManager::RegisterReference(const detail::node& node) { 
-  m_anchorByIdentity.insert(std::make_pair(node.ref(), _CreateNewAnchor())); 
-} 
- 
-anchor_t NodeEvents::AliasManager::LookupAnchor( 
-    const detail::node& node) const { 
-  AnchorByIdentity::const_iterator it = m_anchorByIdentity.find(node.ref()); 
-  if (it == m_anchorByIdentity.end()) 
-    return 0; 
-  return it->second; 
-} 
- 
-NodeEvents::NodeEvents(const Node& node) 
-    : m_pMemory(node.m_pMemory), m_root(node.m_pNode) { 
-  if (m_root) 
-    Setup(*m_root); 
-} 
- 
-void NodeEvents::Setup(const detail::node& node) { 
-  int& refCount = m_refCount[node.ref()]; 
-  refCount++; 
-  if (refCount > 1) 
-    return; 
- 
-  if (node.type() == NodeType::Sequence) { 
-    for (detail::const_node_iterator it = node.begin(); it != node.end(); ++it) 
-      Setup(**it); 
-  } else if (node.type() == NodeType::Map) { 
-    for (detail::const_node_iterator it = node.begin(); it != node.end(); 
-         ++it) { 
-      Setup(*it->first); 
-      Setup(*it->second); 
-    } 
-  } 
-} 
- 
-void NodeEvents::Emit(EventHandler& handler) { 
-  AliasManager am; 
- 
-  handler.OnDocumentStart(Mark()); 
-  if (m_root) 
-    Emit(*m_root, handler, am); 
-  handler.OnDocumentEnd(); 
-} 
- 
-void NodeEvents::Emit(const detail::node& node, EventHandler& handler, 
-                      AliasManager& am) const { 
-  anchor_t anchor = NullAnchor; 
-  if (IsAliased(node)) { 
-    anchor = am.LookupAnchor(node); 
-    if (anchor) { 
-      handler.OnAlias(Mark(), anchor); 
-      return; 
-    } 
- 
-    am.RegisterReference(node); 
-    anchor = am.LookupAnchor(node); 
-  } 
- 
-  switch (node.type()) { 
-    case NodeType::Undefined: 
-      break; 
-    case NodeType::Null: 
-      handler.OnNull(Mark(), anchor); 
-      break; 
-    case NodeType::Scalar: 
-      handler.OnScalar(Mark(), node.tag(), anchor, node.scalar()); 
-      break; 
-    case NodeType::Sequence: 
-      handler.OnSequenceStart(Mark(), node.tag(), anchor, node.style()); 
-      for (detail::const_node_iterator it = node.begin(); it != node.end(); 
-           ++it) 
-        Emit(**it, handler, am); 
-      handler.OnSequenceEnd(); 
-      break; 
-    case NodeType::Map: 
-      handler.OnMapStart(Mark(), node.tag(), anchor, node.style()); 
-      for (detail::const_node_iterator it = node.begin(); it != node.end(); 
-           ++it) { 
-        Emit(*it->first, handler, am); 
-        Emit(*it->second, handler, am); 
-      } 
-      handler.OnMapEnd(); 
-      break; 
-  } 
-} 
- 
-bool NodeEvents::IsAliased(const detail::node& node) const { 
-  RefCount::const_iterator it = m_refCount.find(node.ref()); 
-  return it != m_refCount.end() && it->second > 1; 
-} 
-} 
+#include "nodeevents.h"
+#include "yaml-cpp/eventhandler.h"
+#include "yaml-cpp/mark.h"
+#include "yaml-cpp/node/detail/node.h"
+#include "yaml-cpp/node/detail/node_iterator.h"
+#include "yaml-cpp/node/node.h"
+#include "yaml-cpp/node/type.h"
+
+namespace YAML {
+void NodeEvents::AliasManager::RegisterReference(const detail::node& node) {
+  m_anchorByIdentity.insert(std::make_pair(node.ref(), _CreateNewAnchor()));
+}
+
+anchor_t NodeEvents::AliasManager::LookupAnchor(
+    const detail::node& node) const {
+  AnchorByIdentity::const_iterator it = m_anchorByIdentity.find(node.ref());
+  if (it == m_anchorByIdentity.end())
+    return 0;
+  return it->second;
+}
+
+NodeEvents::NodeEvents(const Node& node)
+    : m_pMemory(node.m_pMemory), m_root(node.m_pNode) {
+  if (m_root)
+    Setup(*m_root);
+}
+
+void NodeEvents::Setup(const detail::node& node) {
+  int& refCount = m_refCount[node.ref()];
+  refCount++;
+  if (refCount > 1)
+    return;
+
+  if (node.type() == NodeType::Sequence) {
+    for (detail::const_node_iterator it = node.begin(); it != node.end(); ++it)
+      Setup(**it);
+  } else if (node.type() == NodeType::Map) {
+    for (detail::const_node_iterator it = node.begin(); it != node.end();
+         ++it) {
+      Setup(*it->first);
+      Setup(*it->second);
+    }
+  }
+}
+
+void NodeEvents::Emit(EventHandler& handler) {
+  AliasManager am;
+
+  handler.OnDocumentStart(Mark());
+  if (m_root)
+    Emit(*m_root, handler, am);
+  handler.OnDocumentEnd();
+}
+
+void NodeEvents::Emit(const detail::node& node, EventHandler& handler,
+                      AliasManager& am) const {
+  anchor_t anchor = NullAnchor;
+  if (IsAliased(node)) {
+    anchor = am.LookupAnchor(node);
+    if (anchor) {
+      handler.OnAlias(Mark(), anchor);
+      return;
+    }
+
+    am.RegisterReference(node);
+    anchor = am.LookupAnchor(node);
+  }
+
+  switch (node.type()) {
+    case NodeType::Undefined:
+      break;
+    case NodeType::Null:
+      handler.OnNull(Mark(), anchor);
+      break;
+    case NodeType::Scalar:
+      handler.OnScalar(Mark(), node.tag(), anchor, node.scalar());
+      break;
+    case NodeType::Sequence:
+      handler.OnSequenceStart(Mark(), node.tag(), anchor, node.style());
+      for (detail::const_node_iterator it = node.begin(); it != node.end();
+           ++it)
+        Emit(**it, handler, am);
+      handler.OnSequenceEnd();
+      break;
+    case NodeType::Map:
+      handler.OnMapStart(Mark(), node.tag(), anchor, node.style());
+      for (detail::const_node_iterator it = node.begin(); it != node.end();
+           ++it) {
+        Emit(*it->first, handler, am);
+        Emit(*it->second, handler, am);
+      }
+      handler.OnMapEnd();
+      break;
+  }
+}
+
+bool NodeEvents::IsAliased(const detail::node& node) const {
+  RefCount::const_iterator it = m_refCount.find(node.ref());
+  return it != m_refCount.end() && it->second > 1;
+}
+}
diff --git a/contrib/libs/yaml-cpp/src/nodeevents.h b/contrib/libs/yaml-cpp/src/nodeevents.h
index ac52cd110ff..49c18eb854a 100644
--- a/contrib/libs/yaml-cpp/src/nodeevents.h
+++ b/contrib/libs/yaml-cpp/src/nodeevents.h
@@ -1,64 +1,64 @@
-#ifndef NODE_NODEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define NODE_NODEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include <map> 
-#include <vector> 
- 
-#include "yaml-cpp/anchor.h" 
-#include "yaml-cpp/node/ptr.h" 
- 
-namespace YAML { 
-namespace detail { 
-class node; 
-}  // namespace detail 
-}  // namespace YAML 
- 
-namespace YAML { 
-class EventHandler; 
-class Node; 
- 
-class NodeEvents { 
- public: 
-  explicit NodeEvents(const Node& node); 
- 
-  void Emit(EventHandler& handler); 
- 
- private: 
-  class AliasManager { 
-   public: 
-    AliasManager() : m_curAnchor(0) {} 
- 
-    void RegisterReference(const detail::node& node); 
-    anchor_t LookupAnchor(const detail::node& node) const; 
- 
-   private: 
-    anchor_t _CreateNewAnchor() { return ++m_curAnchor; } 
- 
-   private: 
-    typedef std::map<const detail::node_ref*, anchor_t> AnchorByIdentity; 
-    AnchorByIdentity m_anchorByIdentity; 
- 
-    anchor_t m_curAnchor; 
-  }; 
- 
-  void Setup(const detail::node& node); 
-  void Emit(const detail::node& node, EventHandler& handler, 
-            AliasManager& am) const; 
-  bool IsAliased(const detail::node& node) const; 
- 
- private: 
-  detail::shared_memory_holder m_pMemory; 
-  detail::node* m_root; 
- 
-  typedef std::map<const detail::node_ref*, int> RefCount; 
-  RefCount m_refCount; 
-}; 
-} 
- 
-#endif  // NODE_NODEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+#ifndef NODE_NODEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODE_NODEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <map>
+#include <vector>
+
+#include "yaml-cpp/anchor.h"
+#include "yaml-cpp/node/ptr.h"
+
+namespace YAML {
+namespace detail {
+class node;
+}  // namespace detail
+}  // namespace YAML
+
+namespace YAML {
+class EventHandler;
+class Node;
+
+class NodeEvents {
+ public:
+  explicit NodeEvents(const Node& node);
+
+  void Emit(EventHandler& handler);
+
+ private:
+  class AliasManager {
+   public:
+    AliasManager() : m_curAnchor(0) {}
+
+    void RegisterReference(const detail::node& node);
+    anchor_t LookupAnchor(const detail::node& node) const;
+
+   private:
+    anchor_t _CreateNewAnchor() { return ++m_curAnchor; }
+
+   private:
+    typedef std::map<const detail::node_ref*, anchor_t> AnchorByIdentity;
+    AnchorByIdentity m_anchorByIdentity;
+
+    anchor_t m_curAnchor;
+  };
+
+  void Setup(const detail::node& node);
+  void Emit(const detail::node& node, EventHandler& handler,
+            AliasManager& am) const;
+  bool IsAliased(const detail::node& node) const;
+
+ private:
+  detail::shared_memory_holder m_pMemory;
+  detail::node* m_root;
+
+  typedef std::map<const detail::node_ref*, int> RefCount;
+  RefCount m_refCount;
+};
+}
+
+#endif  // NODE_NODEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/src/null.cpp b/contrib/libs/yaml-cpp/src/null.cpp
index 3f29fd0f894..d12dd08ce4b 100644
--- a/contrib/libs/yaml-cpp/src/null.cpp
+++ b/contrib/libs/yaml-cpp/src/null.cpp
@@ -1,10 +1,10 @@
-#include "yaml-cpp/null.h" 
- 
-namespace YAML { 
-_Null Null; 
+#include "yaml-cpp/null.h"
+
+namespace YAML {
+_Null Null;
 
 bool IsNullString(const std::string& str) {
   return str.empty() || str == "~" || str == "null" || str == "Null" ||
          str == "NULL";
-} 
+}
 }
diff --git a/contrib/libs/yaml-cpp/src/ostream_wrapper.cpp b/contrib/libs/yaml-cpp/src/ostream_wrapper.cpp
index 4198a943719..357fc0094c4 100644
--- a/contrib/libs/yaml-cpp/src/ostream_wrapper.cpp
+++ b/contrib/libs/yaml-cpp/src/ostream_wrapper.cpp
@@ -1,57 +1,57 @@
-#include "yaml-cpp/ostream_wrapper.h" 
- 
-#include <algorithm> 
-#include <cstring> 
-#include <iostream> 
- 
-namespace YAML { 
-ostream_wrapper::ostream_wrapper() 
-    : m_buffer(1, '\0'), 
-      m_pStream(0), 
-      m_pos(0), 
-      m_row(0), 
-      m_col(0), 
-      m_comment(false) {} 
- 
-ostream_wrapper::ostream_wrapper(std::ostream& stream) 
-    : m_pStream(&stream), m_pos(0), m_row(0), m_col(0), m_comment(false) {} 
- 
-ostream_wrapper::~ostream_wrapper() {} 
- 
-void ostream_wrapper::write(const std::string& str) { 
-  if (m_pStream) { 
-    m_pStream->write(str.c_str(), str.size()); 
-  } else { 
-    m_buffer.resize(std::max(m_buffer.size(), m_pos + str.size() + 1)); 
-    std::copy(str.begin(), str.end(), m_buffer.begin() + m_pos); 
-  } 
- 
-  for (std::size_t i = 0; i < str.size(); i++) { 
-    update_pos(str[i]); 
-  } 
-} 
- 
-void ostream_wrapper::write(const char* str, std::size_t size) { 
-  if (m_pStream) { 
-    m_pStream->write(str, size); 
-  } else { 
-    m_buffer.resize(std::max(m_buffer.size(), m_pos + size + 1)); 
-    std::copy(str, str + size, m_buffer.begin() + m_pos); 
-  } 
- 
-  for (std::size_t i = 0; i < size; i++) { 
-    update_pos(str[i]); 
-  } 
-} 
- 
-void ostream_wrapper::update_pos(char ch) { 
-  m_pos++; 
-  m_col++; 
- 
-  if (ch == '\n') { 
-    m_row++; 
-    m_col = 0; 
-    m_comment = false; 
-  } 
-} 
-} 
+#include "yaml-cpp/ostream_wrapper.h"
+
+#include <algorithm>
+#include <cstring>
+#include <iostream>
+
+namespace YAML {
+ostream_wrapper::ostream_wrapper()
+    : m_buffer(1, '\0'),
+      m_pStream(0),
+      m_pos(0),
+      m_row(0),
+      m_col(0),
+      m_comment(false) {}
+
+ostream_wrapper::ostream_wrapper(std::ostream& stream)
+    : m_pStream(&stream), m_pos(0), m_row(0), m_col(0), m_comment(false) {}
+
+ostream_wrapper::~ostream_wrapper() {}
+
+void ostream_wrapper::write(const std::string& str) {
+  if (m_pStream) {
+    m_pStream->write(str.c_str(), str.size());
+  } else {
+    m_buffer.resize(std::max(m_buffer.size(), m_pos + str.size() + 1));
+    std::copy(str.begin(), str.end(), m_buffer.begin() + m_pos);
+  }
+
+  for (std::size_t i = 0; i < str.size(); i++) {
+    update_pos(str[i]);
+  }
+}
+
+void ostream_wrapper::write(const char* str, std::size_t size) {
+  if (m_pStream) {
+    m_pStream->write(str, size);
+  } else {
+    m_buffer.resize(std::max(m_buffer.size(), m_pos + size + 1));
+    std::copy(str, str + size, m_buffer.begin() + m_pos);
+  }
+
+  for (std::size_t i = 0; i < size; i++) {
+    update_pos(str[i]);
+  }
+}
+
+void ostream_wrapper::update_pos(char ch) {
+  m_pos++;
+  m_col++;
+
+  if (ch == '\n') {
+    m_row++;
+    m_col = 0;
+    m_comment = false;
+  }
+}
+}
diff --git a/contrib/libs/yaml-cpp/src/parse.cpp b/contrib/libs/yaml-cpp/src/parse.cpp
index 6499f85df07..0b2ae4a4f6e 100644
--- a/contrib/libs/yaml-cpp/src/parse.cpp
+++ b/contrib/libs/yaml-cpp/src/parse.cpp
@@ -1,72 +1,72 @@
-#include "yaml-cpp/node/parse.h" 
- 
-#include <fstream> 
-#include <sstream> 
- 
-#include "yaml-cpp/node/node.h" 
-#include "yaml-cpp/node/impl.h" 
-#include "yaml-cpp/parser.h" 
-#include "nodebuilder.h" 
- 
-namespace YAML { 
-Node Load(const std::string& input) { 
-  std::stringstream stream(input); 
-  return Load(stream); 
-} 
- 
-Node Load(const char* input) { 
-  std::stringstream stream(input); 
-  return Load(stream); 
-} 
- 
-Node Load(std::istream& input) { 
-  Parser parser(input); 
-  NodeBuilder builder; 
+#include "yaml-cpp/node/parse.h"
+
+#include <fstream>
+#include <sstream>
+
+#include "yaml-cpp/node/node.h"
+#include "yaml-cpp/node/impl.h"
+#include "yaml-cpp/parser.h"
+#include "nodebuilder.h"
+
+namespace YAML {
+Node Load(const std::string& input) {
+  std::stringstream stream(input);
+  return Load(stream);
+}
+
+Node Load(const char* input) {
+  std::stringstream stream(input);
+  return Load(stream);
+}
+
+Node Load(std::istream& input) {
+  Parser parser(input);
+  NodeBuilder builder;
   if (!parser.HandleNextDocument(builder)) {
-    return Node(); 
+    return Node();
   }
- 
-  return builder.Root(); 
-} 
- 
-Node LoadFile(const std::string& filename) { 
-  std::ifstream fin(filename.c_str()); 
+
+  return builder.Root();
+}
+
+Node LoadFile(const std::string& filename) {
+  std::ifstream fin(filename.c_str());
   if (!fin) {
-    throw BadFile(); 
+    throw BadFile();
   }
-  return Load(fin); 
-} 
- 
-std::vector<Node> LoadAll(const std::string& input) { 
-  std::stringstream stream(input); 
-  return LoadAll(stream); 
-} 
- 
-std::vector<Node> LoadAll(const char* input) { 
-  std::stringstream stream(input); 
-  return LoadAll(stream); 
-} 
- 
-std::vector<Node> LoadAll(std::istream& input) { 
-  std::vector<Node> docs; 
- 
-  Parser parser(input); 
-  while (1) { 
-    NodeBuilder builder; 
+  return Load(fin);
+}
+
+std::vector<Node> LoadAll(const std::string& input) {
+  std::stringstream stream(input);
+  return LoadAll(stream);
+}
+
+std::vector<Node> LoadAll(const char* input) {
+  std::stringstream stream(input);
+  return LoadAll(stream);
+}
+
+std::vector<Node> LoadAll(std::istream& input) {
+  std::vector<Node> docs;
+
+  Parser parser(input);
+  while (1) {
+    NodeBuilder builder;
     if (!parser.HandleNextDocument(builder)) {
-      break; 
+      break;
     }
-    docs.push_back(builder.Root()); 
-  } 
- 
-  return docs; 
-} 
- 
-std::vector<Node> LoadAllFromFile(const std::string& filename) { 
-  std::ifstream fin(filename.c_str()); 
+    docs.push_back(builder.Root());
+  }
+
+  return docs;
+}
+
+std::vector<Node> LoadAllFromFile(const std::string& filename) {
+  std::ifstream fin(filename.c_str());
   if (!fin) {
-    throw BadFile(); 
+    throw BadFile();
   }
-  return LoadAll(fin); 
-} 
+  return LoadAll(fin);
+}
 }  // namespace YAML
diff --git a/contrib/libs/yaml-cpp/src/parser.cpp b/contrib/libs/yaml-cpp/src/parser.cpp
index 1c5ff53c89a..cd69f39fcec 100644
--- a/contrib/libs/yaml-cpp/src/parser.cpp
+++ b/contrib/libs/yaml-cpp/src/parser.cpp
@@ -1,129 +1,129 @@
-#include <cstdio> 
-#include <sstream> 
- 
-#include "directives.h"  // IWYU pragma: keep 
-#include "scanner.h"     // IWYU pragma: keep 
-#include "singledocparser.h" 
-#include "token.h" 
-#include "yaml-cpp/exceptions.h"  // IWYU pragma: keep 
-#include "yaml-cpp/parser.h" 
- 
-namespace YAML { 
-class EventHandler; 
- 
-Parser::Parser() {} 
- 
-Parser::Parser(std::istream& in) { Load(in); } 
- 
-Parser::~Parser() {} 
- 
-Parser::operator bool() const { 
-  return m_pScanner.get() && !m_pScanner->empty(); 
-} 
- 
-void Parser::Load(std::istream& in) { 
-  m_pScanner.reset(new Scanner(in)); 
-  m_pDirectives.reset(new Directives); 
-} 
- 
-bool Parser::HandleNextDocument(EventHandler& eventHandler) { 
-  if (!m_pScanner.get()) 
-    return false; 
- 
-  ParseDirectives(); 
+#include <cstdio>
+#include <sstream>
+
+#include "directives.h"  // IWYU pragma: keep
+#include "scanner.h"     // IWYU pragma: keep
+#include "singledocparser.h"
+#include "token.h"
+#include "yaml-cpp/exceptions.h"  // IWYU pragma: keep
+#include "yaml-cpp/parser.h"
+
+namespace YAML {
+class EventHandler;
+
+Parser::Parser() {}
+
+Parser::Parser(std::istream& in) { Load(in); }
+
+Parser::~Parser() {}
+
+Parser::operator bool() const {
+  return m_pScanner.get() && !m_pScanner->empty();
+}
+
+void Parser::Load(std::istream& in) {
+  m_pScanner.reset(new Scanner(in));
+  m_pDirectives.reset(new Directives);
+}
+
+bool Parser::HandleNextDocument(EventHandler& eventHandler) {
+  if (!m_pScanner.get())
+    return false;
+
+  ParseDirectives();
   if (m_pScanner->empty()) {
-    return false; 
+    return false;
   }
- 
-  SingleDocParser sdp(*m_pScanner, *m_pDirectives); 
-  sdp.HandleDocument(eventHandler); 
-  return true; 
-} 
- 
-void Parser::ParseDirectives() { 
-  bool readDirective = false; 
- 
-  while (1) { 
+
+  SingleDocParser sdp(*m_pScanner, *m_pDirectives);
+  sdp.HandleDocument(eventHandler);
+  return true;
+}
+
+void Parser::ParseDirectives() {
+  bool readDirective = false;
+
+  while (1) {
     if (m_pScanner->empty()) {
-      break; 
+      break;
     }
- 
-    Token& token = m_pScanner->peek(); 
+
+    Token& token = m_pScanner->peek();
     if (token.type != Token::DIRECTIVE) {
-      break; 
+      break;
     }
- 
-    // we keep the directives from the last document if none are specified; 
-    // but if any directives are specific, then we reset them 
+
+    // we keep the directives from the last document if none are specified;
+    // but if any directives are specific, then we reset them
     if (!readDirective) {
-      m_pDirectives.reset(new Directives); 
+      m_pDirectives.reset(new Directives);
     }
- 
-    readDirective = true; 
-    HandleDirective(token); 
-    m_pScanner->pop(); 
-  } 
-} 
- 
-void Parser::HandleDirective(const Token& token) { 
+
+    readDirective = true;
+    HandleDirective(token);
+    m_pScanner->pop();
+  }
+}
+
+void Parser::HandleDirective(const Token& token) {
   if (token.value == "YAML") {
-    HandleYamlDirective(token); 
+    HandleYamlDirective(token);
   } else if (token.value == "TAG") {
-    HandleTagDirective(token); 
+    HandleTagDirective(token);
   }
-} 
- 
-void Parser::HandleYamlDirective(const Token& token) { 
+}
+
+void Parser::HandleYamlDirective(const Token& token) {
   if (token.params.size() != 1) {
-    throw ParserException(token.mark, ErrorMsg::YAML_DIRECTIVE_ARGS); 
+    throw ParserException(token.mark, ErrorMsg::YAML_DIRECTIVE_ARGS);
   }
- 
+
   if (!m_pDirectives->version.isDefault) {
-    throw ParserException(token.mark, ErrorMsg::REPEATED_YAML_DIRECTIVE); 
+    throw ParserException(token.mark, ErrorMsg::REPEATED_YAML_DIRECTIVE);
   }
- 
-  std::stringstream str(token.params[0]); 
-  str >> m_pDirectives->version.major; 
-  str.get(); 
-  str >> m_pDirectives->version.minor; 
+
+  std::stringstream str(token.params[0]);
+  str >> m_pDirectives->version.major;
+  str.get();
+  str >> m_pDirectives->version.minor;
   if (!str || str.peek() != EOF) {
-    throw ParserException( 
-        token.mark, std::string(ErrorMsg::YAML_VERSION) + token.params[0]); 
+    throw ParserException(
+        token.mark, std::string(ErrorMsg::YAML_VERSION) + token.params[0]);
   }
- 
+
   if (m_pDirectives->version.major > 1) {
-    throw ParserException(token.mark, ErrorMsg::YAML_MAJOR_VERSION); 
+    throw ParserException(token.mark, ErrorMsg::YAML_MAJOR_VERSION);
   }
- 
-  m_pDirectives->version.isDefault = false; 
-  // TODO: warning on major == 1, minor > 2? 
-} 
- 
-void Parser::HandleTagDirective(const Token& token) { 
-  if (token.params.size() != 2) 
-    throw ParserException(token.mark, ErrorMsg::TAG_DIRECTIVE_ARGS); 
- 
-  const std::string& handle = token.params[0]; 
-  const std::string& prefix = token.params[1]; 
+
+  m_pDirectives->version.isDefault = false;
+  // TODO: warning on major == 1, minor > 2?
+}
+
+void Parser::HandleTagDirective(const Token& token) {
+  if (token.params.size() != 2)
+    throw ParserException(token.mark, ErrorMsg::TAG_DIRECTIVE_ARGS);
+
+  const std::string& handle = token.params[0];
+  const std::string& prefix = token.params[1];
   if (m_pDirectives->tags.find(handle) != m_pDirectives->tags.end()) {
-    throw ParserException(token.mark, ErrorMsg::REPEATED_TAG_DIRECTIVE); 
+    throw ParserException(token.mark, ErrorMsg::REPEATED_TAG_DIRECTIVE);
   }
- 
-  m_pDirectives->tags[handle] = prefix; 
-} 
- 
-void Parser::PrintTokens(std::ostream& out) { 
+
+  m_pDirectives->tags[handle] = prefix;
+}
+
+void Parser::PrintTokens(std::ostream& out) {
   if (!m_pScanner.get()) {
-    return; 
+    return;
   }
- 
-  while (1) { 
+
+  while (1) {
     if (m_pScanner->empty()) {
-      break; 
+      break;
     }
- 
-    out << m_pScanner->peek() << "\n"; 
-    m_pScanner->pop(); 
-  } 
-} 
-} 
+
+    out << m_pScanner->peek() << "\n";
+    m_pScanner->pop();
+  }
+}
+}
diff --git a/contrib/libs/yaml-cpp/src/ptr_vector.h b/contrib/libs/yaml-cpp/src/ptr_vector.h
index 051a48a1e76..955aebd8d56 100644
--- a/contrib/libs/yaml-cpp/src/ptr_vector.h
+++ b/contrib/libs/yaml-cpp/src/ptr_vector.h
@@ -1,43 +1,43 @@
-#ifndef PTR_VECTOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define PTR_VECTOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include <cstddef> 
-#include <cstdlib> 
-#include <memory> 
-#include <vector> 
- 
-#include "yaml-cpp/noncopyable.h" 
- 
-namespace YAML { 
- 
+#ifndef PTR_VECTOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define PTR_VECTOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <cstddef>
+#include <cstdlib>
+#include <memory>
+#include <vector>
+
+#include "yaml-cpp/noncopyable.h"
+
+namespace YAML {
+
 // TODO: This class is no longer needed
-template <typename T> 
-class ptr_vector : private YAML::noncopyable { 
- public: 
-  ptr_vector() {} 
- 
+template <typename T>
+class ptr_vector : private YAML::noncopyable {
+ public:
+  ptr_vector() {}
+
   void clear() { m_data.clear(); }
- 
-  std::size_t size() const { return m_data.size(); } 
-  bool empty() const { return m_data.empty(); } 
- 
+
+  std::size_t size() const { return m_data.size(); }
+  bool empty() const { return m_data.empty(); }
+
   void push_back(std::unique_ptr<T>&& t) { m_data.push_back(std::move(t)); }
-  T& operator[](std::size_t i) { return *m_data[i]; } 
-  const T& operator[](std::size_t i) const { return *m_data[i]; } 
- 
+  T& operator[](std::size_t i) { return *m_data[i]; }
+  const T& operator[](std::size_t i) const { return *m_data[i]; }
+
   T& back() { return *(m_data.back().get()); }
- 
+
   const T& back() const { return *(m_data.back().get()); }
 
- private: 
+ private:
   std::vector<std::unique_ptr<T>> m_data;
-}; 
-} 
- 
-#endif  // PTR_VECTOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+};
+}
+
+#endif  // PTR_VECTOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/src/regex_yaml.cpp b/contrib/libs/yaml-cpp/src/regex_yaml.cpp
index 2933a012dd0..20b772051d2 100644
--- a/contrib/libs/yaml-cpp/src/regex_yaml.cpp
+++ b/contrib/libs/yaml-cpp/src/regex_yaml.cpp
@@ -1,45 +1,45 @@
-#include "regex_yaml.h" 
- 
-namespace YAML { 
-// constructors 
-RegEx::RegEx() : m_op(REGEX_EMPTY) {} 
- 
-RegEx::RegEx(REGEX_OP op) : m_op(op) {} 
- 
-RegEx::RegEx(char ch) : m_op(REGEX_MATCH), m_a(ch) {} 
- 
-RegEx::RegEx(char a, char z) : m_op(REGEX_RANGE), m_a(a), m_z(z) {} 
- 
-RegEx::RegEx(const std::string& str, REGEX_OP op) : m_op(op) { 
-  for (std::size_t i = 0; i < str.size(); i++) 
-    m_params.push_back(RegEx(str[i])); 
-} 
- 
-// combination constructors 
-RegEx operator!(const RegEx& ex) { 
-  RegEx ret(REGEX_NOT); 
-  ret.m_params.push_back(ex); 
-  return ret; 
-} 
- 
-RegEx operator||(const RegEx& ex1, const RegEx& ex2) { 
-  RegEx ret(REGEX_OR); 
-  ret.m_params.push_back(ex1); 
-  ret.m_params.push_back(ex2); 
-  return ret; 
-} 
- 
-RegEx operator&&(const RegEx& ex1, const RegEx& ex2) { 
-  RegEx ret(REGEX_AND); 
-  ret.m_params.push_back(ex1); 
-  ret.m_params.push_back(ex2); 
-  return ret; 
-} 
- 
-RegEx operator+(const RegEx& ex1, const RegEx& ex2) { 
-  RegEx ret(REGEX_SEQ); 
-  ret.m_params.push_back(ex1); 
-  ret.m_params.push_back(ex2); 
-  return ret; 
-} 
-} 
+#include "regex_yaml.h"
+
+namespace YAML {
+// constructors
+RegEx::RegEx() : m_op(REGEX_EMPTY) {}
+
+RegEx::RegEx(REGEX_OP op) : m_op(op) {}
+
+RegEx::RegEx(char ch) : m_op(REGEX_MATCH), m_a(ch) {}
+
+RegEx::RegEx(char a, char z) : m_op(REGEX_RANGE), m_a(a), m_z(z) {}
+
+RegEx::RegEx(const std::string& str, REGEX_OP op) : m_op(op) {
+  for (std::size_t i = 0; i < str.size(); i++)
+    m_params.push_back(RegEx(str[i]));
+}
+
+// combination constructors
+RegEx operator!(const RegEx& ex) {
+  RegEx ret(REGEX_NOT);
+  ret.m_params.push_back(ex);
+  return ret;
+}
+
+RegEx operator||(const RegEx& ex1, const RegEx& ex2) {
+  RegEx ret(REGEX_OR);
+  ret.m_params.push_back(ex1);
+  ret.m_params.push_back(ex2);
+  return ret;
+}
+
+RegEx operator&&(const RegEx& ex1, const RegEx& ex2) {
+  RegEx ret(REGEX_AND);
+  ret.m_params.push_back(ex1);
+  ret.m_params.push_back(ex2);
+  return ret;
+}
+
+RegEx operator+(const RegEx& ex1, const RegEx& ex2) {
+  RegEx ret(REGEX_SEQ);
+  ret.m_params.push_back(ex1);
+  ret.m_params.push_back(ex2);
+  return ret;
+}
+}
diff --git a/contrib/libs/yaml-cpp/src/regex_yaml.h b/contrib/libs/yaml-cpp/src/regex_yaml.h
index 35f7ef52b70..8f28b852a29 100644
--- a/contrib/libs/yaml-cpp/src/regex_yaml.h
+++ b/contrib/libs/yaml-cpp/src/regex_yaml.h
@@ -1,87 +1,87 @@
-#ifndef REGEX_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define REGEX_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include <string> 
-#include <vector> 
- 
+#ifndef REGEX_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define REGEX_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <string>
+#include <vector>
+
 #include "yaml-cpp/dll.h"
 
-namespace YAML { 
-class Stream; 
- 
-enum REGEX_OP { 
-  REGEX_EMPTY, 
-  REGEX_MATCH, 
-  REGEX_RANGE, 
-  REGEX_OR, 
-  REGEX_AND, 
-  REGEX_NOT, 
-  REGEX_SEQ 
-}; 
- 
-// simplified regular expressions 
-// . Only straightforward matches (no repeated characters) 
-// . Only matches from start of string 
+namespace YAML {
+class Stream;
+
+enum REGEX_OP {
+  REGEX_EMPTY,
+  REGEX_MATCH,
+  REGEX_RANGE,
+  REGEX_OR,
+  REGEX_AND,
+  REGEX_NOT,
+  REGEX_SEQ
+};
+
+// simplified regular expressions
+// . Only straightforward matches (no repeated characters)
+// . Only matches from start of string
 class YAML_CPP_API RegEx {
- public: 
-  RegEx(); 
-  RegEx(char ch); 
-  RegEx(char a, char z); 
-  RegEx(const std::string& str, REGEX_OP op = REGEX_SEQ); 
-  ~RegEx() {} 
- 
+ public:
+  RegEx();
+  RegEx(char ch);
+  RegEx(char a, char z);
+  RegEx(const std::string& str, REGEX_OP op = REGEX_SEQ);
+  ~RegEx() {}
+
   friend YAML_CPP_API RegEx operator!(const RegEx& ex);
   friend YAML_CPP_API RegEx operator||(const RegEx& ex1, const RegEx& ex2);
   friend YAML_CPP_API RegEx operator&&(const RegEx& ex1, const RegEx& ex2);
   friend YAML_CPP_API RegEx operator+(const RegEx& ex1, const RegEx& ex2);
- 
-  bool Matches(char ch) const; 
-  bool Matches(const std::string& str) const; 
-  bool Matches(const Stream& in) const; 
-  template <typename Source> 
-  bool Matches(const Source& source) const; 
- 
-  int Match(const std::string& str) const; 
-  int Match(const Stream& in) const; 
-  template <typename Source> 
-  int Match(const Source& source) const; 
- 
- private: 
-  RegEx(REGEX_OP op); 
- 
-  template <typename Source> 
-  bool IsValidSource(const Source& source) const; 
-  template <typename Source> 
-  int MatchUnchecked(const Source& source) const; 
- 
-  template <typename Source> 
-  int MatchOpEmpty(const Source& source) const; 
-  template <typename Source> 
-  int MatchOpMatch(const Source& source) const; 
-  template <typename Source> 
-  int MatchOpRange(const Source& source) const; 
-  template <typename Source> 
-  int MatchOpOr(const Source& source) const; 
-  template <typename Source> 
-  int MatchOpAnd(const Source& source) const; 
-  template <typename Source> 
-  int MatchOpNot(const Source& source) const; 
-  template <typename Source> 
-  int MatchOpSeq(const Source& source) const; 
- 
- private: 
-  REGEX_OP m_op; 
-  char m_a, m_z; 
-  std::vector<RegEx> m_params; 
-}; 
-} 
- 
-#include "regeximpl.h" 
- 
-#endif  // REGEX_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+
+  bool Matches(char ch) const;
+  bool Matches(const std::string& str) const;
+  bool Matches(const Stream& in) const;
+  template <typename Source>
+  bool Matches(const Source& source) const;
+
+  int Match(const std::string& str) const;
+  int Match(const Stream& in) const;
+  template <typename Source>
+  int Match(const Source& source) const;
+
+ private:
+  RegEx(REGEX_OP op);
+
+  template <typename Source>
+  bool IsValidSource(const Source& source) const;
+  template <typename Source>
+  int MatchUnchecked(const Source& source) const;
+
+  template <typename Source>
+  int MatchOpEmpty(const Source& source) const;
+  template <typename Source>
+  int MatchOpMatch(const Source& source) const;
+  template <typename Source>
+  int MatchOpRange(const Source& source) const;
+  template <typename Source>
+  int MatchOpOr(const Source& source) const;
+  template <typename Source>
+  int MatchOpAnd(const Source& source) const;
+  template <typename Source>
+  int MatchOpNot(const Source& source) const;
+  template <typename Source>
+  int MatchOpSeq(const Source& source) const;
+
+ private:
+  REGEX_OP m_op;
+  char m_a, m_z;
+  std::vector<RegEx> m_params;
+};
+}
+
+#include "regeximpl.h"
+
+#endif  // REGEX_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/src/regeximpl.h b/contrib/libs/yaml-cpp/src/regeximpl.h
index 4a529e7a0dc..709124f0088 100644
--- a/contrib/libs/yaml-cpp/src/regeximpl.h
+++ b/contrib/libs/yaml-cpp/src/regeximpl.h
@@ -1,186 +1,186 @@
-#ifndef REGEXIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define REGEXIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include "stream.h" 
-#include "stringsource.h" 
-#include "streamcharsource.h" 
- 
-namespace YAML { 
-// query matches 
-inline bool RegEx::Matches(char ch) const { 
-  std::string str; 
-  str += ch; 
-  return Matches(str); 
-} 
- 
-inline bool RegEx::Matches(const std::string& str) const { 
-  return Match(str) >= 0; 
-} 
- 
-inline bool RegEx::Matches(const Stream& in) const { return Match(in) >= 0; } 
- 
-template <typename Source> 
-inline bool RegEx::Matches(const Source& source) const { 
-  return Match(source) >= 0; 
-} 
- 
-// Match 
-// . Matches the given string against this regular expression. 
-// . Returns the number of characters matched. 
-// . Returns -1 if no characters were matched (the reason for 
-//   not returning zero is that we may have an empty regex 
-//   which is ALWAYS successful at matching zero characters). 
-// . REMEMBER that we only match from the start of the buffer! 
-inline int RegEx::Match(const std::string& str) const { 
-  StringCharSource source(str.c_str(), str.size()); 
-  return Match(source); 
-} 
- 
-inline int RegEx::Match(const Stream& in) const { 
-  StreamCharSource source(in); 
-  return Match(source); 
-} 
- 
-template <typename Source> 
-inline bool RegEx::IsValidSource(const Source& source) const { 
-  return source; 
-} 
- 
-template <> 
-inline bool RegEx::IsValidSource<StringCharSource>( 
-    const StringCharSource& source) const { 
-  switch (m_op) { 
-    case REGEX_MATCH: 
-    case REGEX_RANGE: 
-      return source; 
-    default: 
-      return true; 
-  } 
-} 
- 
-template <typename Source> 
-inline int RegEx::Match(const Source& source) const { 
-  return IsValidSource(source) ? MatchUnchecked(source) : -1; 
-} 
- 
-template <typename Source> 
-inline int RegEx::MatchUnchecked(const Source& source) const { 
-  switch (m_op) { 
-    case REGEX_EMPTY: 
-      return MatchOpEmpty(source); 
-    case REGEX_MATCH: 
-      return MatchOpMatch(source); 
-    case REGEX_RANGE: 
-      return MatchOpRange(source); 
-    case REGEX_OR: 
-      return MatchOpOr(source); 
-    case REGEX_AND: 
-      return MatchOpAnd(source); 
-    case REGEX_NOT: 
-      return MatchOpNot(source); 
-    case REGEX_SEQ: 
-      return MatchOpSeq(source); 
-  } 
- 
-  return -1; 
-} 
- 
-////////////////////////////////////////////////////////////////////////////// 
-// Operators 
-// Note: the convention MatchOp*<Source> is that we can assume 
-// IsSourceValid(source). 
-//       So we do all our checks *before* we call these functions 
- 
-// EmptyOperator 
-template <typename Source> 
-inline int RegEx::MatchOpEmpty(const Source& source) const { 
-  return source[0] == Stream::eof() ? 0 : -1; 
-} 
- 
-template <> 
-inline int RegEx::MatchOpEmpty<StringCharSource>( 
-    const StringCharSource& source) const { 
-  return !source 
-             ? 0 
-             : -1;  // the empty regex only is successful on the empty string 
-} 
- 
-// MatchOperator 
-template <typename Source> 
-inline int RegEx::MatchOpMatch(const Source& source) const { 
-  if (source[0] != m_a) 
-    return -1; 
-  return 1; 
-} 
- 
-// RangeOperator 
-template <typename Source> 
-inline int RegEx::MatchOpRange(const Source& source) const { 
-  if (m_a > source[0] || m_z < source[0]) 
-    return -1; 
-  return 1; 
-} 
- 
-// OrOperator 
-template <typename Source> 
-inline int RegEx::MatchOpOr(const Source& source) const { 
-  for (std::size_t i = 0; i < m_params.size(); i++) { 
-    int n = m_params[i].MatchUnchecked(source); 
-    if (n >= 0) 
-      return n; 
-  } 
-  return -1; 
-} 
- 
-// AndOperator 
-// Note: 'AND' is a little funny, since we may be required to match things 
-//       of different lengths. If we find a match, we return the length of 
-//       the FIRST entry on the list. 
-template <typename Source> 
-inline int RegEx::MatchOpAnd(const Source& source) const { 
-  int first = -1; 
-  for (std::size_t i = 0; i < m_params.size(); i++) { 
-    int n = m_params[i].MatchUnchecked(source); 
-    if (n == -1) 
-      return -1; 
-    if (i == 0) 
-      first = n; 
-  } 
-  return first; 
-} 
- 
-// NotOperator 
-template <typename Source> 
-inline int RegEx::MatchOpNot(const Source& source) const { 
-  if (m_params.empty()) 
-    return -1; 
-  if (m_params[0].MatchUnchecked(source) >= 0) 
-    return -1; 
-  return 1; 
-} 
- 
-// SeqOperator 
-template <typename Source> 
-inline int RegEx::MatchOpSeq(const Source& source) const { 
-  int offset = 0; 
-  for (std::size_t i = 0; i < m_params.size(); i++) { 
-    int n = m_params[i].Match(source + offset);  // note Match, not 
-                                                 // MatchUnchecked because we 
-                                                 // need to check validity after 
-                                                 // the offset 
-    if (n == -1) 
-      return -1; 
-    offset += n; 
-  } 
- 
-  return offset; 
-} 
-} 
- 
-#endif  // REGEXIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+#ifndef REGEXIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define REGEXIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "stream.h"
+#include "stringsource.h"
+#include "streamcharsource.h"
+
+namespace YAML {
+// query matches
+inline bool RegEx::Matches(char ch) const {
+  std::string str;
+  str += ch;
+  return Matches(str);
+}
+
+inline bool RegEx::Matches(const std::string& str) const {
+  return Match(str) >= 0;
+}
+
+inline bool RegEx::Matches(const Stream& in) const { return Match(in) >= 0; }
+
+template <typename Source>
+inline bool RegEx::Matches(const Source& source) const {
+  return Match(source) >= 0;
+}
+
+// Match
+// . Matches the given string against this regular expression.
+// . Returns the number of characters matched.
+// . Returns -1 if no characters were matched (the reason for
+//   not returning zero is that we may have an empty regex
+//   which is ALWAYS successful at matching zero characters).
+// . REMEMBER that we only match from the start of the buffer!
+inline int RegEx::Match(const std::string& str) const {
+  StringCharSource source(str.c_str(), str.size());
+  return Match(source);
+}
+
+inline int RegEx::Match(const Stream& in) const {
+  StreamCharSource source(in);
+  return Match(source);
+}
+
+template <typename Source>
+inline bool RegEx::IsValidSource(const Source& source) const {
+  return source;
+}
+
+template <>
+inline bool RegEx::IsValidSource<StringCharSource>(
+    const StringCharSource& source) const {
+  switch (m_op) {
+    case REGEX_MATCH:
+    case REGEX_RANGE:
+      return source;
+    default:
+      return true;
+  }
+}
+
+template <typename Source>
+inline int RegEx::Match(const Source& source) const {
+  return IsValidSource(source) ? MatchUnchecked(source) : -1;
+}
+
+template <typename Source>
+inline int RegEx::MatchUnchecked(const Source& source) const {
+  switch (m_op) {
+    case REGEX_EMPTY:
+      return MatchOpEmpty(source);
+    case REGEX_MATCH:
+      return MatchOpMatch(source);
+    case REGEX_RANGE:
+      return MatchOpRange(source);
+    case REGEX_OR:
+      return MatchOpOr(source);
+    case REGEX_AND:
+      return MatchOpAnd(source);
+    case REGEX_NOT:
+      return MatchOpNot(source);
+    case REGEX_SEQ:
+      return MatchOpSeq(source);
+  }
+
+  return -1;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// Operators
+// Note: the convention MatchOp*<Source> is that we can assume
+// IsSourceValid(source).
+//       So we do all our checks *before* we call these functions
+
+// EmptyOperator
+template <typename Source>
+inline int RegEx::MatchOpEmpty(const Source& source) const {
+  return source[0] == Stream::eof() ? 0 : -1;
+}
+
+template <>
+inline int RegEx::MatchOpEmpty<StringCharSource>(
+    const StringCharSource& source) const {
+  return !source
+             ? 0
+             : -1;  // the empty regex only is successful on the empty string
+}
+
+// MatchOperator
+template <typename Source>
+inline int RegEx::MatchOpMatch(const Source& source) const {
+  if (source[0] != m_a)
+    return -1;
+  return 1;
+}
+
+// RangeOperator
+template <typename Source>
+inline int RegEx::MatchOpRange(const Source& source) const {
+  if (m_a > source[0] || m_z < source[0])
+    return -1;
+  return 1;
+}
+
+// OrOperator
+template <typename Source>
+inline int RegEx::MatchOpOr(const Source& source) const {
+  for (std::size_t i = 0; i < m_params.size(); i++) {
+    int n = m_params[i].MatchUnchecked(source);
+    if (n >= 0)
+      return n;
+  }
+  return -1;
+}
+
+// AndOperator
+// Note: 'AND' is a little funny, since we may be required to match things
+//       of different lengths. If we find a match, we return the length of
+//       the FIRST entry on the list.
+template <typename Source>
+inline int RegEx::MatchOpAnd(const Source& source) const {
+  int first = -1;
+  for (std::size_t i = 0; i < m_params.size(); i++) {
+    int n = m_params[i].MatchUnchecked(source);
+    if (n == -1)
+      return -1;
+    if (i == 0)
+      first = n;
+  }
+  return first;
+}
+
+// NotOperator
+template <typename Source>
+inline int RegEx::MatchOpNot(const Source& source) const {
+  if (m_params.empty())
+    return -1;
+  if (m_params[0].MatchUnchecked(source) >= 0)
+    return -1;
+  return 1;
+}
+
+// SeqOperator
+template <typename Source>
+inline int RegEx::MatchOpSeq(const Source& source) const {
+  int offset = 0;
+  for (std::size_t i = 0; i < m_params.size(); i++) {
+    int n = m_params[i].Match(source + offset);  // note Match, not
+                                                 // MatchUnchecked because we
+                                                 // need to check validity after
+                                                 // the offset
+    if (n == -1)
+      return -1;
+    offset += n;
+  }
+
+  return offset;
+}
+}
+
+#endif  // REGEXIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/src/scanner.cpp b/contrib/libs/yaml-cpp/src/scanner.cpp
index 29301f6bb02..b5cfcc12b22 100644
--- a/contrib/libs/yaml-cpp/src/scanner.cpp
+++ b/contrib/libs/yaml-cpp/src/scanner.cpp
@@ -1,386 +1,386 @@
-#include <cassert> 
-#include <memory> 
- 
-#include "exp.h" 
-#include "scanner.h" 
-#include "token.h" 
-#include "yaml-cpp/exceptions.h"  // IWYU pragma: keep 
- 
-namespace YAML { 
-Scanner::Scanner(std::istream& in) 
-    : INPUT(in), 
-      m_startedStream(false), 
-      m_endedStream(false), 
-      m_simpleKeyAllowed(false), 
-      m_canBeJSONFlow(false) {} 
- 
-Scanner::~Scanner() {} 
- 
-bool Scanner::empty() { 
-  EnsureTokensInQueue(); 
-  return m_tokens.empty(); 
-} 
- 
-void Scanner::pop() { 
-  EnsureTokensInQueue(); 
-  if (!m_tokens.empty()) 
-    m_tokens.pop(); 
-} 
- 
-Token& Scanner::peek() { 
-  EnsureTokensInQueue(); 
-  assert(!m_tokens.empty());  // should we be asserting here? I mean, we really 
-                              // just be checking 
-                              // if it's empty before peeking. 
- 
-#if 0 
-		static Token *pLast = 0; 
-		if(pLast != &m_tokens.front()) 
-			std::cerr << "peek: " << m_tokens.front() << "\n"; 
-		pLast = &m_tokens.front(); 
-#endif 
- 
-  return m_tokens.front(); 
-} 
- 
-Mark Scanner::mark() const { return INPUT.mark(); } 
- 
-void Scanner::EnsureTokensInQueue() { 
-  while (1) { 
-    if (!m_tokens.empty()) { 
-      Token& token = m_tokens.front(); 
- 
-      // if this guy's valid, then we're done 
+#include <cassert>
+#include <memory>
+
+#include "exp.h"
+#include "scanner.h"
+#include "token.h"
+#include "yaml-cpp/exceptions.h"  // IWYU pragma: keep
+
+namespace YAML {
+Scanner::Scanner(std::istream& in)
+    : INPUT(in),
+      m_startedStream(false),
+      m_endedStream(false),
+      m_simpleKeyAllowed(false),
+      m_canBeJSONFlow(false) {}
+
+Scanner::~Scanner() {}
+
+bool Scanner::empty() {
+  EnsureTokensInQueue();
+  return m_tokens.empty();
+}
+
+void Scanner::pop() {
+  EnsureTokensInQueue();
+  if (!m_tokens.empty())
+    m_tokens.pop();
+}
+
+Token& Scanner::peek() {
+  EnsureTokensInQueue();
+  assert(!m_tokens.empty());  // should we be asserting here? I mean, we really
+                              // just be checking
+                              // if it's empty before peeking.
+
+#if 0
+		static Token *pLast = 0;
+		if(pLast != &m_tokens.front())
+			std::cerr << "peek: " << m_tokens.front() << "\n";
+		pLast = &m_tokens.front();
+#endif
+
+  return m_tokens.front();
+}
+
+Mark Scanner::mark() const { return INPUT.mark(); }
+
+void Scanner::EnsureTokensInQueue() {
+  while (1) {
+    if (!m_tokens.empty()) {
+      Token& token = m_tokens.front();
+
+      // if this guy's valid, then we're done
       if (token.status == Token::VALID) {
-        return; 
+        return;
       }
- 
-      // here's where we clean up the impossible tokens 
-      if (token.status == Token::INVALID) { 
-        m_tokens.pop(); 
-        continue; 
-      } 
- 
-      // note: what's left are the unverified tokens 
-    } 
- 
-    // no token? maybe we've actually finished 
+
+      // here's where we clean up the impossible tokens
+      if (token.status == Token::INVALID) {
+        m_tokens.pop();
+        continue;
+      }
+
+      // note: what's left are the unverified tokens
+    }
+
+    // no token? maybe we've actually finished
     if (m_endedStream) {
-      return; 
+      return;
     }
- 
-    // no? then scan... 
-    ScanNextToken(); 
-  } 
-} 
- 
-void Scanner::ScanNextToken() { 
+
+    // no? then scan...
+    ScanNextToken();
+  }
+}
+
+void Scanner::ScanNextToken() {
   if (m_endedStream) {
-    return; 
+    return;
   }
- 
+
   if (!m_startedStream) {
-    return StartStream(); 
-  }
- 
-  // get rid of whitespace, etc. (in between tokens it should be irrelevent) 
-  ScanToNextToken(); 
- 
-  // maybe need to end some blocks 
-  PopIndentToHere(); 
- 
-  // ***** 
-  // And now branch based on the next few characters! 
-  // ***** 
- 
-  // end of stream 
+    return StartStream();
+  }
+
+  // get rid of whitespace, etc. (in between tokens it should be irrelevent)
+  ScanToNextToken();
+
+  // maybe need to end some blocks
+  PopIndentToHere();
+
+  // *****
+  // And now branch based on the next few characters!
+  // *****
+
+  // end of stream
   if (!INPUT) {
-    return EndStream(); 
+    return EndStream();
   }
- 
+
   if (INPUT.column() == 0 && INPUT.peek() == Keys::Directive) {
-    return ScanDirective(); 
+    return ScanDirective();
   }
- 
-  // document token 
+
+  // document token
   if (INPUT.column() == 0 && Exp::DocStart().Matches(INPUT)) {
-    return ScanDocStart(); 
+    return ScanDocStart();
   }
- 
+
   if (INPUT.column() == 0 && Exp::DocEnd().Matches(INPUT)) {
-    return ScanDocEnd(); 
+    return ScanDocEnd();
   }
- 
-  // flow start/end/entry 
+
+  // flow start/end/entry
   if (INPUT.peek() == Keys::FlowSeqStart ||
       INPUT.peek() == Keys::FlowMapStart) {
-    return ScanFlowStart(); 
+    return ScanFlowStart();
   }
- 
+
   if (INPUT.peek() == Keys::FlowSeqEnd || INPUT.peek() == Keys::FlowMapEnd) {
-    return ScanFlowEnd(); 
+    return ScanFlowEnd();
   }
- 
+
   if (INPUT.peek() == Keys::FlowEntry) {
-    return ScanFlowEntry(); 
+    return ScanFlowEntry();
   }
- 
-  // block/map stuff 
+
+  // block/map stuff
   if (Exp::BlockEntry().Matches(INPUT)) {
-    return ScanBlockEntry(); 
+    return ScanBlockEntry();
   }
- 
+
   if ((InBlockContext() ? Exp::Key() : Exp::KeyInFlow()).Matches(INPUT)) {
-    return ScanKey(); 
+    return ScanKey();
   }
- 
+
   if (GetValueRegex().Matches(INPUT)) {
-    return ScanValue(); 
+    return ScanValue();
   }
- 
-  // alias/anchor 
+
+  // alias/anchor
   if (INPUT.peek() == Keys::Alias || INPUT.peek() == Keys::Anchor) {
-    return ScanAnchorOrAlias(); 
+    return ScanAnchorOrAlias();
   }
- 
-  // tag 
+
+  // tag
   if (INPUT.peek() == Keys::Tag) {
-    return ScanTag(); 
+    return ScanTag();
   }
- 
-  // special scalars 
-  if (InBlockContext() && (INPUT.peek() == Keys::LiteralScalar || 
+
+  // special scalars
+  if (InBlockContext() && (INPUT.peek() == Keys::LiteralScalar ||
                            INPUT.peek() == Keys::FoldedScalar)) {
-    return ScanBlockScalar(); 
+    return ScanBlockScalar();
   }
- 
+
   if (INPUT.peek() == '\'' || INPUT.peek() == '\"') {
-    return ScanQuotedScalar(); 
+    return ScanQuotedScalar();
   }
- 
-  // plain scalars 
-  if ((InBlockContext() ? Exp::PlainScalar() : Exp::PlainScalarInFlow()) 
+
+  // plain scalars
+  if ((InBlockContext() ? Exp::PlainScalar() : Exp::PlainScalarInFlow())
           .Matches(INPUT)) {
-    return ScanPlainScalar(); 
-  }
- 
-  // don't know what it is! 
-  throw ParserException(INPUT.mark(), ErrorMsg::UNKNOWN_TOKEN); 
-} 
- 
-void Scanner::ScanToNextToken() { 
-  while (1) { 
-    // first eat whitespace 
-    while (INPUT && IsWhitespaceToBeEaten(INPUT.peek())) { 
+    return ScanPlainScalar();
+  }
+
+  // don't know what it is!
+  throw ParserException(INPUT.mark(), ErrorMsg::UNKNOWN_TOKEN);
+}
+
+void Scanner::ScanToNextToken() {
+  while (1) {
+    // first eat whitespace
+    while (INPUT && IsWhitespaceToBeEaten(INPUT.peek())) {
       if (InBlockContext() && Exp::Tab().Matches(INPUT)) {
-        m_simpleKeyAllowed = false; 
+        m_simpleKeyAllowed = false;
       }
-      INPUT.eat(1); 
-    } 
- 
-    // then eat a comment 
-    if (Exp::Comment().Matches(INPUT)) { 
-      // eat until line break 
+      INPUT.eat(1);
+    }
+
+    // then eat a comment
+    if (Exp::Comment().Matches(INPUT)) {
+      // eat until line break
       while (INPUT && !Exp::Break().Matches(INPUT)) {
-        INPUT.eat(1); 
+        INPUT.eat(1);
       }
-    } 
- 
-    // if it's NOT a line break, then we're done! 
+    }
+
+    // if it's NOT a line break, then we're done!
     if (!Exp::Break().Matches(INPUT)) {
-      break; 
+      break;
     }
- 
-    // otherwise, let's eat the line break and keep going 
-    int n = Exp::Break().Match(INPUT); 
-    INPUT.eat(n); 
- 
-    // oh yeah, and let's get rid of that simple key 
-    InvalidateSimpleKey(); 
- 
-    // new line - we may be able to accept a simple key now 
+
+    // otherwise, let's eat the line break and keep going
+    int n = Exp::Break().Match(INPUT);
+    INPUT.eat(n);
+
+    // oh yeah, and let's get rid of that simple key
+    InvalidateSimpleKey();
+
+    // new line - we may be able to accept a simple key now
     if (InBlockContext()) {
-      m_simpleKeyAllowed = true; 
+      m_simpleKeyAllowed = true;
     }
-  } 
-} 
- 
-/////////////////////////////////////////////////////////////////////// 
-// Misc. helpers 
- 
-// IsWhitespaceToBeEaten 
-// . We can eat whitespace if it's a space or tab 
-// . Note: originally tabs in block context couldn't be eaten 
-//         "where a simple key could be allowed 
-//         (i.e., not at the beginning of a line, or following '-', '?', or 
-// ':')" 
-//   I think this is wrong, since tabs can be non-content whitespace; it's just 
-//   that they can't contribute to indentation, so once you've seen a tab in a 
-//   line, you can't start a simple key 
-bool Scanner::IsWhitespaceToBeEaten(char ch) { 
+  }
+}
+
+///////////////////////////////////////////////////////////////////////
+// Misc. helpers
+
+// IsWhitespaceToBeEaten
+// . We can eat whitespace if it's a space or tab
+// . Note: originally tabs in block context couldn't be eaten
+//         "where a simple key could be allowed
+//         (i.e., not at the beginning of a line, or following '-', '?', or
+// ':')"
+//   I think this is wrong, since tabs can be non-content whitespace; it's just
+//   that they can't contribute to indentation, so once you've seen a tab in a
+//   line, you can't start a simple key
+bool Scanner::IsWhitespaceToBeEaten(char ch) {
   if (ch == ' ') {
-    return true; 
+    return true;
   }
- 
+
   if (ch == '\t') {
-    return true; 
+    return true;
   }
- 
-  return false; 
-} 
- 
-const RegEx& Scanner::GetValueRegex() const { 
+
+  return false;
+}
+
+const RegEx& Scanner::GetValueRegex() const {
   if (InBlockContext()) {
-    return Exp::Value(); 
-  }
- 
-  return m_canBeJSONFlow ? Exp::ValueInJSONFlow() : Exp::ValueInFlow(); 
-} 
- 
-void Scanner::StartStream() { 
-  m_startedStream = true; 
-  m_simpleKeyAllowed = true; 
+    return Exp::Value();
+  }
+
+  return m_canBeJSONFlow ? Exp::ValueInJSONFlow() : Exp::ValueInFlow();
+}
+
+void Scanner::StartStream() {
+  m_startedStream = true;
+  m_simpleKeyAllowed = true;
   std::unique_ptr<IndentMarker> pIndent(
       new IndentMarker(-1, IndentMarker::NONE));
   m_indentRefs.push_back(std::move(pIndent));
-  m_indents.push(&m_indentRefs.back()); 
-} 
- 
-void Scanner::EndStream() { 
-  // force newline 
+  m_indents.push(&m_indentRefs.back());
+}
+
+void Scanner::EndStream() {
+  // force newline
   if (INPUT.column() > 0) {
-    INPUT.ResetColumn(); 
-  }
- 
-  PopAllIndents(); 
-  PopAllSimpleKeys(); 
- 
-  m_simpleKeyAllowed = false; 
-  m_endedStream = true; 
-} 
- 
-Token* Scanner::PushToken(Token::TYPE type) { 
-  m_tokens.push(Token(type, INPUT.mark())); 
-  return &m_tokens.back(); 
-} 
- 
-Token::TYPE Scanner::GetStartTokenFor(IndentMarker::INDENT_TYPE type) const { 
-  switch (type) { 
-    case IndentMarker::SEQ: 
-      return Token::BLOCK_SEQ_START; 
-    case IndentMarker::MAP: 
-      return Token::BLOCK_MAP_START; 
-    case IndentMarker::NONE: 
-      assert(false); 
-      break; 
-  } 
-  assert(false); 
-  throw std::runtime_error("yaml-cpp: internal error, invalid indent type"); 
-} 
- 
-Scanner::IndentMarker* Scanner::PushIndentTo(int column, 
-                                             IndentMarker::INDENT_TYPE type) { 
-  // are we in flow? 
+    INPUT.ResetColumn();
+  }
+
+  PopAllIndents();
+  PopAllSimpleKeys();
+
+  m_simpleKeyAllowed = false;
+  m_endedStream = true;
+}
+
+Token* Scanner::PushToken(Token::TYPE type) {
+  m_tokens.push(Token(type, INPUT.mark()));
+  return &m_tokens.back();
+}
+
+Token::TYPE Scanner::GetStartTokenFor(IndentMarker::INDENT_TYPE type) const {
+  switch (type) {
+    case IndentMarker::SEQ:
+      return Token::BLOCK_SEQ_START;
+    case IndentMarker::MAP:
+      return Token::BLOCK_MAP_START;
+    case IndentMarker::NONE:
+      assert(false);
+      break;
+  }
+  assert(false);
+  throw std::runtime_error("yaml-cpp: internal error, invalid indent type");
+}
+
+Scanner::IndentMarker* Scanner::PushIndentTo(int column,
+                                             IndentMarker::INDENT_TYPE type) {
+  // are we in flow?
   if (InFlowContext()) {
-    return 0; 
+    return 0;
   }
- 
+
   std::unique_ptr<IndentMarker> pIndent(new IndentMarker(column, type));
-  IndentMarker& indent = *pIndent; 
-  const IndentMarker& lastIndent = *m_indents.top(); 
- 
-  // is this actually an indentation? 
+  IndentMarker& indent = *pIndent;
+  const IndentMarker& lastIndent = *m_indents.top();
+
+  // is this actually an indentation?
   if (indent.column < lastIndent.column) {
-    return 0; 
+    return 0;
   }
-  if (indent.column == lastIndent.column && 
-      !(indent.type == IndentMarker::SEQ && 
+  if (indent.column == lastIndent.column &&
+      !(indent.type == IndentMarker::SEQ &&
         lastIndent.type == IndentMarker::MAP)) {
-    return 0; 
-  }
- 
-  // push a start token 
-  indent.pStartToken = PushToken(GetStartTokenFor(type)); 
- 
-  // and then the indent 
-  m_indents.push(&indent); 
+    return 0;
+  }
+
+  // push a start token
+  indent.pStartToken = PushToken(GetStartTokenFor(type));
+
+  // and then the indent
+  m_indents.push(&indent);
   m_indentRefs.push_back(std::move(pIndent));
-  return &m_indentRefs.back(); 
-} 
- 
-void Scanner::PopIndentToHere() { 
-  // are we in flow? 
+  return &m_indentRefs.back();
+}
+
+void Scanner::PopIndentToHere() {
+  // are we in flow?
   if (InFlowContext()) {
-    return; 
+    return;
   }
- 
-  // now pop away 
-  while (!m_indents.empty()) { 
-    const IndentMarker& indent = *m_indents.top(); 
+
+  // now pop away
+  while (!m_indents.empty()) {
+    const IndentMarker& indent = *m_indents.top();
     if (indent.column < INPUT.column()) {
-      break; 
+      break;
     }
-    if (indent.column == INPUT.column() && 
-        !(indent.type == IndentMarker::SEQ && 
+    if (indent.column == INPUT.column() &&
+        !(indent.type == IndentMarker::SEQ &&
           !Exp::BlockEntry().Matches(INPUT))) {
-      break; 
+      break;
     }
- 
-    PopIndent(); 
-  } 
- 
+
+    PopIndent();
+  }
+
   while (!m_indents.empty() &&
          m_indents.top()->status == IndentMarker::INVALID) {
-    PopIndent(); 
+    PopIndent();
   }
-} 
- 
-void Scanner::PopAllIndents() { 
-  // are we in flow? 
+}
+
+void Scanner::PopAllIndents() {
+  // are we in flow?
   if (InFlowContext()) {
-    return; 
+    return;
   }
- 
-  // now pop away 
-  while (!m_indents.empty()) { 
-    const IndentMarker& indent = *m_indents.top(); 
+
+  // now pop away
+  while (!m_indents.empty()) {
+    const IndentMarker& indent = *m_indents.top();
     if (indent.type == IndentMarker::NONE) {
-      break; 
+      break;
     }
- 
-    PopIndent(); 
-  } 
-} 
- 
-void Scanner::PopIndent() { 
-  const IndentMarker& indent = *m_indents.top(); 
-  m_indents.pop(); 
- 
-  if (indent.status != IndentMarker::VALID) { 
-    InvalidateSimpleKey(); 
-    return; 
-  } 
- 
+
+    PopIndent();
+  }
+}
+
+void Scanner::PopIndent() {
+  const IndentMarker& indent = *m_indents.top();
+  m_indents.pop();
+
+  if (indent.status != IndentMarker::VALID) {
+    InvalidateSimpleKey();
+    return;
+  }
+
   if (indent.type == IndentMarker::SEQ) {
-    m_tokens.push(Token(Token::BLOCK_SEQ_END, INPUT.mark())); 
+    m_tokens.push(Token(Token::BLOCK_SEQ_END, INPUT.mark()));
   } else if (indent.type == IndentMarker::MAP) {
-    m_tokens.push(Token(Token::BLOCK_MAP_END, INPUT.mark())); 
+    m_tokens.push(Token(Token::BLOCK_MAP_END, INPUT.mark()));
   }
-} 
- 
-int Scanner::GetTopIndent() const { 
+}
+
+int Scanner::GetTopIndent() const {
   if (m_indents.empty()) {
-    return 0; 
-  }
-  return m_indents.top()->column; 
-} 
- 
-void Scanner::ThrowParserException(const std::string& msg) const { 
-  Mark mark = Mark::null_mark(); 
-  if (!m_tokens.empty()) { 
-    const Token& token = m_tokens.front(); 
-    mark = token.mark; 
-  } 
-  throw ParserException(mark, msg); 
-} 
+    return 0;
+  }
+  return m_indents.top()->column;
+}
+
+void Scanner::ThrowParserException(const std::string& msg) const {
+  Mark mark = Mark::null_mark();
+  if (!m_tokens.empty()) {
+    const Token& token = m_tokens.front();
+    mark = token.mark;
+  }
+  throw ParserException(mark, msg);
+}
 }  // namespace YAML
diff --git a/contrib/libs/yaml-cpp/src/scanner.h b/contrib/libs/yaml-cpp/src/scanner.h
index 62a385b3eac..7bb2ccc71a5 100644
--- a/contrib/libs/yaml-cpp/src/scanner.h
+++ b/contrib/libs/yaml-cpp/src/scanner.h
@@ -1,96 +1,96 @@
-#ifndef SCANNER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define SCANNER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include <cstddef> 
-#include <ios> 
-#include <map> 
-#include <queue> 
-#include <set> 
-#include <stack> 
-#include <string> 
- 
-#include "ptr_vector.h" 
-#include "stream.h" 
-#include "token.h" 
-#include "yaml-cpp/mark.h" 
- 
-namespace YAML { 
-class Node; 
-class RegEx; 
- 
+#ifndef SCANNER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define SCANNER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <cstddef>
+#include <ios>
+#include <map>
+#include <queue>
+#include <set>
+#include <stack>
+#include <string>
+
+#include "ptr_vector.h"
+#include "stream.h"
+#include "token.h"
+#include "yaml-cpp/mark.h"
+
+namespace YAML {
+class Node;
+class RegEx;
+
 /**
  * A scanner transforms a stream of characters into a stream of tokens.
  */
-class Scanner { 
- public: 
+class Scanner {
+ public:
   explicit Scanner(std::istream &in);
-  ~Scanner(); 
- 
+  ~Scanner();
+
   /** Returns true if there are no more tokens to be read. */
-  bool empty(); 
+  bool empty();
 
   /** Removes the next token in the queue. */
-  void pop(); 
+  void pop();
 
   /** Returns, but does not remove, the next token in the queue. */
-  Token &peek(); 
+  Token &peek();
 
   /** Returns the current mark in the input stream. */
-  Mark mark() const; 
- 
- private: 
-  struct IndentMarker { 
-    enum INDENT_TYPE { MAP, SEQ, NONE }; 
-    enum STATUS { VALID, INVALID, UNKNOWN }; 
-    IndentMarker(int column_, INDENT_TYPE type_) 
-        : column(column_), type(type_), status(VALID), pStartToken(0) {} 
- 
-    int column; 
-    INDENT_TYPE type; 
-    STATUS status; 
-    Token *pStartToken; 
-  }; 
- 
-  enum FLOW_MARKER { FLOW_MAP, FLOW_SEQ }; 
- 
- private: 
-  // scanning 
+  Mark mark() const;
+
+ private:
+  struct IndentMarker {
+    enum INDENT_TYPE { MAP, SEQ, NONE };
+    enum STATUS { VALID, INVALID, UNKNOWN };
+    IndentMarker(int column_, INDENT_TYPE type_)
+        : column(column_), type(type_), status(VALID), pStartToken(0) {}
+
+    int column;
+    INDENT_TYPE type;
+    STATUS status;
+    Token *pStartToken;
+  };
+
+  enum FLOW_MARKER { FLOW_MAP, FLOW_SEQ };
+
+ private:
+  // scanning
 
   /**
    * Scans until there's a valid token at the front of the queue, or the queue
    * is empty. The state can be checked by {@link #empty}, and the next token
    * retrieved by {@link #peek}.
    */
-  void EnsureTokensInQueue(); 
+  void EnsureTokensInQueue();
 
   /**
    * The main scanning function; this method branches out to scan whatever the
    * next token should be.
    */
-  void ScanNextToken(); 
+  void ScanNextToken();
 
   /** Eats the input stream until it reaches the next token-like thing. */
-  void ScanToNextToken(); 
+  void ScanToNextToken();
 
   /** Sets the initial conditions for starting a stream. */
-  void StartStream(); 
+  void StartStream();
 
   /** Closes out the stream, finish up, etc. */
-  void EndStream(); 
+  void EndStream();
+
+  Token *PushToken(Token::TYPE type);
+
+  bool InFlowContext() const { return !m_flows.empty(); }
+  bool InBlockContext() const { return m_flows.empty(); }
+  std::size_t GetFlowLevel() const { return m_flows.size(); }
 
-  Token *PushToken(Token::TYPE type); 
- 
-  bool InFlowContext() const { return !m_flows.empty(); } 
-  bool InBlockContext() const { return m_flows.empty(); } 
-  std::size_t GetFlowLevel() const { return m_flows.size(); } 
- 
-  Token::TYPE GetStartTokenFor(IndentMarker::INDENT_TYPE type) const; 
+  Token::TYPE GetStartTokenFor(IndentMarker::INDENT_TYPE type) const;
 
   /**
    * Pushes an indentation onto the stack, and enqueues the proper token
@@ -98,93 +98,93 @@ class Scanner {
    *
    * @return the indent marker it generates (if any).
    */
-  IndentMarker *PushIndentTo(int column, IndentMarker::INDENT_TYPE type); 
+  IndentMarker *PushIndentTo(int column, IndentMarker::INDENT_TYPE type);
 
   /**
    * Pops indentations off the stack until it reaches the current indentation
    * level, and enqueues the proper token each time. Then pops all invalid
    * indentations off.
    */
-  void PopIndentToHere(); 
+  void PopIndentToHere();
 
   /**
    * Pops all indentations (except for the base empty one) off the stack, and
    * enqueues the proper token each time.
    */
-  void PopAllIndents(); 
+  void PopAllIndents();
 
   /** Pops a single indent, pushing the proper token. */
-  void PopIndent(); 
-  int GetTopIndent() const; 
- 
-  // checking input 
-  bool CanInsertPotentialSimpleKey() const; 
-  bool ExistsActiveSimpleKey() const; 
-  void InsertPotentialSimpleKey(); 
-  void InvalidateSimpleKey(); 
-  bool VerifySimpleKey(); 
-  void PopAllSimpleKeys(); 
- 
+  void PopIndent();
+  int GetTopIndent() const;
+
+  // checking input
+  bool CanInsertPotentialSimpleKey() const;
+  bool ExistsActiveSimpleKey() const;
+  void InsertPotentialSimpleKey();
+  void InvalidateSimpleKey();
+  bool VerifySimpleKey();
+  void PopAllSimpleKeys();
+
   /**
    * Throws a ParserException with the current token location (if available),
    * and does not parse any more tokens.
    */
-  void ThrowParserException(const std::string &msg) const; 
- 
-  bool IsWhitespaceToBeEaten(char ch); 
+  void ThrowParserException(const std::string &msg) const;
+
+  bool IsWhitespaceToBeEaten(char ch);
 
   /**
    * Returns the appropriate regex to check if the next token is a value token.
    */
-  const RegEx &GetValueRegex() const; 
- 
-  struct SimpleKey { 
-    SimpleKey(const Mark &mark_, std::size_t flowLevel_); 
- 
-    void Validate(); 
-    void Invalidate(); 
- 
-    Mark mark; 
-    std::size_t flowLevel; 
-    IndentMarker *pIndent; 
-    Token *pMapStart, *pKey; 
-  }; 
- 
-  // and the tokens 
-  void ScanDirective(); 
-  void ScanDocStart(); 
-  void ScanDocEnd(); 
-  void ScanBlockSeqStart(); 
-  void ScanBlockMapSTart(); 
-  void ScanBlockEnd(); 
-  void ScanBlockEntry(); 
-  void ScanFlowStart(); 
-  void ScanFlowEnd(); 
-  void ScanFlowEntry(); 
-  void ScanKey(); 
-  void ScanValue(); 
-  void ScanAnchorOrAlias(); 
-  void ScanTag(); 
-  void ScanPlainScalar(); 
-  void ScanQuotedScalar(); 
-  void ScanBlockScalar(); 
- 
- private: 
-  // the stream 
-  Stream INPUT; 
- 
-  // the output (tokens) 
-  std::queue<Token> m_tokens; 
- 
-  // state info 
-  bool m_startedStream, m_endedStream; 
-  bool m_simpleKeyAllowed; 
-  bool m_canBeJSONFlow; 
-  std::stack<SimpleKey> m_simpleKeys; 
-  std::stack<IndentMarker *> m_indents; 
-  ptr_vector<IndentMarker> m_indentRefs;  // for "garbage collection" 
-  std::stack<FLOW_MARKER> m_flows; 
-}; 
-} 
- 
-#endif  // SCANNER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+  const RegEx &GetValueRegex() const;
+
+  struct SimpleKey {
+    SimpleKey(const Mark &mark_, std::size_t flowLevel_);
+
+    void Validate();
+    void Invalidate();
+
+    Mark mark;
+    std::size_t flowLevel;
+    IndentMarker *pIndent;
+    Token *pMapStart, *pKey;
+  };
+
+  // and the tokens
+  void ScanDirective();
+  void ScanDocStart();
+  void ScanDocEnd();
+  void ScanBlockSeqStart();
+  void ScanBlockMapSTart();
+  void ScanBlockEnd();
+  void ScanBlockEntry();
+  void ScanFlowStart();
+  void ScanFlowEnd();
+  void ScanFlowEntry();
+  void ScanKey();
+  void ScanValue();
+  void ScanAnchorOrAlias();
+  void ScanTag();
+  void ScanPlainScalar();
+  void ScanQuotedScalar();
+  void ScanBlockScalar();
+
+ private:
+  // the stream
+  Stream INPUT;
+
+  // the output (tokens)
+  std::queue<Token> m_tokens;
+
+  // state info
+  bool m_startedStream, m_endedStream;
+  bool m_simpleKeyAllowed;
+  bool m_canBeJSONFlow;
+  std::stack<SimpleKey> m_simpleKeys;
+  std::stack<IndentMarker *> m_indents;
+  ptr_vector<IndentMarker> m_indentRefs;  // for "garbage collection"
+  std::stack<FLOW_MARKER> m_flows;
+};
+}
+
+#endif  // SCANNER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/src/scanscalar.cpp b/contrib/libs/yaml-cpp/src/scanscalar.cpp
index 02faea08fb5..10e359d4466 100644
--- a/contrib/libs/yaml-cpp/src/scanscalar.cpp
+++ b/contrib/libs/yaml-cpp/src/scanscalar.cpp
@@ -1,250 +1,250 @@
-#include "scanscalar.h" 
- 
-#include <algorithm> 
- 
-#include "exp.h" 
-#include "regeximpl.h" 
-#include "stream.h" 
-#include "yaml-cpp/exceptions.h"  // IWYU pragma: keep 
- 
-namespace YAML { 
-// ScanScalar 
-// . This is where the scalar magic happens. 
-// 
-// . We do the scanning in three phases: 
-//   1. Scan until newline 
-//   2. Eat newline 
-//   3. Scan leading blanks. 
-// 
-// . Depending on the parameters given, we store or stop 
-//   and different places in the above flow. 
-std::string ScanScalar(Stream& INPUT, ScanScalarParams& params) { 
-  bool foundNonEmptyLine = false; 
-  bool pastOpeningBreak = (params.fold == FOLD_FLOW); 
-  bool emptyLine = false, moreIndented = false; 
-  int foldedNewlineCount = 0; 
-  bool foldedNewlineStartedMoreIndented = false; 
-  std::size_t lastEscapedChar = std::string::npos; 
-  std::string scalar; 
-  params.leadingSpaces = false; 
- 
+#include "scanscalar.h"
+
+#include <algorithm>
+
+#include "exp.h"
+#include "regeximpl.h"
+#include "stream.h"
+#include "yaml-cpp/exceptions.h"  // IWYU pragma: keep
+
+namespace YAML {
+// ScanScalar
+// . This is where the scalar magic happens.
+//
+// . We do the scanning in three phases:
+//   1. Scan until newline
+//   2. Eat newline
+//   3. Scan leading blanks.
+//
+// . Depending on the parameters given, we store or stop
+//   and different places in the above flow.
+std::string ScanScalar(Stream& INPUT, ScanScalarParams& params) {
+  bool foundNonEmptyLine = false;
+  bool pastOpeningBreak = (params.fold == FOLD_FLOW);
+  bool emptyLine = false, moreIndented = false;
+  int foldedNewlineCount = 0;
+  bool foldedNewlineStartedMoreIndented = false;
+  std::size_t lastEscapedChar = std::string::npos;
+  std::string scalar;
+  params.leadingSpaces = false;
+
   if (!params.end) {
     params.end = &Exp::Empty();
   }
 
-  while (INPUT) { 
-    // ******************************** 
-    // Phase #1: scan until line ending 
- 
-    std::size_t lastNonWhitespaceChar = scalar.size(); 
-    bool escapedNewline = false; 
+  while (INPUT) {
+    // ********************************
+    // Phase #1: scan until line ending
+
+    std::size_t lastNonWhitespaceChar = scalar.size();
+    bool escapedNewline = false;
     while (!params.end->Matches(INPUT) && !Exp::Break().Matches(INPUT)) {
       if (!INPUT) {
-        break; 
+        break;
       }
- 
-      // document indicator? 
-      if (INPUT.column() == 0 && Exp::DocIndicator().Matches(INPUT)) { 
+
+      // document indicator?
+      if (INPUT.column() == 0 && Exp::DocIndicator().Matches(INPUT)) {
         if (params.onDocIndicator == BREAK) {
-          break; 
+          break;
         } else if (params.onDocIndicator == THROW) {
-          throw ParserException(INPUT.mark(), ErrorMsg::DOC_IN_SCALAR); 
+          throw ParserException(INPUT.mark(), ErrorMsg::DOC_IN_SCALAR);
         }
-      } 
- 
-      foundNonEmptyLine = true; 
-      pastOpeningBreak = true; 
- 
-      // escaped newline? (only if we're escaping on slash) 
-      if (params.escape == '\\' && Exp::EscBreak().Matches(INPUT)) { 
-        // eat escape character and get out (but preserve trailing whitespace!) 
-        INPUT.get(); 
-        lastNonWhitespaceChar = scalar.size(); 
-        lastEscapedChar = scalar.size(); 
-        escapedNewline = true; 
-        break; 
-      } 
- 
-      // escape this? 
-      if (INPUT.peek() == params.escape) { 
-        scalar += Exp::Escape(INPUT); 
-        lastNonWhitespaceChar = scalar.size(); 
-        lastEscapedChar = scalar.size(); 
-        continue; 
-      } 
- 
-      // otherwise, just add the damn character 
-      char ch = INPUT.get(); 
-      scalar += ch; 
+      }
+
+      foundNonEmptyLine = true;
+      pastOpeningBreak = true;
+
+      // escaped newline? (only if we're escaping on slash)
+      if (params.escape == '\\' && Exp::EscBreak().Matches(INPUT)) {
+        // eat escape character and get out (but preserve trailing whitespace!)
+        INPUT.get();
+        lastNonWhitespaceChar = scalar.size();
+        lastEscapedChar = scalar.size();
+        escapedNewline = true;
+        break;
+      }
+
+      // escape this?
+      if (INPUT.peek() == params.escape) {
+        scalar += Exp::Escape(INPUT);
+        lastNonWhitespaceChar = scalar.size();
+        lastEscapedChar = scalar.size();
+        continue;
+      }
+
+      // otherwise, just add the damn character
+      char ch = INPUT.get();
+      scalar += ch;
       if (ch != ' ' && ch != '\t') {
-        lastNonWhitespaceChar = scalar.size(); 
+        lastNonWhitespaceChar = scalar.size();
       }
-    } 
- 
-    // eof? if we're looking to eat something, then we throw 
-    if (!INPUT) { 
+    }
+
+    // eof? if we're looking to eat something, then we throw
+    if (!INPUT) {
       if (params.eatEnd) {
-        throw ParserException(INPUT.mark(), ErrorMsg::EOF_IN_SCALAR); 
+        throw ParserException(INPUT.mark(), ErrorMsg::EOF_IN_SCALAR);
       }
-      break; 
-    } 
- 
-    // doc indicator? 
-    if (params.onDocIndicator == BREAK && INPUT.column() == 0 && 
+      break;
+    }
+
+    // doc indicator?
+    if (params.onDocIndicator == BREAK && INPUT.column() == 0 &&
         Exp::DocIndicator().Matches(INPUT)) {
-      break; 
+      break;
     }
- 
-    // are we done via character match? 
+
+    // are we done via character match?
     int n = params.end->Match(INPUT);
-    if (n >= 0) { 
+    if (n >= 0) {
       if (params.eatEnd) {
-        INPUT.eat(n); 
-      }
-      break; 
-    } 
- 
-    // do we remove trailing whitespace? 
-    if (params.fold == FOLD_FLOW) 
-      scalar.erase(lastNonWhitespaceChar); 
- 
-    // ******************************** 
-    // Phase #2: eat line ending 
-    n = Exp::Break().Match(INPUT); 
-    INPUT.eat(n); 
- 
-    // ******************************** 
-    // Phase #3: scan initial spaces 
- 
-    // first the required indentation 
+        INPUT.eat(n);
+      }
+      break;
+    }
+
+    // do we remove trailing whitespace?
+    if (params.fold == FOLD_FLOW)
+      scalar.erase(lastNonWhitespaceChar);
+
+    // ********************************
+    // Phase #2: eat line ending
+    n = Exp::Break().Match(INPUT);
+    INPUT.eat(n);
+
+    // ********************************
+    // Phase #3: scan initial spaces
+
+    // first the required indentation
     while (INPUT.peek() == ' ' &&
            (INPUT.column() < params.indent ||
             (params.detectIndent && !foundNonEmptyLine)) &&
            !params.end->Matches(INPUT)) {
-      INPUT.eat(1); 
+      INPUT.eat(1);
     }
- 
-    // update indent if we're auto-detecting 
+
+    // update indent if we're auto-detecting
     if (params.detectIndent && !foundNonEmptyLine) {
-      params.indent = std::max(params.indent, INPUT.column()); 
+      params.indent = std::max(params.indent, INPUT.column());
     }
- 
-    // and then the rest of the whitespace 
-    while (Exp::Blank().Matches(INPUT)) { 
-      // we check for tabs that masquerade as indentation 
-      if (INPUT.peek() == '\t' && INPUT.column() < params.indent && 
+
+    // and then the rest of the whitespace
+    while (Exp::Blank().Matches(INPUT)) {
+      // we check for tabs that masquerade as indentation
+      if (INPUT.peek() == '\t' && INPUT.column() < params.indent &&
           params.onTabInIndentation == THROW) {
-        throw ParserException(INPUT.mark(), ErrorMsg::TAB_IN_INDENTATION); 
+        throw ParserException(INPUT.mark(), ErrorMsg::TAB_IN_INDENTATION);
       }
- 
+
       if (!params.eatLeadingWhitespace) {
-        break; 
+        break;
       }
- 
+
       if (params.end->Matches(INPUT)) {
         break;
       }
 
-      INPUT.eat(1); 
-    } 
- 
-    // was this an empty line? 
-    bool nextEmptyLine = Exp::Break().Matches(INPUT); 
-    bool nextMoreIndented = Exp::Blank().Matches(INPUT); 
-    if (params.fold == FOLD_BLOCK && foldedNewlineCount == 0 && nextEmptyLine) 
-      foldedNewlineStartedMoreIndented = moreIndented; 
- 
-    // for block scalars, we always start with a newline, so we should ignore it 
-    // (not fold or keep) 
-    if (pastOpeningBreak) { 
-      switch (params.fold) { 
-        case DONT_FOLD: 
-          scalar += "\n"; 
-          break; 
-        case FOLD_BLOCK: 
-          if (!emptyLine && !nextEmptyLine && !moreIndented && 
+      INPUT.eat(1);
+    }
+
+    // was this an empty line?
+    bool nextEmptyLine = Exp::Break().Matches(INPUT);
+    bool nextMoreIndented = Exp::Blank().Matches(INPUT);
+    if (params.fold == FOLD_BLOCK && foldedNewlineCount == 0 && nextEmptyLine)
+      foldedNewlineStartedMoreIndented = moreIndented;
+
+    // for block scalars, we always start with a newline, so we should ignore it
+    // (not fold or keep)
+    if (pastOpeningBreak) {
+      switch (params.fold) {
+        case DONT_FOLD:
+          scalar += "\n";
+          break;
+        case FOLD_BLOCK:
+          if (!emptyLine && !nextEmptyLine && !moreIndented &&
               !nextMoreIndented && INPUT.column() >= params.indent) {
-            scalar += " "; 
+            scalar += " ";
           } else if (nextEmptyLine) {
-            foldedNewlineCount++; 
+            foldedNewlineCount++;
           } else {
-            scalar += "\n"; 
+            scalar += "\n";
           }
- 
-          if (!nextEmptyLine && foldedNewlineCount > 0) { 
-            scalar += std::string(foldedNewlineCount - 1, '\n'); 
-            if (foldedNewlineStartedMoreIndented || 
+
+          if (!nextEmptyLine && foldedNewlineCount > 0) {
+            scalar += std::string(foldedNewlineCount - 1, '\n');
+            if (foldedNewlineStartedMoreIndented ||
                 nextMoreIndented | !foundNonEmptyLine) {
-              scalar += "\n"; 
+              scalar += "\n";
             }
-            foldedNewlineCount = 0; 
-          } 
-          break; 
-        case FOLD_FLOW: 
+            foldedNewlineCount = 0;
+          }
+          break;
+        case FOLD_FLOW:
           if (nextEmptyLine) {
-            scalar += "\n"; 
+            scalar += "\n";
           } else if (!emptyLine && !nextEmptyLine && !escapedNewline) {
-            scalar += " "; 
+            scalar += " ";
           }
-          break; 
-      } 
-    } 
- 
-    emptyLine = nextEmptyLine; 
-    moreIndented = nextMoreIndented; 
-    pastOpeningBreak = true; 
- 
-    // are we done via indentation? 
-    if (!emptyLine && INPUT.column() < params.indent) { 
-      params.leadingSpaces = true; 
-      break; 
-    } 
-  } 
- 
-  // post-processing 
-  if (params.trimTrailingSpaces) { 
-    std::size_t pos = scalar.find_last_not_of(' '); 
-    if (lastEscapedChar != std::string::npos) { 
+          break;
+      }
+    }
+
+    emptyLine = nextEmptyLine;
+    moreIndented = nextMoreIndented;
+    pastOpeningBreak = true;
+
+    // are we done via indentation?
+    if (!emptyLine && INPUT.column() < params.indent) {
+      params.leadingSpaces = true;
+      break;
+    }
+  }
+
+  // post-processing
+  if (params.trimTrailingSpaces) {
+    std::size_t pos = scalar.find_last_not_of(' ');
+    if (lastEscapedChar != std::string::npos) {
       if (pos < lastEscapedChar || pos == std::string::npos) {
-        pos = lastEscapedChar; 
+        pos = lastEscapedChar;
       }
-    } 
+    }
     if (pos < scalar.size()) {
-      scalar.erase(pos + 1); 
+      scalar.erase(pos + 1);
     }
-  } 
- 
-  switch (params.chomp) { 
-    case CLIP: { 
-      std::size_t pos = scalar.find_last_not_of('\n'); 
-      if (lastEscapedChar != std::string::npos) { 
+  }
+
+  switch (params.chomp) {
+    case CLIP: {
+      std::size_t pos = scalar.find_last_not_of('\n');
+      if (lastEscapedChar != std::string::npos) {
         if (pos < lastEscapedChar || pos == std::string::npos) {
-          pos = lastEscapedChar; 
+          pos = lastEscapedChar;
         }
-      } 
+      }
       if (pos == std::string::npos) {
-        scalar.erase(); 
+        scalar.erase();
       } else if (pos + 1 < scalar.size()) {
-        scalar.erase(pos + 2); 
+        scalar.erase(pos + 2);
       }
-    } break; 
-    case STRIP: { 
-      std::size_t pos = scalar.find_last_not_of('\n'); 
-      if (lastEscapedChar != std::string::npos) { 
+    } break;
+    case STRIP: {
+      std::size_t pos = scalar.find_last_not_of('\n');
+      if (lastEscapedChar != std::string::npos) {
         if (pos < lastEscapedChar || pos == std::string::npos) {
-          pos = lastEscapedChar; 
+          pos = lastEscapedChar;
         }
-      } 
+      }
       if (pos == std::string::npos) {
-        scalar.erase(); 
+        scalar.erase();
       } else if (pos < scalar.size()) {
-        scalar.erase(pos + 1); 
-      }
-    } break; 
-    default: 
-      break; 
-  } 
- 
-  return scalar; 
-} 
-} 
+        scalar.erase(pos + 1);
+      }
+    } break;
+    default:
+      break;
+  }
+
+  return scalar;
+}
+}
diff --git a/contrib/libs/yaml-cpp/src/scanscalar.h b/contrib/libs/yaml-cpp/src/scanscalar.h
index f7fce060ae0..c3a574ad9b6 100644
--- a/contrib/libs/yaml-cpp/src/scanscalar.h
+++ b/contrib/libs/yaml-cpp/src/scanscalar.h
@@ -1,63 +1,63 @@
-#ifndef SCANSCALAR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define SCANSCALAR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include <string> 
- 
-#include "regex_yaml.h" 
-#include "stream.h" 
- 
-namespace YAML { 
-enum CHOMP { STRIP = -1, CLIP, KEEP }; 
-enum ACTION { NONE, BREAK, THROW }; 
-enum FOLD { DONT_FOLD, FOLD_BLOCK, FOLD_FLOW }; 
- 
-struct ScanScalarParams { 
-  ScanScalarParams() 
+#ifndef SCANSCALAR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define SCANSCALAR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <string>
+
+#include "regex_yaml.h"
+#include "stream.h"
+
+namespace YAML {
+enum CHOMP { STRIP = -1, CLIP, KEEP };
+enum ACTION { NONE, BREAK, THROW };
+enum FOLD { DONT_FOLD, FOLD_BLOCK, FOLD_FLOW };
+
+struct ScanScalarParams {
+  ScanScalarParams()
       : end(nullptr),
         eatEnd(false),
-        indent(0), 
-        detectIndent(false), 
-        eatLeadingWhitespace(0), 
-        escape(0), 
-        fold(DONT_FOLD), 
-        trimTrailingSpaces(0), 
-        chomp(CLIP), 
-        onDocIndicator(NONE), 
-        onTabInIndentation(NONE), 
-        leadingSpaces(false) {} 
- 
-  // input: 
+        indent(0),
+        detectIndent(false),
+        eatLeadingWhitespace(0),
+        escape(0),
+        fold(DONT_FOLD),
+        trimTrailingSpaces(0),
+        chomp(CLIP),
+        onDocIndicator(NONE),
+        onTabInIndentation(NONE),
+        leadingSpaces(false) {}
+
+  // input:
   const RegEx* end;   // what condition ends this scalar?
                       // unowned.
-  bool eatEnd;        // should we eat that condition when we see it? 
-  int indent;         // what level of indentation should be eaten and ignored? 
-  bool detectIndent;  // should we try to autodetect the indent? 
-  bool eatLeadingWhitespace;  // should we continue eating this delicious 
-                              // indentation after 'indent' spaces? 
-  char escape;  // what character do we escape on (i.e., slash or single quote) 
-                // (0 for none) 
-  FOLD fold;    // how do we fold line ends? 
-  bool trimTrailingSpaces;  // do we remove all trailing spaces (at the very 
-                            // end) 
-  CHOMP chomp;  // do we strip, clip, or keep trailing newlines (at the very 
-                // end) 
-  //   Note: strip means kill all, clip means keep at most one, keep means keep 
-  // all 
-  ACTION onDocIndicator;      // what do we do if we see a document indicator? 
-  ACTION onTabInIndentation;  // what do we do if we see a tab where we should 
-                              // be seeing indentation spaces 
- 
-  // output: 
-  bool leadingSpaces; 
-}; 
- 
-std::string ScanScalar(Stream& INPUT, ScanScalarParams& info); 
-} 
- 
-#endif  // SCANSCALAR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+  bool eatEnd;        // should we eat that condition when we see it?
+  int indent;         // what level of indentation should be eaten and ignored?
+  bool detectIndent;  // should we try to autodetect the indent?
+  bool eatLeadingWhitespace;  // should we continue eating this delicious
+                              // indentation after 'indent' spaces?
+  char escape;  // what character do we escape on (i.e., slash or single quote)
+                // (0 for none)
+  FOLD fold;    // how do we fold line ends?
+  bool trimTrailingSpaces;  // do we remove all trailing spaces (at the very
+                            // end)
+  CHOMP chomp;  // do we strip, clip, or keep trailing newlines (at the very
+                // end)
+  //   Note: strip means kill all, clip means keep at most one, keep means keep
+  // all
+  ACTION onDocIndicator;      // what do we do if we see a document indicator?
+  ACTION onTabInIndentation;  // what do we do if we see a tab where we should
+                              // be seeing indentation spaces
+
+  // output:
+  bool leadingSpaces;
+};
+
+std::string ScanScalar(Stream& INPUT, ScanScalarParams& info);
+}
+
+#endif  // SCANSCALAR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/src/scantag.cpp b/contrib/libs/yaml-cpp/src/scantag.cpp
index f775ed5758d..c5b39652ad0 100644
--- a/contrib/libs/yaml-cpp/src/scantag.cpp
+++ b/contrib/libs/yaml-cpp/src/scantag.cpp
@@ -1,81 +1,81 @@
-#include "exp.h" 
-#include "regex_yaml.h" 
-#include "regeximpl.h" 
-#include "stream.h" 
-#include "yaml-cpp/exceptions.h"  // IWYU pragma: keep 
-#include "yaml-cpp/mark.h" 
- 
-namespace YAML { 
-const std::string ScanVerbatimTag(Stream& INPUT) { 
-  std::string tag; 
- 
-  // eat the start character 
-  INPUT.get(); 
- 
-  while (INPUT) { 
-    if (INPUT.peek() == Keys::VerbatimTagEnd) { 
-      // eat the end character 
-      INPUT.get(); 
-      return tag; 
-    } 
- 
-    int n = Exp::URI().Match(INPUT); 
-    if (n <= 0) 
-      break; 
- 
-    tag += INPUT.get(n); 
-  } 
- 
-  throw ParserException(INPUT.mark(), ErrorMsg::END_OF_VERBATIM_TAG); 
-} 
- 
-const std::string ScanTagHandle(Stream& INPUT, bool& canBeHandle) { 
-  std::string tag; 
-  canBeHandle = true; 
-  Mark firstNonWordChar; 
- 
-  while (INPUT) { 
-    if (INPUT.peek() == Keys::Tag) { 
-      if (!canBeHandle) 
-        throw ParserException(firstNonWordChar, ErrorMsg::CHAR_IN_TAG_HANDLE); 
-      break; 
-    } 
- 
-    int n = 0; 
-    if (canBeHandle) { 
-      n = Exp::Word().Match(INPUT); 
-      if (n <= 0) { 
-        canBeHandle = false; 
-        firstNonWordChar = INPUT.mark(); 
-      } 
-    } 
- 
-    if (!canBeHandle) 
-      n = Exp::Tag().Match(INPUT); 
- 
-    if (n <= 0) 
-      break; 
- 
-    tag += INPUT.get(n); 
-  } 
- 
-  return tag; 
-} 
- 
-const std::string ScanTagSuffix(Stream& INPUT) { 
-  std::string tag; 
- 
-  while (INPUT) { 
-    int n = Exp::Tag().Match(INPUT); 
-    if (n <= 0) 
-      break; 
- 
-    tag += INPUT.get(n); 
-  } 
- 
-  if (tag.empty()) 
-    throw ParserException(INPUT.mark(), ErrorMsg::TAG_WITH_NO_SUFFIX); 
- 
-  return tag; 
-} 
-} 
+#include "exp.h"
+#include "regex_yaml.h"
+#include "regeximpl.h"
+#include "stream.h"
+#include "yaml-cpp/exceptions.h"  // IWYU pragma: keep
+#include "yaml-cpp/mark.h"
+
+namespace YAML {
+const std::string ScanVerbatimTag(Stream& INPUT) {
+  std::string tag;
+
+  // eat the start character
+  INPUT.get();
+
+  while (INPUT) {
+    if (INPUT.peek() == Keys::VerbatimTagEnd) {
+      // eat the end character
+      INPUT.get();
+      return tag;
+    }
+
+    int n = Exp::URI().Match(INPUT);
+    if (n <= 0)
+      break;
+
+    tag += INPUT.get(n);
+  }
+
+  throw ParserException(INPUT.mark(), ErrorMsg::END_OF_VERBATIM_TAG);
+}
+
+const std::string ScanTagHandle(Stream& INPUT, bool& canBeHandle) {
+  std::string tag;
+  canBeHandle = true;
+  Mark firstNonWordChar;
+
+  while (INPUT) {
+    if (INPUT.peek() == Keys::Tag) {
+      if (!canBeHandle)
+        throw ParserException(firstNonWordChar, ErrorMsg::CHAR_IN_TAG_HANDLE);
+      break;
+    }
+
+    int n = 0;
+    if (canBeHandle) {
+      n = Exp::Word().Match(INPUT);
+      if (n <= 0) {
+        canBeHandle = false;
+        firstNonWordChar = INPUT.mark();
+      }
+    }
+
+    if (!canBeHandle)
+      n = Exp::Tag().Match(INPUT);
+
+    if (n <= 0)
+      break;
+
+    tag += INPUT.get(n);
+  }
+
+  return tag;
+}
+
+const std::string ScanTagSuffix(Stream& INPUT) {
+  std::string tag;
+
+  while (INPUT) {
+    int n = Exp::Tag().Match(INPUT);
+    if (n <= 0)
+      break;
+
+    tag += INPUT.get(n);
+  }
+
+  if (tag.empty())
+    throw ParserException(INPUT.mark(), ErrorMsg::TAG_WITH_NO_SUFFIX);
+
+  return tag;
+}
+}
diff --git a/contrib/libs/yaml-cpp/src/scantag.h b/contrib/libs/yaml-cpp/src/scantag.h
index e904751b313..522ba5495e8 100644
--- a/contrib/libs/yaml-cpp/src/scantag.h
+++ b/contrib/libs/yaml-cpp/src/scantag.h
@@ -1,19 +1,19 @@
-#ifndef SCANTAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define SCANTAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include <string> 
-#include "stream.h" 
- 
-namespace YAML { 
-const std::string ScanVerbatimTag(Stream& INPUT); 
-const std::string ScanTagHandle(Stream& INPUT, bool& canBeHandle); 
-const std::string ScanTagSuffix(Stream& INPUT); 
-} 
- 
-#endif  // SCANTAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+#ifndef SCANTAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define SCANTAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <string>
+#include "stream.h"
+
+namespace YAML {
+const std::string ScanVerbatimTag(Stream& INPUT);
+const std::string ScanTagHandle(Stream& INPUT, bool& canBeHandle);
+const std::string ScanTagSuffix(Stream& INPUT);
+}
+
+#endif  // SCANTAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/src/scantoken.cpp b/contrib/libs/yaml-cpp/src/scantoken.cpp
index 4b308a78d50..fd8758d7815 100644
--- a/contrib/libs/yaml-cpp/src/scantoken.cpp
+++ b/contrib/libs/yaml-cpp/src/scantoken.cpp
@@ -1,437 +1,437 @@
-#include <sstream> 
- 
-#include "exp.h" 
-#include "regex_yaml.h" 
-#include "regeximpl.h" 
-#include "scanner.h" 
-#include "scanscalar.h" 
-#include "scantag.h"  // IWYU pragma: keep 
-#include "tag.h"      // IWYU pragma: keep 
-#include "token.h" 
-#include "yaml-cpp/exceptions.h"  // IWYU pragma: keep 
-#include "yaml-cpp/mark.h" 
- 
-namespace YAML { 
-/////////////////////////////////////////////////////////////////////// 
-// Specialization for scanning specific tokens 
- 
-// Directive 
-// . Note: no semantic checking is done here (that's for the parser to do) 
-void Scanner::ScanDirective() { 
-  std::string name; 
-  std::vector<std::string> params; 
- 
-  // pop indents and simple keys 
-  PopAllIndents(); 
-  PopAllSimpleKeys(); 
- 
-  m_simpleKeyAllowed = false; 
-  m_canBeJSONFlow = false; 
- 
-  // store pos and eat indicator 
-  Token token(Token::DIRECTIVE, INPUT.mark()); 
-  INPUT.eat(1); 
- 
-  // read name 
-  while (INPUT && !Exp::BlankOrBreak().Matches(INPUT)) 
-    token.value += INPUT.get(); 
- 
-  // read parameters 
-  while (1) { 
-    // first get rid of whitespace 
-    while (Exp::Blank().Matches(INPUT)) 
-      INPUT.eat(1); 
- 
-    // break on newline or comment 
-    if (!INPUT || Exp::Break().Matches(INPUT) || Exp::Comment().Matches(INPUT)) 
-      break; 
- 
-    // now read parameter 
-    std::string param; 
-    while (INPUT && !Exp::BlankOrBreak().Matches(INPUT)) 
-      param += INPUT.get(); 
- 
-    token.params.push_back(param); 
-  } 
- 
-  m_tokens.push(token); 
-} 
- 
-// DocStart 
-void Scanner::ScanDocStart() { 
-  PopAllIndents(); 
-  PopAllSimpleKeys(); 
-  m_simpleKeyAllowed = false; 
-  m_canBeJSONFlow = false; 
- 
-  // eat 
-  Mark mark = INPUT.mark(); 
-  INPUT.eat(3); 
-  m_tokens.push(Token(Token::DOC_START, mark)); 
-} 
- 
-// DocEnd 
-void Scanner::ScanDocEnd() { 
-  PopAllIndents(); 
-  PopAllSimpleKeys(); 
-  m_simpleKeyAllowed = false; 
-  m_canBeJSONFlow = false; 
- 
-  // eat 
-  Mark mark = INPUT.mark(); 
-  INPUT.eat(3); 
-  m_tokens.push(Token(Token::DOC_END, mark)); 
-} 
- 
-// FlowStart 
-void Scanner::ScanFlowStart() { 
-  // flows can be simple keys 
-  InsertPotentialSimpleKey(); 
-  m_simpleKeyAllowed = true; 
-  m_canBeJSONFlow = false; 
- 
-  // eat 
-  Mark mark = INPUT.mark(); 
-  char ch = INPUT.get(); 
-  FLOW_MARKER flowType = (ch == Keys::FlowSeqStart ? FLOW_SEQ : FLOW_MAP); 
-  m_flows.push(flowType); 
-  Token::TYPE type = 
-      (flowType == FLOW_SEQ ? Token::FLOW_SEQ_START : Token::FLOW_MAP_START); 
-  m_tokens.push(Token(type, mark)); 
-} 
- 
-// FlowEnd 
-void Scanner::ScanFlowEnd() { 
-  if (InBlockContext()) 
-    throw ParserException(INPUT.mark(), ErrorMsg::FLOW_END); 
- 
-  // we might have a solo entry in the flow context 
-  if (InFlowContext()) { 
-    if (m_flows.top() == FLOW_MAP && VerifySimpleKey()) 
-      m_tokens.push(Token(Token::VALUE, INPUT.mark())); 
-    else if (m_flows.top() == FLOW_SEQ) 
-      InvalidateSimpleKey(); 
-  } 
- 
-  m_simpleKeyAllowed = false; 
-  m_canBeJSONFlow = true; 
- 
-  // eat 
-  Mark mark = INPUT.mark(); 
-  char ch = INPUT.get(); 
- 
-  // check that it matches the start 
-  FLOW_MARKER flowType = (ch == Keys::FlowSeqEnd ? FLOW_SEQ : FLOW_MAP); 
-  if (m_flows.top() != flowType) 
-    throw ParserException(mark, ErrorMsg::FLOW_END); 
-  m_flows.pop(); 
- 
-  Token::TYPE type = (flowType ? Token::FLOW_SEQ_END : Token::FLOW_MAP_END); 
-  m_tokens.push(Token(type, mark)); 
-} 
- 
-// FlowEntry 
-void Scanner::ScanFlowEntry() { 
-  // we might have a solo entry in the flow context 
-  if (InFlowContext()) { 
-    if (m_flows.top() == FLOW_MAP && VerifySimpleKey()) 
-      m_tokens.push(Token(Token::VALUE, INPUT.mark())); 
-    else if (m_flows.top() == FLOW_SEQ) 
-      InvalidateSimpleKey(); 
-  } 
- 
-  m_simpleKeyAllowed = true; 
-  m_canBeJSONFlow = false; 
- 
-  // eat 
-  Mark mark = INPUT.mark(); 
-  INPUT.eat(1); 
-  m_tokens.push(Token(Token::FLOW_ENTRY, mark)); 
-} 
- 
-// BlockEntry 
-void Scanner::ScanBlockEntry() { 
-  // we better be in the block context! 
-  if (InFlowContext()) 
-    throw ParserException(INPUT.mark(), ErrorMsg::BLOCK_ENTRY); 
- 
-  // can we put it here? 
-  if (!m_simpleKeyAllowed) 
-    throw ParserException(INPUT.mark(), ErrorMsg::BLOCK_ENTRY); 
- 
-  PushIndentTo(INPUT.column(), IndentMarker::SEQ); 
-  m_simpleKeyAllowed = true; 
-  m_canBeJSONFlow = false; 
- 
-  // eat 
-  Mark mark = INPUT.mark(); 
-  INPUT.eat(1); 
-  m_tokens.push(Token(Token::BLOCK_ENTRY, mark)); 
-} 
- 
-// Key 
-void Scanner::ScanKey() { 
-  // handle keys diffently in the block context (and manage indents) 
-  if (InBlockContext()) { 
-    if (!m_simpleKeyAllowed) 
-      throw ParserException(INPUT.mark(), ErrorMsg::MAP_KEY); 
- 
-    PushIndentTo(INPUT.column(), IndentMarker::MAP); 
-  } 
- 
-  // can only put a simple key here if we're in block context 
-  m_simpleKeyAllowed = InBlockContext(); 
- 
-  // eat 
-  Mark mark = INPUT.mark(); 
-  INPUT.eat(1); 
-  m_tokens.push(Token(Token::KEY, mark)); 
-} 
- 
-// Value 
-void Scanner::ScanValue() { 
-  // and check that simple key 
-  bool isSimpleKey = VerifySimpleKey(); 
-  m_canBeJSONFlow = false; 
- 
-  if (isSimpleKey) { 
-    // can't follow a simple key with another simple key (dunno why, though - it 
-    // seems fine) 
-    m_simpleKeyAllowed = false; 
-  } else { 
-    // handle values diffently in the block context (and manage indents) 
-    if (InBlockContext()) { 
-      if (!m_simpleKeyAllowed) 
-        throw ParserException(INPUT.mark(), ErrorMsg::MAP_VALUE); 
- 
-      PushIndentTo(INPUT.column(), IndentMarker::MAP); 
-    } 
- 
-    // can only put a simple key here if we're in block context 
-    m_simpleKeyAllowed = InBlockContext(); 
-  } 
- 
-  // eat 
-  Mark mark = INPUT.mark(); 
-  INPUT.eat(1); 
-  m_tokens.push(Token(Token::VALUE, mark)); 
-} 
- 
-// AnchorOrAlias 
-void Scanner::ScanAnchorOrAlias() { 
-  bool alias; 
-  std::string name; 
- 
-  // insert a potential simple key 
-  InsertPotentialSimpleKey(); 
-  m_simpleKeyAllowed = false; 
-  m_canBeJSONFlow = false; 
- 
-  // eat the indicator 
-  Mark mark = INPUT.mark(); 
-  char indicator = INPUT.get(); 
-  alias = (indicator == Keys::Alias); 
- 
-  // now eat the content 
-  while (INPUT && Exp::Anchor().Matches(INPUT)) 
-    name += INPUT.get(); 
- 
-  // we need to have read SOMETHING! 
-  if (name.empty()) 
-    throw ParserException(INPUT.mark(), alias ? ErrorMsg::ALIAS_NOT_FOUND 
-                                              : ErrorMsg::ANCHOR_NOT_FOUND); 
- 
-  // and needs to end correctly 
-  if (INPUT && !Exp::AnchorEnd().Matches(INPUT)) 
-    throw ParserException(INPUT.mark(), alias ? ErrorMsg::CHAR_IN_ALIAS 
-                                              : ErrorMsg::CHAR_IN_ANCHOR); 
- 
-  // and we're done 
-  Token token(alias ? Token::ALIAS : Token::ANCHOR, mark); 
-  token.value = name; 
-  m_tokens.push(token); 
-} 
- 
-// Tag 
-void Scanner::ScanTag() { 
-  // insert a potential simple key 
-  InsertPotentialSimpleKey(); 
-  m_simpleKeyAllowed = false; 
-  m_canBeJSONFlow = false; 
- 
-  Token token(Token::TAG, INPUT.mark()); 
- 
-  // eat the indicator 
-  INPUT.get(); 
- 
-  if (INPUT && INPUT.peek() == Keys::VerbatimTagStart) { 
-    std::string tag = ScanVerbatimTag(INPUT); 
- 
-    token.value = tag; 
-    token.data = Tag::VERBATIM; 
-  } else { 
-    bool canBeHandle; 
-    token.value = ScanTagHandle(INPUT, canBeHandle); 
-    if (!canBeHandle && token.value.empty()) 
-      token.data = Tag::NON_SPECIFIC; 
-    else if (token.value.empty()) 
-      token.data = Tag::SECONDARY_HANDLE; 
-    else 
-      token.data = Tag::PRIMARY_HANDLE; 
- 
-    // is there a suffix? 
-    if (canBeHandle && INPUT.peek() == Keys::Tag) { 
-      // eat the indicator 
-      INPUT.get(); 
-      token.params.push_back(ScanTagSuffix(INPUT)); 
-      token.data = Tag::NAMED_HANDLE; 
-    } 
-  } 
- 
-  m_tokens.push(token); 
-} 
- 
-// PlainScalar 
-void Scanner::ScanPlainScalar() { 
-  std::string scalar; 
- 
-  // set up the scanning parameters 
-  ScanScalarParams params; 
+#include <sstream>
+
+#include "exp.h"
+#include "regex_yaml.h"
+#include "regeximpl.h"
+#include "scanner.h"
+#include "scanscalar.h"
+#include "scantag.h"  // IWYU pragma: keep
+#include "tag.h"      // IWYU pragma: keep
+#include "token.h"
+#include "yaml-cpp/exceptions.h"  // IWYU pragma: keep
+#include "yaml-cpp/mark.h"
+
+namespace YAML {
+///////////////////////////////////////////////////////////////////////
+// Specialization for scanning specific tokens
+
+// Directive
+// . Note: no semantic checking is done here (that's for the parser to do)
+void Scanner::ScanDirective() {
+  std::string name;
+  std::vector<std::string> params;
+
+  // pop indents and simple keys
+  PopAllIndents();
+  PopAllSimpleKeys();
+
+  m_simpleKeyAllowed = false;
+  m_canBeJSONFlow = false;
+
+  // store pos and eat indicator
+  Token token(Token::DIRECTIVE, INPUT.mark());
+  INPUT.eat(1);
+
+  // read name
+  while (INPUT && !Exp::BlankOrBreak().Matches(INPUT))
+    token.value += INPUT.get();
+
+  // read parameters
+  while (1) {
+    // first get rid of whitespace
+    while (Exp::Blank().Matches(INPUT))
+      INPUT.eat(1);
+
+    // break on newline or comment
+    if (!INPUT || Exp::Break().Matches(INPUT) || Exp::Comment().Matches(INPUT))
+      break;
+
+    // now read parameter
+    std::string param;
+    while (INPUT && !Exp::BlankOrBreak().Matches(INPUT))
+      param += INPUT.get();
+
+    token.params.push_back(param);
+  }
+
+  m_tokens.push(token);
+}
+
+// DocStart
+void Scanner::ScanDocStart() {
+  PopAllIndents();
+  PopAllSimpleKeys();
+  m_simpleKeyAllowed = false;
+  m_canBeJSONFlow = false;
+
+  // eat
+  Mark mark = INPUT.mark();
+  INPUT.eat(3);
+  m_tokens.push(Token(Token::DOC_START, mark));
+}
+
+// DocEnd
+void Scanner::ScanDocEnd() {
+  PopAllIndents();
+  PopAllSimpleKeys();
+  m_simpleKeyAllowed = false;
+  m_canBeJSONFlow = false;
+
+  // eat
+  Mark mark = INPUT.mark();
+  INPUT.eat(3);
+  m_tokens.push(Token(Token::DOC_END, mark));
+}
+
+// FlowStart
+void Scanner::ScanFlowStart() {
+  // flows can be simple keys
+  InsertPotentialSimpleKey();
+  m_simpleKeyAllowed = true;
+  m_canBeJSONFlow = false;
+
+  // eat
+  Mark mark = INPUT.mark();
+  char ch = INPUT.get();
+  FLOW_MARKER flowType = (ch == Keys::FlowSeqStart ? FLOW_SEQ : FLOW_MAP);
+  m_flows.push(flowType);
+  Token::TYPE type =
+      (flowType == FLOW_SEQ ? Token::FLOW_SEQ_START : Token::FLOW_MAP_START);
+  m_tokens.push(Token(type, mark));
+}
+
+// FlowEnd
+void Scanner::ScanFlowEnd() {
+  if (InBlockContext())
+    throw ParserException(INPUT.mark(), ErrorMsg::FLOW_END);
+
+  // we might have a solo entry in the flow context
+  if (InFlowContext()) {
+    if (m_flows.top() == FLOW_MAP && VerifySimpleKey())
+      m_tokens.push(Token(Token::VALUE, INPUT.mark()));
+    else if (m_flows.top() == FLOW_SEQ)
+      InvalidateSimpleKey();
+  }
+
+  m_simpleKeyAllowed = false;
+  m_canBeJSONFlow = true;
+
+  // eat
+  Mark mark = INPUT.mark();
+  char ch = INPUT.get();
+
+  // check that it matches the start
+  FLOW_MARKER flowType = (ch == Keys::FlowSeqEnd ? FLOW_SEQ : FLOW_MAP);
+  if (m_flows.top() != flowType)
+    throw ParserException(mark, ErrorMsg::FLOW_END);
+  m_flows.pop();
+
+  Token::TYPE type = (flowType ? Token::FLOW_SEQ_END : Token::FLOW_MAP_END);
+  m_tokens.push(Token(type, mark));
+}
+
+// FlowEntry
+void Scanner::ScanFlowEntry() {
+  // we might have a solo entry in the flow context
+  if (InFlowContext()) {
+    if (m_flows.top() == FLOW_MAP && VerifySimpleKey())
+      m_tokens.push(Token(Token::VALUE, INPUT.mark()));
+    else if (m_flows.top() == FLOW_SEQ)
+      InvalidateSimpleKey();
+  }
+
+  m_simpleKeyAllowed = true;
+  m_canBeJSONFlow = false;
+
+  // eat
+  Mark mark = INPUT.mark();
+  INPUT.eat(1);
+  m_tokens.push(Token(Token::FLOW_ENTRY, mark));
+}
+
+// BlockEntry
+void Scanner::ScanBlockEntry() {
+  // we better be in the block context!
+  if (InFlowContext())
+    throw ParserException(INPUT.mark(), ErrorMsg::BLOCK_ENTRY);
+
+  // can we put it here?
+  if (!m_simpleKeyAllowed)
+    throw ParserException(INPUT.mark(), ErrorMsg::BLOCK_ENTRY);
+
+  PushIndentTo(INPUT.column(), IndentMarker::SEQ);
+  m_simpleKeyAllowed = true;
+  m_canBeJSONFlow = false;
+
+  // eat
+  Mark mark = INPUT.mark();
+  INPUT.eat(1);
+  m_tokens.push(Token(Token::BLOCK_ENTRY, mark));
+}
+
+// Key
+void Scanner::ScanKey() {
+  // handle keys diffently in the block context (and manage indents)
+  if (InBlockContext()) {
+    if (!m_simpleKeyAllowed)
+      throw ParserException(INPUT.mark(), ErrorMsg::MAP_KEY);
+
+    PushIndentTo(INPUT.column(), IndentMarker::MAP);
+  }
+
+  // can only put a simple key here if we're in block context
+  m_simpleKeyAllowed = InBlockContext();
+
+  // eat
+  Mark mark = INPUT.mark();
+  INPUT.eat(1);
+  m_tokens.push(Token(Token::KEY, mark));
+}
+
+// Value
+void Scanner::ScanValue() {
+  // and check that simple key
+  bool isSimpleKey = VerifySimpleKey();
+  m_canBeJSONFlow = false;
+
+  if (isSimpleKey) {
+    // can't follow a simple key with another simple key (dunno why, though - it
+    // seems fine)
+    m_simpleKeyAllowed = false;
+  } else {
+    // handle values diffently in the block context (and manage indents)
+    if (InBlockContext()) {
+      if (!m_simpleKeyAllowed)
+        throw ParserException(INPUT.mark(), ErrorMsg::MAP_VALUE);
+
+      PushIndentTo(INPUT.column(), IndentMarker::MAP);
+    }
+
+    // can only put a simple key here if we're in block context
+    m_simpleKeyAllowed = InBlockContext();
+  }
+
+  // eat
+  Mark mark = INPUT.mark();
+  INPUT.eat(1);
+  m_tokens.push(Token(Token::VALUE, mark));
+}
+
+// AnchorOrAlias
+void Scanner::ScanAnchorOrAlias() {
+  bool alias;
+  std::string name;
+
+  // insert a potential simple key
+  InsertPotentialSimpleKey();
+  m_simpleKeyAllowed = false;
+  m_canBeJSONFlow = false;
+
+  // eat the indicator
+  Mark mark = INPUT.mark();
+  char indicator = INPUT.get();
+  alias = (indicator == Keys::Alias);
+
+  // now eat the content
+  while (INPUT && Exp::Anchor().Matches(INPUT))
+    name += INPUT.get();
+
+  // we need to have read SOMETHING!
+  if (name.empty())
+    throw ParserException(INPUT.mark(), alias ? ErrorMsg::ALIAS_NOT_FOUND
+                                              : ErrorMsg::ANCHOR_NOT_FOUND);
+
+  // and needs to end correctly
+  if (INPUT && !Exp::AnchorEnd().Matches(INPUT))
+    throw ParserException(INPUT.mark(), alias ? ErrorMsg::CHAR_IN_ALIAS
+                                              : ErrorMsg::CHAR_IN_ANCHOR);
+
+  // and we're done
+  Token token(alias ? Token::ALIAS : Token::ANCHOR, mark);
+  token.value = name;
+  m_tokens.push(token);
+}
+
+// Tag
+void Scanner::ScanTag() {
+  // insert a potential simple key
+  InsertPotentialSimpleKey();
+  m_simpleKeyAllowed = false;
+  m_canBeJSONFlow = false;
+
+  Token token(Token::TAG, INPUT.mark());
+
+  // eat the indicator
+  INPUT.get();
+
+  if (INPUT && INPUT.peek() == Keys::VerbatimTagStart) {
+    std::string tag = ScanVerbatimTag(INPUT);
+
+    token.value = tag;
+    token.data = Tag::VERBATIM;
+  } else {
+    bool canBeHandle;
+    token.value = ScanTagHandle(INPUT, canBeHandle);
+    if (!canBeHandle && token.value.empty())
+      token.data = Tag::NON_SPECIFIC;
+    else if (token.value.empty())
+      token.data = Tag::SECONDARY_HANDLE;
+    else
+      token.data = Tag::PRIMARY_HANDLE;
+
+    // is there a suffix?
+    if (canBeHandle && INPUT.peek() == Keys::Tag) {
+      // eat the indicator
+      INPUT.get();
+      token.params.push_back(ScanTagSuffix(INPUT));
+      token.data = Tag::NAMED_HANDLE;
+    }
+  }
+
+  m_tokens.push(token);
+}
+
+// PlainScalar
+void Scanner::ScanPlainScalar() {
+  std::string scalar;
+
+  // set up the scanning parameters
+  ScanScalarParams params;
   params.end =
       (InFlowContext() ? &Exp::ScanScalarEndInFlow() : &Exp::ScanScalarEnd());
-  params.eatEnd = false; 
-  params.indent = (InFlowContext() ? 0 : GetTopIndent() + 1); 
-  params.fold = FOLD_FLOW; 
-  params.eatLeadingWhitespace = true; 
-  params.trimTrailingSpaces = true; 
-  params.chomp = STRIP; 
-  params.onDocIndicator = BREAK; 
-  params.onTabInIndentation = THROW; 
- 
-  // insert a potential simple key 
-  InsertPotentialSimpleKey(); 
- 
-  Mark mark = INPUT.mark(); 
-  scalar = ScanScalar(INPUT, params); 
- 
-  // can have a simple key only if we ended the scalar by starting a new line 
-  m_simpleKeyAllowed = params.leadingSpaces; 
-  m_canBeJSONFlow = false; 
- 
-  // finally, check and see if we ended on an illegal character 
-  // if(Exp::IllegalCharInScalar.Matches(INPUT)) 
-  //	throw ParserException(INPUT.mark(), ErrorMsg::CHAR_IN_SCALAR); 
- 
-  Token token(Token::PLAIN_SCALAR, mark); 
-  token.value = scalar; 
-  m_tokens.push(token); 
-} 
- 
-// QuotedScalar 
-void Scanner::ScanQuotedScalar() { 
-  std::string scalar; 
- 
-  // peek at single or double quote (don't eat because we need to preserve (for 
-  // the time being) the input position) 
-  char quote = INPUT.peek(); 
-  bool single = (quote == '\''); 
- 
-  // setup the scanning parameters 
-  ScanScalarParams params; 
+  params.eatEnd = false;
+  params.indent = (InFlowContext() ? 0 : GetTopIndent() + 1);
+  params.fold = FOLD_FLOW;
+  params.eatLeadingWhitespace = true;
+  params.trimTrailingSpaces = true;
+  params.chomp = STRIP;
+  params.onDocIndicator = BREAK;
+  params.onTabInIndentation = THROW;
+
+  // insert a potential simple key
+  InsertPotentialSimpleKey();
+
+  Mark mark = INPUT.mark();
+  scalar = ScanScalar(INPUT, params);
+
+  // can have a simple key only if we ended the scalar by starting a new line
+  m_simpleKeyAllowed = params.leadingSpaces;
+  m_canBeJSONFlow = false;
+
+  // finally, check and see if we ended on an illegal character
+  // if(Exp::IllegalCharInScalar.Matches(INPUT))
+  //	throw ParserException(INPUT.mark(), ErrorMsg::CHAR_IN_SCALAR);
+
+  Token token(Token::PLAIN_SCALAR, mark);
+  token.value = scalar;
+  m_tokens.push(token);
+}
+
+// QuotedScalar
+void Scanner::ScanQuotedScalar() {
+  std::string scalar;
+
+  // peek at single or double quote (don't eat because we need to preserve (for
+  // the time being) the input position)
+  char quote = INPUT.peek();
+  bool single = (quote == '\'');
+
+  // setup the scanning parameters
+  ScanScalarParams params;
   RegEx end = (single ? RegEx(quote) && !Exp::EscSingleQuote() : RegEx(quote));
   params.end = &end;
-  params.eatEnd = true; 
-  params.escape = (single ? '\'' : '\\'); 
-  params.indent = 0; 
-  params.fold = FOLD_FLOW; 
-  params.eatLeadingWhitespace = true; 
-  params.trimTrailingSpaces = false; 
-  params.chomp = CLIP; 
-  params.onDocIndicator = THROW; 
- 
-  // insert a potential simple key 
-  InsertPotentialSimpleKey(); 
- 
-  Mark mark = INPUT.mark(); 
- 
-  // now eat that opening quote 
-  INPUT.get(); 
- 
-  // and scan 
-  scalar = ScanScalar(INPUT, params); 
-  m_simpleKeyAllowed = false; 
-  m_canBeJSONFlow = true; 
- 
-  Token token(Token::NON_PLAIN_SCALAR, mark); 
-  token.value = scalar; 
-  m_tokens.push(token); 
-} 
- 
-// BlockScalarToken 
-// . These need a little extra processing beforehand. 
-// . We need to scan the line where the indicator is (this doesn't count as part 
-// of the scalar), 
-//   and then we need to figure out what level of indentation we'll be using. 
-void Scanner::ScanBlockScalar() { 
-  std::string scalar; 
- 
-  ScanScalarParams params; 
-  params.indent = 1; 
-  params.detectIndent = true; 
- 
-  // eat block indicator ('|' or '>') 
-  Mark mark = INPUT.mark(); 
-  char indicator = INPUT.get(); 
-  params.fold = (indicator == Keys::FoldedScalar ? FOLD_BLOCK : DONT_FOLD); 
- 
-  // eat chomping/indentation indicators 
-  params.chomp = CLIP; 
-  int n = Exp::Chomp().Match(INPUT); 
-  for (int i = 0; i < n; i++) { 
-    char ch = INPUT.get(); 
-    if (ch == '+') 
-      params.chomp = KEEP; 
-    else if (ch == '-') 
-      params.chomp = STRIP; 
-    else if (Exp::Digit().Matches(ch)) { 
-      if (ch == '0') 
-        throw ParserException(INPUT.mark(), ErrorMsg::ZERO_INDENT_IN_BLOCK); 
- 
-      params.indent = ch - '0'; 
-      params.detectIndent = false; 
-    } 
-  } 
- 
-  // now eat whitespace 
-  while (Exp::Blank().Matches(INPUT)) 
-    INPUT.eat(1); 
- 
-  // and comments to the end of the line 
-  if (Exp::Comment().Matches(INPUT)) 
-    while (INPUT && !Exp::Break().Matches(INPUT)) 
-      INPUT.eat(1); 
- 
-  // if it's not a line break, then we ran into a bad character inline 
-  if (INPUT && !Exp::Break().Matches(INPUT)) 
-    throw ParserException(INPUT.mark(), ErrorMsg::CHAR_IN_BLOCK); 
- 
-  // set the initial indentation 
-  if (GetTopIndent() >= 0) 
-    params.indent += GetTopIndent(); 
- 
-  params.eatLeadingWhitespace = false; 
-  params.trimTrailingSpaces = false; 
-  params.onTabInIndentation = THROW; 
- 
-  scalar = ScanScalar(INPUT, params); 
- 
-  // simple keys always ok after block scalars (since we're gonna start a new 
-  // line anyways) 
-  m_simpleKeyAllowed = true; 
-  m_canBeJSONFlow = false; 
- 
-  Token token(Token::NON_PLAIN_SCALAR, mark); 
-  token.value = scalar; 
-  m_tokens.push(token); 
-} 
-} 
+  params.eatEnd = true;
+  params.escape = (single ? '\'' : '\\');
+  params.indent = 0;
+  params.fold = FOLD_FLOW;
+  params.eatLeadingWhitespace = true;
+  params.trimTrailingSpaces = false;
+  params.chomp = CLIP;
+  params.onDocIndicator = THROW;
+
+  // insert a potential simple key
+  InsertPotentialSimpleKey();
+
+  Mark mark = INPUT.mark();
+
+  // now eat that opening quote
+  INPUT.get();
+
+  // and scan
+  scalar = ScanScalar(INPUT, params);
+  m_simpleKeyAllowed = false;
+  m_canBeJSONFlow = true;
+
+  Token token(Token::NON_PLAIN_SCALAR, mark);
+  token.value = scalar;
+  m_tokens.push(token);
+}
+
+// BlockScalarToken
+// . These need a little extra processing beforehand.
+// . We need to scan the line where the indicator is (this doesn't count as part
+// of the scalar),
+//   and then we need to figure out what level of indentation we'll be using.
+void Scanner::ScanBlockScalar() {
+  std::string scalar;
+
+  ScanScalarParams params;
+  params.indent = 1;
+  params.detectIndent = true;
+
+  // eat block indicator ('|' or '>')
+  Mark mark = INPUT.mark();
+  char indicator = INPUT.get();
+  params.fold = (indicator == Keys::FoldedScalar ? FOLD_BLOCK : DONT_FOLD);
+
+  // eat chomping/indentation indicators
+  params.chomp = CLIP;
+  int n = Exp::Chomp().Match(INPUT);
+  for (int i = 0; i < n; i++) {
+    char ch = INPUT.get();
+    if (ch == '+')
+      params.chomp = KEEP;
+    else if (ch == '-')
+      params.chomp = STRIP;
+    else if (Exp::Digit().Matches(ch)) {
+      if (ch == '0')
+        throw ParserException(INPUT.mark(), ErrorMsg::ZERO_INDENT_IN_BLOCK);
+
+      params.indent = ch - '0';
+      params.detectIndent = false;
+    }
+  }
+
+  // now eat whitespace
+  while (Exp::Blank().Matches(INPUT))
+    INPUT.eat(1);
+
+  // and comments to the end of the line
+  if (Exp::Comment().Matches(INPUT))
+    while (INPUT && !Exp::Break().Matches(INPUT))
+      INPUT.eat(1);
+
+  // if it's not a line break, then we ran into a bad character inline
+  if (INPUT && !Exp::Break().Matches(INPUT))
+    throw ParserException(INPUT.mark(), ErrorMsg::CHAR_IN_BLOCK);
+
+  // set the initial indentation
+  if (GetTopIndent() >= 0)
+    params.indent += GetTopIndent();
+
+  params.eatLeadingWhitespace = false;
+  params.trimTrailingSpaces = false;
+  params.onTabInIndentation = THROW;
+
+  scalar = ScanScalar(INPUT, params);
+
+  // simple keys always ok after block scalars (since we're gonna start a new
+  // line anyways)
+  m_simpleKeyAllowed = true;
+  m_canBeJSONFlow = false;
+
+  Token token(Token::NON_PLAIN_SCALAR, mark);
+  token.value = scalar;
+  m_tokens.push(token);
+}
+}
diff --git a/contrib/libs/yaml-cpp/src/setting.h b/contrib/libs/yaml-cpp/src/setting.h
index c6a81e6e851..b78d40e2e85 100644
--- a/contrib/libs/yaml-cpp/src/setting.h
+++ b/contrib/libs/yaml-cpp/src/setting.h
@@ -1,95 +1,95 @@
-#ifndef SETTING_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define SETTING_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include <memory> 
-#include <vector> 
-#include "yaml-cpp/noncopyable.h" 
- 
-namespace YAML { 
-class SettingChangeBase; 
- 
-template <typename T> 
-class Setting { 
- public: 
-  Setting() : m_value() {} 
- 
-  const T get() const { return m_value; } 
+#ifndef SETTING_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define SETTING_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <memory>
+#include <vector>
+#include "yaml-cpp/noncopyable.h"
+
+namespace YAML {
+class SettingChangeBase;
+
+template <typename T>
+class Setting {
+ public:
+  Setting() : m_value() {}
+
+  const T get() const { return m_value; }
   std::unique_ptr<SettingChangeBase> set(const T& value);
-  void restore(const Setting<T>& oldSetting) { m_value = oldSetting.get(); } 
- 
- private: 
-  T m_value; 
-}; 
- 
-class SettingChangeBase { 
- public: 
-  virtual ~SettingChangeBase() {} 
-  virtual void pop() = 0; 
-}; 
- 
-template <typename T> 
-class SettingChange : public SettingChangeBase { 
- public: 
-  SettingChange(Setting<T>* pSetting) : m_pCurSetting(pSetting) { 
-    // copy old setting to save its state 
-    m_oldSetting = *pSetting; 
-  } 
- 
-  virtual void pop() { m_pCurSetting->restore(m_oldSetting); } 
- 
- private: 
-  Setting<T>* m_pCurSetting; 
-  Setting<T> m_oldSetting; 
-}; 
- 
-template <typename T> 
+  void restore(const Setting<T>& oldSetting) { m_value = oldSetting.get(); }
+
+ private:
+  T m_value;
+};
+
+class SettingChangeBase {
+ public:
+  virtual ~SettingChangeBase() {}
+  virtual void pop() = 0;
+};
+
+template <typename T>
+class SettingChange : public SettingChangeBase {
+ public:
+  SettingChange(Setting<T>* pSetting) : m_pCurSetting(pSetting) {
+    // copy old setting to save its state
+    m_oldSetting = *pSetting;
+  }
+
+  virtual void pop() { m_pCurSetting->restore(m_oldSetting); }
+
+ private:
+  Setting<T>* m_pCurSetting;
+  Setting<T> m_oldSetting;
+};
+
+template <typename T>
 inline std::unique_ptr<SettingChangeBase> Setting<T>::set(const T& value) {
   std::unique_ptr<SettingChangeBase> pChange(new SettingChange<T>(this));
-  m_value = value; 
-  return pChange; 
-} 
- 
-class SettingChanges : private noncopyable { 
- public: 
-  SettingChanges() {} 
-  ~SettingChanges() { clear(); } 
- 
-  void clear() { 
-    restore(); 
-    m_settingChanges.clear(); 
-  } 
- 
-  void restore() { 
-    for (setting_changes::const_iterator it = m_settingChanges.begin(); 
-         it != m_settingChanges.end(); ++it) 
-      (*it)->pop(); 
-  } 
- 
+  m_value = value;
+  return pChange;
+}
+
+class SettingChanges : private noncopyable {
+ public:
+  SettingChanges() {}
+  ~SettingChanges() { clear(); }
+
+  void clear() {
+    restore();
+    m_settingChanges.clear();
+  }
+
+  void restore() {
+    for (setting_changes::const_iterator it = m_settingChanges.begin();
+         it != m_settingChanges.end(); ++it)
+      (*it)->pop();
+  }
+
   void push(std::unique_ptr<SettingChangeBase> pSettingChange) {
     m_settingChanges.push_back(std::move(pSettingChange));
-  } 
- 
+  }
+
   // like std::unique_ptr - assignment is transfer of ownership
   SettingChanges& operator=(SettingChanges&& rhs) {
-    if (this == &rhs) 
-      return *this; 
- 
-    clear(); 
+    if (this == &rhs)
+      return *this;
+
+    clear();
     std::swap(m_settingChanges, rhs.m_settingChanges);
 
-    return *this; 
-  } 
- 
- private: 
+    return *this;
+  }
+
+ private:
   typedef std::vector<std::unique_ptr<SettingChangeBase>> setting_changes;
-  setting_changes m_settingChanges; 
-}; 
-} 
- 
-#endif  // SETTING_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+  setting_changes m_settingChanges;
+};
+}
+
+#endif  // SETTING_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/src/simplekey.cpp b/contrib/libs/yaml-cpp/src/simplekey.cpp
index 4d8835c6e68..70f56b6ae42 100644
--- a/contrib/libs/yaml-cpp/src/simplekey.cpp
+++ b/contrib/libs/yaml-cpp/src/simplekey.cpp
@@ -1,128 +1,128 @@
-#include "scanner.h" 
-#include "token.h" 
- 
-namespace YAML { 
-struct Mark; 
- 
-Scanner::SimpleKey::SimpleKey(const Mark& mark_, std::size_t flowLevel_) 
-    : mark(mark_), flowLevel(flowLevel_), pIndent(0), pMapStart(0), pKey(0) {} 
- 
-void Scanner::SimpleKey::Validate() { 
-  // Note: pIndent will *not* be garbage here; 
-  //       we "garbage collect" them so we can 
-  //       always refer to them 
-  if (pIndent) 
-    pIndent->status = IndentMarker::VALID; 
-  if (pMapStart) 
-    pMapStart->status = Token::VALID; 
-  if (pKey) 
-    pKey->status = Token::VALID; 
-} 
- 
-void Scanner::SimpleKey::Invalidate() { 
-  if (pIndent) 
-    pIndent->status = IndentMarker::INVALID; 
-  if (pMapStart) 
-    pMapStart->status = Token::INVALID; 
-  if (pKey) 
-    pKey->status = Token::INVALID; 
-} 
- 
-// CanInsertPotentialSimpleKey 
-bool Scanner::CanInsertPotentialSimpleKey() const { 
-  if (!m_simpleKeyAllowed) 
-    return false; 
- 
-  return !ExistsActiveSimpleKey(); 
-} 
- 
-// ExistsActiveSimpleKey 
-// . Returns true if there's a potential simple key at our flow level 
-//   (there's allowed at most one per flow level, i.e., at the start of the flow 
-// start token) 
-bool Scanner::ExistsActiveSimpleKey() const { 
-  if (m_simpleKeys.empty()) 
-    return false; 
- 
-  const SimpleKey& key = m_simpleKeys.top(); 
-  return key.flowLevel == GetFlowLevel(); 
-} 
- 
-// InsertPotentialSimpleKey 
-// . If we can, add a potential simple key to the queue, 
-//   and save it on a stack. 
-void Scanner::InsertPotentialSimpleKey() { 
-  if (!CanInsertPotentialSimpleKey()) 
-    return; 
- 
-  SimpleKey key(INPUT.mark(), GetFlowLevel()); 
- 
-  // first add a map start, if necessary 
-  if (InBlockContext()) { 
-    key.pIndent = PushIndentTo(INPUT.column(), IndentMarker::MAP); 
-    if (key.pIndent) { 
-      key.pIndent->status = IndentMarker::UNKNOWN; 
-      key.pMapStart = key.pIndent->pStartToken; 
-      key.pMapStart->status = Token::UNVERIFIED; 
-    } 
-  } 
- 
-  // then add the (now unverified) key 
-  m_tokens.push(Token(Token::KEY, INPUT.mark())); 
-  key.pKey = &m_tokens.back(); 
-  key.pKey->status = Token::UNVERIFIED; 
- 
-  m_simpleKeys.push(key); 
-} 
- 
-// InvalidateSimpleKey 
-// . Automatically invalidate the simple key in our flow level 
-void Scanner::InvalidateSimpleKey() { 
-  if (m_simpleKeys.empty()) 
-    return; 
- 
-  // grab top key 
-  SimpleKey& key = m_simpleKeys.top(); 
-  if (key.flowLevel != GetFlowLevel()) 
-    return; 
- 
-  key.Invalidate(); 
-  m_simpleKeys.pop(); 
-} 
- 
-// VerifySimpleKey 
-// . Determines whether the latest simple key to be added is valid, 
-//   and if so, makes it valid. 
-bool Scanner::VerifySimpleKey() { 
-  if (m_simpleKeys.empty()) 
-    return false; 
- 
-  // grab top key 
-  SimpleKey key = m_simpleKeys.top(); 
- 
-  // only validate if we're in the correct flow level 
-  if (key.flowLevel != GetFlowLevel()) 
-    return false; 
- 
-  m_simpleKeys.pop(); 
- 
-  bool isValid = true; 
- 
-  // needs to be less than 1024 characters and inline 
-  if (INPUT.line() != key.mark.line || INPUT.pos() - key.mark.pos > 1024) 
-    isValid = false; 
- 
-  // invalidate key 
-  if (isValid) 
-    key.Validate(); 
-  else 
-    key.Invalidate(); 
- 
-  return isValid; 
-} 
- 
-void Scanner::PopAllSimpleKeys() { 
-  while (!m_simpleKeys.empty()) 
-    m_simpleKeys.pop(); 
-} 
-} 
+#include "scanner.h"
+#include "token.h"
+
+namespace YAML {
+struct Mark;
+
+Scanner::SimpleKey::SimpleKey(const Mark& mark_, std::size_t flowLevel_)
+    : mark(mark_), flowLevel(flowLevel_), pIndent(0), pMapStart(0), pKey(0) {}
+
+void Scanner::SimpleKey::Validate() {
+  // Note: pIndent will *not* be garbage here;
+  //       we "garbage collect" them so we can
+  //       always refer to them
+  if (pIndent)
+    pIndent->status = IndentMarker::VALID;
+  if (pMapStart)
+    pMapStart->status = Token::VALID;
+  if (pKey)
+    pKey->status = Token::VALID;
+}
+
+void Scanner::SimpleKey::Invalidate() {
+  if (pIndent)
+    pIndent->status = IndentMarker::INVALID;
+  if (pMapStart)
+    pMapStart->status = Token::INVALID;
+  if (pKey)
+    pKey->status = Token::INVALID;
+}
+
+// CanInsertPotentialSimpleKey
+bool Scanner::CanInsertPotentialSimpleKey() const {
+  if (!m_simpleKeyAllowed)
+    return false;
+
+  return !ExistsActiveSimpleKey();
+}
+
+// ExistsActiveSimpleKey
+// . Returns true if there's a potential simple key at our flow level
+//   (there's allowed at most one per flow level, i.e., at the start of the flow
+// start token)
+bool Scanner::ExistsActiveSimpleKey() const {
+  if (m_simpleKeys.empty())
+    return false;
+
+  const SimpleKey& key = m_simpleKeys.top();
+  return key.flowLevel == GetFlowLevel();
+}
+
+// InsertPotentialSimpleKey
+// . If we can, add a potential simple key to the queue,
+//   and save it on a stack.
+void Scanner::InsertPotentialSimpleKey() {
+  if (!CanInsertPotentialSimpleKey())
+    return;
+
+  SimpleKey key(INPUT.mark(), GetFlowLevel());
+
+  // first add a map start, if necessary
+  if (InBlockContext()) {
+    key.pIndent = PushIndentTo(INPUT.column(), IndentMarker::MAP);
+    if (key.pIndent) {
+      key.pIndent->status = IndentMarker::UNKNOWN;
+      key.pMapStart = key.pIndent->pStartToken;
+      key.pMapStart->status = Token::UNVERIFIED;
+    }
+  }
+
+  // then add the (now unverified) key
+  m_tokens.push(Token(Token::KEY, INPUT.mark()));
+  key.pKey = &m_tokens.back();
+  key.pKey->status = Token::UNVERIFIED;
+
+  m_simpleKeys.push(key);
+}
+
+// InvalidateSimpleKey
+// . Automatically invalidate the simple key in our flow level
+void Scanner::InvalidateSimpleKey() {
+  if (m_simpleKeys.empty())
+    return;
+
+  // grab top key
+  SimpleKey& key = m_simpleKeys.top();
+  if (key.flowLevel != GetFlowLevel())
+    return;
+
+  key.Invalidate();
+  m_simpleKeys.pop();
+}
+
+// VerifySimpleKey
+// . Determines whether the latest simple key to be added is valid,
+//   and if so, makes it valid.
+bool Scanner::VerifySimpleKey() {
+  if (m_simpleKeys.empty())
+    return false;
+
+  // grab top key
+  SimpleKey key = m_simpleKeys.top();
+
+  // only validate if we're in the correct flow level
+  if (key.flowLevel != GetFlowLevel())
+    return false;
+
+  m_simpleKeys.pop();
+
+  bool isValid = true;
+
+  // needs to be less than 1024 characters and inline
+  if (INPUT.line() != key.mark.line || INPUT.pos() - key.mark.pos > 1024)
+    isValid = false;
+
+  // invalidate key
+  if (isValid)
+    key.Validate();
+  else
+    key.Invalidate();
+
+  return isValid;
+}
+
+void Scanner::PopAllSimpleKeys() {
+  while (!m_simpleKeys.empty())
+    m_simpleKeys.pop();
+}
+}
diff --git a/contrib/libs/yaml-cpp/src/singledocparser.cpp b/contrib/libs/yaml-cpp/src/singledocparser.cpp
index bf13a4b433e..a27c1c3b04d 100644
--- a/contrib/libs/yaml-cpp/src/singledocparser.cpp
+++ b/contrib/libs/yaml-cpp/src/singledocparser.cpp
@@ -1,414 +1,414 @@
-#include <algorithm> 
-#include <cstdio> 
-#include <sstream> 
- 
-#include "collectionstack.h"  // IWYU pragma: keep 
-#include "scanner.h" 
-#include "singledocparser.h" 
-#include "tag.h" 
-#include "token.h" 
-#include "yaml-cpp/emitterstyle.h" 
-#include "yaml-cpp/eventhandler.h" 
-#include "yaml-cpp/exceptions.h"  // IWYU pragma: keep 
-#include "yaml-cpp/mark.h" 
+#include <algorithm>
+#include <cstdio>
+#include <sstream>
+
+#include "collectionstack.h"  // IWYU pragma: keep
+#include "scanner.h"
+#include "singledocparser.h"
+#include "tag.h"
+#include "token.h"
+#include "yaml-cpp/emitterstyle.h"
+#include "yaml-cpp/eventhandler.h"
+#include "yaml-cpp/exceptions.h"  // IWYU pragma: keep
+#include "yaml-cpp/mark.h"
 #include "yaml-cpp/null.h"
- 
-namespace YAML { 
-SingleDocParser::SingleDocParser(Scanner& scanner, const Directives& directives) 
-    : m_scanner(scanner), 
-      m_directives(directives), 
-      m_pCollectionStack(new CollectionStack), 
-      m_curAnchor(0) {} 
- 
-SingleDocParser::~SingleDocParser() {} 
- 
-// HandleDocument 
-// . Handles the next document 
-// . Throws a ParserException on error. 
-void SingleDocParser::HandleDocument(EventHandler& eventHandler) { 
-  assert(!m_scanner.empty());  // guaranteed that there are tokens 
-  assert(!m_curAnchor); 
- 
-  eventHandler.OnDocumentStart(m_scanner.peek().mark); 
- 
-  // eat doc start 
-  if (m_scanner.peek().type == Token::DOC_START) 
-    m_scanner.pop(); 
- 
-  // recurse! 
-  HandleNode(eventHandler); 
- 
-  eventHandler.OnDocumentEnd(); 
- 
-  // and finally eat any doc ends we see 
-  while (!m_scanner.empty() && m_scanner.peek().type == Token::DOC_END) 
-    m_scanner.pop(); 
-} 
- 
-void SingleDocParser::HandleNode(EventHandler& eventHandler) { 
-  // an empty node *is* a possibility 
-  if (m_scanner.empty()) { 
-    eventHandler.OnNull(m_scanner.mark(), NullAnchor); 
-    return; 
-  } 
- 
-  // save location 
-  Mark mark = m_scanner.peek().mark; 
- 
-  // special case: a value node by itself must be a map, with no header 
-  if (m_scanner.peek().type == Token::VALUE) { 
-    eventHandler.OnMapStart(mark, "?", NullAnchor, EmitterStyle::Default); 
-    HandleMap(eventHandler); 
-    eventHandler.OnMapEnd(); 
-    return; 
-  } 
- 
-  // special case: an alias node 
-  if (m_scanner.peek().type == Token::ALIAS) { 
-    eventHandler.OnAlias(mark, LookupAnchor(mark, m_scanner.peek().value)); 
-    m_scanner.pop(); 
-    return; 
-  } 
- 
-  std::string tag; 
-  anchor_t anchor; 
-  ParseProperties(tag, anchor); 
- 
-  const Token& token = m_scanner.peek(); 
- 
+
+namespace YAML {
+SingleDocParser::SingleDocParser(Scanner& scanner, const Directives& directives)
+    : m_scanner(scanner),
+      m_directives(directives),
+      m_pCollectionStack(new CollectionStack),
+      m_curAnchor(0) {}
+
+SingleDocParser::~SingleDocParser() {}
+
+// HandleDocument
+// . Handles the next document
+// . Throws a ParserException on error.
+void SingleDocParser::HandleDocument(EventHandler& eventHandler) {
+  assert(!m_scanner.empty());  // guaranteed that there are tokens
+  assert(!m_curAnchor);
+
+  eventHandler.OnDocumentStart(m_scanner.peek().mark);
+
+  // eat doc start
+  if (m_scanner.peek().type == Token::DOC_START)
+    m_scanner.pop();
+
+  // recurse!
+  HandleNode(eventHandler);
+
+  eventHandler.OnDocumentEnd();
+
+  // and finally eat any doc ends we see
+  while (!m_scanner.empty() && m_scanner.peek().type == Token::DOC_END)
+    m_scanner.pop();
+}
+
+void SingleDocParser::HandleNode(EventHandler& eventHandler) {
+  // an empty node *is* a possibility
+  if (m_scanner.empty()) {
+    eventHandler.OnNull(m_scanner.mark(), NullAnchor);
+    return;
+  }
+
+  // save location
+  Mark mark = m_scanner.peek().mark;
+
+  // special case: a value node by itself must be a map, with no header
+  if (m_scanner.peek().type == Token::VALUE) {
+    eventHandler.OnMapStart(mark, "?", NullAnchor, EmitterStyle::Default);
+    HandleMap(eventHandler);
+    eventHandler.OnMapEnd();
+    return;
+  }
+
+  // special case: an alias node
+  if (m_scanner.peek().type == Token::ALIAS) {
+    eventHandler.OnAlias(mark, LookupAnchor(mark, m_scanner.peek().value));
+    m_scanner.pop();
+    return;
+  }
+
+  std::string tag;
+  anchor_t anchor;
+  ParseProperties(tag, anchor);
+
+  const Token& token = m_scanner.peek();
+
   if (token.type == Token::PLAIN_SCALAR && IsNullString(token.value)) {
-    eventHandler.OnNull(mark, anchor); 
-    m_scanner.pop(); 
-    return; 
-  } 
- 
-  // add non-specific tags 
-  if (tag.empty()) 
-    tag = (token.type == Token::NON_PLAIN_SCALAR ? "!" : "?"); 
- 
-  // now split based on what kind of node we should be 
-  switch (token.type) { 
-    case Token::PLAIN_SCALAR: 
-    case Token::NON_PLAIN_SCALAR: 
-      eventHandler.OnScalar(mark, tag, anchor, token.value); 
-      m_scanner.pop(); 
-      return; 
-    case Token::FLOW_SEQ_START: 
-      eventHandler.OnSequenceStart(mark, tag, anchor, EmitterStyle::Flow); 
-      HandleSequence(eventHandler); 
-      eventHandler.OnSequenceEnd(); 
-      return; 
-    case Token::BLOCK_SEQ_START: 
-      eventHandler.OnSequenceStart(mark, tag, anchor, EmitterStyle::Block); 
-      HandleSequence(eventHandler); 
-      eventHandler.OnSequenceEnd(); 
-      return; 
-    case Token::FLOW_MAP_START: 
-      eventHandler.OnMapStart(mark, tag, anchor, EmitterStyle::Flow); 
-      HandleMap(eventHandler); 
-      eventHandler.OnMapEnd(); 
-      return; 
-    case Token::BLOCK_MAP_START: 
-      eventHandler.OnMapStart(mark, tag, anchor, EmitterStyle::Block); 
-      HandleMap(eventHandler); 
-      eventHandler.OnMapEnd(); 
-      return; 
-    case Token::KEY: 
-      // compact maps can only go in a flow sequence 
-      if (m_pCollectionStack->GetCurCollectionType() == 
-          CollectionType::FlowSeq) { 
-        eventHandler.OnMapStart(mark, tag, anchor, EmitterStyle::Flow); 
-        HandleMap(eventHandler); 
-        eventHandler.OnMapEnd(); 
-        return; 
-      } 
-      break; 
-    default: 
-      break; 
-  } 
- 
-  if (tag == "?") 
-    eventHandler.OnNull(mark, anchor); 
-  else 
-    eventHandler.OnScalar(mark, tag, anchor, ""); 
-} 
- 
-void SingleDocParser::HandleSequence(EventHandler& eventHandler) { 
-  // split based on start token 
-  switch (m_scanner.peek().type) { 
-    case Token::BLOCK_SEQ_START: 
-      HandleBlockSequence(eventHandler); 
-      break; 
-    case Token::FLOW_SEQ_START: 
-      HandleFlowSequence(eventHandler); 
-      break; 
-    default: 
-      break; 
-  } 
-} 
- 
-void SingleDocParser::HandleBlockSequence(EventHandler& eventHandler) { 
-  // eat start token 
-  m_scanner.pop(); 
-  m_pCollectionStack->PushCollectionType(CollectionType::BlockSeq); 
- 
-  while (1) { 
-    if (m_scanner.empty()) 
-      throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_SEQ); 
- 
-    Token token = m_scanner.peek(); 
-    if (token.type != Token::BLOCK_ENTRY && token.type != Token::BLOCK_SEQ_END) 
-      throw ParserException(token.mark, ErrorMsg::END_OF_SEQ); 
- 
-    m_scanner.pop(); 
-    if (token.type == Token::BLOCK_SEQ_END) 
-      break; 
- 
-    // check for null 
-    if (!m_scanner.empty()) { 
-      const Token& token = m_scanner.peek(); 
-      if (token.type == Token::BLOCK_ENTRY || 
-          token.type == Token::BLOCK_SEQ_END) { 
-        eventHandler.OnNull(token.mark, NullAnchor); 
-        continue; 
-      } 
-    } 
- 
-    HandleNode(eventHandler); 
-  } 
- 
-  m_pCollectionStack->PopCollectionType(CollectionType::BlockSeq); 
-} 
- 
-void SingleDocParser::HandleFlowSequence(EventHandler& eventHandler) { 
-  // eat start token 
-  m_scanner.pop(); 
-  m_pCollectionStack->PushCollectionType(CollectionType::FlowSeq); 
- 
-  while (1) { 
-    if (m_scanner.empty()) 
-      throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_SEQ_FLOW); 
- 
-    // first check for end 
-    if (m_scanner.peek().type == Token::FLOW_SEQ_END) { 
-      m_scanner.pop(); 
-      break; 
-    } 
- 
-    // then read the node 
-    HandleNode(eventHandler); 
- 
-    if (m_scanner.empty()) 
-      throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_SEQ_FLOW); 
- 
-    // now eat the separator (or could be a sequence end, which we ignore - but 
-    // if it's neither, then it's a bad node) 
-    Token& token = m_scanner.peek(); 
-    if (token.type == Token::FLOW_ENTRY) 
-      m_scanner.pop(); 
-    else if (token.type != Token::FLOW_SEQ_END) 
-      throw ParserException(token.mark, ErrorMsg::END_OF_SEQ_FLOW); 
-  } 
- 
-  m_pCollectionStack->PopCollectionType(CollectionType::FlowSeq); 
-} 
- 
-void SingleDocParser::HandleMap(EventHandler& eventHandler) { 
-  // split based on start token 
-  switch (m_scanner.peek().type) { 
-    case Token::BLOCK_MAP_START: 
-      HandleBlockMap(eventHandler); 
-      break; 
-    case Token::FLOW_MAP_START: 
-      HandleFlowMap(eventHandler); 
-      break; 
-    case Token::KEY: 
-      HandleCompactMap(eventHandler); 
-      break; 
-    case Token::VALUE: 
-      HandleCompactMapWithNoKey(eventHandler); 
-      break; 
-    default: 
-      break; 
-  } 
-} 
- 
-void SingleDocParser::HandleBlockMap(EventHandler& eventHandler) { 
-  // eat start token 
-  m_scanner.pop(); 
-  m_pCollectionStack->PushCollectionType(CollectionType::BlockMap); 
- 
-  while (1) { 
-    if (m_scanner.empty()) 
-      throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_MAP); 
- 
-    Token token = m_scanner.peek(); 
-    if (token.type != Token::KEY && token.type != Token::VALUE && 
-        token.type != Token::BLOCK_MAP_END) 
-      throw ParserException(token.mark, ErrorMsg::END_OF_MAP); 
- 
-    if (token.type == Token::BLOCK_MAP_END) { 
-      m_scanner.pop(); 
-      break; 
-    } 
- 
-    // grab key (if non-null) 
-    if (token.type == Token::KEY) { 
-      m_scanner.pop(); 
-      HandleNode(eventHandler); 
-    } else { 
-      eventHandler.OnNull(token.mark, NullAnchor); 
-    } 
- 
-    // now grab value (optional) 
-    if (!m_scanner.empty() && m_scanner.peek().type == Token::VALUE) { 
-      m_scanner.pop(); 
-      HandleNode(eventHandler); 
-    } else { 
-      eventHandler.OnNull(token.mark, NullAnchor); 
-    } 
-  } 
- 
-  m_pCollectionStack->PopCollectionType(CollectionType::BlockMap); 
-} 
- 
-void SingleDocParser::HandleFlowMap(EventHandler& eventHandler) { 
-  // eat start token 
-  m_scanner.pop(); 
-  m_pCollectionStack->PushCollectionType(CollectionType::FlowMap); 
- 
-  while (1) { 
-    if (m_scanner.empty()) 
-      throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_MAP_FLOW); 
- 
-    Token& token = m_scanner.peek(); 
-    const Mark mark = token.mark; 
-    // first check for end 
-    if (token.type == Token::FLOW_MAP_END) { 
-      m_scanner.pop(); 
-      break; 
-    } 
- 
-    // grab key (if non-null) 
-    if (token.type == Token::KEY) { 
-      m_scanner.pop(); 
-      HandleNode(eventHandler); 
-    } else { 
-      eventHandler.OnNull(mark, NullAnchor); 
-    } 
- 
-    // now grab value (optional) 
-    if (!m_scanner.empty() && m_scanner.peek().type == Token::VALUE) { 
-      m_scanner.pop(); 
-      HandleNode(eventHandler); 
-    } else { 
-      eventHandler.OnNull(mark, NullAnchor); 
-    } 
- 
-    if (m_scanner.empty()) 
-      throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_MAP_FLOW); 
- 
-    // now eat the separator (or could be a map end, which we ignore - but if 
-    // it's neither, then it's a bad node) 
-    Token& nextToken = m_scanner.peek(); 
-    if (nextToken.type == Token::FLOW_ENTRY) 
-      m_scanner.pop(); 
-    else if (nextToken.type != Token::FLOW_MAP_END) 
-      throw ParserException(nextToken.mark, ErrorMsg::END_OF_MAP_FLOW); 
-  } 
- 
-  m_pCollectionStack->PopCollectionType(CollectionType::FlowMap); 
-} 
- 
-// . Single "key: value" pair in a flow sequence 
-void SingleDocParser::HandleCompactMap(EventHandler& eventHandler) { 
-  m_pCollectionStack->PushCollectionType(CollectionType::CompactMap); 
- 
-  // grab key 
-  Mark mark = m_scanner.peek().mark; 
-  m_scanner.pop(); 
-  HandleNode(eventHandler); 
- 
-  // now grab value (optional) 
-  if (!m_scanner.empty() && m_scanner.peek().type == Token::VALUE) { 
-    m_scanner.pop(); 
-    HandleNode(eventHandler); 
-  } else { 
-    eventHandler.OnNull(mark, NullAnchor); 
-  } 
- 
-  m_pCollectionStack->PopCollectionType(CollectionType::CompactMap); 
-} 
- 
-// . Single ": value" pair in a flow sequence 
-void SingleDocParser::HandleCompactMapWithNoKey(EventHandler& eventHandler) { 
-  m_pCollectionStack->PushCollectionType(CollectionType::CompactMap); 
- 
-  // null key 
-  eventHandler.OnNull(m_scanner.peek().mark, NullAnchor); 
- 
-  // grab value 
-  m_scanner.pop(); 
-  HandleNode(eventHandler); 
- 
-  m_pCollectionStack->PopCollectionType(CollectionType::CompactMap); 
-} 
- 
-// ParseProperties 
-// . Grabs any tag or anchor tokens and deals with them. 
-void SingleDocParser::ParseProperties(std::string& tag, anchor_t& anchor) { 
-  tag.clear(); 
-  anchor = NullAnchor; 
- 
-  while (1) { 
-    if (m_scanner.empty()) 
-      return; 
- 
-    switch (m_scanner.peek().type) { 
-      case Token::TAG: 
-        ParseTag(tag); 
-        break; 
-      case Token::ANCHOR: 
-        ParseAnchor(anchor); 
-        break; 
-      default: 
-        return; 
-    } 
-  } 
-} 
- 
-void SingleDocParser::ParseTag(std::string& tag) { 
-  Token& token = m_scanner.peek(); 
-  if (!tag.empty()) 
-    throw ParserException(token.mark, ErrorMsg::MULTIPLE_TAGS); 
- 
-  Tag tagInfo(token); 
-  tag = tagInfo.Translate(m_directives); 
-  m_scanner.pop(); 
-} 
- 
-void SingleDocParser::ParseAnchor(anchor_t& anchor) { 
-  Token& token = m_scanner.peek(); 
-  if (anchor) 
-    throw ParserException(token.mark, ErrorMsg::MULTIPLE_ANCHORS); 
- 
-  anchor = RegisterAnchor(token.value); 
-  m_scanner.pop(); 
-} 
- 
-anchor_t SingleDocParser::RegisterAnchor(const std::string& name) { 
-  if (name.empty()) 
-    return NullAnchor; 
- 
-  return m_anchors[name] = ++m_curAnchor; 
-} 
- 
-anchor_t SingleDocParser::LookupAnchor(const Mark& mark, 
-                                       const std::string& name) const { 
-  Anchors::const_iterator it = m_anchors.find(name); 
-  if (it == m_anchors.end()) 
-    throw ParserException(mark, ErrorMsg::UNKNOWN_ANCHOR); 
- 
-  return it->second; 
-} 
-} 
+    eventHandler.OnNull(mark, anchor);
+    m_scanner.pop();
+    return;
+  }
+
+  // add non-specific tags
+  if (tag.empty())
+    tag = (token.type == Token::NON_PLAIN_SCALAR ? "!" : "?");
+
+  // now split based on what kind of node we should be
+  switch (token.type) {
+    case Token::PLAIN_SCALAR:
+    case Token::NON_PLAIN_SCALAR:
+      eventHandler.OnScalar(mark, tag, anchor, token.value);
+      m_scanner.pop();
+      return;
+    case Token::FLOW_SEQ_START:
+      eventHandler.OnSequenceStart(mark, tag, anchor, EmitterStyle::Flow);
+      HandleSequence(eventHandler);
+      eventHandler.OnSequenceEnd();
+      return;
+    case Token::BLOCK_SEQ_START:
+      eventHandler.OnSequenceStart(mark, tag, anchor, EmitterStyle::Block);
+      HandleSequence(eventHandler);
+      eventHandler.OnSequenceEnd();
+      return;
+    case Token::FLOW_MAP_START:
+      eventHandler.OnMapStart(mark, tag, anchor, EmitterStyle::Flow);
+      HandleMap(eventHandler);
+      eventHandler.OnMapEnd();
+      return;
+    case Token::BLOCK_MAP_START:
+      eventHandler.OnMapStart(mark, tag, anchor, EmitterStyle::Block);
+      HandleMap(eventHandler);
+      eventHandler.OnMapEnd();
+      return;
+    case Token::KEY:
+      // compact maps can only go in a flow sequence
+      if (m_pCollectionStack->GetCurCollectionType() ==
+          CollectionType::FlowSeq) {
+        eventHandler.OnMapStart(mark, tag, anchor, EmitterStyle::Flow);
+        HandleMap(eventHandler);
+        eventHandler.OnMapEnd();
+        return;
+      }
+      break;
+    default:
+      break;
+  }
+
+  if (tag == "?")
+    eventHandler.OnNull(mark, anchor);
+  else
+    eventHandler.OnScalar(mark, tag, anchor, "");
+}
+
+void SingleDocParser::HandleSequence(EventHandler& eventHandler) {
+  // split based on start token
+  switch (m_scanner.peek().type) {
+    case Token::BLOCK_SEQ_START:
+      HandleBlockSequence(eventHandler);
+      break;
+    case Token::FLOW_SEQ_START:
+      HandleFlowSequence(eventHandler);
+      break;
+    default:
+      break;
+  }
+}
+
+void SingleDocParser::HandleBlockSequence(EventHandler& eventHandler) {
+  // eat start token
+  m_scanner.pop();
+  m_pCollectionStack->PushCollectionType(CollectionType::BlockSeq);
+
+  while (1) {
+    if (m_scanner.empty())
+      throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_SEQ);
+
+    Token token = m_scanner.peek();
+    if (token.type != Token::BLOCK_ENTRY && token.type != Token::BLOCK_SEQ_END)
+      throw ParserException(token.mark, ErrorMsg::END_OF_SEQ);
+
+    m_scanner.pop();
+    if (token.type == Token::BLOCK_SEQ_END)
+      break;
+
+    // check for null
+    if (!m_scanner.empty()) {
+      const Token& token = m_scanner.peek();
+      if (token.type == Token::BLOCK_ENTRY ||
+          token.type == Token::BLOCK_SEQ_END) {
+        eventHandler.OnNull(token.mark, NullAnchor);
+        continue;
+      }
+    }
+
+    HandleNode(eventHandler);
+  }
+
+  m_pCollectionStack->PopCollectionType(CollectionType::BlockSeq);
+}
+
+void SingleDocParser::HandleFlowSequence(EventHandler& eventHandler) {
+  // eat start token
+  m_scanner.pop();
+  m_pCollectionStack->PushCollectionType(CollectionType::FlowSeq);
+
+  while (1) {
+    if (m_scanner.empty())
+      throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_SEQ_FLOW);
+
+    // first check for end
+    if (m_scanner.peek().type == Token::FLOW_SEQ_END) {
+      m_scanner.pop();
+      break;
+    }
+
+    // then read the node
+    HandleNode(eventHandler);
+
+    if (m_scanner.empty())
+      throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_SEQ_FLOW);
+
+    // now eat the separator (or could be a sequence end, which we ignore - but
+    // if it's neither, then it's a bad node)
+    Token& token = m_scanner.peek();
+    if (token.type == Token::FLOW_ENTRY)
+      m_scanner.pop();
+    else if (token.type != Token::FLOW_SEQ_END)
+      throw ParserException(token.mark, ErrorMsg::END_OF_SEQ_FLOW);
+  }
+
+  m_pCollectionStack->PopCollectionType(CollectionType::FlowSeq);
+}
+
+void SingleDocParser::HandleMap(EventHandler& eventHandler) {
+  // split based on start token
+  switch (m_scanner.peek().type) {
+    case Token::BLOCK_MAP_START:
+      HandleBlockMap(eventHandler);
+      break;
+    case Token::FLOW_MAP_START:
+      HandleFlowMap(eventHandler);
+      break;
+    case Token::KEY:
+      HandleCompactMap(eventHandler);
+      break;
+    case Token::VALUE:
+      HandleCompactMapWithNoKey(eventHandler);
+      break;
+    default:
+      break;
+  }
+}
+
+void SingleDocParser::HandleBlockMap(EventHandler& eventHandler) {
+  // eat start token
+  m_scanner.pop();
+  m_pCollectionStack->PushCollectionType(CollectionType::BlockMap);
+
+  while (1) {
+    if (m_scanner.empty())
+      throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_MAP);
+
+    Token token = m_scanner.peek();
+    if (token.type != Token::KEY && token.type != Token::VALUE &&
+        token.type != Token::BLOCK_MAP_END)
+      throw ParserException(token.mark, ErrorMsg::END_OF_MAP);
+
+    if (token.type == Token::BLOCK_MAP_END) {
+      m_scanner.pop();
+      break;
+    }
+
+    // grab key (if non-null)
+    if (token.type == Token::KEY) {
+      m_scanner.pop();
+      HandleNode(eventHandler);
+    } else {
+      eventHandler.OnNull(token.mark, NullAnchor);
+    }
+
+    // now grab value (optional)
+    if (!m_scanner.empty() && m_scanner.peek().type == Token::VALUE) {
+      m_scanner.pop();
+      HandleNode(eventHandler);
+    } else {
+      eventHandler.OnNull(token.mark, NullAnchor);
+    }
+  }
+
+  m_pCollectionStack->PopCollectionType(CollectionType::BlockMap);
+}
+
+void SingleDocParser::HandleFlowMap(EventHandler& eventHandler) {
+  // eat start token
+  m_scanner.pop();
+  m_pCollectionStack->PushCollectionType(CollectionType::FlowMap);
+
+  while (1) {
+    if (m_scanner.empty())
+      throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_MAP_FLOW);
+
+    Token& token = m_scanner.peek();
+    const Mark mark = token.mark;
+    // first check for end
+    if (token.type == Token::FLOW_MAP_END) {
+      m_scanner.pop();
+      break;
+    }
+
+    // grab key (if non-null)
+    if (token.type == Token::KEY) {
+      m_scanner.pop();
+      HandleNode(eventHandler);
+    } else {
+      eventHandler.OnNull(mark, NullAnchor);
+    }
+
+    // now grab value (optional)
+    if (!m_scanner.empty() && m_scanner.peek().type == Token::VALUE) {
+      m_scanner.pop();
+      HandleNode(eventHandler);
+    } else {
+      eventHandler.OnNull(mark, NullAnchor);
+    }
+
+    if (m_scanner.empty())
+      throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_MAP_FLOW);
+
+    // now eat the separator (or could be a map end, which we ignore - but if
+    // it's neither, then it's a bad node)
+    Token& nextToken = m_scanner.peek();
+    if (nextToken.type == Token::FLOW_ENTRY)
+      m_scanner.pop();
+    else if (nextToken.type != Token::FLOW_MAP_END)
+      throw ParserException(nextToken.mark, ErrorMsg::END_OF_MAP_FLOW);
+  }
+
+  m_pCollectionStack->PopCollectionType(CollectionType::FlowMap);
+}
+
+// . Single "key: value" pair in a flow sequence
+void SingleDocParser::HandleCompactMap(EventHandler& eventHandler) {
+  m_pCollectionStack->PushCollectionType(CollectionType::CompactMap);
+
+  // grab key
+  Mark mark = m_scanner.peek().mark;
+  m_scanner.pop();
+  HandleNode(eventHandler);
+
+  // now grab value (optional)
+  if (!m_scanner.empty() && m_scanner.peek().type == Token::VALUE) {
+    m_scanner.pop();
+    HandleNode(eventHandler);
+  } else {
+    eventHandler.OnNull(mark, NullAnchor);
+  }
+
+  m_pCollectionStack->PopCollectionType(CollectionType::CompactMap);
+}
+
+// . Single ": value" pair in a flow sequence
+void SingleDocParser::HandleCompactMapWithNoKey(EventHandler& eventHandler) {
+  m_pCollectionStack->PushCollectionType(CollectionType::CompactMap);
+
+  // null key
+  eventHandler.OnNull(m_scanner.peek().mark, NullAnchor);
+
+  // grab value
+  m_scanner.pop();
+  HandleNode(eventHandler);
+
+  m_pCollectionStack->PopCollectionType(CollectionType::CompactMap);
+}
+
+// ParseProperties
+// . Grabs any tag or anchor tokens and deals with them.
+void SingleDocParser::ParseProperties(std::string& tag, anchor_t& anchor) {
+  tag.clear();
+  anchor = NullAnchor;
+
+  while (1) {
+    if (m_scanner.empty())
+      return;
+
+    switch (m_scanner.peek().type) {
+      case Token::TAG:
+        ParseTag(tag);
+        break;
+      case Token::ANCHOR:
+        ParseAnchor(anchor);
+        break;
+      default:
+        return;
+    }
+  }
+}
+
+void SingleDocParser::ParseTag(std::string& tag) {
+  Token& token = m_scanner.peek();
+  if (!tag.empty())
+    throw ParserException(token.mark, ErrorMsg::MULTIPLE_TAGS);
+
+  Tag tagInfo(token);
+  tag = tagInfo.Translate(m_directives);
+  m_scanner.pop();
+}
+
+void SingleDocParser::ParseAnchor(anchor_t& anchor) {
+  Token& token = m_scanner.peek();
+  if (anchor)
+    throw ParserException(token.mark, ErrorMsg::MULTIPLE_ANCHORS);
+
+  anchor = RegisterAnchor(token.value);
+  m_scanner.pop();
+}
+
+anchor_t SingleDocParser::RegisterAnchor(const std::string& name) {
+  if (name.empty())
+    return NullAnchor;
+
+  return m_anchors[name] = ++m_curAnchor;
+}
+
+anchor_t SingleDocParser::LookupAnchor(const Mark& mark,
+                                       const std::string& name) const {
+  Anchors::const_iterator it = m_anchors.find(name);
+  if (it == m_anchors.end())
+    throw ParserException(mark, ErrorMsg::UNKNOWN_ANCHOR);
+
+  return it->second;
+}
+}
diff --git a/contrib/libs/yaml-cpp/src/singledocparser.h b/contrib/libs/yaml-cpp/src/singledocparser.h
index 7f480d9b457..2b92067cddb 100644
--- a/contrib/libs/yaml-cpp/src/singledocparser.h
+++ b/contrib/libs/yaml-cpp/src/singledocparser.h
@@ -1,65 +1,65 @@
-#ifndef SINGLEDOCPARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define SINGLEDOCPARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include <map> 
-#include <memory> 
-#include <string> 
- 
-#include "yaml-cpp/anchor.h" 
-#include "yaml-cpp/noncopyable.h" 
- 
-namespace YAML { 
-class CollectionStack; 
-class EventHandler; 
-class Node; 
-class Scanner; 
-struct Directives; 
-struct Mark; 
-struct Token; 
- 
-class SingleDocParser : private noncopyable { 
- public: 
-  SingleDocParser(Scanner& scanner, const Directives& directives); 
-  ~SingleDocParser(); 
- 
-  void HandleDocument(EventHandler& eventHandler); 
- 
- private: 
-  void HandleNode(EventHandler& eventHandler); 
- 
-  void HandleSequence(EventHandler& eventHandler); 
-  void HandleBlockSequence(EventHandler& eventHandler); 
-  void HandleFlowSequence(EventHandler& eventHandler); 
- 
-  void HandleMap(EventHandler& eventHandler); 
-  void HandleBlockMap(EventHandler& eventHandler); 
-  void HandleFlowMap(EventHandler& eventHandler); 
-  void HandleCompactMap(EventHandler& eventHandler); 
-  void HandleCompactMapWithNoKey(EventHandler& eventHandler); 
- 
-  void ParseProperties(std::string& tag, anchor_t& anchor); 
-  void ParseTag(std::string& tag); 
-  void ParseAnchor(anchor_t& anchor); 
- 
-  anchor_t RegisterAnchor(const std::string& name); 
-  anchor_t LookupAnchor(const Mark& mark, const std::string& name) const; 
- 
- private: 
-  Scanner& m_scanner; 
-  const Directives& m_directives; 
+#ifndef SINGLEDOCPARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define SINGLEDOCPARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <map>
+#include <memory>
+#include <string>
+
+#include "yaml-cpp/anchor.h"
+#include "yaml-cpp/noncopyable.h"
+
+namespace YAML {
+class CollectionStack;
+class EventHandler;
+class Node;
+class Scanner;
+struct Directives;
+struct Mark;
+struct Token;
+
+class SingleDocParser : private noncopyable {
+ public:
+  SingleDocParser(Scanner& scanner, const Directives& directives);
+  ~SingleDocParser();
+
+  void HandleDocument(EventHandler& eventHandler);
+
+ private:
+  void HandleNode(EventHandler& eventHandler);
+
+  void HandleSequence(EventHandler& eventHandler);
+  void HandleBlockSequence(EventHandler& eventHandler);
+  void HandleFlowSequence(EventHandler& eventHandler);
+
+  void HandleMap(EventHandler& eventHandler);
+  void HandleBlockMap(EventHandler& eventHandler);
+  void HandleFlowMap(EventHandler& eventHandler);
+  void HandleCompactMap(EventHandler& eventHandler);
+  void HandleCompactMapWithNoKey(EventHandler& eventHandler);
+
+  void ParseProperties(std::string& tag, anchor_t& anchor);
+  void ParseTag(std::string& tag);
+  void ParseAnchor(anchor_t& anchor);
+
+  anchor_t RegisterAnchor(const std::string& name);
+  anchor_t LookupAnchor(const Mark& mark, const std::string& name) const;
+
+ private:
+  Scanner& m_scanner;
+  const Directives& m_directives;
   std::unique_ptr<CollectionStack> m_pCollectionStack;
- 
-  typedef std::map<std::string, anchor_t> Anchors; 
-  Anchors m_anchors; 
- 
-  anchor_t m_curAnchor; 
-}; 
-} 
- 
-#endif  // SINGLEDOCPARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+
+  typedef std::map<std::string, anchor_t> Anchors;
+  Anchors m_anchors;
+
+  anchor_t m_curAnchor;
+};
+}
+
+#endif  // SINGLEDOCPARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/src/stream.cpp b/contrib/libs/yaml-cpp/src/stream.cpp
index 070eda1ad9b..3b013cfa7d3 100644
--- a/contrib/libs/yaml-cpp/src/stream.cpp
+++ b/contrib/libs/yaml-cpp/src/stream.cpp
@@ -1,448 +1,448 @@
-#include <iostream> 
- 
-#include "stream.h" 
- 
-#ifndef YAML_PREFETCH_SIZE 
-#define YAML_PREFETCH_SIZE 2048 
-#endif 
- 
-#define S_ARRAY_SIZE(A) (sizeof(A) / sizeof(*(A))) 
-#define S_ARRAY_END(A) ((A) + S_ARRAY_SIZE(A)) 
- 
-#define CP_REPLACEMENT_CHARACTER (0xFFFD) 
- 
-namespace YAML { 
-enum UtfIntroState { 
-  uis_start, 
-  uis_utfbe_b1, 
-  uis_utf32be_b2, 
-  uis_utf32be_bom3, 
-  uis_utf32be, 
-  uis_utf16be, 
-  uis_utf16be_bom1, 
-  uis_utfle_bom1, 
-  uis_utf16le_bom2, 
-  uis_utf32le_bom3, 
-  uis_utf16le, 
-  uis_utf32le, 
-  uis_utf8_imp, 
-  uis_utf16le_imp, 
-  uis_utf32le_imp3, 
-  uis_utf8_bom1, 
-  uis_utf8_bom2, 
-  uis_utf8, 
-  uis_error 
-}; 
- 
-enum UtfIntroCharType { 
-  uict00, 
-  uictBB, 
-  uictBF, 
-  uictEF, 
-  uictFE, 
-  uictFF, 
-  uictAscii, 
-  uictOther, 
-  uictMax 
-}; 
- 
-static bool s_introFinalState[] = { 
-    false,  // uis_start 
-    false,  // uis_utfbe_b1 
-    false,  // uis_utf32be_b2 
-    false,  // uis_utf32be_bom3 
-    true,   // uis_utf32be 
-    true,   // uis_utf16be 
-    false,  // uis_utf16be_bom1 
-    false,  // uis_utfle_bom1 
-    false,  // uis_utf16le_bom2 
-    false,  // uis_utf32le_bom3 
-    true,   // uis_utf16le 
-    true,   // uis_utf32le 
-    false,  // uis_utf8_imp 
-    false,  // uis_utf16le_imp 
-    false,  // uis_utf32le_imp3 
-    false,  // uis_utf8_bom1 
-    false,  // uis_utf8_bom2 
-    true,   // uis_utf8 
-    true,   // uis_error 
-}; 
- 
-static UtfIntroState s_introTransitions[][uictMax] = { 
-    // uict00,           uictBB,           uictBF,           uictEF, 
-    // uictFE,           uictFF,           uictAscii,        uictOther 
-    {uis_utfbe_b1, uis_utf8, uis_utf8, uis_utf8_bom1, uis_utf16be_bom1, 
-     uis_utfle_bom1, uis_utf8_imp, uis_utf8}, 
-    {uis_utf32be_b2, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, 
-     uis_utf16be, uis_utf8}, 
-    {uis_utf32be, uis_utf8, uis_utf8, uis_utf8, uis_utf32be_bom3, uis_utf8, 
-     uis_utf8, uis_utf8}, 
-    {uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf32be, uis_utf8, 
-     uis_utf8}, 
-    {uis_utf32be, uis_utf32be, uis_utf32be, uis_utf32be, uis_utf32be, 
-     uis_utf32be, uis_utf32be, uis_utf32be}, 
-    {uis_utf16be, uis_utf16be, uis_utf16be, uis_utf16be, uis_utf16be, 
-     uis_utf16be, uis_utf16be, uis_utf16be}, 
-    {uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf16be, uis_utf8, 
-     uis_utf8}, 
-    {uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf16le_bom2, uis_utf8, 
-     uis_utf8, uis_utf8}, 
-    {uis_utf32le_bom3, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le, 
-     uis_utf16le, uis_utf16le, uis_utf16le}, 
-    {uis_utf32le, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le, 
-     uis_utf16le, uis_utf16le, uis_utf16le}, 
-    {uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le, 
-     uis_utf16le, uis_utf16le, uis_utf16le}, 
-    {uis_utf32le, uis_utf32le, uis_utf32le, uis_utf32le, uis_utf32le, 
-     uis_utf32le, uis_utf32le, uis_utf32le}, 
-    {uis_utf16le_imp, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, 
-     uis_utf8, uis_utf8}, 
-    {uis_utf32le_imp3, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le, 
-     uis_utf16le, uis_utf16le, uis_utf16le}, 
-    {uis_utf32le, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le, 
-     uis_utf16le, uis_utf16le, uis_utf16le}, 
-    {uis_utf8, uis_utf8_bom2, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, 
-     uis_utf8}, 
-    {uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, 
-     uis_utf8}, 
-    {uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, 
-     uis_utf8}, 
-}; 
- 
-static char s_introUngetCount[][uictMax] = { 
-    // uict00, uictBB, uictBF, uictEF, uictFE, uictFF, uictAscii, uictOther 
-    {0, 1, 1, 0, 0, 0, 0, 1}, 
-    {0, 2, 2, 2, 2, 2, 2, 2}, 
-    {3, 3, 3, 3, 0, 3, 3, 3}, 
-    {4, 4, 4, 4, 4, 0, 4, 4}, 
-    {1, 1, 1, 1, 1, 1, 1, 1}, 
-    {1, 1, 1, 1, 1, 1, 1, 1}, 
-    {2, 2, 2, 2, 2, 0, 2, 2}, 
-    {2, 2, 2, 2, 0, 2, 2, 2}, 
-    {0, 1, 1, 1, 1, 1, 1, 1}, 
-    {0, 2, 2, 2, 2, 2, 2, 2}, 
-    {1, 1, 1, 1, 1, 1, 1, 1}, 
-    {1, 1, 1, 1, 1, 1, 1, 1}, 
-    {0, 2, 2, 2, 2, 2, 2, 2}, 
-    {0, 3, 3, 3, 3, 3, 3, 3}, 
-    {4, 4, 4, 4, 4, 4, 4, 4}, 
-    {2, 0, 2, 2, 2, 2, 2, 2}, 
-    {3, 3, 0, 3, 3, 3, 3, 3}, 
-    {1, 1, 1, 1, 1, 1, 1, 1}, 
-}; 
- 
-inline UtfIntroCharType IntroCharTypeOf(std::istream::int_type ch) { 
-  if (std::istream::traits_type::eof() == ch) { 
-    return uictOther; 
-  } 
- 
-  switch (ch) { 
-    case 0: 
-      return uict00; 
-    case 0xBB: 
-      return uictBB; 
-    case 0xBF: 
-      return uictBF; 
-    case 0xEF: 
-      return uictEF; 
-    case 0xFE: 
-      return uictFE; 
-    case 0xFF: 
-      return uictFF; 
-  } 
- 
-  if ((ch > 0) && (ch < 0xFF)) { 
-    return uictAscii; 
-  } 
- 
-  return uictOther; 
-} 
- 
-inline char Utf8Adjust(unsigned long ch, unsigned char lead_bits, 
-                       unsigned char rshift) { 
-  const unsigned char header = ((1 << lead_bits) - 1) << (8 - lead_bits); 
-  const unsigned char mask = (0xFF >> (lead_bits + 1)); 
-  return static_cast<char>( 
-      static_cast<unsigned char>(header | ((ch >> rshift) & mask))); 
-} 
- 
-inline void QueueUnicodeCodepoint(std::deque<char>& q, unsigned long ch) { 
-  // We are not allowed to queue the Stream::eof() codepoint, so 
-  // replace it with CP_REPLACEMENT_CHARACTER 
-  if (static_cast<unsigned long>(Stream::eof()) == ch) { 
-    ch = CP_REPLACEMENT_CHARACTER; 
-  } 
- 
-  if (ch < 0x80) { 
-    q.push_back(Utf8Adjust(ch, 0, 0)); 
-  } else if (ch < 0x800) { 
-    q.push_back(Utf8Adjust(ch, 2, 6)); 
-    q.push_back(Utf8Adjust(ch, 1, 0)); 
-  } else if (ch < 0x10000) { 
-    q.push_back(Utf8Adjust(ch, 3, 12)); 
-    q.push_back(Utf8Adjust(ch, 1, 6)); 
-    q.push_back(Utf8Adjust(ch, 1, 0)); 
-  } else { 
-    q.push_back(Utf8Adjust(ch, 4, 18)); 
-    q.push_back(Utf8Adjust(ch, 1, 12)); 
-    q.push_back(Utf8Adjust(ch, 1, 6)); 
-    q.push_back(Utf8Adjust(ch, 1, 0)); 
-  } 
-} 
- 
-Stream::Stream(std::istream& input) 
-    : m_input(input), 
-      m_pPrefetched(new unsigned char[YAML_PREFETCH_SIZE]), 
-      m_nPrefetchedAvailable(0), 
-      m_nPrefetchedUsed(0) { 
-  typedef std::istream::traits_type char_traits; 
- 
-  if (!input) 
-    return; 
- 
-  // Determine (or guess) the character-set by reading the BOM, if any.  See 
-  // the YAML specification for the determination algorithm. 
-  char_traits::int_type intro[4]; 
-  int nIntroUsed = 0; 
-  UtfIntroState state = uis_start; 
-  for (; !s_introFinalState[state];) { 
-    std::istream::int_type ch = input.get(); 
-    intro[nIntroUsed++] = ch; 
-    UtfIntroCharType charType = IntroCharTypeOf(ch); 
-    UtfIntroState newState = s_introTransitions[state][charType]; 
-    int nUngets = s_introUngetCount[state][charType]; 
-    if (nUngets > 0) { 
-      input.clear(); 
-      for (; nUngets > 0; --nUngets) { 
-        if (char_traits::eof() != intro[--nIntroUsed]) 
-          input.putback(char_traits::to_char_type(intro[nIntroUsed])); 
-      } 
-    } 
-    state = newState; 
-  } 
- 
-  switch (state) { 
-    case uis_utf8: 
-      m_charSet = utf8; 
-      break; 
-    case uis_utf16le: 
-      m_charSet = utf16le; 
-      break; 
-    case uis_utf16be: 
-      m_charSet = utf16be; 
-      break; 
-    case uis_utf32le: 
-      m_charSet = utf32le; 
-      break; 
-    case uis_utf32be: 
-      m_charSet = utf32be; 
-      break; 
-    default: 
-      m_charSet = utf8; 
-      break; 
-  } 
- 
-  ReadAheadTo(0); 
-} 
- 
-Stream::~Stream() { delete[] m_pPrefetched; } 
- 
-char Stream::peek() const { 
-  if (m_readahead.empty()) { 
-    return Stream::eof(); 
-  } 
- 
-  return m_readahead[0]; 
-} 
- 
-Stream::operator bool() const { 
-  return m_input.good() || 
-         (!m_readahead.empty() && m_readahead[0] != Stream::eof()); 
-} 
- 
-// get 
-// . Extracts a character from the stream and updates our position 
-char Stream::get() { 
-  char ch = peek(); 
-  AdvanceCurrent(); 
-  m_mark.column++; 
- 
-  if (ch == '\n') { 
-    m_mark.column = 0; 
-    m_mark.line++; 
-  } 
- 
-  return ch; 
-} 
- 
-// get 
-// . Extracts 'n' characters from the stream and updates our position 
-std::string Stream::get(int n) { 
-  std::string ret; 
-  ret.reserve(n); 
-  for (int i = 0; i < n; i++) 
-    ret += get(); 
-  return ret; 
-} 
- 
-// eat 
-// . Eats 'n' characters and updates our position. 
-void Stream::eat(int n) { 
-  for (int i = 0; i < n; i++) 
-    get(); 
-} 
- 
-void Stream::AdvanceCurrent() { 
-  if (!m_readahead.empty()) { 
-    m_readahead.pop_front(); 
-    m_mark.pos++; 
-  } 
- 
-  ReadAheadTo(0); 
-} 
- 
-bool Stream::_ReadAheadTo(size_t i) const { 
-  while (m_input.good() && (m_readahead.size() <= i)) { 
-    switch (m_charSet) { 
-      case utf8: 
-        StreamInUtf8(); 
-        break; 
-      case utf16le: 
-        StreamInUtf16(); 
-        break; 
-      case utf16be: 
-        StreamInUtf16(); 
-        break; 
-      case utf32le: 
-        StreamInUtf32(); 
-        break; 
-      case utf32be: 
-        StreamInUtf32(); 
-        break; 
-    } 
-  } 
- 
-  // signal end of stream 
-  if (!m_input.good()) 
-    m_readahead.push_back(Stream::eof()); 
- 
-  return m_readahead.size() > i; 
-} 
- 
-void Stream::StreamInUtf8() const { 
-  unsigned char b = GetNextByte(); 
-  if (m_input.good()) { 
-    m_readahead.push_back(b); 
-  } 
-} 
- 
-void Stream::StreamInUtf16() const { 
-  unsigned long ch = 0; 
-  unsigned char bytes[2]; 
-  int nBigEnd = (m_charSet == utf16be) ? 0 : 1; 
- 
-  bytes[0] = GetNextByte(); 
-  bytes[1] = GetNextByte(); 
-  if (!m_input.good()) { 
-    return; 
-  } 
-  ch = (static_cast<unsigned long>(bytes[nBigEnd]) << 8) | 
-       static_cast<unsigned long>(bytes[1 ^ nBigEnd]); 
- 
-  if (ch >= 0xDC00 && ch < 0xE000) { 
-    // Trailing (low) surrogate...ugh, wrong order 
-    QueueUnicodeCodepoint(m_readahead, CP_REPLACEMENT_CHARACTER); 
-    return; 
-  } else if (ch >= 0xD800 && ch < 0xDC00) { 
-    // ch is a leading (high) surrogate 
- 
-    // Four byte UTF-8 code point 
- 
-    // Read the trailing (low) surrogate 
-    for (;;) { 
-      bytes[0] = GetNextByte(); 
-      bytes[1] = GetNextByte(); 
-      if (!m_input.good()) { 
-        QueueUnicodeCodepoint(m_readahead, CP_REPLACEMENT_CHARACTER); 
-        return; 
-      } 
-      unsigned long chLow = (static_cast<unsigned long>(bytes[nBigEnd]) << 8) | 
-                            static_cast<unsigned long>(bytes[1 ^ nBigEnd]); 
-      if (chLow < 0xDC00 || chLow >= 0xE000) { 
-        // Trouble...not a low surrogate.  Dump a REPLACEMENT CHARACTER into the 
-        // stream. 
-        QueueUnicodeCodepoint(m_readahead, CP_REPLACEMENT_CHARACTER); 
- 
-        // Deal with the next UTF-16 unit 
-        if (chLow < 0xD800 || chLow >= 0xE000) { 
-          // Easiest case: queue the codepoint and return 
-          QueueUnicodeCodepoint(m_readahead, ch); 
-          return; 
-        } else { 
-          // Start the loop over with the new high surrogate 
-          ch = chLow; 
-          continue; 
-        } 
-      } 
- 
-      // Select the payload bits from the high surrogate 
-      ch &= 0x3FF; 
-      ch <<= 10; 
- 
-      // Include bits from low surrogate 
-      ch |= (chLow & 0x3FF); 
- 
-      // Add the surrogacy offset 
-      ch += 0x10000; 
-      break; 
-    } 
-  } 
- 
-  QueueUnicodeCodepoint(m_readahead, ch); 
-} 
- 
-inline char* ReadBuffer(unsigned char* pBuffer) { 
-  return reinterpret_cast<char*>(pBuffer); 
-} 
- 
-unsigned char Stream::GetNextByte() const { 
-  if (m_nPrefetchedUsed >= m_nPrefetchedAvailable) { 
-    std::streambuf* pBuf = m_input.rdbuf(); 
-    m_nPrefetchedAvailable = static_cast<std::size_t>( 
-        pBuf->sgetn(ReadBuffer(m_pPrefetched), YAML_PREFETCH_SIZE)); 
-    m_nPrefetchedUsed = 0; 
-    if (!m_nPrefetchedAvailable) { 
-      m_input.setstate(std::ios_base::eofbit); 
-    } 
- 
-    if (0 == m_nPrefetchedAvailable) { 
-      return 0; 
-    } 
-  } 
- 
-  return m_pPrefetched[m_nPrefetchedUsed++]; 
-} 
- 
-void Stream::StreamInUtf32() const { 
-  static int indexes[2][4] = {{3, 2, 1, 0}, {0, 1, 2, 3}}; 
- 
-  unsigned long ch = 0; 
-  unsigned char bytes[4]; 
-  int* pIndexes = (m_charSet == utf32be) ? indexes[1] : indexes[0]; 
- 
-  bytes[0] = GetNextByte(); 
-  bytes[1] = GetNextByte(); 
-  bytes[2] = GetNextByte(); 
-  bytes[3] = GetNextByte(); 
-  if (!m_input.good()) { 
-    return; 
-  } 
- 
-  for (int i = 0; i < 4; ++i) { 
-    ch <<= 8; 
-    ch |= bytes[pIndexes[i]]; 
-  } 
- 
-  QueueUnicodeCodepoint(m_readahead, ch); 
-} 
-} 
+#include <iostream>
+
+#include "stream.h"
+
+#ifndef YAML_PREFETCH_SIZE
+#define YAML_PREFETCH_SIZE 2048
+#endif
+
+#define S_ARRAY_SIZE(A) (sizeof(A) / sizeof(*(A)))
+#define S_ARRAY_END(A) ((A) + S_ARRAY_SIZE(A))
+
+#define CP_REPLACEMENT_CHARACTER (0xFFFD)
+
+namespace YAML {
+enum UtfIntroState {
+  uis_start,
+  uis_utfbe_b1,
+  uis_utf32be_b2,
+  uis_utf32be_bom3,
+  uis_utf32be,
+  uis_utf16be,
+  uis_utf16be_bom1,
+  uis_utfle_bom1,
+  uis_utf16le_bom2,
+  uis_utf32le_bom3,
+  uis_utf16le,
+  uis_utf32le,
+  uis_utf8_imp,
+  uis_utf16le_imp,
+  uis_utf32le_imp3,
+  uis_utf8_bom1,
+  uis_utf8_bom2,
+  uis_utf8,
+  uis_error
+};
+
+enum UtfIntroCharType {
+  uict00,
+  uictBB,
+  uictBF,
+  uictEF,
+  uictFE,
+  uictFF,
+  uictAscii,
+  uictOther,
+  uictMax
+};
+
+static bool s_introFinalState[] = {
+    false,  // uis_start
+    false,  // uis_utfbe_b1
+    false,  // uis_utf32be_b2
+    false,  // uis_utf32be_bom3
+    true,   // uis_utf32be
+    true,   // uis_utf16be
+    false,  // uis_utf16be_bom1
+    false,  // uis_utfle_bom1
+    false,  // uis_utf16le_bom2
+    false,  // uis_utf32le_bom3
+    true,   // uis_utf16le
+    true,   // uis_utf32le
+    false,  // uis_utf8_imp
+    false,  // uis_utf16le_imp
+    false,  // uis_utf32le_imp3
+    false,  // uis_utf8_bom1
+    false,  // uis_utf8_bom2
+    true,   // uis_utf8
+    true,   // uis_error
+};
+
+static UtfIntroState s_introTransitions[][uictMax] = {
+    // uict00,           uictBB,           uictBF,           uictEF,
+    // uictFE,           uictFF,           uictAscii,        uictOther
+    {uis_utfbe_b1, uis_utf8, uis_utf8, uis_utf8_bom1, uis_utf16be_bom1,
+     uis_utfle_bom1, uis_utf8_imp, uis_utf8},
+    {uis_utf32be_b2, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8,
+     uis_utf16be, uis_utf8},
+    {uis_utf32be, uis_utf8, uis_utf8, uis_utf8, uis_utf32be_bom3, uis_utf8,
+     uis_utf8, uis_utf8},
+    {uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf32be, uis_utf8,
+     uis_utf8},
+    {uis_utf32be, uis_utf32be, uis_utf32be, uis_utf32be, uis_utf32be,
+     uis_utf32be, uis_utf32be, uis_utf32be},
+    {uis_utf16be, uis_utf16be, uis_utf16be, uis_utf16be, uis_utf16be,
+     uis_utf16be, uis_utf16be, uis_utf16be},
+    {uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf16be, uis_utf8,
+     uis_utf8},
+    {uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf16le_bom2, uis_utf8,
+     uis_utf8, uis_utf8},
+    {uis_utf32le_bom3, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le,
+     uis_utf16le, uis_utf16le, uis_utf16le},
+    {uis_utf32le, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le,
+     uis_utf16le, uis_utf16le, uis_utf16le},
+    {uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le,
+     uis_utf16le, uis_utf16le, uis_utf16le},
+    {uis_utf32le, uis_utf32le, uis_utf32le, uis_utf32le, uis_utf32le,
+     uis_utf32le, uis_utf32le, uis_utf32le},
+    {uis_utf16le_imp, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8,
+     uis_utf8, uis_utf8},
+    {uis_utf32le_imp3, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le,
+     uis_utf16le, uis_utf16le, uis_utf16le},
+    {uis_utf32le, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le,
+     uis_utf16le, uis_utf16le, uis_utf16le},
+    {uis_utf8, uis_utf8_bom2, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8,
+     uis_utf8},
+    {uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8,
+     uis_utf8},
+    {uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8,
+     uis_utf8},
+};
+
+static char s_introUngetCount[][uictMax] = {
+    // uict00, uictBB, uictBF, uictEF, uictFE, uictFF, uictAscii, uictOther
+    {0, 1, 1, 0, 0, 0, 0, 1},
+    {0, 2, 2, 2, 2, 2, 2, 2},
+    {3, 3, 3, 3, 0, 3, 3, 3},
+    {4, 4, 4, 4, 4, 0, 4, 4},
+    {1, 1, 1, 1, 1, 1, 1, 1},
+    {1, 1, 1, 1, 1, 1, 1, 1},
+    {2, 2, 2, 2, 2, 0, 2, 2},
+    {2, 2, 2, 2, 0, 2, 2, 2},
+    {0, 1, 1, 1, 1, 1, 1, 1},
+    {0, 2, 2, 2, 2, 2, 2, 2},
+    {1, 1, 1, 1, 1, 1, 1, 1},
+    {1, 1, 1, 1, 1, 1, 1, 1},
+    {0, 2, 2, 2, 2, 2, 2, 2},
+    {0, 3, 3, 3, 3, 3, 3, 3},
+    {4, 4, 4, 4, 4, 4, 4, 4},
+    {2, 0, 2, 2, 2, 2, 2, 2},
+    {3, 3, 0, 3, 3, 3, 3, 3},
+    {1, 1, 1, 1, 1, 1, 1, 1},
+};
+
+inline UtfIntroCharType IntroCharTypeOf(std::istream::int_type ch) {
+  if (std::istream::traits_type::eof() == ch) {
+    return uictOther;
+  }
+
+  switch (ch) {
+    case 0:
+      return uict00;
+    case 0xBB:
+      return uictBB;
+    case 0xBF:
+      return uictBF;
+    case 0xEF:
+      return uictEF;
+    case 0xFE:
+      return uictFE;
+    case 0xFF:
+      return uictFF;
+  }
+
+  if ((ch > 0) && (ch < 0xFF)) {
+    return uictAscii;
+  }
+
+  return uictOther;
+}
+
+inline char Utf8Adjust(unsigned long ch, unsigned char lead_bits,
+                       unsigned char rshift) {
+  const unsigned char header = ((1 << lead_bits) - 1) << (8 - lead_bits);
+  const unsigned char mask = (0xFF >> (lead_bits + 1));
+  return static_cast<char>(
+      static_cast<unsigned char>(header | ((ch >> rshift) & mask)));
+}
+
+inline void QueueUnicodeCodepoint(std::deque<char>& q, unsigned long ch) {
+  // We are not allowed to queue the Stream::eof() codepoint, so
+  // replace it with CP_REPLACEMENT_CHARACTER
+  if (static_cast<unsigned long>(Stream::eof()) == ch) {
+    ch = CP_REPLACEMENT_CHARACTER;
+  }
+
+  if (ch < 0x80) {
+    q.push_back(Utf8Adjust(ch, 0, 0));
+  } else if (ch < 0x800) {
+    q.push_back(Utf8Adjust(ch, 2, 6));
+    q.push_back(Utf8Adjust(ch, 1, 0));
+  } else if (ch < 0x10000) {
+    q.push_back(Utf8Adjust(ch, 3, 12));
+    q.push_back(Utf8Adjust(ch, 1, 6));
+    q.push_back(Utf8Adjust(ch, 1, 0));
+  } else {
+    q.push_back(Utf8Adjust(ch, 4, 18));
+    q.push_back(Utf8Adjust(ch, 1, 12));
+    q.push_back(Utf8Adjust(ch, 1, 6));
+    q.push_back(Utf8Adjust(ch, 1, 0));
+  }
+}
+
+Stream::Stream(std::istream& input)
+    : m_input(input),
+      m_pPrefetched(new unsigned char[YAML_PREFETCH_SIZE]),
+      m_nPrefetchedAvailable(0),
+      m_nPrefetchedUsed(0) {
+  typedef std::istream::traits_type char_traits;
+
+  if (!input)
+    return;
+
+  // Determine (or guess) the character-set by reading the BOM, if any.  See
+  // the YAML specification for the determination algorithm.
+  char_traits::int_type intro[4];
+  int nIntroUsed = 0;
+  UtfIntroState state = uis_start;
+  for (; !s_introFinalState[state];) {
+    std::istream::int_type ch = input.get();
+    intro[nIntroUsed++] = ch;
+    UtfIntroCharType charType = IntroCharTypeOf(ch);
+    UtfIntroState newState = s_introTransitions[state][charType];
+    int nUngets = s_introUngetCount[state][charType];
+    if (nUngets > 0) {
+      input.clear();
+      for (; nUngets > 0; --nUngets) {
+        if (char_traits::eof() != intro[--nIntroUsed])
+          input.putback(char_traits::to_char_type(intro[nIntroUsed]));
+      }
+    }
+    state = newState;
+  }
+
+  switch (state) {
+    case uis_utf8:
+      m_charSet = utf8;
+      break;
+    case uis_utf16le:
+      m_charSet = utf16le;
+      break;
+    case uis_utf16be:
+      m_charSet = utf16be;
+      break;
+    case uis_utf32le:
+      m_charSet = utf32le;
+      break;
+    case uis_utf32be:
+      m_charSet = utf32be;
+      break;
+    default:
+      m_charSet = utf8;
+      break;
+  }
+
+  ReadAheadTo(0);
+}
+
+Stream::~Stream() { delete[] m_pPrefetched; }
+
+char Stream::peek() const {
+  if (m_readahead.empty()) {
+    return Stream::eof();
+  }
+
+  return m_readahead[0];
+}
+
+Stream::operator bool() const {
+  return m_input.good() ||
+         (!m_readahead.empty() && m_readahead[0] != Stream::eof());
+}
+
+// get
+// . Extracts a character from the stream and updates our position
+char Stream::get() {
+  char ch = peek();
+  AdvanceCurrent();
+  m_mark.column++;
+
+  if (ch == '\n') {
+    m_mark.column = 0;
+    m_mark.line++;
+  }
+
+  return ch;
+}
+
+// get
+// . Extracts 'n' characters from the stream and updates our position
+std::string Stream::get(int n) {
+  std::string ret;
+  ret.reserve(n);
+  for (int i = 0; i < n; i++)
+    ret += get();
+  return ret;
+}
+
+// eat
+// . Eats 'n' characters and updates our position.
+void Stream::eat(int n) {
+  for (int i = 0; i < n; i++)
+    get();
+}
+
+void Stream::AdvanceCurrent() {
+  if (!m_readahead.empty()) {
+    m_readahead.pop_front();
+    m_mark.pos++;
+  }
+
+  ReadAheadTo(0);
+}
+
+bool Stream::_ReadAheadTo(size_t i) const {
+  while (m_input.good() && (m_readahead.size() <= i)) {
+    switch (m_charSet) {
+      case utf8:
+        StreamInUtf8();
+        break;
+      case utf16le:
+        StreamInUtf16();
+        break;
+      case utf16be:
+        StreamInUtf16();
+        break;
+      case utf32le:
+        StreamInUtf32();
+        break;
+      case utf32be:
+        StreamInUtf32();
+        break;
+    }
+  }
+
+  // signal end of stream
+  if (!m_input.good())
+    m_readahead.push_back(Stream::eof());
+
+  return m_readahead.size() > i;
+}
+
+void Stream::StreamInUtf8() const {
+  unsigned char b = GetNextByte();
+  if (m_input.good()) {
+    m_readahead.push_back(b);
+  }
+}
+
+void Stream::StreamInUtf16() const {
+  unsigned long ch = 0;
+  unsigned char bytes[2];
+  int nBigEnd = (m_charSet == utf16be) ? 0 : 1;
+
+  bytes[0] = GetNextByte();
+  bytes[1] = GetNextByte();
+  if (!m_input.good()) {
+    return;
+  }
+  ch = (static_cast<unsigned long>(bytes[nBigEnd]) << 8) |
+       static_cast<unsigned long>(bytes[1 ^ nBigEnd]);
+
+  if (ch >= 0xDC00 && ch < 0xE000) {
+    // Trailing (low) surrogate...ugh, wrong order
+    QueueUnicodeCodepoint(m_readahead, CP_REPLACEMENT_CHARACTER);
+    return;
+  } else if (ch >= 0xD800 && ch < 0xDC00) {
+    // ch is a leading (high) surrogate
+
+    // Four byte UTF-8 code point
+
+    // Read the trailing (low) surrogate
+    for (;;) {
+      bytes[0] = GetNextByte();
+      bytes[1] = GetNextByte();
+      if (!m_input.good()) {
+        QueueUnicodeCodepoint(m_readahead, CP_REPLACEMENT_CHARACTER);
+        return;
+      }
+      unsigned long chLow = (static_cast<unsigned long>(bytes[nBigEnd]) << 8) |
+                            static_cast<unsigned long>(bytes[1 ^ nBigEnd]);
+      if (chLow < 0xDC00 || chLow >= 0xE000) {
+        // Trouble...not a low surrogate.  Dump a REPLACEMENT CHARACTER into the
+        // stream.
+        QueueUnicodeCodepoint(m_readahead, CP_REPLACEMENT_CHARACTER);
+
+        // Deal with the next UTF-16 unit
+        if (chLow < 0xD800 || chLow >= 0xE000) {
+          // Easiest case: queue the codepoint and return
+          QueueUnicodeCodepoint(m_readahead, ch);
+          return;
+        } else {
+          // Start the loop over with the new high surrogate
+          ch = chLow;
+          continue;
+        }
+      }
+
+      // Select the payload bits from the high surrogate
+      ch &= 0x3FF;
+      ch <<= 10;
+
+      // Include bits from low surrogate
+      ch |= (chLow & 0x3FF);
+
+      // Add the surrogacy offset
+      ch += 0x10000;
+      break;
+    }
+  }
+
+  QueueUnicodeCodepoint(m_readahead, ch);
+}
+
+inline char* ReadBuffer(unsigned char* pBuffer) {
+  return reinterpret_cast<char*>(pBuffer);
+}
+
+unsigned char Stream::GetNextByte() const {
+  if (m_nPrefetchedUsed >= m_nPrefetchedAvailable) {
+    std::streambuf* pBuf = m_input.rdbuf();
+    m_nPrefetchedAvailable = static_cast<std::size_t>(
+        pBuf->sgetn(ReadBuffer(m_pPrefetched), YAML_PREFETCH_SIZE));
+    m_nPrefetchedUsed = 0;
+    if (!m_nPrefetchedAvailable) {
+      m_input.setstate(std::ios_base::eofbit);
+    }
+
+    if (0 == m_nPrefetchedAvailable) {
+      return 0;
+    }
+  }
+
+  return m_pPrefetched[m_nPrefetchedUsed++];
+}
+
+void Stream::StreamInUtf32() const {
+  static int indexes[2][4] = {{3, 2, 1, 0}, {0, 1, 2, 3}};
+
+  unsigned long ch = 0;
+  unsigned char bytes[4];
+  int* pIndexes = (m_charSet == utf32be) ? indexes[1] : indexes[0];
+
+  bytes[0] = GetNextByte();
+  bytes[1] = GetNextByte();
+  bytes[2] = GetNextByte();
+  bytes[3] = GetNextByte();
+  if (!m_input.good()) {
+    return;
+  }
+
+  for (int i = 0; i < 4; ++i) {
+    ch <<= 8;
+    ch |= bytes[pIndexes[i]];
+  }
+
+  QueueUnicodeCodepoint(m_readahead, ch);
+}
+}
diff --git a/contrib/libs/yaml-cpp/src/stream.h b/contrib/libs/yaml-cpp/src/stream.h
index 410051b8336..42d542d5b16 100644
--- a/contrib/libs/yaml-cpp/src/stream.h
+++ b/contrib/libs/yaml-cpp/src/stream.h
@@ -1,76 +1,76 @@
-#ifndef STREAM_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define STREAM_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include "yaml-cpp/noncopyable.h" 
-#include "yaml-cpp/mark.h" 
-#include <cstddef> 
-#include <deque> 
-#include <ios> 
-#include <iostream> 
-#include <set> 
-#include <string> 
- 
-namespace YAML { 
-class Stream : private noncopyable { 
- public: 
-  friend class StreamCharSource; 
- 
-  Stream(std::istream& input); 
-  ~Stream(); 
- 
-  operator bool() const; 
-  bool operator!() const { return !static_cast<bool>(*this); } 
- 
-  char peek() const; 
-  char get(); 
-  std::string get(int n); 
-  void eat(int n = 1); 
- 
-  static char eof() { return 0x04; } 
- 
-  const Mark mark() const { return m_mark; } 
-  int pos() const { return m_mark.pos; } 
-  int line() const { return m_mark.line; } 
-  int column() const { return m_mark.column; } 
-  void ResetColumn() { m_mark.column = 0; } 
- 
- private: 
-  enum CharacterSet { utf8, utf16le, utf16be, utf32le, utf32be }; 
- 
-  std::istream& m_input; 
-  Mark m_mark; 
- 
-  CharacterSet m_charSet; 
-  mutable std::deque<char> m_readahead; 
-  unsigned char* const m_pPrefetched; 
-  mutable size_t m_nPrefetchedAvailable; 
-  mutable size_t m_nPrefetchedUsed; 
- 
-  void AdvanceCurrent(); 
-  char CharAt(size_t i) const; 
-  bool ReadAheadTo(size_t i) const; 
-  bool _ReadAheadTo(size_t i) const; 
-  void StreamInUtf8() const; 
-  void StreamInUtf16() const; 
-  void StreamInUtf32() const; 
-  unsigned char GetNextByte() const; 
-}; 
- 
-// CharAt 
-// . Unchecked access 
-inline char Stream::CharAt(size_t i) const { return m_readahead[i]; } 
- 
-inline bool Stream::ReadAheadTo(size_t i) const { 
-  if (m_readahead.size() > i) 
-    return true; 
-  return _ReadAheadTo(i); 
-} 
-} 
- 
-#endif  // STREAM_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+#ifndef STREAM_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define STREAM_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/noncopyable.h"
+#include "yaml-cpp/mark.h"
+#include <cstddef>
+#include <deque>
+#include <ios>
+#include <iostream>
+#include <set>
+#include <string>
+
+namespace YAML {
+class Stream : private noncopyable {
+ public:
+  friend class StreamCharSource;
+
+  Stream(std::istream& input);
+  ~Stream();
+
+  operator bool() const;
+  bool operator!() const { return !static_cast<bool>(*this); }
+
+  char peek() const;
+  char get();
+  std::string get(int n);
+  void eat(int n = 1);
+
+  static char eof() { return 0x04; }
+
+  const Mark mark() const { return m_mark; }
+  int pos() const { return m_mark.pos; }
+  int line() const { return m_mark.line; }
+  int column() const { return m_mark.column; }
+  void ResetColumn() { m_mark.column = 0; }
+
+ private:
+  enum CharacterSet { utf8, utf16le, utf16be, utf32le, utf32be };
+
+  std::istream& m_input;
+  Mark m_mark;
+
+  CharacterSet m_charSet;
+  mutable std::deque<char> m_readahead;
+  unsigned char* const m_pPrefetched;
+  mutable size_t m_nPrefetchedAvailable;
+  mutable size_t m_nPrefetchedUsed;
+
+  void AdvanceCurrent();
+  char CharAt(size_t i) const;
+  bool ReadAheadTo(size_t i) const;
+  bool _ReadAheadTo(size_t i) const;
+  void StreamInUtf8() const;
+  void StreamInUtf16() const;
+  void StreamInUtf32() const;
+  unsigned char GetNextByte() const;
+};
+
+// CharAt
+// . Unchecked access
+inline char Stream::CharAt(size_t i) const { return m_readahead[i]; }
+
+inline bool Stream::ReadAheadTo(size_t i) const {
+  if (m_readahead.size() > i)
+    return true;
+  return _ReadAheadTo(i);
+}
+}
+
+#endif  // STREAM_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/src/streamcharsource.h b/contrib/libs/yaml-cpp/src/streamcharsource.h
index 0918413f112..624599e65da 100644
--- a/contrib/libs/yaml-cpp/src/streamcharsource.h
+++ b/contrib/libs/yaml-cpp/src/streamcharsource.h
@@ -1,48 +1,48 @@
-#ifndef STREAMCHARSOURCE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define STREAMCHARSOURCE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include "yaml-cpp/noncopyable.h" 
-#include <cstddef> 
- 
-namespace YAML { 
-class StreamCharSource { 
- public: 
-  StreamCharSource(const Stream& stream) : m_offset(0), m_stream(stream) {} 
-  StreamCharSource(const StreamCharSource& source) 
-      : m_offset(source.m_offset), m_stream(source.m_stream) {} 
-  ~StreamCharSource() {} 
- 
-  operator bool() const; 
-  char operator[](std::size_t i) const { return m_stream.CharAt(m_offset + i); } 
-  bool operator!() const { return !static_cast<bool>(*this); } 
- 
-  const StreamCharSource operator+(int i) const; 
- 
- private: 
-  std::size_t m_offset; 
-  const Stream& m_stream; 
- 
-  StreamCharSource& operator=(const StreamCharSource&);  // non-assignable 
-}; 
- 
-inline StreamCharSource::operator bool() const { 
-  return m_stream.ReadAheadTo(m_offset); 
-} 
- 
-inline const StreamCharSource StreamCharSource::operator+(int i) const { 
-  StreamCharSource source(*this); 
-  if (static_cast<int>(source.m_offset) + i >= 0) 
-    source.m_offset += i; 
-  else 
-    source.m_offset = 0; 
-  return source; 
-} 
-} 
- 
-#endif  // STREAMCHARSOURCE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+#ifndef STREAMCHARSOURCE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define STREAMCHARSOURCE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/noncopyable.h"
+#include <cstddef>
+
+namespace YAML {
+class StreamCharSource {
+ public:
+  StreamCharSource(const Stream& stream) : m_offset(0), m_stream(stream) {}
+  StreamCharSource(const StreamCharSource& source)
+      : m_offset(source.m_offset), m_stream(source.m_stream) {}
+  ~StreamCharSource() {}
+
+  operator bool() const;
+  char operator[](std::size_t i) const { return m_stream.CharAt(m_offset + i); }
+  bool operator!() const { return !static_cast<bool>(*this); }
+
+  const StreamCharSource operator+(int i) const;
+
+ private:
+  std::size_t m_offset;
+  const Stream& m_stream;
+
+  StreamCharSource& operator=(const StreamCharSource&);  // non-assignable
+};
+
+inline StreamCharSource::operator bool() const {
+  return m_stream.ReadAheadTo(m_offset);
+}
+
+inline const StreamCharSource StreamCharSource::operator+(int i) const {
+  StreamCharSource source(*this);
+  if (static_cast<int>(source.m_offset) + i >= 0)
+    source.m_offset += i;
+  else
+    source.m_offset = 0;
+  return source;
+}
+}
+
+#endif  // STREAMCHARSOURCE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/src/stringsource.h b/contrib/libs/yaml-cpp/src/stringsource.h
index 1691040db70..6fee44bb288 100644
--- a/contrib/libs/yaml-cpp/src/stringsource.h
+++ b/contrib/libs/yaml-cpp/src/stringsource.h
@@ -1,48 +1,48 @@
-#ifndef STRINGSOURCE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define STRINGSOURCE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include <cstddef> 
- 
-namespace YAML { 
-class StringCharSource { 
- public: 
-  StringCharSource(const char* str, std::size_t size) 
-      : m_str(str), m_size(size), m_offset(0) {} 
- 
-  operator bool() const { return m_offset < m_size; } 
-  char operator[](std::size_t i) const { return m_str[m_offset + i]; } 
-  bool operator!() const { return !static_cast<bool>(*this); } 
- 
-  const StringCharSource operator+(int i) const { 
-    StringCharSource source(*this); 
-    if (static_cast<int>(source.m_offset) + i >= 0) 
-      source.m_offset += i; 
-    else 
-      source.m_offset = 0; 
-    return source; 
-  } 
- 
-  StringCharSource& operator++() { 
-    ++m_offset; 
-    return *this; 
-  } 
- 
-  StringCharSource& operator+=(std::size_t offset) { 
-    m_offset += offset; 
-    return *this; 
-  } 
- 
- private: 
-  const char* m_str; 
-  std::size_t m_size; 
-  std::size_t m_offset; 
-}; 
-} 
- 
-#endif  // STRINGSOURCE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+#ifndef STRINGSOURCE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define STRINGSOURCE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <cstddef>
+
+namespace YAML {
+class StringCharSource {
+ public:
+  StringCharSource(const char* str, std::size_t size)
+      : m_str(str), m_size(size), m_offset(0) {}
+
+  operator bool() const { return m_offset < m_size; }
+  char operator[](std::size_t i) const { return m_str[m_offset + i]; }
+  bool operator!() const { return !static_cast<bool>(*this); }
+
+  const StringCharSource operator+(int i) const {
+    StringCharSource source(*this);
+    if (static_cast<int>(source.m_offset) + i >= 0)
+      source.m_offset += i;
+    else
+      source.m_offset = 0;
+    return source;
+  }
+
+  StringCharSource& operator++() {
+    ++m_offset;
+    return *this;
+  }
+
+  StringCharSource& operator+=(std::size_t offset) {
+    m_offset += offset;
+    return *this;
+  }
+
+ private:
+  const char* m_str;
+  std::size_t m_size;
+  std::size_t m_offset;
+};
+}
+
+#endif  // STRINGSOURCE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/src/tag.cpp b/contrib/libs/yaml-cpp/src/tag.cpp
index 16b4b6ae5c6..51435520e46 100644
--- a/contrib/libs/yaml-cpp/src/tag.cpp
+++ b/contrib/libs/yaml-cpp/src/tag.cpp
@@ -1,49 +1,49 @@
-#include <cassert> 
-#include <stdexcept> 
- 
-#include "directives.h"  // IWYU pragma: keep 
-#include "tag.h" 
-#include "token.h" 
- 
-namespace YAML { 
-Tag::Tag(const Token& token) : type(static_cast<TYPE>(token.data)) { 
-  switch (type) { 
-    case VERBATIM: 
-      value = token.value; 
-      break; 
-    case PRIMARY_HANDLE: 
-      value = token.value; 
-      break; 
-    case SECONDARY_HANDLE: 
-      value = token.value; 
-      break; 
-    case NAMED_HANDLE: 
-      handle = token.value; 
-      value = token.params[0]; 
-      break; 
-    case NON_SPECIFIC: 
-      break; 
-    default: 
-      assert(false); 
-  } 
-} 
- 
-const std::string Tag::Translate(const Directives& directives) { 
-  switch (type) { 
-    case VERBATIM: 
-      return value; 
-    case PRIMARY_HANDLE: 
-      return directives.TranslateTagHandle("!") + value; 
-    case SECONDARY_HANDLE: 
-      return directives.TranslateTagHandle("!!") + value; 
-    case NAMED_HANDLE: 
-      return directives.TranslateTagHandle("!" + handle + "!") + value; 
-    case NON_SPECIFIC: 
-      // TODO: 
-      return "!"; 
-    default: 
-      assert(false); 
-  } 
-  throw std::runtime_error("yaml-cpp: internal error, bad tag type"); 
-} 
-} 
+#include <cassert>
+#include <stdexcept>
+
+#include "directives.h"  // IWYU pragma: keep
+#include "tag.h"
+#include "token.h"
+
+namespace YAML {
+Tag::Tag(const Token& token) : type(static_cast<TYPE>(token.data)) {
+  switch (type) {
+    case VERBATIM:
+      value = token.value;
+      break;
+    case PRIMARY_HANDLE:
+      value = token.value;
+      break;
+    case SECONDARY_HANDLE:
+      value = token.value;
+      break;
+    case NAMED_HANDLE:
+      handle = token.value;
+      value = token.params[0];
+      break;
+    case NON_SPECIFIC:
+      break;
+    default:
+      assert(false);
+  }
+}
+
+const std::string Tag::Translate(const Directives& directives) {
+  switch (type) {
+    case VERBATIM:
+      return value;
+    case PRIMARY_HANDLE:
+      return directives.TranslateTagHandle("!") + value;
+    case SECONDARY_HANDLE:
+      return directives.TranslateTagHandle("!!") + value;
+    case NAMED_HANDLE:
+      return directives.TranslateTagHandle("!" + handle + "!") + value;
+    case NON_SPECIFIC:
+      // TODO:
+      return "!";
+    default:
+      assert(false);
+  }
+  throw std::runtime_error("yaml-cpp: internal error, bad tag type");
+}
+}
diff --git a/contrib/libs/yaml-cpp/src/tag.h b/contrib/libs/yaml-cpp/src/tag.h
index a51645cf1f8..ac30673b9e8 100644
--- a/contrib/libs/yaml-cpp/src/tag.h
+++ b/contrib/libs/yaml-cpp/src/tag.h
@@ -1,33 +1,33 @@
-#ifndef TAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define TAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include <string> 
- 
-namespace YAML { 
-struct Directives; 
-struct Token; 
- 
-struct Tag { 
-  enum TYPE { 
-    VERBATIM, 
-    PRIMARY_HANDLE, 
-    SECONDARY_HANDLE, 
-    NAMED_HANDLE, 
-    NON_SPECIFIC 
-  }; 
- 
-  Tag(const Token& token); 
-  const std::string Translate(const Directives& directives); 
- 
-  TYPE type; 
-  std::string handle, value; 
-}; 
-} 
- 
-#endif  // TAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+#ifndef TAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define TAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <string>
+
+namespace YAML {
+struct Directives;
+struct Token;
+
+struct Tag {
+  enum TYPE {
+    VERBATIM,
+    PRIMARY_HANDLE,
+    SECONDARY_HANDLE,
+    NAMED_HANDLE,
+    NON_SPECIFIC
+  };
+
+  Tag(const Token& token);
+  const std::string Translate(const Directives& directives);
+
+  TYPE type;
+  std::string handle, value;
+};
+}
+
+#endif  // TAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/src/token.h b/contrib/libs/yaml-cpp/src/token.h
index f7486b0c6d9..ad0b7d0a005 100644
--- a/contrib/libs/yaml-cpp/src/token.h
+++ b/contrib/libs/yaml-cpp/src/token.h
@@ -1,69 +1,69 @@
-#ifndef TOKEN_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
-#define TOKEN_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
- 
-#if defined(_MSC_VER) ||                                            \ 
-    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ 
-     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4 
-#pragma once 
-#endif 
- 
-#include "yaml-cpp/mark.h" 
-#include <iostream> 
-#include <string> 
-#include <vector> 
- 
-namespace YAML { 
-const std::string TokenNames[] = { 
-    "DIRECTIVE", "DOC_START", "DOC_END", "BLOCK_SEQ_START", "BLOCK_MAP_START", 
-    "BLOCK_SEQ_END", "BLOCK_MAP_END", "BLOCK_ENTRY", "FLOW_SEQ_START", 
-    "FLOW_MAP_START", "FLOW_SEQ_END", "FLOW_MAP_END", "FLOW_MAP_COMPACT", 
-    "FLOW_ENTRY", "KEY", "VALUE", "ANCHOR", "ALIAS", "TAG", "SCALAR"}; 
- 
-struct Token { 
-  // enums 
-  enum STATUS { VALID, INVALID, UNVERIFIED }; 
-  enum TYPE { 
-    DIRECTIVE, 
-    DOC_START, 
-    DOC_END, 
-    BLOCK_SEQ_START, 
-    BLOCK_MAP_START, 
-    BLOCK_SEQ_END, 
-    BLOCK_MAP_END, 
-    BLOCK_ENTRY, 
-    FLOW_SEQ_START, 
-    FLOW_MAP_START, 
-    FLOW_SEQ_END, 
-    FLOW_MAP_END, 
-    FLOW_MAP_COMPACT, 
-    FLOW_ENTRY, 
-    KEY, 
-    VALUE, 
-    ANCHOR, 
-    ALIAS, 
-    TAG, 
-    PLAIN_SCALAR, 
-    NON_PLAIN_SCALAR 
-  }; 
- 
-  // data 
-  Token(TYPE type_, const Mark& mark_) 
-      : status(VALID), type(type_), mark(mark_), data(0) {} 
- 
-  friend std::ostream& operator<<(std::ostream& out, const Token& token) { 
-    out << TokenNames[token.type] << std::string(": ") << token.value; 
-    for (std::size_t i = 0; i < token.params.size(); i++) 
-      out << std::string(" ") << token.params[i]; 
-    return out; 
-  } 
- 
-  STATUS status; 
-  TYPE type; 
-  Mark mark; 
-  std::string value; 
-  std::vector<std::string> params; 
-  int data; 
-}; 
-} 
- 
-#endif  // TOKEN_H_62B23520_7C8E_11DE_8A39_0800200C9A66 
+#ifndef TOKEN_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define TOKEN_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/mark.h"
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace YAML {
+const std::string TokenNames[] = {
+    "DIRECTIVE", "DOC_START", "DOC_END", "BLOCK_SEQ_START", "BLOCK_MAP_START",
+    "BLOCK_SEQ_END", "BLOCK_MAP_END", "BLOCK_ENTRY", "FLOW_SEQ_START",
+    "FLOW_MAP_START", "FLOW_SEQ_END", "FLOW_MAP_END", "FLOW_MAP_COMPACT",
+    "FLOW_ENTRY", "KEY", "VALUE", "ANCHOR", "ALIAS", "TAG", "SCALAR"};
+
+struct Token {
+  // enums
+  enum STATUS { VALID, INVALID, UNVERIFIED };
+  enum TYPE {
+    DIRECTIVE,
+    DOC_START,
+    DOC_END,
+    BLOCK_SEQ_START,
+    BLOCK_MAP_START,
+    BLOCK_SEQ_END,
+    BLOCK_MAP_END,
+    BLOCK_ENTRY,
+    FLOW_SEQ_START,
+    FLOW_MAP_START,
+    FLOW_SEQ_END,
+    FLOW_MAP_END,
+    FLOW_MAP_COMPACT,
+    FLOW_ENTRY,
+    KEY,
+    VALUE,
+    ANCHOR,
+    ALIAS,
+    TAG,
+    PLAIN_SCALAR,
+    NON_PLAIN_SCALAR
+  };
+
+  // data
+  Token(TYPE type_, const Mark& mark_)
+      : status(VALID), type(type_), mark(mark_), data(0) {}
+
+  friend std::ostream& operator<<(std::ostream& out, const Token& token) {
+    out << TokenNames[token.type] << std::string(": ") << token.value;
+    for (std::size_t i = 0; i < token.params.size(); i++)
+      out << std::string(" ") << token.params[i];
+    return out;
+  }
+
+  STATUS status;
+  TYPE type;
+  Mark mark;
+  std::string value;
+  std::vector<std::string> params;
+  int data;
+};
+}
+
+#endif  // TOKEN_H_62B23520_7C8E_11DE_8A39_0800200C9A66
diff --git a/contrib/libs/yaml-cpp/ya.make b/contrib/libs/yaml-cpp/ya.make
index 6313048de1d..058caf92fa9 100644
--- a/contrib/libs/yaml-cpp/ya.make
+++ b/contrib/libs/yaml-cpp/ya.make
@@ -1,52 +1,52 @@
-LIBRARY() 
- 
+LIBRARY()
+
 LICENSE(MIT)
 
 LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
 
 VERSION(0.5.3)
 
-OWNER( 
+OWNER(
     g:antiinfra
     g:contrib
     g:cpp-contrib
-) 
- 
-NO_UTIL() 
+)
+
+NO_UTIL()
 
 NO_WSHADOW()
- 
+
 ADDINCL(GLOBAL contrib/libs/yaml-cpp/include)
- 
-SRCS( 
-    src/binary.cpp 
-    src/convert.cpp 
-    src/directives.cpp 
-    src/emit.cpp 
-    src/emitfromevents.cpp 
-    src/emitter.cpp 
-    src/emitterstate.cpp 
-    src/emitterutils.cpp 
+
+SRCS(
+    src/binary.cpp
+    src/convert.cpp
+    src/directives.cpp
+    src/emit.cpp
+    src/emitfromevents.cpp
+    src/emitter.cpp
+    src/emitterstate.cpp
+    src/emitterutils.cpp
     src/exceptions.cpp
-    src/exp.cpp 
-    src/memory.cpp 
-    src/nodebuilder.cpp 
-    src/node.cpp 
-    src/node_data.cpp 
-    src/nodeevents.cpp 
-    src/null.cpp 
-    src/ostream_wrapper.cpp 
-    src/parse.cpp 
-    src/parser.cpp 
-    src/regex_yaml.cpp 
-    src/scanner.cpp 
-    src/scanscalar.cpp 
-    src/scantag.cpp 
-    src/scantoken.cpp 
-    src/simplekey.cpp 
-    src/singledocparser.cpp 
-    src/stream.cpp 
-    src/tag.cpp 
-) 
- 
-END() 
+    src/exp.cpp
+    src/memory.cpp
+    src/nodebuilder.cpp
+    src/node.cpp
+    src/node_data.cpp
+    src/nodeevents.cpp
+    src/null.cpp
+    src/ostream_wrapper.cpp
+    src/parse.cpp
+    src/parser.cpp
+    src/regex_yaml.cpp
+    src/scanner.cpp
+    src/scanscalar.cpp
+    src/scantag.cpp
+    src/scantoken.cpp
+    src/simplekey.cpp
+    src/singledocparser.cpp
+    src/stream.cpp
+    src/tag.cpp
+)
+
+END()