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

44 files changed, 738 insertions, 738 deletions

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 78db9ec928..c84f892fae 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/contrib/anchordict.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/contrib/anchordict.h
@@ -12,13 +12,13 @@
 #include "../anchor.h"
 
 namespace YAML {
-/**
- * An object that stores and retrieves values correlating to {@link anchor_t}
- * values.
- *
- * <p>Efficient implementation that can make assumptions about how
- * {@code anchor_t} values are assigned by the {@link Parser} class.
- */
+/** 
+ * An object that stores and retrieves values correlating to {@link anchor_t} 
+ * values. 
+ * 
+ * <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:
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 f0a38f2887..f4af6448cc 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/contrib/graphbuilder.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/contrib/graphbuilder.h
@@ -19,8 +19,8 @@ class Parser;
 //   functions.
 class GraphBuilderInterface {
  public:
-  virtual ~GraphBuilderInterface() = 0;
-
+  virtual ~GraphBuilderInterface() = 0; 
+ 
   // Create and return a new node with a null value.
   virtual void *NewNull(const Mark &mark, void *pParentNode) = 0;
 
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/dll.h b/contrib/libs/yaml-cpp/include/yaml-cpp/dll.h
index a32c06b2e3..41e41ace8e 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/dll.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/dll.h
@@ -8,12 +8,12 @@
 #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.
+// 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
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/emitter.h b/contrib/libs/yaml-cpp/include/yaml-cpp/emitter.h
index ef92cc4035..ca461ca8e9 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/emitter.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/emitter.h
@@ -122,7 +122,7 @@ class YAML_CPP_API Emitter : private noncopyable {
   bool CanEmitNewline() const;
 
  private:
-  std::unique_ptr<EmitterState> m_pState;
+  std::unique_ptr<EmitterState> m_pState; 
   ostream_wrapper m_stream;
 };
 
@@ -162,12 +162,12 @@ inline Emitter& Emitter::WriteStreamable(T value) {
 
 template <>
 inline void Emitter::SetStreamablePrecision<float>(std::stringstream& stream) {
-  stream.precision(static_cast<std::streamsize>(GetFloatPrecision()));
+  stream.precision(static_cast<std::streamsize>(GetFloatPrecision())); 
 }
 
 template <>
 inline void Emitter::SetStreamablePrecision<double>(std::stringstream& stream) {
-  stream.precision(static_cast<std::streamsize>(GetDoublePrecision()));
+  stream.precision(static_cast<std::streamsize>(GetDoublePrecision())); 
 }
 
 // overloads of insertion
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/exceptions.h b/contrib/libs/yaml-cpp/include/yaml-cpp/exceptions.h
index 9c96859b2c..261f7e303d 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/exceptions.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/exceptions.h
@@ -9,18 +9,18 @@
 
 #include "yaml-cpp/mark.h"
 #include "yaml-cpp/traits.h"
-#include <sstream>
+#include <sstream> 
 #include <stdexcept>
 #include <string>
 
-// This is here for compatibility with older versions of Visual Studio
-// which don't support noexcept
-#ifdef _MSC_VER
-    #define YAML_CPP_NOEXCEPT _NOEXCEPT
-#else
-    #define YAML_CPP_NOEXCEPT noexcept
-#endif
-
+// This is here for compatibility with older versions of Visual Studio 
+// which don't support noexcept 
+#ifdef _MSC_VER 
+    #define YAML_CPP_NOEXCEPT _NOEXCEPT 
+#else 
+    #define YAML_CPP_NOEXCEPT noexcept 
+#endif 
+ 
 namespace YAML {
 // error messages
 namespace ErrorMsg {
@@ -97,7 +97,7 @@ 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) {
+    const T&, typename disable_if<is_numeric<T>>::type* = 0) { 
   return KEY_NOT_FOUND;
 }
 
@@ -109,21 +109,21 @@ inline const std::string KEY_NOT_FOUND_WITH_KEY(const std::string& key) {
 
 template <typename T>
 inline const std::string KEY_NOT_FOUND_WITH_KEY(
-    const T& key, typename enable_if<is_numeric<T>>::type* = 0) {
+    const T& key, typename enable_if<is_numeric<T>>::type* = 0) { 
   std::stringstream stream;
   stream << KEY_NOT_FOUND << ": " << key;
   return stream.str();
 }
 }
 
-class YAML_CPP_API Exception : public std::runtime_error {
+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_) {}
-  virtual ~Exception() YAML_CPP_NOEXCEPT;
-
-  Exception(const Exception&) = default;
+  virtual ~Exception() YAML_CPP_NOEXCEPT; 
 
+  Exception(const Exception&) = default; 
+ 
   Mark mark;
   std::string msg;
 
@@ -141,47 +141,47 @@ class YAML_CPP_API Exception : public std::runtime_error {
   }
 };
 
-class YAML_CPP_API ParserException : public Exception {
+class YAML_CPP_API ParserException : public Exception { 
  public:
   ParserException(const Mark& mark_, const std::string& msg_)
       : Exception(mark_, msg_) {}
-  ParserException(const ParserException&) = default;
-  virtual ~ParserException() YAML_CPP_NOEXCEPT;
+  ParserException(const ParserException&) = default; 
+  virtual ~ParserException() YAML_CPP_NOEXCEPT; 
 };
 
-class YAML_CPP_API RepresentationException : public Exception {
+class YAML_CPP_API RepresentationException : public Exception { 
  public:
   RepresentationException(const Mark& mark_, const std::string& msg_)
       : Exception(mark_, msg_) {}
-  RepresentationException(const RepresentationException&) = default;
-  virtual ~RepresentationException() YAML_CPP_NOEXCEPT;
+  RepresentationException(const RepresentationException&) = default; 
+  virtual ~RepresentationException() YAML_CPP_NOEXCEPT; 
 };
 
 // representation exceptions
-class YAML_CPP_API InvalidScalar : public RepresentationException {
+class YAML_CPP_API InvalidScalar : public RepresentationException { 
  public:
   InvalidScalar(const Mark& mark_)
       : RepresentationException(mark_, ErrorMsg::INVALID_SCALAR) {}
-  InvalidScalar(const InvalidScalar&) = default;
-  virtual ~InvalidScalar() YAML_CPP_NOEXCEPT;
+  InvalidScalar(const InvalidScalar&) = default; 
+  virtual ~InvalidScalar() YAML_CPP_NOEXCEPT; 
 };
 
-class YAML_CPP_API KeyNotFound : public RepresentationException {
+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_)) {
   }
-  KeyNotFound(const KeyNotFound&) = default;
-  virtual ~KeyNotFound() YAML_CPP_NOEXCEPT;
+  KeyNotFound(const KeyNotFound&) = default; 
+  virtual ~KeyNotFound() YAML_CPP_NOEXCEPT; 
 };
 
 template <typename T>
-class YAML_CPP_API TypedKeyNotFound : public KeyNotFound {
+class YAML_CPP_API TypedKeyNotFound : public KeyNotFound { 
  public:
   TypedKeyNotFound(const Mark& mark_, const T& key_)
       : KeyNotFound(mark_, key_), key(key_) {}
-  virtual ~TypedKeyNotFound() YAML_CPP_NOEXCEPT {}
+  virtual ~TypedKeyNotFound() YAML_CPP_NOEXCEPT {} 
 
   T key;
 };
@@ -192,20 +192,20 @@ inline TypedKeyNotFound<T> MakeTypedKeyNotFound(const Mark& mark,
   return TypedKeyNotFound<T>(mark, key);
 }
 
-class YAML_CPP_API InvalidNode : public RepresentationException {
+class YAML_CPP_API InvalidNode : public RepresentationException { 
  public:
   InvalidNode()
       : RepresentationException(Mark::null_mark(), ErrorMsg::INVALID_NODE) {}
-  InvalidNode(const InvalidNode&) = default;
-  virtual ~InvalidNode() YAML_CPP_NOEXCEPT;
+  InvalidNode(const InvalidNode&) = default; 
+  virtual ~InvalidNode() YAML_CPP_NOEXCEPT; 
 };
 
-class YAML_CPP_API BadConversion : public RepresentationException {
+class YAML_CPP_API BadConversion : public RepresentationException { 
  public:
   explicit BadConversion(const Mark& mark_)
       : RepresentationException(mark_, ErrorMsg::BAD_CONVERSION) {}
-  BadConversion(const BadConversion&) = default;
-  virtual ~BadConversion() YAML_CPP_NOEXCEPT;
+  BadConversion(const BadConversion&) = default; 
+  virtual ~BadConversion() YAML_CPP_NOEXCEPT; 
 };
 
 template <typename T>
@@ -214,54 +214,54 @@ class TypedBadConversion : public BadConversion {
   explicit TypedBadConversion(const Mark& mark_) : BadConversion(mark_) {}
 };
 
-class YAML_CPP_API BadDereference : public RepresentationException {
+class YAML_CPP_API BadDereference : public RepresentationException { 
  public:
   BadDereference()
       : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_DEREFERENCE) {}
-  BadDereference(const BadDereference&) = default;
-  virtual ~BadDereference() YAML_CPP_NOEXCEPT;
+  BadDereference(const BadDereference&) = default; 
+  virtual ~BadDereference() YAML_CPP_NOEXCEPT; 
 };
 
-class YAML_CPP_API BadSubscript : public RepresentationException {
+class YAML_CPP_API BadSubscript : public RepresentationException { 
  public:
   BadSubscript()
       : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_SUBSCRIPT) {}
-  BadSubscript(const BadSubscript&) = default;
-  virtual ~BadSubscript() YAML_CPP_NOEXCEPT;
+  BadSubscript(const BadSubscript&) = default; 
+  virtual ~BadSubscript() YAML_CPP_NOEXCEPT; 
 };
 
-class YAML_CPP_API BadPushback : public RepresentationException {
+class YAML_CPP_API BadPushback : public RepresentationException { 
  public:
   BadPushback()
       : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_PUSHBACK) {}
-  BadPushback(const BadPushback&) = default;
-  virtual ~BadPushback() YAML_CPP_NOEXCEPT;
+  BadPushback(const BadPushback&) = default; 
+  virtual ~BadPushback() YAML_CPP_NOEXCEPT; 
 };
 
-class YAML_CPP_API BadInsert : public RepresentationException {
+class YAML_CPP_API BadInsert : public RepresentationException { 
  public:
   BadInsert()
       : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_INSERT) {}
-  BadInsert(const BadInsert&) = default;
-  virtual ~BadInsert() YAML_CPP_NOEXCEPT;
+  BadInsert(const BadInsert&) = default; 
+  virtual ~BadInsert() YAML_CPP_NOEXCEPT; 
 };
 
-class YAML_CPP_API EmitterException : public Exception {
+class YAML_CPP_API EmitterException : public Exception { 
  public:
   EmitterException(const std::string& msg_)
       : Exception(Mark::null_mark(), msg_) {}
-  EmitterException(const EmitterException&) = default;
-  virtual ~EmitterException() YAML_CPP_NOEXCEPT;
+  EmitterException(const EmitterException&) = default; 
+  virtual ~EmitterException() YAML_CPP_NOEXCEPT; 
 };
 
-class YAML_CPP_API BadFile : public Exception {
+class YAML_CPP_API BadFile : public Exception { 
  public:
   BadFile() : Exception(Mark::null_mark(), ErrorMsg::BAD_FILE) {}
-  BadFile(const BadFile&) = default;
-  virtual ~BadFile() YAML_CPP_NOEXCEPT;
+  BadFile(const BadFile&) = default; 
+  virtual ~BadFile() YAML_CPP_NOEXCEPT; 
 };
 }
 
-#undef YAML_CPP_NOEXCEPT
-
+#undef YAML_CPP_NOEXCEPT 
+ 
 #endif  // EXCEPTIONS_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 45a878ab0c..6434968f51 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/node/convert.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/node/convert.h
@@ -7,7 +7,7 @@
 #pragma once
 #endif
 
-#include <array>
+#include <array> 
 #include <limits>
 #include <list>
 #include <map>
@@ -163,7 +163,7 @@ struct convert<bool> {
 
 // std::map
 template <typename K, typename V>
-struct convert<std::map<K, 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();
@@ -190,7 +190,7 @@ struct convert<std::map<K, V>> {
 
 // std::vector
 template <typename T>
-struct convert<std::vector<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();
@@ -217,7 +217,7 @@ struct convert<std::vector<T>> {
 
 // std::list
 template <typename T>
-struct convert<std::list<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();
@@ -242,42 +242,42 @@ struct convert<std::list<T>> {
   }
 };
 
-// std::array
-template <typename T, std::size_t N>
-struct convert<std::array<T, N>> {
-  static Node encode(const std::array<T, N>& rhs) {
-    Node node(NodeType::Sequence);
-    for (const auto& element : rhs) {
-      node.push_back(element);
-    }
-    return node;
-  }
-
-  static bool decode(const Node& node, std::array<T, N>& rhs) {
-    if (!isNodeValid(node)) {
-      return false;
-    }
-
-    for (auto i = 0u; i < node.size(); ++i) {
-#if defined(__GNUC__) && __GNUC__ < 4
-      // workaround for GCC 3:
-      rhs[i] = node[i].template as<T>();
-#else
-      rhs[i] = node[i].as<T>();
-#endif
-    }
-    return true;
-  }
-
- private:
-  static bool isNodeValid(const Node& node) {
-    return node.IsSequence() && node.size() == N;
-  }
-};
-
+// std::array 
+template <typename T, std::size_t N> 
+struct convert<std::array<T, N>> { 
+  static Node encode(const std::array<T, N>& rhs) { 
+    Node node(NodeType::Sequence); 
+    for (const auto& element : rhs) { 
+      node.push_back(element); 
+    } 
+    return node; 
+  } 
+ 
+  static bool decode(const Node& node, std::array<T, N>& rhs) { 
+    if (!isNodeValid(node)) { 
+      return false; 
+    } 
+ 
+    for (auto i = 0u; i < node.size(); ++i) { 
+#if defined(__GNUC__) && __GNUC__ < 4 
+      // workaround for GCC 3: 
+      rhs[i] = node[i].template as<T>(); 
+#else 
+      rhs[i] = node[i].as<T>(); 
+#endif 
+    } 
+    return true; 
+  } 
+ 
+ private: 
+  static bool isNodeValid(const Node& node) { 
+    return node.IsSequence() && node.size() == N; 
+  } 
+}; 
+ 
 // std::pair
 template <typename T, typename U>
-struct convert<std::pair<T, 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);
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 09e55f838c..c730c5ca83 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
@@ -9,7 +9,7 @@
 
 #include "yaml-cpp/node/detail/node.h"
 #include "yaml-cpp/node/detail/node_data.h"
-#include <type_traits>
+#include <type_traits> 
 
 namespace YAML {
 namespace detail {
@@ -22,9 +22,9 @@ struct get_idx {
 };
 
 template <typename Key>
-struct get_idx<Key,
-               typename std::enable_if<std::is_unsigned<Key>::value &&
-                                       !std::is_same<Key, bool>::value>::type> {
+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;
@@ -32,7 +32,7 @@ struct get_idx<Key,
 
   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()))
+   if (key > sequence.size() || (key > 0 && !sequence[key-1]->is_defined())) 
       return 0;
     if (key == sequence.size())
       sequence.push_back(&pMemory->create_node());
@@ -41,7 +41,7 @@ struct get_idx<Key,
 };
 
 template <typename Key>
-struct get_idx<Key, typename std::enable_if<std::is_signed<Key>::value>::type> {
+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(
@@ -132,14 +132,14 @@ 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);
-    if (it->first->equals(key, pMemory))
-      m_undefinedPairs.erase(it);
-    it = jt;
-  }
-
+  for (kv_pairs::iterator it = m_undefinedPairs.begin(); 
+       it != m_undefinedPairs.end();) { 
+    kv_pairs::iterator jt = std::next(it); 
+    if (it->first->equals(key, pMemory)) 
+      m_undefinedPairs.erase(it); 
+    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);
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 deec8fb62c..1df7116cc9 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
@@ -8,71 +8,71 @@
 #endif
 
 #include "yaml-cpp/dll.h"
-#include "yaml-cpp/node/node.h"
+#include "yaml-cpp/node/node.h" 
 #include "yaml-cpp/node/ptr.h"
 #include "yaml-cpp/node/detail/node_iterator.h"
-#include <cstddef>
-#include <iterator>
+#include <cstddef> 
+#include <iterator> 
 
 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> {
-
+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 {};
-  typedef node_iterator base_type;
-
-  struct proxy {
-    explicit proxy(const V& x) : m_ref(x) {}
-    V* operator->() { return std::addressof(m_ref); }
-    operator V*() { return std::addressof(m_ref); }
-
-    V m_ref;
-  };
-
+  typedef node_iterator base_type; 
+
+  struct proxy { 
+    explicit proxy(const V& x) : m_ref(x) {} 
+    V* operator->() { return std::addressof(m_ref); } 
+    operator V*() { return std::addressof(m_ref); } 
+ 
+    V m_ref; 
+  }; 
+ 
  public:
   typedef typename iterator_base::value_type value_type;
 
  public:
-  iterator_base() : m_iterator(), m_pMemory() {}
+  iterator_base() : m_iterator(), m_pMemory() {} 
   explicit iterator_base(base_type rhs, shared_memory_holder pMemory)
-      : m_iterator(rhs), m_pMemory(pMemory) {}
+      : m_iterator(rhs), m_pMemory(pMemory) {} 
 
   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;
-  }
-
-  template <typename W>
-  bool operator!=(const iterator_base<W>& rhs) const {
-    return m_iterator != rhs.m_iterator;
-  }
-
-  value_type operator*() const {
-    const typename base_type::value_type& v = *m_iterator;
+                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; 
+  } 
+ 
+  template <typename W> 
+  bool operator!=(const iterator_base<W>& rhs) const { 
+    return m_iterator != rhs.m_iterator; 
+  } 
+ 
+  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)
@@ -80,10 +80,10 @@ class iterator_base : public std::iterator<std::forward_iterator_tag, V,
     return value_type();
   }
 
-  proxy operator->() const { return proxy(**this); }
-
+  proxy operator->() const { return proxy(**this); } 
+ 
  private:
-  base_type m_iterator;
+  base_type m_iterator; 
   shared_memory_holder m_pMemory;
 };
 }
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 8a776f62a9..a573991cfa 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
@@ -16,11 +16,11 @@
 
 namespace YAML {
 namespace detail {
-class node {
+class node { 
  public:
   node() : m_pRef(new node_ref) {}
-  node(const node&) = delete;
-  node& operator=(const node&) = delete;
+  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(); }
@@ -66,7 +66,7 @@ class node {
     m_pRef->set_data(*rhs.m_pRef);
   }
 
-  void set_mark(const Mark& mark) { m_pRef->set_mark(mark); }
+  void set_mark(const Mark& mark) { m_pRef->set_mark(mark); } 
 
   void set_type(NodeType::value type) {
     if (type != NodeType::Undefined)
@@ -106,9 +106,9 @@ class node {
   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 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);
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 50bcd74352..bdbd58a7cd 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
@@ -27,11 +27,11 @@ class node;
 
 namespace YAML {
 namespace detail {
-class YAML_CPP_API node_data {
+class YAML_CPP_API node_data { 
  public:
   node_data();
-  node_data(const node_data&) = delete;
-  node_data& operator=(const node_data&) = delete;
+  node_data(const node_data&) = delete; 
+  node_data& operator=(const node_data&) = delete; 
 
   void mark_defined();
   void set_mark(const Mark& mark);
@@ -114,7 +114,7 @@ class YAML_CPP_API node_data {
   mutable std::size_t m_seqSize;
 
   // map
-  typedef std::vector<std::pair<node*, node*>> node_map;
+  typedef std::vector<std::pair<node*, node*>> node_map; 
   node_map m_map;
 
   typedef std::pair<node*, node*> kv_pair;
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 088090fe74..5b94ae6c7b 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
@@ -9,9 +9,9 @@
 
 #include "yaml-cpp/dll.h"
 #include "yaml-cpp/node/ptr.h"
-#include <cstddef>
-#include <iterator>
-#include <memory>
+#include <cstddef> 
+#include <iterator> 
+#include <memory> 
 #include <map>
 #include <utility>
 #include <vector>
@@ -19,7 +19,7 @@
 namespace YAML {
 namespace detail {
 struct iterator_type {
-  enum value { NoneType, Sequence, Map };
+  enum value { NoneType, Sequence, Map }; 
 };
 
 template <typename V>
@@ -37,7 +37,7 @@ struct node_iterator_value : public std::pair<V*, V*> {
 };
 
 typedef std::vector<node*> node_seq;
-typedef std::vector<std::pair<node*, node*>> node_map;
+typedef std::vector<std::pair<node*, node*>> node_map; 
 
 template <typename V>
 struct node_iterator_type {
@@ -53,27 +53,27 @@ struct node_iterator_type<const V> {
 
 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>> {
+    : 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 {};
 
-  struct proxy {
-    explicit proxy(const node_iterator_value<V>& x) : m_ref(x) {}
-    node_iterator_value<V>* operator->() { return std::addressof(m_ref); }
-    operator node_iterator_value<V>*() { return std::addressof(m_ref); }
-
-    node_iterator_value<V> m_ref;
-  };
-
+  struct proxy { 
+    explicit proxy(const node_iterator_value<V>& x) : m_ref(x) {} 
+    node_iterator_value<V>* operator->() { return std::addressof(m_ref); } 
+    operator node_iterator_value<V>*() { return std::addressof(m_ref); } 
+ 
+    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()
-      : m_type(iterator_type::NoneType), m_seqIt(), m_mapIt(), m_mapEnd() {}
+      : 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),
@@ -89,8 +89,8 @@ class node_iterator_base
 
   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())
+                     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),
@@ -100,12 +100,12 @@ class node_iterator_base
   friend class node_iterator_base;
 
   template <typename W>
-  bool operator==(const node_iterator_base<W>& rhs) const {
+  bool operator==(const node_iterator_base<W>& rhs) const { 
     if (m_type != rhs.m_type)
       return false;
 
     switch (m_type) {
-      case iterator_type::NoneType:
+      case iterator_type::NoneType: 
         return true;
       case iterator_type::Sequence:
         return m_seqIt == rhs.m_seqIt;
@@ -115,14 +115,14 @@ class node_iterator_base
     return true;
   }
 
-  template <typename W>
-  bool operator!=(const node_iterator_base<W>& rhs) const {
-    return !(*this == rhs);
-  }
-
-  node_iterator_base<V>& operator++() {
+  template <typename W> 
+  bool operator!=(const node_iterator_base<W>& rhs) const { 
+    return !(*this == rhs); 
+  } 
+ 
+  node_iterator_base<V>& operator++() { 
     switch (m_type) {
-      case iterator_type::NoneType:
+      case iterator_type::NoneType: 
         break;
       case iterator_type::Sequence:
         ++m_seqIt;
@@ -132,18 +132,18 @@ class node_iterator_base
         m_mapIt = increment_until_defined(m_mapIt);
         break;
     }
-    return *this;
-  }
-
-  node_iterator_base<V> operator++(int) {
-    node_iterator_base<V> iterator_pre(*this);
-    ++(*this);
-    return iterator_pre;
+    return *this; 
   }
 
-  value_type operator*() const {
+  node_iterator_base<V> operator++(int) { 
+    node_iterator_base<V> iterator_pre(*this); 
+    ++(*this); 
+    return iterator_pre; 
+  } 
+ 
+  value_type operator*() const { 
     switch (m_type) {
-      case iterator_type::NoneType:
+      case iterator_type::NoneType: 
         return value_type();
       case iterator_type::Sequence:
         return value_type(**m_seqIt);
@@ -153,8 +153,8 @@ class node_iterator_base
     return value_type();
   }
 
-  proxy operator->() const { return proxy(**this); }
-
+  proxy operator->() const { return proxy(**this); } 
+ 
   MapIter increment_until_defined(MapIter it) {
     while (it != m_mapEnd && !is_defined(it))
       ++it;
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 d8a94f8b80..a54e5e1129 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
@@ -14,11 +14,11 @@
 
 namespace YAML {
 namespace detail {
-class node_ref {
+class node_ref { 
  public:
   node_ref() : m_pData(new node_data) {}
-  node_ref(const node_ref&) = delete;
-  node_ref& operator=(const node_ref&) = delete;
+  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(); }
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 032268c5d0..d344da9759 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/node/emit.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/node/emit.h
@@ -16,17 +16,17 @@ 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.
- */
+/** 
+ * 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);
-
-/** Emits the node to the given output stream. */
+ 
+/** Emits the node to the given output stream. */ 
 YAML_CPP_API std::ostream& operator<<(std::ostream& out, const Node& node);
 
-/** Converts the node to a YAML string. */
+/** Converts the node to a YAML string. */ 
 YAML_CPP_API std::string Dump(const Node& node);
-}  // namespace YAML
+}  // namespace YAML 
 
 #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 20c487a687..e73fb44d5f 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/node/impl.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/node/impl.h
