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

37 files changed, 3232 insertions, 3232 deletions

diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/anchor.h b/contrib/libs/yaml-cpp/include/yaml-cpp/anchor.h
index 06965e8fba..06759c724d 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 ed61f438dd..29d5dbd027 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 132f4e7f4a..78db9ec928 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 4555291d41..f0a38f2887 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 639f5410a9..a32c06b2e3 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 bb4eee7789..f14b051ab0 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 0567704148..ef92cc4035 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 f610a1cfcb..0b426957fa 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 06e855ae9e..89f7256714 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 623b80260e..67bb3981b1 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 e1e793f5d9..efe381c621 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 78f22d42d5..9c96859b2c 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 27c4f74128..bf94b4f41f 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 791036869e..45a878ab0c 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 203a7a4f27..2c80705c9a 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 c058852e63..09e55f838c 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 2dd31391dd..deec8fb62c 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 4a1490ecc6..5f1ffe7436 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 bdd190bc4c..8f2bc2657a 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 e7a77ef671..8a776f62a9 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 e3001efae2..50bcd74352 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 c97e48adc8..088090fe74 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 6b0f3dae89..d8a94f8b80 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 df61813c4e..032268c5d0 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 fc048a9f8e..20c487a687 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 551a693331..6618169c53 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 5e1bd5510f..1ded7d27b7 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 af5352ad14..7745fd7245 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 7f30642edb..ce085dd5cd 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 4a56d8e3ac..9d55ca9662 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 c33c294590..a261040739 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 79ebe4db07..b9521d488a 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 bf79511d16..09d45f39b7 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 9d22439769..ceac22d026 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 4c19a67277..06780c861f 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 8775085a39..f33d0e1f63 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 11b6ad8ba9..7f515efb96 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