@@ -103,7 +103,7 @@ struct as_if<std::string, S> {
   explicit as_if(const Node& node_) : node(node_) {}
   const Node& node;
 
-  std::string operator()(const S& fallback) const {
+  std::string operator()(const S& fallback) const { 
     if (node.Type() != NodeType::Scalar)
       return fallback;
     return node.Scalar();
@@ -115,7 +115,7 @@ struct as_if<T, void> {
   explicit as_if(const Node& node_) : node(node_) {}
   const Node& node;
 
-  T operator()() const {
+  T operator()() const { 
     if (!node.m_pNode)
       throw TypedBadConversion<T>(node.Mark());
 
@@ -131,7 +131,7 @@ struct as_if<std::string, void> {
   explicit as_if(const Node& node_) : node(node_) {}
   const Node& node;
 
-  std::string operator()() const {
+  std::string operator()() const { 
     if (node.Type() != NodeType::Scalar)
       throw TypedBadConversion<std::string>(node.Mark());
     return node.Scalar();
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 1ded7d27b7..0f52f0896b 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/node/node.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/node/node.h
@@ -58,7 +58,7 @@ class YAML_CPP_API Node {
   bool IsMap() const { return Type() == NodeType::Map; }
 
   // bool conversions
-  YAML_CPP_OPERATOR_BOOL()
+  YAML_CPP_OPERATOR_BOOL() 
   bool operator!() const { return !IsDefined(); }
 
   // access
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 7745fd7245..6984c0f05d 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/node/parse.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/node/parse.h
@@ -16,63 +16,63 @@
 namespace YAML {
 class Node;
 
-/**
- * Loads the input string as a single YAML document.
- *
- * @throws {@link ParserException} if it is malformed.
- */
+/** 
+ * 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);
-
-/**
- * Loads the input string as a single YAML document.
- *
- * @throws {@link ParserException} if it is malformed.
- */
+ 
+/** 
+ * Loads the input string as a single YAML document. 
+ * 
+ * @throws {@link ParserException} if it is malformed. 
+ */ 
 YAML_CPP_API Node Load(const char* input);
-
-/**
- * Loads the input stream as a single YAML document.
- *
- * @throws {@link ParserException} if it is malformed.
- */
+ 
+/** 
+ * Loads the input stream as a single YAML document. 
+ * 
+ * @throws {@link ParserException} if it is malformed. 
+ */ 
 YAML_CPP_API Node Load(std::istream& input);
-
-/**
- * Loads the input file as a single YAML document.
- *
- * @throws {@link ParserException} if it is malformed.
- * @throws {@link BadFile} if the file cannot be loaded.
- */
+ 
+/** 
+ * Loads the input file as a single YAML document. 
+ * 
+ * @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);
 
-/**
- * Loads the input string as a list of YAML documents.
- *
- * @throws {@link ParserException} if it is malformed.
- */
+/** 
+ * 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);
-
-/**
- * Loads the input string as a list of YAML documents.
- *
- * @throws {@link ParserException} if it is malformed.
- */
+ 
+/** 
+ * 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);
-
-/**
- * Loads the input stream as a list of YAML documents.
- *
- * @throws {@link ParserException} if it is malformed.
- */
+ 
+/** 
+ * 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);
-
-/**
- * Loads the input file as a list of YAML documents.
- *
- * @throws {@link ParserException} if it is malformed.
- * @throws {@link BadFile} if the file cannot be loaded.
- */
+ 
+/** 
+ * Loads the input file as a list of YAML documents. 
+ * 
+ * @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);
-}  // namespace YAML
+}  // namespace YAML 
 
 #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 ce085dd5cd..5fbed4be9d 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/node/ptr.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/node/ptr.h
@@ -8,7 +8,7 @@
 #endif
 
 #include "yaml-cpp/dll.h"
-#include <memory>
+#include <memory> 
 
 namespace YAML {
 namespace detail {
@@ -18,11 +18,11 @@ 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;
+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; 
 }
 }
 
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/null.h b/contrib/libs/yaml-cpp/include/yaml-cpp/null.h
index b9521d488a..ecfe1524bd 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/null.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/null.h
@@ -8,7 +8,7 @@
 #endif
 
 #include "yaml-cpp/dll.h"
-#include <string>
+#include <string> 
 
 namespace YAML {
 class Node;
@@ -18,7 +18,7 @@ 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);
+YAML_CPP_API bool IsNullString(const std::string& str); 
 
 extern YAML_CPP_API _Null Null;
 }
diff --git a/contrib/libs/yaml-cpp/include/yaml-cpp/parser.h b/contrib/libs/yaml-cpp/include/yaml-cpp/parser.h
index ceac22d026..2f71a03b1f 100644
--- a/contrib/libs/yaml-cpp/include/yaml-cpp/parser.h
+++ b/contrib/libs/yaml-cpp/include/yaml-cpp/parser.h
@@ -20,66 +20,66 @@ 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.
- */
+/** 
+ * 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:
-  /** Constructs an empty parser (with no input. */
+  /** Constructs an empty parser (with no input. */ 
   Parser();
-
-  /**
-   * Constructs a parser from the given input stream. The input stream must
-   * live as long as the parser.
-   */
-  explicit Parser(std::istream& in);
-
+ 
+  /** 
+   * Constructs a parser from the given input stream. The input stream must 
+   * live as long as the parser. 
+   */ 
+  explicit Parser(std::istream& in); 
+ 
   ~Parser();
 
-  /** Evaluates to true if the parser has some valid input to be read. */
-  explicit operator bool() const;
+  /** 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.
-   */
+  /** 
+   * Resets the parser with the given input stream. Any existing state is 
+   * erased. 
+   */ 
   void Load(std::istream& in);
-
-  /**
-   * Handles the next document by calling events on the {@code eventHandler}.
-   *
-   * @throw a ParserException on error.
-   * @return false if there are no more documents
-   */
+ 
+  /** 
+   * Handles the next document by calling events on the {@code eventHandler}. 
+   * 
+   * @throw a ParserException on error. 
+   * @return false if there are no more documents 
+   */ 
   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.
-   */
+  /** 
+   * Reads any directives that are next in the queue, setting the internal 
+   * {@code m_pDirectives} state. 
+   */ 
   void ParseDirectives();
-
+ 
   void HandleDirective(const Token& token);
-
-  /**
-   * Handles a "YAML" directive, which should be of the form 'major.minor' (like
-   * a version number).
-   */
+ 
+  /** 
+   * Handles a "YAML" directive, which should be of the form 'major.minor' (like 
+   * a version number). 
+   */ 
   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.
-   */
+ 
+  /** 
+   * 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:
-  std::unique_ptr<Scanner> m_pScanner;
-  std::unique_ptr<Directives> m_pDirectives;
+  std::unique_ptr<Scanner> m_pScanner; 
+  std::unique_ptr<Directives> m_pDirectives; 
 };
 }
 
diff --git a/contrib/libs/yaml-cpp/src/collectionstack.h b/contrib/libs/yaml-cpp/src/collectionstack.h
index 46c463ebce..23e1bd397a 100644
--- a/contrib/libs/yaml-cpp/src/collectionstack.h
+++ b/contrib/libs/yaml-cpp/src/collectionstack.h
@@ -27,7 +27,7 @@ class CollectionStack {
     collectionStack.push(type);
   }
   void PopCollectionType(CollectionType::value type) {
-    (void)type;
+    (void)type; 
     assert(type == GetCurCollectionType());
     collectionStack.pop();
   }
diff --git a/contrib/libs/yaml-cpp/src/emit.cpp b/contrib/libs/yaml-cpp/src/emit.cpp
index 51bc791533..4eac410986 100644
--- a/contrib/libs/yaml-cpp/src/emit.cpp
+++ b/contrib/libs/yaml-cpp/src/emit.cpp
@@ -22,4 +22,4 @@ std::string Dump(const Node& node) {
   emitter << node;
   return emitter.c_str();
 }
-}  // namespace YAML
+}  // namespace YAML 
diff --git a/contrib/libs/yaml-cpp/src/emitfromevents.cpp b/contrib/libs/yaml-cpp/src/emitfromevents.cpp
index 4832649f3c..3d72822bd5 100644
--- a/contrib/libs/yaml-cpp/src/emitfromevents.cpp
+++ b/contrib/libs/yaml-cpp/src/emitfromevents.cpp
@@ -111,7 +111,7 @@ void EmitFromEvents::BeginNode() {
 }
 
 void EmitFromEvents::EmitProps(const std::string& tag, anchor_t anchor) {
-  if (!tag.empty() && tag != "?" && tag != "!")
+  if (!tag.empty() && tag != "?" && tag != "!") 
     m_emitter << VerbatimTag(tag);
   if (anchor)
     m_emitter << Anchor(ToString(anchor));
diff --git a/contrib/libs/yaml-cpp/src/emitterstate.cpp b/contrib/libs/yaml-cpp/src/emitterstate.cpp
index 3542aaf507..8b785e852b 100644
--- a/contrib/libs/yaml-cpp/src/emitterstate.cpp
+++ b/contrib/libs/yaml-cpp/src/emitterstate.cpp
@@ -53,31 +53,31 @@ void EmitterState::SetNonContent() { m_hasNonContent = true; }
 
 void EmitterState::SetLongKey() {
   assert(!m_groups.empty());
-  if (m_groups.empty()) {
+  if (m_groups.empty()) { 
     return;
-  }
+  } 
 
-  assert(m_groups.back()->type == GroupType::Map);
-  m_groups.back()->longKey = true;
+  assert(m_groups.back()->type == GroupType::Map); 
+  m_groups.back()->longKey = true; 
 }
 
 void EmitterState::ForceFlow() {
   assert(!m_groups.empty());
-  if (m_groups.empty()) {
+  if (m_groups.empty()) { 
     return;
-  }
+  } 
 
-  m_groups.back()->flowType = FlowType::Flow;
+  m_groups.back()->flowType = FlowType::Flow; 
 }
 
 void EmitterState::StartedNode() {
   if (m_groups.empty()) {
     m_docCount++;
   } else {
-    m_groups.back()->childCount++;
-    if (m_groups.back()->childCount % 2 == 0) {
-      m_groups.back()->longKey = false;
-    }
+    m_groups.back()->childCount++; 
+    if (m_groups.back()->childCount % 2 == 0) { 
+      m_groups.back()->longKey = false; 
+    } 
   }
 
   m_hasAnchor = false;
@@ -124,50 +124,50 @@ void EmitterState::StartedScalar() {
 void EmitterState::StartedGroup(GroupType::value type) {
   StartedNode();
 
-  const std::size_t lastGroupIndent =
-      (m_groups.empty() ? 0 : m_groups.back()->indent);
+  const std::size_t lastGroupIndent = 
+      (m_groups.empty() ? 0 : m_groups.back()->indent); 
   m_curIndent += lastGroupIndent;
 
-  // TODO: Create move constructors for settings types to simplify transfer
-  std::unique_ptr<Group> pGroup(new Group(type));
+  // TODO: Create move constructors for settings types to simplify transfer 
+  std::unique_ptr<Group> pGroup(new Group(type)); 
 
   // transfer settings (which last until this group is done)
-  //
-  // NB: if pGroup->modifiedSettings == m_modifiedSettings,
-  // m_modifiedSettings is not changed!
-  pGroup->modifiedSettings = std::move(m_modifiedSettings);
+  // 
+  // NB: if pGroup->modifiedSettings == m_modifiedSettings, 
+  // m_modifiedSettings is not changed! 
+  pGroup->modifiedSettings = std::move(m_modifiedSettings); 
 
   // set up group
-  if (GetFlowType(type) == Block) {
+  if (GetFlowType(type) == Block) { 
     pGroup->flowType = FlowType::Block;
-  } else {
+  } else { 
     pGroup->flowType = FlowType::Flow;
-  }
+  } 
   pGroup->indent = GetIndent();
 
-  m_groups.push_back(std::move(pGroup));
+  m_groups.push_back(std::move(pGroup)); 
 }
 
 void EmitterState::EndedGroup(GroupType::value type) {
   if (m_groups.empty()) {
-    if (type == GroupType::Seq) {
+    if (type == GroupType::Seq) { 
       return SetError(ErrorMsg::UNEXPECTED_END_SEQ);
-    } else {
+    } else { 
       return SetError(ErrorMsg::UNEXPECTED_END_MAP);
-    }
+    } 
   }
 
   // get rid of the current group
   {
-    std::unique_ptr<Group> pFinishedGroup = std::move(m_groups.back());
-    m_groups.pop_back();
-    if (pFinishedGroup->type != type) {
+    std::unique_ptr<Group> pFinishedGroup = std::move(m_groups.back()); 
+    m_groups.pop_back(); 
+    if (pFinishedGroup->type != type) { 
       return SetError(ErrorMsg::UNMATCHED_GROUP_TAG);
-    }
+    } 
   }
 
   // reset old settings
-  std::size_t lastIndent = (m_groups.empty() ? 0 : m_groups.back()->indent);
+  std::size_t lastIndent = (m_groups.empty() ? 0 : m_groups.back()->indent); 
   assert(m_curIndent >= lastIndent);
   m_curIndent -= lastIndent;
 
@@ -179,39 +179,39 @@ void EmitterState::EndedGroup(GroupType::value type) {
 }
 
 EmitterNodeType::value EmitterState::CurGroupNodeType() const {
-  if (m_groups.empty()) {
+  if (m_groups.empty()) { 
     return EmitterNodeType::NoType;
-  }
+  } 
 
-  return m_groups.back()->NodeType();
+  return m_groups.back()->NodeType(); 
 }
 
 GroupType::value EmitterState::CurGroupType() const {
-  return m_groups.empty() ? GroupType::NoType : m_groups.back()->type;
+  return m_groups.empty() ? GroupType::NoType : m_groups.back()->type; 
 }
 
 FlowType::value EmitterState::CurGroupFlowType() const {
-  return m_groups.empty() ? FlowType::NoType : m_groups.back()->flowType;
+  return m_groups.empty() ? FlowType::NoType : m_groups.back()->flowType; 
 }
 
-std::size_t EmitterState::CurGroupIndent() const {
-  return m_groups.empty() ? 0 : m_groups.back()->indent;
+std::size_t EmitterState::CurGroupIndent() const { 
+  return m_groups.empty() ? 0 : m_groups.back()->indent; 
 }
 
 std::size_t EmitterState::CurGroupChildCount() const {
-  return m_groups.empty() ? m_docCount : m_groups.back()->childCount;
+  return m_groups.empty() ? m_docCount : m_groups.back()->childCount; 
 }
 
 bool EmitterState::CurGroupLongKey() const {
-  return m_groups.empty() ? false : m_groups.back()->longKey;
+  return m_groups.empty() ? false : m_groups.back()->longKey; 
 }
 
-std::size_t EmitterState::LastIndent() const {
-  if (m_groups.size() <= 1) {
+std::size_t EmitterState::LastIndent() const { 
+  if (m_groups.size() <= 1) { 
     return 0;
-  }
+  } 
 
-  return m_curIndent - m_groups[m_groups.size() - 2]->indent;
+  return m_curIndent - m_groups[m_groups.size() - 2]->indent; 
 }
 
 void EmitterState::ClearModifiedSettings() { m_modifiedSettings.clear(); }
@@ -348,16 +348,16 @@ bool EmitterState::SetMapKeyFormat(EMITTER_MANIP value, FmtScope::value scope) {
   }
 }
 
-bool EmitterState::SetFloatPrecision(std::size_t value, FmtScope::value scope) {
-  if (value > std::numeric_limits<float>::digits10 + 1)
+bool EmitterState::SetFloatPrecision(std::size_t value, FmtScope::value scope) { 
+  if (value > std::numeric_limits<float>::digits10 + 1) 
     return false;
   _Set(m_floatPrecision, value, scope);
   return true;
 }
 
-bool EmitterState::SetDoublePrecision(std::size_t value,
-                                      FmtScope::value scope) {
-  if (value > std::numeric_limits<double>::digits10 + 1)
+bool EmitterState::SetDoublePrecision(std::size_t value, 
+                                      FmtScope::value scope) { 
+  if (value > std::numeric_limits<double>::digits10 + 1) 
     return false;
   _Set(m_doublePrecision, value, scope);
   return true;
diff --git a/contrib/libs/yaml-cpp/src/emitterstate.h b/contrib/libs/yaml-cpp/src/emitterstate.h
index 0937f000d9..a6f4ba7b8e 100644
--- a/contrib/libs/yaml-cpp/src/emitterstate.h
+++ b/contrib/libs/yaml-cpp/src/emitterstate.h
@@ -10,12 +10,12 @@
 #include "setting.h"
 #include "yaml-cpp/emitterdef.h"
 #include "yaml-cpp/emittermanip.h"
-
+ 
 #include <cassert>
-#include <memory>
+#include <memory> 
 #include <stack>
 #include <stdexcept>
-#include <vector>
+#include <vector> 
 
 namespace YAML {
 struct FmtScope {
@@ -58,12 +58,12 @@ class EmitterState {
 
   GroupType::value CurGroupType() const;
   FlowType::value CurGroupFlowType() const;
-  std::size_t CurGroupIndent() const;
+  std::size_t CurGroupIndent() const; 
   std::size_t CurGroupChildCount() const;
   bool CurGroupLongKey() const;
 
-  std::size_t LastIndent() const;
-  std::size_t CurIndent() const { return m_curIndent; }
+  std::size_t LastIndent() const; 
+  std::size_t CurIndent() const { return m_curIndent; } 
   bool HasAnchor() const { return m_hasAnchor; }
   bool HasTag() const { return m_hasTag; }
   bool HasBegunNode() const {
@@ -95,12 +95,12 @@ class EmitterState {
   EMITTER_MANIP GetIntFormat() const { return m_intFmt.get(); }
 
   bool SetIndent(std::size_t value, FmtScope::value scope);
-  std::size_t GetIndent() const { return m_indent.get(); }
+  std::size_t GetIndent() const { return m_indent.get(); } 
 
   bool SetPreCommentIndent(std::size_t value, FmtScope::value scope);
-  std::size_t GetPreCommentIndent() const { return m_preCommentIndent.get(); }
+  std::size_t GetPreCommentIndent() const { return m_preCommentIndent.get(); } 
   bool SetPostCommentIndent(std::size_t value, FmtScope::value scope);
-  std::size_t GetPostCommentIndent() const { return m_postCommentIndent.get(); }
+  std::size_t GetPostCommentIndent() const { return m_postCommentIndent.get(); } 
 
   bool SetFlowType(GroupType::value groupType, EMITTER_MANIP value,
                    FmtScope::value scope);
@@ -109,9 +109,9 @@ class EmitterState {
   bool SetMapKeyFormat(EMITTER_MANIP value, FmtScope::value scope);
   EMITTER_MANIP GetMapKeyFormat() const { return m_mapKeyFmt.get(); }
 
-  bool SetFloatPrecision(std::size_t value, FmtScope::value scope);
+  bool SetFloatPrecision(std::size_t value, FmtScope::value scope); 
   std::size_t GetFloatPrecision() const { return m_floatPrecision.get(); }
-  bool SetDoublePrecision(std::size_t value, FmtScope::value scope);
+  bool SetDoublePrecision(std::size_t value, FmtScope::value scope); 
   std::size_t GetDoublePrecision() const { return m_doublePrecision.get(); }
 
  private:
@@ -137,8 +137,8 @@ class EmitterState {
   Setting<EMITTER_MANIP> m_seqFmt;
   Setting<EMITTER_MANIP> m_mapFmt;
   Setting<EMITTER_MANIP> m_mapKeyFmt;
-  Setting<std::size_t> m_floatPrecision;
-  Setting<std::size_t> m_doublePrecision;
+  Setting<std::size_t> m_floatPrecision; 
+  Setting<std::size_t> m_doublePrecision; 
 
   SettingChanges m_modifiedSettings;
   SettingChanges m_globalModifiedSettings;
@@ -149,7 +149,7 @@ class EmitterState {
 
     GroupType::value type;
     FlowType::value flowType;
-    std::size_t indent;
+    std::size_t indent; 
     std::size_t childCount;
     bool longKey;
 
@@ -174,7 +174,7 @@ class EmitterState {
     }
   };
 
-  std::vector<std::unique_ptr<Group>> m_groups;
+  std::vector<std::unique_ptr<Group>> m_groups; 
   std::size_t m_curIndent;
   bool m_hasAnchor;
   bool m_hasTag;
diff --git a/contrib/libs/yaml-cpp/src/emitterutils.cpp b/contrib/libs/yaml-cpp/src/emitterutils.cpp
index 147738ad8a..cbb68e50fc 100644
--- a/contrib/libs/yaml-cpp/src/emitterutils.cpp
+++ b/contrib/libs/yaml-cpp/src/emitterutils.cpp
@@ -9,7 +9,7 @@
 #include "stringsource.h"
 #include "yaml-cpp/binary.h"  // IWYU pragma: keep
 #include "yaml-cpp/ostream_wrapper.h"
-#include "yaml-cpp/null.h"
+#include "yaml-cpp/null.h" 
 
 namespace YAML {
 namespace Utils {
@@ -154,7 +154,7 @@ void WriteCodePoint(ostream_wrapper& out, int codePoint) {
 bool IsValidPlainScalar(const std::string& str, FlowType::value flowType,
                         bool allowOnlyAscii) {
   // check against null
-  if (IsNullString(str)) {
+  if (IsNullString(str)) { 
     return false;
   }
 
@@ -354,7 +354,7 @@ bool WriteDoubleQuotedString(ostream_wrapper& out, const std::string& str,
 }
 
 bool WriteLiteralString(ostream_wrapper& out, const std::string& str,
-                        std::size_t indent) {
+                        std::size_t indent) { 
   out << "|\n";
   out << IndentTo(indent);
   int codePoint;
@@ -380,8 +380,8 @@ bool WriteChar(ostream_wrapper& out, char ch) {
     out << "\"\\n\"";
   } else if (ch == '\b') {
     out << "\"\\b\"";
-  } else if (ch == '\\') {
-    out << "\"\\\\\"";
+  } else if (ch == '\\') { 
+    out << "\"\\\\\""; 
   } else if ((0x20 <= ch && ch <= 0x7e) || ch == ' ') {
     out << "\"" << ch << "\"";
   } else {
@@ -393,7 +393,7 @@ bool WriteChar(ostream_wrapper& out, char ch) {
 }
 
 bool WriteComment(ostream_wrapper& out, const std::string& str,
-                  std::size_t postCommentIndent) {
+                  std::size_t postCommentIndent) { 
   const std::size_t curIndent = out.col();
   out << "#" << Indentation(postCommentIndent);
   out.set_comment();
diff --git a/contrib/libs/yaml-cpp/src/emitterutils.h b/contrib/libs/yaml-cpp/src/emitterutils.h
index 6cc7319147..04777e9299 100644
--- a/contrib/libs/yaml-cpp/src/emitterutils.h
+++ b/contrib/libs/yaml-cpp/src/emitterutils.h
@@ -34,10 +34,10 @@ bool WriteSingleQuotedString(ostream_wrapper& out, const std::string& str);
 bool WriteDoubleQuotedString(ostream_wrapper& out, const std::string& str,
                              bool escapeNonAscii);
 bool WriteLiteralString(ostream_wrapper& out, const std::string& str,
-                        std::size_t indent);
+                        std::size_t indent); 
 bool WriteChar(ostream_wrapper& out, char ch);
 bool WriteComment(ostream_wrapper& out, const std::string& str,
-                  std::size_t postCommentIndent);
+                  std::size_t postCommentIndent); 
 bool WriteAlias(ostream_wrapper& out, const std::string& str);
 bool WriteAnchor(ostream_wrapper& out, const std::string& str);
 bool WriteTag(ostream_wrapper& out, const std::string& str, bool verbatim);
diff --git a/contrib/libs/yaml-cpp/src/exceptions.cpp b/contrib/libs/yaml-cpp/src/exceptions.cpp
index 9b6d8912c1..50387db489 100644
--- a/contrib/libs/yaml-cpp/src/exceptions.cpp
+++ b/contrib/libs/yaml-cpp/src/exceptions.cpp
@@ -1,31 +1,31 @@
-#include "yaml-cpp/exceptions.h"
-
-// This is here for compatibility with older versions of Visual Studio
-// which don't support noexcept
-#ifdef _MSC_VER
-    #define YAML_CPP_NOEXCEPT _NOEXCEPT
-#else
-    #define YAML_CPP_NOEXCEPT noexcept
-#endif
-
-namespace YAML {
-
-// These destructors are defined out-of-line so the vtable is only emitted once.
-Exception::~Exception() YAML_CPP_NOEXCEPT {}
-ParserException::~ParserException() YAML_CPP_NOEXCEPT {}
-RepresentationException::~RepresentationException() YAML_CPP_NOEXCEPT {}
-InvalidScalar::~InvalidScalar() YAML_CPP_NOEXCEPT {}
-KeyNotFound::~KeyNotFound() YAML_CPP_NOEXCEPT {}
-InvalidNode::~InvalidNode() YAML_CPP_NOEXCEPT {}
-BadConversion::~BadConversion() YAML_CPP_NOEXCEPT {}
-BadDereference::~BadDereference() YAML_CPP_NOEXCEPT {}
-BadSubscript::~BadSubscript() YAML_CPP_NOEXCEPT {}
-BadPushback::~BadPushback() YAML_CPP_NOEXCEPT {}
-BadInsert::~BadInsert() YAML_CPP_NOEXCEPT {}
-EmitterException::~EmitterException() YAML_CPP_NOEXCEPT {}
-BadFile::~BadFile() YAML_CPP_NOEXCEPT {}
-}
-
-#undef YAML_CPP_NOEXCEPT
-
-
+#include "yaml-cpp/exceptions.h" 
+ 
+// This is here for compatibility with older versions of Visual Studio 
+// which don't support noexcept 
+#ifdef _MSC_VER 
+    #define YAML_CPP_NOEXCEPT _NOEXCEPT 
+#else 
+    #define YAML_CPP_NOEXCEPT noexcept 
+#endif 
+ 
+namespace YAML { 
+ 
+// These destructors are defined out-of-line so the vtable is only emitted once. 
+Exception::~Exception() YAML_CPP_NOEXCEPT {} 
+ParserException::~ParserException() YAML_CPP_NOEXCEPT {} 
+RepresentationException::~RepresentationException() YAML_CPP_NOEXCEPT {} 
+InvalidScalar::~InvalidScalar() YAML_CPP_NOEXCEPT {} 
+KeyNotFound::~KeyNotFound() YAML_CPP_NOEXCEPT {} 
+InvalidNode::~InvalidNode() YAML_CPP_NOEXCEPT {} 
+BadConversion::~BadConversion() YAML_CPP_NOEXCEPT {} 
+BadDereference::~BadDereference() YAML_CPP_NOEXCEPT {} 
+BadSubscript::~BadSubscript() YAML_CPP_NOEXCEPT {} 
+BadPushback::~BadPushback() YAML_CPP_NOEXCEPT {} 
+BadInsert::~BadInsert() YAML_CPP_NOEXCEPT {} 
+EmitterException::~EmitterException() YAML_CPP_NOEXCEPT {} 
+BadFile::~BadFile() YAML_CPP_NOEXCEPT {} 
+} 
+ 
+#undef YAML_CPP_NOEXCEPT 
+ 
+ 
diff --git a/contrib/libs/yaml-cpp/src/exp.h b/contrib/libs/yaml-cpp/src/exp.h
index 50b0220b81..a17a21750a 100644
--- a/contrib/libs/yaml-cpp/src/exp.h
+++ b/contrib/libs/yaml-cpp/src/exp.h
@@ -20,10 +20,10 @@ namespace YAML {
 
 namespace Exp {
 // misc
-inline const RegEx& Empty() {
-  static const RegEx e;
-  return e;
-}
+inline const RegEx& Empty() { 
+  static const RegEx e; 
+  return e; 
+} 
 inline const RegEx& Space() {
   static const RegEx e = RegEx(' ');
   return e;
@@ -169,15 +169,15 @@ inline const RegEx& EndScalarInFlow() {
   return e;
 }
 
-inline const RegEx& ScanScalarEndInFlow() {
-  static const RegEx e = (EndScalarInFlow() || (BlankOrBreak() + Comment()));
-  return e;
-}
-
-inline const RegEx& ScanScalarEnd() {
-  static const RegEx e = EndScalar() || (BlankOrBreak() + Comment());
-  return e;
-}
+inline const RegEx& ScanScalarEndInFlow() { 
+  static const RegEx e = (EndScalarInFlow() || (BlankOrBreak() + Comment())); 
+  return e; 
+} 
+ 
+inline const RegEx& ScanScalarEnd() { 
+  static const RegEx e = EndScalar() || (BlankOrBreak() + Comment()); 
+  return e; 
+} 
 inline const RegEx& EscSingleQuote() {
   static const RegEx e = RegEx("\'\'");
   return e;
diff --git a/contrib/libs/yaml-cpp/src/node_data.cpp b/contrib/libs/yaml-cpp/src/node_data.cpp
index 77cd465780..0e613a4113 100644
--- a/contrib/libs/yaml-cpp/src/node_data.cpp
+++ b/contrib/libs/yaml-cpp/src/node_data.cpp
@@ -1,5 +1,5 @@
 #include <assert.h>
-#include <iterator>
+#include <iterator> 
 #include <sstream>
 
 #include "yaml-cpp/exceptions.h"
@@ -28,7 +28,7 @@ void node_data::mark_defined() {
   m_isDefined = true;
 }
 
-void node_data::set_mark(const Mark& mark) { m_mark = mark; }
+void node_data::set_mark(const Mark& mark) { m_mark = mark; } 
 
 void node_data::set_type(NodeType::value type) {
   if (type == NodeType::Undefined) {
@@ -102,7 +102,7 @@ void node_data::compute_seq_size() const {
 void node_data::compute_map_size() const {
   kv_pairs::iterator it = m_undefinedPairs.begin();
   while (it != m_undefinedPairs.end()) {
-    kv_pairs::iterator jt = std::next(it);
+    kv_pairs::iterator jt = std::next(it); 
     if (it->first->is_defined() && it->second->is_defined())
       m_undefinedPairs.erase(it);
     it = jt;
@@ -256,10 +256,10 @@ void node_data::reset_map() {
 }
 
 void node_data::insert_map_pair(node& key, node& value) {
-  m_map.emplace_back(&key, &value);
-
+  m_map.emplace_back(&key, &value); 
+ 
   if (!key.is_defined() || !value.is_defined())
-    m_undefinedPairs.emplace_back(&key, &value);
+    m_undefinedPairs.emplace_back(&key, &value); 
 }
 
 void node_data::convert_to_map(shared_memory_holder pMemory) {
diff --git a/contrib/libs/yaml-cpp/src/nodebuilder.cpp b/contrib/libs/yaml-cpp/src/nodebuilder.cpp
index 093d2efeb7..3b9417ea7f 100644
--- a/contrib/libs/yaml-cpp/src/nodebuilder.cpp
+++ b/contrib/libs/yaml-cpp/src/nodebuilder.cpp
@@ -48,8 +48,8 @@ void NodeBuilder::OnScalar(const Mark& mark, const std::string& tag,
   Pop();
 }
 
-void NodeBuilder::OnSequenceStart(const Mark& mark, const std::string& tag,
-                                  anchor_t anchor, EmitterStyle::value style) {
+void NodeBuilder::OnSequenceStart(const Mark& mark, const std::string& tag, 
+                                  anchor_t anchor, EmitterStyle::value style) { 
   detail::node& node = Push(mark, anchor);
   node.set_tag(tag);
   node.set_type(NodeType::Sequence);
diff --git a/contrib/libs/yaml-cpp/src/null.cpp b/contrib/libs/yaml-cpp/src/null.cpp
index d12dd08ce4..443e4f98da 100644
--- a/contrib/libs/yaml-cpp/src/null.cpp
+++ b/contrib/libs/yaml-cpp/src/null.cpp
@@ -2,9 +2,9 @@
 
 namespace YAML {
 _Null Null;
-
-bool IsNullString(const std::string& str) {
-  return str.empty() || str == "~" || str == "null" || str == "Null" ||
-         str == "NULL";
-}
+ 
+bool IsNullString(const std::string& str) { 
+  return str.empty() || str == "~" || str == "null" || str == "Null" || 
+         str == "NULL"; 
 }
+} 
diff --git a/contrib/libs/yaml-cpp/src/parse.cpp b/contrib/libs/yaml-cpp/src/parse.cpp
index 0b2ae4a4f6..9e0efdc8c2 100644
--- a/contrib/libs/yaml-cpp/src/parse.cpp
+++ b/contrib/libs/yaml-cpp/src/parse.cpp
@@ -22,18 +22,18 @@ Node Load(const char* input) {
 Node Load(std::istream& input) {
   Parser parser(input);
   NodeBuilder builder;
-  if (!parser.HandleNextDocument(builder)) {
+  if (!parser.HandleNextDocument(builder)) { 
     return Node();
-  }
+  } 
 
   return builder.Root();
 }
 
 Node LoadFile(const std::string& filename) {
   std::ifstream fin(filename.c_str());
-  if (!fin) {
+  if (!fin) { 
     throw BadFile();
-  }
+  } 
   return Load(fin);
 }
 
@@ -53,9 +53,9 @@ std::vector<Node> LoadAll(std::istream& input) {
   Parser parser(input);
   while (1) {
     NodeBuilder builder;
-    if (!parser.HandleNextDocument(builder)) {
+    if (!parser.HandleNextDocument(builder)) { 
       break;
-    }
+    } 
     docs.push_back(builder.Root());
   }
 
@@ -64,9 +64,9 @@ std::vector<Node> LoadAll(std::istream& input) {
 
 std::vector<Node> LoadAllFromFile(const std::string& filename) {
   std::ifstream fin(filename.c_str());
-  if (!fin) {
+  if (!fin) { 
     throw BadFile();
-  }
+  } 
   return LoadAll(fin);
 }
-}  // namespace YAML
+}  // namespace YAML 
diff --git a/contrib/libs/yaml-cpp/src/parser.cpp b/contrib/libs/yaml-cpp/src/parser.cpp
index cd69f39fce..d5d9e20a4e 100644
--- a/contrib/libs/yaml-cpp/src/parser.cpp
+++ b/contrib/libs/yaml-cpp/src/parser.cpp
@@ -31,9 +31,9 @@ bool Parser::HandleNextDocument(EventHandler& eventHandler) {
     return false;
 
   ParseDirectives();
-  if (m_pScanner->empty()) {
+  if (m_pScanner->empty()) { 
     return false;
-  }
+  } 
 
   SingleDocParser sdp(*m_pScanner, *m_pDirectives);
   sdp.HandleDocument(eventHandler);
@@ -44,20 +44,20 @@ void Parser::ParseDirectives() {
   bool readDirective = false;
 
   while (1) {
-    if (m_pScanner->empty()) {
+    if (m_pScanner->empty()) { 
       break;
-    }
+    } 
 
     Token& token = m_pScanner->peek();
-    if (token.type != Token::DIRECTIVE) {
+    if (token.type != Token::DIRECTIVE) { 
       break;
-    }
+    } 
 
     // we keep the directives from the last document if none are specified;
     // but if any directives are specific, then we reset them
-    if (!readDirective) {
+    if (!readDirective) { 
       m_pDirectives.reset(new Directives);
-    }
+    } 
 
     readDirective = true;
     HandleDirective(token);
@@ -66,34 +66,34 @@ void Parser::ParseDirectives() {
 }
 
 void Parser::HandleDirective(const Token& token) {
-  if (token.value == "YAML") {
+  if (token.value == "YAML") { 
     HandleYamlDirective(token);
-  } else if (token.value == "TAG") {
+  } else if (token.value == "TAG") { 
     HandleTagDirective(token);
-  }
+  } 
 }
 
 void Parser::HandleYamlDirective(const Token& token) {
-  if (token.params.size() != 1) {
+  if (token.params.size() != 1) { 
     throw ParserException(token.mark, ErrorMsg::YAML_DIRECTIVE_ARGS);
-  }
+  } 
 
-  if (!m_pDirectives->version.isDefault) {
+  if (!m_pDirectives->version.isDefault) { 
     throw ParserException(token.mark, ErrorMsg::REPEATED_YAML_DIRECTIVE);
-  }
+  } 
 
   std::stringstream str(token.params[0]);
   str >> m_pDirectives->version.major;
   str.get();
   str >> m_pDirectives->version.minor;
-  if (!str || str.peek() != EOF) {
+  if (!str || str.peek() != EOF) { 
     throw ParserException(
         token.mark, std::string(ErrorMsg::YAML_VERSION) + token.params[0]);
-  }
+  } 
 
-  if (m_pDirectives->version.major > 1) {
+  if (m_pDirectives->version.major > 1) { 
     throw ParserException(token.mark, ErrorMsg::YAML_MAJOR_VERSION);
-  }
+  } 
 
   m_pDirectives->version.isDefault = false;
   // TODO: warning on major == 1, minor > 2?
@@ -105,22 +105,22 @@ void Parser::HandleTagDirective(const Token& token) {
 
   const std::string& handle = token.params[0];
   const std::string& prefix = token.params[1];
-  if (m_pDirectives->tags.find(handle) != m_pDirectives->tags.end()) {
+  if (m_pDirectives->tags.find(handle) != m_pDirectives->tags.end()) { 
     throw ParserException(token.mark, ErrorMsg::REPEATED_TAG_DIRECTIVE);
-  }
+  } 
 
   m_pDirectives->tags[handle] = prefix;
 }
 
 void Parser::PrintTokens(std::ostream& out) {
-  if (!m_pScanner.get()) {
+  if (!m_pScanner.get()) { 
     return;
-  }
+  } 
 
   while (1) {
-    if (m_pScanner->empty()) {
+    if (m_pScanner->empty()) { 
       break;
-    }
+    } 
 
     out << m_pScanner->peek() << "\n";
     m_pScanner->pop();
diff --git a/contrib/libs/yaml-cpp/src/ptr_vector.h b/contrib/libs/yaml-cpp/src/ptr_vector.h
index 955aebd8d5..b4f899035b 100644
--- a/contrib/libs/yaml-cpp/src/ptr_vector.h
+++ b/contrib/libs/yaml-cpp/src/ptr_vector.h
@@ -16,27 +16,27 @@
 
 namespace YAML {
 
-// TODO: This class is no longer needed
+// TODO: This class is no longer needed 
 template <typename T>
 class ptr_vector : private YAML::noncopyable {
  public:
   ptr_vector() {}
 
-  void clear() { m_data.clear(); }
+  void clear() { m_data.clear(); } 
 
   std::size_t size() const { return m_data.size(); }
   bool empty() const { return m_data.empty(); }
 
-  void push_back(std::unique_ptr<T>&& t) { m_data.push_back(std::move(t)); }
+  void push_back(std::unique_ptr<T>&& t) { m_data.push_back(std::move(t)); } 
   T& operator[](std::size_t i) { return *m_data[i]; }
   const T& operator[](std::size_t i) const { return *m_data[i]; }
 
-  T& back() { return *(m_data.back().get()); }
-
-  const T& back() const { return *(m_data.back().get()); }
+  T& back() { return *(m_data.back().get()); } 
 
+  const T& back() const { return *(m_data.back().get()); } 
+ 
  private:
-  std::vector<std::unique_ptr<T>> m_data;
+  std::vector<std::unique_ptr<T>> m_data; 
 };
 }
 
diff --git a/contrib/libs/yaml-cpp/src/regex_yaml.h b/contrib/libs/yaml-cpp/src/regex_yaml.h
index 8f28b852a2..3e7c5042b1 100644
--- a/contrib/libs/yaml-cpp/src/regex_yaml.h
+++ b/contrib/libs/yaml-cpp/src/regex_yaml.h
@@ -10,8 +10,8 @@
 #include <string>
 #include <vector>
 
-#include "yaml-cpp/dll.h"
-
+#include "yaml-cpp/dll.h" 
+ 
 namespace YAML {
 class Stream;
 
@@ -28,7 +28,7 @@ enum REGEX_OP {
 // simplified regular expressions
 // . Only straightforward matches (no repeated characters)
 // . Only matches from start of string
-class YAML_CPP_API RegEx {
+class YAML_CPP_API RegEx { 
  public:
   RegEx();
   RegEx(char ch);
@@ -36,10 +36,10 @@ class YAML_CPP_API RegEx {
   RegEx(const std::string& str, REGEX_OP op = REGEX_SEQ);
   ~RegEx() {}
 
-  friend YAML_CPP_API RegEx operator!(const RegEx& ex);
-  friend YAML_CPP_API RegEx operator||(const RegEx& ex1, const RegEx& ex2);
-  friend YAML_CPP_API RegEx operator&&(const RegEx& ex1, const RegEx& ex2);
-  friend YAML_CPP_API RegEx operator+(const RegEx& ex1, const RegEx& ex2);
+  friend YAML_CPP_API RegEx operator!(const RegEx& ex); 
+  friend YAML_CPP_API RegEx operator||(const RegEx& ex1, const RegEx& ex2); 
+  friend YAML_CPP_API RegEx operator&&(const RegEx& ex1, const RegEx& ex2); 
+  friend YAML_CPP_API RegEx operator+(const RegEx& ex1, const RegEx& ex2); 
 
   bool Matches(char ch) const;
   bool Matches(const std::string& str) const;
diff --git a/contrib/libs/yaml-cpp/src/scanner.cpp b/contrib/libs/yaml-cpp/src/scanner.cpp
index b5cfcc12b2..7176d6d6d0 100644
--- a/contrib/libs/yaml-cpp/src/scanner.cpp
+++ b/contrib/libs/yaml-cpp/src/scanner.cpp
@@ -51,9 +51,9 @@ void Scanner::EnsureTokensInQueue() {
       Token& token = m_tokens.front();
 
       // if this guy's valid, then we're done
-      if (token.status == Token::VALID) {
+      if (token.status == Token::VALID) { 
         return;
-      }
+      } 
 
       // here's where we clean up the impossible tokens
       if (token.status == Token::INVALID) {
@@ -65,9 +65,9 @@ void Scanner::EnsureTokensInQueue() {
     }
 
     // no token? maybe we've actually finished
-    if (m_endedStream) {
+    if (m_endedStream) { 
       return;
-    }
+    } 
 
     // no? then scan...
     ScanNextToken();
@@ -75,13 +75,13 @@ void Scanner::EnsureTokensInQueue() {
 }
 
 void Scanner::ScanNextToken() {
-  if (m_endedStream) {
+  if (m_endedStream) { 
     return;
-  }
+  } 
 
-  if (!m_startedStream) {
+  if (!m_startedStream) { 
     return StartStream();
-  }
+  } 
 
   // get rid of whitespace, etc. (in between tokens it should be irrelevent)
   ScanToNextToken();
@@ -94,75 +94,75 @@ void Scanner::ScanNextToken() {
   // *****
 
   // end of stream
-  if (!INPUT) {
+  if (!INPUT) { 
     return EndStream();
-  }
+  } 
 
-  if (INPUT.column() == 0 && INPUT.peek() == Keys::Directive) {
+  if (INPUT.column() == 0 && INPUT.peek() == Keys::Directive) { 
     return ScanDirective();
-  }
+  } 
 
   // document token
-  if (INPUT.column() == 0 && Exp::DocStart().Matches(INPUT)) {
+  if (INPUT.column() == 0 && Exp::DocStart().Matches(INPUT)) { 
     return ScanDocStart();
-  }
+  } 
 
-  if (INPUT.column() == 0 && Exp::DocEnd().Matches(INPUT)) {
+  if (INPUT.column() == 0 && Exp::DocEnd().Matches(INPUT)) { 
     return ScanDocEnd();
-  }
+  } 
 
   // flow start/end/entry
-  if (INPUT.peek() == Keys::FlowSeqStart ||
-      INPUT.peek() == Keys::FlowMapStart) {
+  if (INPUT.peek() == Keys::FlowSeqStart || 
+      INPUT.peek() == Keys::FlowMapStart) { 
     return ScanFlowStart();
-  }
+  } 
 
-  if (INPUT.peek() == Keys::FlowSeqEnd || INPUT.peek() == Keys::FlowMapEnd) {
+  if (INPUT.peek() == Keys::FlowSeqEnd || INPUT.peek() == Keys::FlowMapEnd) { 
     return ScanFlowEnd();
-  }
+  } 
 
-  if (INPUT.peek() == Keys::FlowEntry) {
+  if (INPUT.peek() == Keys::FlowEntry) { 
     return ScanFlowEntry();
-  }
+  } 
 
   // block/map stuff
-  if (Exp::BlockEntry().Matches(INPUT)) {
+  if (Exp::BlockEntry().Matches(INPUT)) { 
     return ScanBlockEntry();
-  }
+  } 
 
-  if ((InBlockContext() ? Exp::Key() : Exp::KeyInFlow()).Matches(INPUT)) {
+  if ((InBlockContext() ? Exp::Key() : Exp::KeyInFlow()).Matches(INPUT)) { 
     return ScanKey();
-  }
+  } 
 
-  if (GetValueRegex().Matches(INPUT)) {
+  if (GetValueRegex().Matches(INPUT)) { 
     return ScanValue();
-  }
+  } 
 
   // alias/anchor
-  if (INPUT.peek() == Keys::Alias || INPUT.peek() == Keys::Anchor) {
+  if (INPUT.peek() == Keys::Alias || INPUT.peek() == Keys::Anchor) { 
     return ScanAnchorOrAlias();
-  }
+  } 
 
   // tag
-  if (INPUT.peek() == Keys::Tag) {
+  if (INPUT.peek() == Keys::Tag) { 
     return ScanTag();
-  }
+  } 
 
   // special scalars
   if (InBlockContext() && (INPUT.peek() == Keys::LiteralScalar ||
-                           INPUT.peek() == Keys::FoldedScalar)) {
+                           INPUT.peek() == Keys::FoldedScalar)) { 
     return ScanBlockScalar();
-  }
+  } 
 
-  if (INPUT.peek() == '\'' || INPUT.peek() == '\"') {
+  if (INPUT.peek() == '\'' || INPUT.peek() == '\"') { 
     return ScanQuotedScalar();
-  }
+  } 
 
   // plain scalars
   if ((InBlockContext() ? Exp::PlainScalar() : Exp::PlainScalarInFlow())
-          .Matches(INPUT)) {
+          .Matches(INPUT)) { 
     return ScanPlainScalar();
-  }
+  } 
 
   // don't know what it is!
   throw ParserException(INPUT.mark(), ErrorMsg::UNKNOWN_TOKEN);
@@ -172,24 +172,24 @@ void Scanner::ScanToNextToken() {
   while (1) {
     // first eat whitespace
     while (INPUT && IsWhitespaceToBeEaten(INPUT.peek())) {
-      if (InBlockContext() && Exp::Tab().Matches(INPUT)) {
+      if (InBlockContext() && Exp::Tab().Matches(INPUT)) { 
         m_simpleKeyAllowed = false;
-      }
+      } 
       INPUT.eat(1);
     }
 
     // then eat a comment
     if (Exp::Comment().Matches(INPUT)) {
       // eat until line break
-      while (INPUT && !Exp::Break().Matches(INPUT)) {
+      while (INPUT && !Exp::Break().Matches(INPUT)) { 
         INPUT.eat(1);
-      }
+      } 
     }
 
     // if it's NOT a line break, then we're done!
-    if (!Exp::Break().Matches(INPUT)) {
+    if (!Exp::Break().Matches(INPUT)) { 
       break;
-    }
+    } 
 
     // otherwise, let's eat the line break and keep going
     int n = Exp::Break().Match(INPUT);
@@ -199,9 +199,9 @@ void Scanner::ScanToNextToken() {
     InvalidateSimpleKey();
 
     // new line - we may be able to accept a simple key now
-    if (InBlockContext()) {
+    if (InBlockContext()) { 
       m_simpleKeyAllowed = true;
-    }
+    } 
   }
 }
 
@@ -218,21 +218,21 @@ void Scanner::ScanToNextToken() {
 //   that they can't contribute to indentation, so once you've seen a tab in a
 //   line, you can't start a simple key
 bool Scanner::IsWhitespaceToBeEaten(char ch) {
-  if (ch == ' ') {
+  if (ch == ' ') { 
     return true;
-  }
+  } 
 
-  if (ch == '\t') {
+  if (ch == '\t') { 
     return true;
-  }
+  } 
 
   return false;
 }
 
 const RegEx& Scanner::GetValueRegex() const {
-  if (InBlockContext()) {
+  if (InBlockContext()) { 
     return Exp::Value();
-  }
+  } 
 
   return m_canBeJSONFlow ? Exp::ValueInJSONFlow() : Exp::ValueInFlow();
 }
@@ -240,17 +240,17 @@ const RegEx& Scanner::GetValueRegex() const {
 void Scanner::StartStream() {
   m_startedStream = true;
   m_simpleKeyAllowed = true;
-  std::unique_ptr<IndentMarker> pIndent(
-      new IndentMarker(-1, IndentMarker::NONE));
-  m_indentRefs.push_back(std::move(pIndent));
+  std::unique_ptr<IndentMarker> pIndent( 
+      new IndentMarker(-1, IndentMarker::NONE)); 
+  m_indentRefs.push_back(std::move(pIndent)); 
   m_indents.push(&m_indentRefs.back());
 }
 
 void Scanner::EndStream() {
   // force newline
-  if (INPUT.column() > 0) {
+  if (INPUT.column() > 0) { 
     INPUT.ResetColumn();
-  }
+  } 
 
   PopAllIndents();
   PopAllSimpleKeys();
@@ -281,72 +281,72 @@ Token::TYPE Scanner::GetStartTokenFor(IndentMarker::INDENT_TYPE type) const {
 Scanner::IndentMarker* Scanner::PushIndentTo(int column,
                                              IndentMarker::INDENT_TYPE type) {
   // are we in flow?
-  if (InFlowContext()) {
+  if (InFlowContext()) { 
     return 0;
-  }
+  } 
 
-  std::unique_ptr<IndentMarker> pIndent(new IndentMarker(column, type));
+  std::unique_ptr<IndentMarker> pIndent(new IndentMarker(column, type)); 
   IndentMarker& indent = *pIndent;
   const IndentMarker& lastIndent = *m_indents.top();
 
   // is this actually an indentation?
-  if (indent.column < lastIndent.column) {
+  if (indent.column < lastIndent.column) { 
     return 0;
-  }
+  } 
   if (indent.column == lastIndent.column &&
       !(indent.type == IndentMarker::SEQ &&
-        lastIndent.type == IndentMarker::MAP)) {
+        lastIndent.type == IndentMarker::MAP)) { 
     return 0;
-  }
+  } 
 
   // push a start token
   indent.pStartToken = PushToken(GetStartTokenFor(type));
 
   // and then the indent
   m_indents.push(&indent);
-  m_indentRefs.push_back(std::move(pIndent));
+  m_indentRefs.push_back(std::move(pIndent)); 
   return &m_indentRefs.back();
 }
 
 void Scanner::PopIndentToHere() {
   // are we in flow?
-  if (InFlowContext()) {
+  if (InFlowContext()) { 
     return;
-  }
+  } 
 
   // now pop away
   while (!m_indents.empty()) {
     const IndentMarker& indent = *m_indents.top();
-    if (indent.column < INPUT.column()) {
+    if (indent.column < INPUT.column()) { 
       break;
-    }
+    } 
     if (indent.column == INPUT.column() &&
         !(indent.type == IndentMarker::SEQ &&
-          !Exp::BlockEntry().Matches(INPUT))) {
+          !Exp::BlockEntry().Matches(INPUT))) { 
       break;
-    }
+    } 
 
     PopIndent();
   }
 
-  while (!m_indents.empty() &&
-         m_indents.top()->status == IndentMarker::INVALID) {
+  while (!m_indents.empty() && 
+         m_indents.top()->status == IndentMarker::INVALID) { 
     PopIndent();
-  }
+  } 
 }
 
 void Scanner::PopAllIndents() {
   // are we in flow?
-  if (InFlowContext()) {
+  if (InFlowContext()) { 
     return;
-  }
+  } 
 
   // now pop away
   while (!m_indents.empty()) {
     const IndentMarker& indent = *m_indents.top();
-    if (indent.type == IndentMarker::NONE) {
+    if (indent.type == IndentMarker::NONE) { 
       break;
-    }
+    } 
 
     PopIndent();
   }
@@ -361,17 +361,17 @@ void Scanner::PopIndent() {
     return;
   }
 
-  if (indent.type == IndentMarker::SEQ) {
+  if (indent.type == IndentMarker::SEQ) { 
     m_tokens.push(Token(Token::BLOCK_SEQ_END, INPUT.mark()));
-  } else if (indent.type == IndentMarker::MAP) {
+  } else if (indent.type == IndentMarker::MAP) { 
     m_tokens.push(Token(Token::BLOCK_MAP_END, INPUT.mark()));
-  }
+  } 
 }
 
 int Scanner::GetTopIndent() const {
-  if (m_indents.empty()) {
+  if (m_indents.empty()) { 
     return 0;
-  }
+  } 
   return m_indents.top()->column;
 }
 
@@ -383,4 +383,4 @@ void Scanner::ThrowParserException(const std::string& msg) const {
   }
   throw ParserException(mark, msg);
 }
-}  // namespace YAML
+}  // namespace YAML 
diff --git a/contrib/libs/yaml-cpp/src/scanner.h b/contrib/libs/yaml-cpp/src/scanner.h
index 7bb2ccc71a..6c1ebcecfe 100644
--- a/contrib/libs/yaml-cpp/src/scanner.h
+++ b/contrib/libs/yaml-cpp/src/scanner.h
@@ -24,24 +24,24 @@ namespace YAML {
 class Node;
 class RegEx;
 
-/**
- * A scanner transforms a stream of characters into a stream of tokens.
- */
+/** 
+ * A scanner transforms a stream of characters into a stream of tokens. 
+ */ 
 class Scanner {
  public:
-  explicit Scanner(std::istream &in);
+  explicit Scanner(std::istream &in); 
   ~Scanner();
 
-  /** Returns true if there are no more tokens to be read. */
+  /** Returns true if there are no more tokens to be read. */ 
   bool empty();
-
-  /** Removes the next token in the queue. */
+ 
+  /** Removes the next token in the queue. */ 
   void pop();
-
-  /** Returns, but does not remove, the next token in the queue. */
+ 
+  /** Returns, but does not remove, the next token in the queue. */ 
   Token &peek();
-
-  /** Returns the current mark in the input stream. */
+ 
+  /** Returns the current mark in the input stream. */ 
   Mark mark() const;
 
  private:
@@ -61,29 +61,29 @@ class Scanner {
 
  private:
   // scanning
-
-  /**
-   * Scans until there's a valid token at the front of the queue, or the queue
-   * is empty. The state can be checked by {@link #empty}, and the next token
-   * retrieved by {@link #peek}.
-   */
+ 
+  /** 
+   * Scans until there's a valid token at the front of the queue, or the queue 
+   * is empty. The state can be checked by {@link #empty}, and the next token 
+   * retrieved by {@link #peek}. 
+   */ 
   void EnsureTokensInQueue();
-
-  /**
-   * The main scanning function; this method branches out to scan whatever the
-   * next token should be.
-   */
+ 
+  /** 
+   * The main scanning function; this method branches out to scan whatever the 
+   * next token should be. 
+   */ 
   void ScanNextToken();
-
-  /** Eats the input stream until it reaches the next token-like thing. */
+ 
+  /** Eats the input stream until it reaches the next token-like thing. */ 
   void ScanToNextToken();
-
-  /** Sets the initial conditions for starting a stream. */
+ 
+  /** Sets the initial conditions for starting a stream. */ 
   void StartStream();
-
-  /** Closes out the stream, finish up, etc. */
+ 
+  /** Closes out the stream, finish up, etc. */ 
   void EndStream();
-
+ 
   Token *PushToken(Token::TYPE type);
 
   bool InFlowContext() const { return !m_flows.empty(); }
@@ -91,29 +91,29 @@ class Scanner {
   std::size_t GetFlowLevel() const { return m_flows.size(); }
 
   Token::TYPE GetStartTokenFor(IndentMarker::INDENT_TYPE type) const;
-
-  /**
-   * Pushes an indentation onto the stack, and enqueues the proper token
-   * (sequence start or mapping start).
-   *
-   * @return the indent marker it generates (if any).
-   */
+ 
+  /** 
+   * Pushes an indentation onto the stack, and enqueues the proper token 
+   * (sequence start or mapping start). 
+   * 
+   * @return the indent marker it generates (if any). 
+   */ 
   IndentMarker *PushIndentTo(int column, IndentMarker::INDENT_TYPE type);
-
-  /**
-   * Pops indentations off the stack until it reaches the current indentation
-   * level, and enqueues the proper token each time. Then pops all invalid
-   * indentations off.
-   */
+ 
+  /** 
+   * Pops indentations off the stack until it reaches the current indentation 
+   * level, and enqueues the proper token each time. Then pops all invalid 
+   * indentations off. 
+   */ 
   void PopIndentToHere();
-
-  /**
-   * Pops all indentations (except for the base empty one) off the stack, and
-   * enqueues the proper token each time.
-   */
+ 
+  /** 
+   * Pops all indentations (except for the base empty one) off the stack, and 
+   * enqueues the proper token each time. 
+   */ 
   void PopAllIndents();
-
-  /** Pops a single indent, pushing the proper token. */
+ 
+  /** Pops a single indent, pushing the proper token. */ 
   void PopIndent();
   int GetTopIndent() const;
 
@@ -125,17 +125,17 @@ class Scanner {
   bool VerifySimpleKey();
   void PopAllSimpleKeys();
 
-  /**
-   * Throws a ParserException with the current token location (if available),
-   * and does not parse any more tokens.
-   */
+  /** 
+   * Throws a ParserException with the current token location (if available), 
+   * and does not parse any more tokens. 
+   */ 
   void ThrowParserException(const std::string &msg) const;
 
   bool IsWhitespaceToBeEaten(char ch);
-
-  /**
-   * Returns the appropriate regex to check if the next token is a value token.
-   */
+ 
+  /** 
+   * Returns the appropriate regex to check if the next token is a value token. 
+   */ 
   const RegEx &GetValueRegex() const;
 
   struct SimpleKey {
diff --git a/contrib/libs/yaml-cpp/src/scanscalar.cpp b/contrib/libs/yaml-cpp/src/scanscalar.cpp
index 10e359d446..28fcf10eed 100644
--- a/contrib/libs/yaml-cpp/src/scanscalar.cpp
+++ b/contrib/libs/yaml-cpp/src/scanscalar.cpp
@@ -28,28 +28,28 @@ std::string ScanScalar(Stream& INPUT, ScanScalarParams& params) {
   std::string scalar;
   params.leadingSpaces = false;
 
-  if (!params.end) {
-    params.end = &Exp::Empty();
-  }
-
+  if (!params.end) { 
+    params.end = &Exp::Empty(); 
+  } 
+ 
   while (INPUT) {
     // ********************************
     // Phase #1: scan until line ending
 
     std::size_t lastNonWhitespaceChar = scalar.size();
     bool escapedNewline = false;
-    while (!params.end->Matches(INPUT) && !Exp::Break().Matches(INPUT)) {
-      if (!INPUT) {
+    while (!params.end->Matches(INPUT) && !Exp::Break().Matches(INPUT)) { 
+      if (!INPUT) { 
         break;
-      }
+      } 
 
       // document indicator?
       if (INPUT.column() == 0 && Exp::DocIndicator().Matches(INPUT)) {
-        if (params.onDocIndicator == BREAK) {
+        if (params.onDocIndicator == BREAK) { 
           break;
-        } else if (params.onDocIndicator == THROW) {
+        } else if (params.onDocIndicator == THROW) { 
           throw ParserException(INPUT.mark(), ErrorMsg::DOC_IN_SCALAR);
-        }
+        } 
       }
 
       foundNonEmptyLine = true;
@@ -76,31 +76,31 @@ std::string ScanScalar(Stream& INPUT, ScanScalarParams& params) {
       // otherwise, just add the damn character
       char ch = INPUT.get();
       scalar += ch;
-      if (ch != ' ' && ch != '\t') {
+      if (ch != ' ' && ch != '\t') { 
         lastNonWhitespaceChar = scalar.size();
-      }
+      } 
     }
 
     // eof? if we're looking to eat something, then we throw
     if (!INPUT) {
-      if (params.eatEnd) {
+      if (params.eatEnd) { 
         throw ParserException(INPUT.mark(), ErrorMsg::EOF_IN_SCALAR);
-      }
+      } 
       break;
     }
 
     // doc indicator?
     if (params.onDocIndicator == BREAK && INPUT.column() == 0 &&
-        Exp::DocIndicator().Matches(INPUT)) {
+        Exp::DocIndicator().Matches(INPUT)) { 
       break;
-    }
+    } 
 
     // are we done via character match?
-    int n = params.end->Match(INPUT);
+    int n = params.end->Match(INPUT); 
     if (n >= 0) {
-      if (params.eatEnd) {
+      if (params.eatEnd) { 
         INPUT.eat(n);
-      }
+      } 
       break;
     }
 
@@ -117,34 +117,34 @@ std::string ScanScalar(Stream& INPUT, ScanScalarParams& params) {
     // Phase #3: scan initial spaces
 
     // first the required indentation
-    while (INPUT.peek() == ' ' &&
-           (INPUT.column() < params.indent ||
-            (params.detectIndent && !foundNonEmptyLine)) &&
-           !params.end->Matches(INPUT)) {
+    while (INPUT.peek() == ' ' && 
+           (INPUT.column() < params.indent || 
+            (params.detectIndent && !foundNonEmptyLine)) && 
+           !params.end->Matches(INPUT)) { 
       INPUT.eat(1);
-    }
+    } 
 
     // update indent if we're auto-detecting
-    if (params.detectIndent && !foundNonEmptyLine) {
+    if (params.detectIndent && !foundNonEmptyLine) { 
       params.indent = std::max(params.indent, INPUT.column());
-    }
+    } 
 
     // and then the rest of the whitespace
     while (Exp::Blank().Matches(INPUT)) {
       // we check for tabs that masquerade as indentation
       if (INPUT.peek() == '\t' && INPUT.column() < params.indent &&
-          params.onTabInIndentation == THROW) {
+          params.onTabInIndentation == THROW) { 
         throw ParserException(INPUT.mark(), ErrorMsg::TAB_IN_INDENTATION);
-      }
+      } 
 
-      if (!params.eatLeadingWhitespace) {
+      if (!params.eatLeadingWhitespace) { 
         break;
-      }
-
-      if (params.end->Matches(INPUT)) {
-        break;
-      }
+      } 
 
+      if (params.end->Matches(INPUT)) { 
+        break; 
+      } 
+ 
       INPUT.eat(1);
     }
 
@@ -163,29 +163,29 @@ std::string ScanScalar(Stream& INPUT, ScanScalarParams& params) {
           break;
         case FOLD_BLOCK:
           if (!emptyLine && !nextEmptyLine && !moreIndented &&
-              !nextMoreIndented && INPUT.column() >= params.indent) {
+              !nextMoreIndented && INPUT.column() >= params.indent) { 
             scalar += " ";
-          } else if (nextEmptyLine) {
+          } else if (nextEmptyLine) { 
             foldedNewlineCount++;
-          } else {
+          } else { 
             scalar += "\n";
-          }
+          } 
 
           if (!nextEmptyLine && foldedNewlineCount > 0) {
             scalar += std::string(foldedNewlineCount - 1, '\n');
             if (foldedNewlineStartedMoreIndented ||
-                nextMoreIndented | !foundNonEmptyLine) {
+                nextMoreIndented | !foundNonEmptyLine) { 
               scalar += "\n";
-            }
+            } 
             foldedNewlineCount = 0;
           }
           break;
         case FOLD_FLOW:
-          if (nextEmptyLine) {
+          if (nextEmptyLine) { 
             scalar += "\n";
-          } else if (!emptyLine && !nextEmptyLine && !escapedNewline) {
+          } else if (!emptyLine && !nextEmptyLine && !escapedNewline) { 
             scalar += " ";
-          }
+          } 
           break;
       }
     }
@@ -205,41 +205,41 @@ std::string ScanScalar(Stream& INPUT, ScanScalarParams& params) {
   if (params.trimTrailingSpaces) {
     std::size_t pos = scalar.find_last_not_of(' ');
     if (lastEscapedChar != std::string::npos) {
-      if (pos < lastEscapedChar || pos == std::string::npos) {
+      if (pos < lastEscapedChar || pos == std::string::npos) { 
         pos = lastEscapedChar;
-      }
+      } 
     }
-    if (pos < scalar.size()) {
+    if (pos < scalar.size()) { 
       scalar.erase(pos + 1);
-    }
+    } 
   }
 
   switch (params.chomp) {
     case CLIP: {
       std::size_t pos = scalar.find_last_not_of('\n');
       if (lastEscapedChar != std::string::npos) {
-        if (pos < lastEscapedChar || pos == std::string::npos) {
+        if (pos < lastEscapedChar || pos == std::string::npos) { 
           pos = lastEscapedChar;
-        }
+        } 
       }
-      if (pos == std::string::npos) {
+      if (pos == std::string::npos) { 
         scalar.erase();
-      } else if (pos + 1 < scalar.size()) {
+      } else if (pos + 1 < scalar.size()) { 
         scalar.erase(pos + 2);
-      }
+      } 
     } break;
     case STRIP: {
       std::size_t pos = scalar.find_last_not_of('\n');
       if (lastEscapedChar != std::string::npos) {
-        if (pos < lastEscapedChar || pos == std::string::npos) {
+        if (pos < lastEscapedChar || pos == std::string::npos) { 
           pos = lastEscapedChar;
-        }
+        } 
       }
-      if (pos == std::string::npos) {
+      if (pos == std::string::npos) { 
         scalar.erase();
-      } else if (pos < scalar.size()) {
+      } else if (pos < scalar.size()) { 
         scalar.erase(pos + 1);
-      }
+      } 
     } break;
     default:
       break;
diff --git a/contrib/libs/yaml-cpp/src/scanscalar.h b/contrib/libs/yaml-cpp/src/scanscalar.h
index c3a574ad9b..a8282f61f7 100644
--- a/contrib/libs/yaml-cpp/src/scanscalar.h
+++ b/contrib/libs/yaml-cpp/src/scanscalar.h
@@ -19,8 +19,8 @@ enum FOLD { DONT_FOLD, FOLD_BLOCK, FOLD_FLOW };
 
 struct ScanScalarParams {
   ScanScalarParams()
-      : end(nullptr),
-        eatEnd(false),
+      : end(nullptr), 
+        eatEnd(false), 
         indent(0),
         detectIndent(false),
         eatLeadingWhitespace(0),
@@ -33,8 +33,8 @@ struct ScanScalarParams {
         leadingSpaces(false) {}
 
   // input:
-  const RegEx* end;   // what condition ends this scalar?
-                      // unowned.
+  const RegEx* end;   // what condition ends this scalar? 
+                      // unowned. 
   bool eatEnd;        // should we eat that condition when we see it?
   int indent;         // what level of indentation should be eaten and ignored?
   bool detectIndent;  // should we try to autodetect the indent?
diff --git a/contrib/libs/yaml-cpp/src/scantoken.cpp b/contrib/libs/yaml-cpp/src/scantoken.cpp
index fd8758d781..9a722b15b6 100644
--- a/contrib/libs/yaml-cpp/src/scantoken.cpp
+++ b/contrib/libs/yaml-cpp/src/scantoken.cpp
@@ -297,8 +297,8 @@ void Scanner::ScanPlainScalar() {
 
   // set up the scanning parameters
   ScanScalarParams params;
-  params.end =
-      (InFlowContext() ? &Exp::ScanScalarEndInFlow() : &Exp::ScanScalarEnd());
+  params.end = 
+      (InFlowContext() ? &Exp::ScanScalarEndInFlow() : &Exp::ScanScalarEnd()); 
   params.eatEnd = false;
   params.indent = (InFlowContext() ? 0 : GetTopIndent() + 1);
   params.fold = FOLD_FLOW;
@@ -338,8 +338,8 @@ void Scanner::ScanQuotedScalar() {
 
   // setup the scanning parameters
   ScanScalarParams params;
-  RegEx end = (single ? RegEx(quote) && !Exp::EscSingleQuote() : RegEx(quote));
-  params.end = &end;
+  RegEx end = (single ? RegEx(quote) && !Exp::EscSingleQuote() : RegEx(quote)); 
+  params.end = &end; 
   params.eatEnd = true;
   params.escape = (single ? '\'' : '\\');
   params.indent = 0;
diff --git a/contrib/libs/yaml-cpp/src/setting.h b/contrib/libs/yaml-cpp/src/setting.h
index b78d40e2e8..0f8e19fbc6 100644
--- a/contrib/libs/yaml-cpp/src/setting.h
+++ b/contrib/libs/yaml-cpp/src/setting.h
@@ -20,7 +20,7 @@ class Setting {
   Setting() : m_value() {}
 
   const T get() const { return m_value; }
-  std::unique_ptr<SettingChangeBase> set(const T& value);
+  std::unique_ptr<SettingChangeBase> set(const T& value); 
   void restore(const Setting<T>& oldSetting) { m_value = oldSetting.get(); }
 
  private:
@@ -49,8 +49,8 @@ class SettingChange : public SettingChangeBase {
 };
 
 template <typename T>
-inline std::unique_ptr<SettingChangeBase> Setting<T>::set(const T& value) {
-  std::unique_ptr<SettingChangeBase> pChange(new SettingChange<T>(this));
+inline std::unique_ptr<SettingChangeBase> Setting<T>::set(const T& value) { 
+  std::unique_ptr<SettingChangeBase> pChange(new SettingChange<T>(this)); 
   m_value = value;
   return pChange;
 }
@@ -71,23 +71,23 @@ class SettingChanges : private noncopyable {
       (*it)->pop();
   }
 
-  void push(std::unique_ptr<SettingChangeBase> pSettingChange) {
-    m_settingChanges.push_back(std::move(pSettingChange));
+  void push(std::unique_ptr<SettingChangeBase> pSettingChange) { 
+    m_settingChanges.push_back(std::move(pSettingChange)); 
   }
 
-  // like std::unique_ptr - assignment is transfer of ownership
-  SettingChanges& operator=(SettingChanges&& rhs) {
+  // like std::unique_ptr - assignment is transfer of ownership 
+  SettingChanges& operator=(SettingChanges&& rhs) { 
     if (this == &rhs)
       return *this;
 
     clear();
-    std::swap(m_settingChanges, rhs.m_settingChanges);
-
+    std::swap(m_settingChanges, rhs.m_settingChanges); 
+ 
     return *this;
   }
 
  private:
-  typedef std::vector<std::unique_ptr<SettingChangeBase>> setting_changes;
+  typedef std::vector<std::unique_ptr<SettingChangeBase>> setting_changes; 
   setting_changes m_settingChanges;
 };
 }
diff --git a/contrib/libs/yaml-cpp/src/singledocparser.cpp b/contrib/libs/yaml-cpp/src/singledocparser.cpp
index a27c1c3b04..b2d9bbfad4 100644
--- a/contrib/libs/yaml-cpp/src/singledocparser.cpp
+++ b/contrib/libs/yaml-cpp/src/singledocparser.cpp
@@ -11,7 +11,7 @@
 #include "yaml-cpp/eventhandler.h"
 #include "yaml-cpp/exceptions.h"  // IWYU pragma: keep
 #include "yaml-cpp/mark.h"
-#include "yaml-cpp/null.h"
+#include "yaml-cpp/null.h" 
 
 namespace YAML {
 SingleDocParser::SingleDocParser(Scanner& scanner, const Directives& directives)
@@ -76,7 +76,7 @@ void SingleDocParser::HandleNode(EventHandler& eventHandler) {
 
   const Token& token = m_scanner.peek();
 
-  if (token.type == Token::PLAIN_SCALAR && IsNullString(token.value)) {
+  if (token.type == Token::PLAIN_SCALAR && IsNullString(token.value)) { 
     eventHandler.OnNull(mark, anchor);
     m_scanner.pop();
     return;
diff --git a/contrib/libs/yaml-cpp/src/singledocparser.h b/contrib/libs/yaml-cpp/src/singledocparser.h
index 2b92067cdd..4c005b1ad0 100644
--- a/contrib/libs/yaml-cpp/src/singledocparser.h
+++ b/contrib/libs/yaml-cpp/src/singledocparser.h
@@ -53,7 +53,7 @@ class SingleDocParser : private noncopyable {
  private:
   Scanner& m_scanner;
   const Directives& m_directives;
-  std::unique_ptr<CollectionStack> m_pCollectionStack;
+  std::unique_ptr<CollectionStack> m_pCollectionStack; 
 
   typedef std::map<std::string, anchor_t> Anchors;
   Anchors m_anchors;
diff --git a/contrib/libs/yaml-cpp/ya.make b/contrib/libs/yaml-cpp/ya.make
index 058caf92fa..293ae35ea1 100644
--- a/contrib/libs/yaml-cpp/ya.make
+++ b/contrib/libs/yaml-cpp/ya.make
@@ -27,7 +27,7 @@ SRCS(
     src/emitter.cpp
     src/emitterstate.cpp
     src/emitterutils.cpp
-    src/exceptions.cpp
+    src/exceptions.cpp 
     src/exp.cpp
     src/memory.cpp
     src/nodebuilder.cpp