oas_router_gen.go

// Code generated by ogen, DO NOT EDIT.

package oas

import (
	"net/http"
	"net/url"
	"strings"

	"github.com/ogen-go/ogen/uri"
)

func (s *Server) cutPrefix(path string) (string, bool) {
	prefix := s.cfg.Prefix
	if prefix == "" {
		return path, true
	}
	if !strings.HasPrefix(path, prefix) {
		// Prefix doesn't match.
		return "", false
	}
	// Cut prefix from the path.
	return strings.TrimPrefix(path, prefix), true
}

// ServeHTTP serves http request as defined by OpenAPI v3 specification,
// calling handler that matches the path or returning not found error.
func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	elem := r.URL.Path
	elemIsEscaped := false
	if rawPath := r.URL.RawPath; rawPath != "" {
		if normalized, ok := uri.NormalizeEscapedPath(rawPath); ok {
			elem = normalized
			elemIsEscaped = strings.ContainsRune(elem, '%')
		}
	}

	elem, ok := s.cutPrefix(elem)
	if !ok || len(elem) == 0 {
		s.notFound(w, r)
		return
	}
	args := [2]string{}

	// Static code generated router with unwrapped path search.
	switch {
	default:
		if len(elem) == 0 {
			break
		}
		switch elem[0] {
		case '/': // Prefix: "/v2/"
			origElem := elem
			if l := len("/v2/"); len(elem) >= l && elem[0:l] == "/v2/" {
				elem = elem[l:]
			} else {
				break
			}

			if len(elem) == 0 {
				break
			}
			switch elem[0] {
			case 'a': // Prefix: "a"
				origElem := elem
				if l := len("a"); len(elem) >= l && elem[0:l] == "a" {
					elem = elem[l:]
				} else {
					break
				}

				if len(elem) == 0 {
					break
				}
				switch elem[0] {
				case 'c': // Prefix: "ccounts/"
					origElem := elem
					if l := len("ccounts/"); len(elem) >= l && elem[0:l] == "ccounts/" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						break
					}
					switch elem[0] {
					case '_': // Prefix: "_bulk"
						origElem := elem
						if l := len("_bulk"); len(elem) >= l && elem[0:l] == "_bulk" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							// Leaf node.
							switch r.Method {
							case "POST":
								s.handleGetAccountsRequest([0]string{}, elemIsEscaped, w, r)
							default:
								s.notAllowed(w, r, "POST")
							}

							return
						}

						elem = origElem
					case 's': // Prefix: "search"
						origElem := elem
						if l := len("search"); len(elem) >= l && elem[0:l] == "search" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							// Leaf node.
							switch r.Method {
							case "GET":
								s.handleSearchAccountsRequest([0]string{}, elemIsEscaped, w, r)
							default:
								s.notAllowed(w, r, "GET")
							}

							return
						}

						elem = origElem
					}
					// Param: "account_id"
					// Match until "/"
					idx := strings.IndexByte(elem, '/')
					if idx < 0 {
						idx = len(elem)
					}
					args[0] = elem[:idx]
					elem = elem[idx:]

					if len(elem) == 0 {
						switch r.Method {
						case "GET":
							s.handleGetAccountRequest([1]string{
								args[0],
							}, elemIsEscaped, w, r)
						default:
							s.notAllowed(w, r, "GET")
						}

						return
					}
					switch elem[0] {
					case '/': // Prefix: "/"
						origElem := elem
						if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							break
						}
						switch elem[0] {
						case 'd': // Prefix: "d"
							origElem := elem
							if l := len("d"); len(elem) >= l && elem[0:l] == "d" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								break
							}
							switch elem[0] {
							case 'i': // Prefix: "iff"
								origElem := elem
								if l := len("iff"); len(elem) >= l && elem[0:l] == "iff" {
									elem = elem[l:]
								} else {
									break
								}

								if len(elem) == 0 {
									// Leaf node.
									switch r.Method {
									case "GET":
										s.handleGetAccountDiffRequest([1]string{
											args[0],
										}, elemIsEscaped, w, r)
									default:
										s.notAllowed(w, r, "GET")
									}

									return
								}

								elem = origElem
							case 'n': // Prefix: "ns/"
								origElem := elem
								if l := len("ns/"); len(elem) >= l && elem[0:l] == "ns/" {
									elem = elem[l:]
								} else {
									break
								}

								if len(elem) == 0 {
									break
								}
								switch elem[0] {
								case 'b': // Prefix: "backresolve"
									origElem := elem
									if l := len("backresolve"); len(elem) >= l && elem[0:l] == "backresolve" {
										elem = elem[l:]
									} else {
										break
									}

									if len(elem) == 0 {
										// Leaf node.
										switch r.Method {
										case "GET":
											s.handleAccountDnsBackResolveRequest([1]string{
												args[0],
											}, elemIsEscaped, w, r)
										default:
											s.notAllowed(w, r, "GET")
										}

										return
									}

									elem = origElem
								case 'e': // Prefix: "expiring"
									origElem := elem
									if l := len("expiring"); len(elem) >= l && elem[0:l] == "expiring" {
										elem = elem[l:]
									} else {
										break
									}

									if len(elem) == 0 {
										// Leaf node.
										switch r.Method {
										case "GET":
											s.handleGetAccountDnsExpiringRequest([1]string{
												args[0],
											}, elemIsEscaped, w, r)
										default:
											s.notAllowed(w, r, "GET")
										}

										return
									}

									elem = origElem
								}

								elem = origElem
							}

							elem = origElem
						case 'e': // Prefix: "e"
							origElem := elem
							if l := len("e"); len(elem) >= l && elem[0:l] == "e" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								break
							}
							switch elem[0] {
							case 'v': // Prefix: "vents"
								origElem := elem
								if l := len("vents"); len(elem) >= l && elem[0:l] == "vents" {
									elem = elem[l:]
								} else {
									break
								}

								if len(elem) == 0 {
									switch r.Method {
									case "GET":
										s.handleGetAccountEventsRequest([1]string{
											args[0],
										}, elemIsEscaped, w, r)
									default:
										s.notAllowed(w, r, "GET")
									}

									return
								}
								switch elem[0] {
								case '/': // Prefix: "/"
									origElem := elem
									if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
										elem = elem[l:]
									} else {
										break
									}

									if len(elem) == 0 {
										break
									}
									switch elem[0] {
									case 'e': // Prefix: "emulate"
										origElem := elem
										if l := len("emulate"); len(elem) >= l && elem[0:l] == "emulate" {
											elem = elem[l:]
										} else {
											break
										}

										if len(elem) == 0 {
											// Leaf node.
											switch r.Method {
											case "POST":
												s.handleEmulateMessageToAccountEventRequest([1]string{
													args[0],
												}, elemIsEscaped, w, r)
											default:
												s.notAllowed(w, r, "POST")
											}

											return
										}

										elem = origElem
									}
									// Param: "event_id"
									// Leaf parameter
									args[1] = elem
									elem = ""

									if len(elem) == 0 {
										// Leaf node.
										switch r.Method {
										case "GET":
											s.handleGetAccountEventRequest([2]string{
												args[0],
												args[1],
											}, elemIsEscaped, w, r)
										default:
											s.notAllowed(w, r, "GET")
										}

										return
									}

									elem = origElem
								}

								elem = origElem
							case 'x': // Prefix: "xtra-currency/"
								origElem := elem
								if l := len("xtra-currency/"); len(elem) >= l && elem[0:l] == "xtra-currency/" {
									elem = elem[l:]
								} else {
									break
								}

								// Param: "id"
								// Match until "/"
								idx := strings.IndexByte(elem, '/')
								if idx < 0 {
									idx = len(elem)
								}
								args[1] = elem[:idx]
								elem = elem[idx:]

								if len(elem) == 0 {
									break
								}
								switch elem[0] {
								case '/': // Prefix: "/history"
									origElem := elem
									if l := len("/history"); len(elem) >= l && elem[0:l] == "/history" {
										elem = elem[l:]
									} else {
										break
									}

									if len(elem) == 0 {
										// Leaf node.
										switch r.Method {
										case "GET":
											s.handleGetAccountExtraCurrencyHistoryByIDRequest([2]string{
												args[0],
												args[1],
											}, elemIsEscaped, w, r)
										default:
											s.notAllowed(w, r, "GET")
										}

										return
									}

									elem = origElem
								}

								elem = origElem
							}

							elem = origElem
						case 'j': // Prefix: "jettons"
							origElem := elem
							if l := len("jettons"); len(elem) >= l && elem[0:l] == "jettons" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								switch r.Method {
								case "GET":
									s.handleGetAccountJettonsBalancesRequest([1]string{
										args[0],
									}, elemIsEscaped, w, r)
								default:
									s.notAllowed(w, r, "GET")
								}

								return
							}
							switch elem[0] {
							case '/': // Prefix: "/"
								origElem := elem
								if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
									elem = elem[l:]
								} else {
									break
								}

								if len(elem) == 0 {
									break
								}
								switch elem[0] {
								case 'h': // Prefix: "history"
									origElem := elem
									if l := len("history"); len(elem) >= l && elem[0:l] == "history" {
										elem = elem[l:]
									} else {
										break
									}

									if len(elem) == 0 {
										// Leaf node.
										switch r.Method {
										case "GET":
											s.handleGetAccountJettonsHistoryRequest([1]string{
												args[0],
											}, elemIsEscaped, w, r)
										default:
											s.notAllowed(w, r, "GET")
										}

										return
									}

									elem = origElem
								}
								// Param: "jetton_id"
								// Match until "/"
								idx := strings.IndexByte(elem, '/')
								if idx < 0 {
									idx = len(elem)
								}
								args[1] = elem[:idx]
								elem = elem[idx:]

								if len(elem) == 0 {
									switch r.Method {
									case "GET":
										s.handleGetAccountJettonBalanceRequest([2]string{
											args[0],
											args[1],
										}, elemIsEscaped, w, r)
									default:
										s.notAllowed(w, r, "GET")
									}

									return
								}
								switch elem[0] {
								case '/': // Prefix: "/history"
									origElem := elem
									if l := len("/history"); len(elem) >= l && elem[0:l] == "/history" {
										elem = elem[l:]
									} else {
										break
									}

									if len(elem) == 0 {
										// Leaf node.
										switch r.Method {
										case "GET":
											s.handleGetAccountJettonHistoryByIDRequest([2]string{
												args[0],
												args[1],
											}, elemIsEscaped, w, r)
										default:
											s.notAllowed(w, r, "GET")
										}

										return
									}

									elem = origElem
								}

								elem = origElem
							}

							elem = origElem
						case 'm': // Prefix: "multisigs"
							origElem := elem
							if l := len("multisigs"); len(elem) >= l && elem[0:l] == "multisigs" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								// Leaf node.
								switch r.Method {
								case "GET":
									s.handleGetAccountMultisigsRequest([1]string{
										args[0],
									}, elemIsEscaped, w, r)
								default:
									s.notAllowed(w, r, "GET")
								}

								return
							}

							elem = origElem
						case 'n': // Prefix: "nfts"
							origElem := elem
							if l := len("nfts"); len(elem) >= l && elem[0:l] == "nfts" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								switch r.Method {
								case "GET":
									s.handleGetAccountNftItemsRequest([1]string{
										args[0],
									}, elemIsEscaped, w, r)
								default:
									s.notAllowed(w, r, "GET")
								}

								return
							}
							switch elem[0] {
							case '/': // Prefix: "/history"
								origElem := elem
								if l := len("/history"); len(elem) >= l && elem[0:l] == "/history" {
									elem = elem[l:]
								} else {
									break
								}

								if len(elem) == 0 {
									// Leaf node.
									switch r.Method {
									case "GET":
										s.handleGetAccountNftHistoryRequest([1]string{
											args[0],
										}, elemIsEscaped, w, r)
									default:
										s.notAllowed(w, r, "GET")
									}

									return
								}

								elem = origElem
							}

							elem = origElem
						case 'p': // Prefix: "publickey"
							origElem := elem
							if l := len("publickey"); len(elem) >= l && elem[0:l] == "publickey" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								// Leaf node.
								switch r.Method {
								case "GET":
									s.handleGetAccountPublicKeyRequest([1]string{
										args[0],
									}, elemIsEscaped, w, r)
								default:
									s.notAllowed(w, r, "GET")
								}

								return
							}

							elem = origElem
						case 'r': // Prefix: "reindex"
							origElem := elem
							if l := len("reindex"); len(elem) >= l && elem[0:l] == "reindex" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								// Leaf node.
								switch r.Method {
								case "POST":
									s.handleReindexAccountRequest([1]string{
										args[0],
									}, elemIsEscaped, w, r)
								default:
									s.notAllowed(w, r, "POST")
								}

								return
							}

							elem = origElem
						case 's': // Prefix: "subscriptions"
							origElem := elem
							if l := len("subscriptions"); len(elem) >= l && elem[0:l] == "subscriptions" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								// Leaf node.
								switch r.Method {
								case "GET":
									s.handleGetAccountSubscriptionsRequest([1]string{
										args[0],
									}, elemIsEscaped, w, r)
								default:
									s.notAllowed(w, r, "GET")
								}

								return
							}

							elem = origElem
						case 't': // Prefix: "traces"
							origElem := elem
							if l := len("traces"); len(elem) >= l && elem[0:l] == "traces" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								// Leaf node.
								switch r.Method {
								case "GET":
									s.handleGetAccountTracesRequest([1]string{
										args[0],
									}, elemIsEscaped, w, r)
								default:
									s.notAllowed(w, r, "GET")
								}

								return
							}

							elem = origElem
						}

						elem = origElem
					}

					elem = origElem
				case 'd': // Prefix: "ddress/"
					origElem := elem
					if l := len("ddress/"); len(elem) >= l && elem[0:l] == "ddress/" {
						elem = elem[l:]
					} else {
						break
					}

					// Param: "account_id"
					// Match until "/"
					idx := strings.IndexByte(elem, '/')
					if idx < 0 {
						idx = len(elem)
					}
					args[0] = elem[:idx]
					elem = elem[idx:]

					if len(elem) == 0 {
						break
					}
					switch elem[0] {
					case '/': // Prefix: "/parse"
						origElem := elem
						if l := len("/parse"); len(elem) >= l && elem[0:l] == "/parse" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							// Leaf node.
							switch r.Method {
							case "GET":
								s.handleAddressParseRequest([1]string{
									args[0],
								}, elemIsEscaped, w, r)
							default:
								s.notAllowed(w, r, "GET")
							}

							return
						}

						elem = origElem
					}

					elem = origElem
				}

				elem = origElem
			case 'b': // Prefix: "blockchain/"
				origElem := elem
				if l := len("blockchain/"); len(elem) >= l && elem[0:l] == "blockchain/" {
					elem = elem[l:]
				} else {
					break
				}

				if len(elem) == 0 {
					break
				}
				switch elem[0] {
				case 'a': // Prefix: "accounts/"
					origElem := elem
					if l := len("accounts/"); len(elem) >= l && elem[0:l] == "accounts/" {
						elem = elem[l:]
					} else {
						break
					}

					// Param: "account_id"
					// Match until "/"
					idx := strings.IndexByte(elem, '/')
					if idx < 0 {
						idx = len(elem)
					}
					args[0] = elem[:idx]
					elem = elem[idx:]

					if len(elem) == 0 {
						switch r.Method {
						case "GET":
							s.handleGetBlockchainRawAccountRequest([1]string{
								args[0],
							}, elemIsEscaped, w, r)
						default:
							s.notAllowed(w, r, "GET")
						}

						return
					}
					switch elem[0] {
					case '/': // Prefix: "/"
						origElem := elem
						if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							break
						}
						switch elem[0] {
						case 'i': // Prefix: "inspect"
							origElem := elem
							if l := len("inspect"); len(elem) >= l && elem[0:l] == "inspect" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								// Leaf node.
								switch r.Method {
								case "GET":
									s.handleBlockchainAccountInspectRequest([1]string{
										args[0],
									}, elemIsEscaped, w, r)
								default:
									s.notAllowed(w, r, "GET")
								}

								return
							}

							elem = origElem
						case 'm': // Prefix: "methods/"
							origElem := elem
							if l := len("methods/"); len(elem) >= l && elem[0:l] == "methods/" {
								elem = elem[l:]
							} else {
								break
							}

							// Param: "method_name"
							// Leaf parameter
							args[1] = elem
							elem = ""

							if len(elem) == 0 {
								// Leaf node.
								switch r.Method {
								case "GET":
									s.handleExecGetMethodForBlockchainAccountRequest([2]string{
										args[0],
										args[1],
									}, elemIsEscaped, w, r)
								default:
									s.notAllowed(w, r, "GET")
								}

								return
							}

							elem = origElem
						case 't': // Prefix: "transactions"
							origElem := elem
							if l := len("transactions"); len(elem) >= l && elem[0:l] == "transactions" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								// Leaf node.
								switch r.Method {
								case "GET":
									s.handleGetBlockchainAccountTransactionsRequest([1]string{
										args[0],
									}, elemIsEscaped, w, r)
								default:
									s.notAllowed(w, r, "GET")
								}

								return
							}

							elem = origElem
						}

						elem = origElem
					}

					elem = origElem
				case 'b': // Prefix: "blocks/"
					origElem := elem
					if l := len("blocks/"); len(elem) >= l && elem[0:l] == "blocks/" {
						elem = elem[l:]
					} else {
						break
					}

					// Param: "block_id"
					// Match until "/"
					idx := strings.IndexByte(elem, '/')
					if idx < 0 {
						idx = len(elem)
					}
					args[0] = elem[:idx]
					elem = elem[idx:]

					if len(elem) == 0 {
						switch r.Method {
						case "GET":
							s.handleGetBlockchainBlockRequest([1]string{
								args[0],
							}, elemIsEscaped, w, r)
						default:
							s.notAllowed(w, r, "GET")
						}

						return
					}
					switch elem[0] {
					case '/': // Prefix: "/"
						origElem := elem
						if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							break
						}
						switch elem[0] {
						case 'b': // Prefix: "boc"
							origElem := elem
							if l := len("boc"); len(elem) >= l && elem[0:l] == "boc" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								// Leaf node.
								switch r.Method {
								case "GET":
									s.handleDownloadBlockchainBlockBocRequest([1]string{
										args[0],
									}, elemIsEscaped, w, r)
								default:
									s.notAllowed(w, r, "GET")
								}

								return
							}

							elem = origElem
						case 't': // Prefix: "transactions"
							origElem := elem
							if l := len("transactions"); len(elem) >= l && elem[0:l] == "transactions" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								// Leaf node.
								switch r.Method {
								case "GET":
									s.handleGetBlockchainBlockTransactionsRequest([1]string{
										args[0],
									}, elemIsEscaped, w, r)
								default:
									s.notAllowed(w, r, "GET")
								}

								return
							}

							elem = origElem
						}

						elem = origElem
					}

					elem = origElem
				case 'c': // Prefix: "config"
					origElem := elem
					if l := len("config"); len(elem) >= l && elem[0:l] == "config" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						switch r.Method {
						case "GET":
							s.handleGetBlockchainConfigRequest([0]string{}, elemIsEscaped, w, r)
						default:
							s.notAllowed(w, r, "GET")
						}

						return
					}
					switch elem[0] {
					case '/': // Prefix: "/raw"
						origElem := elem
						if l := len("/raw"); len(elem) >= l && elem[0:l] == "/raw" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							// Leaf node.
							switch r.Method {
							case "GET":
								s.handleGetRawBlockchainConfigRequest([0]string{}, elemIsEscaped, w, r)
							default:
								s.notAllowed(w, r, "GET")
							}

							return
						}

						elem = origElem
					}

					elem = origElem
				case 'm': // Prefix: "m"
					origElem := elem
					if l := len("m"); len(elem) >= l && elem[0:l] == "m" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						break
					}
					switch elem[0] {
					case 'a': // Prefix: "asterchain"
						origElem := elem
						if l := len("asterchain"); len(elem) >= l && elem[0:l] == "asterchain" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							break
						}
						switch elem[0] {
						case '-': // Prefix: "-head"
							origElem := elem
							if l := len("-head"); len(elem) >= l && elem[0:l] == "-head" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								// Leaf node.
								switch r.Method {
								case "GET":
									s.handleGetBlockchainMasterchainHeadRequest([0]string{}, elemIsEscaped, w, r)
								default:
									s.notAllowed(w, r, "GET")
								}

								return
							}

							elem = origElem
						case '/': // Prefix: "/"
							origElem := elem
							if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
								elem = elem[l:]
							} else {
								break
							}

							// Param: "masterchain_seqno"
							// Match until "/"
							idx := strings.IndexByte(elem, '/')
							if idx < 0 {
								idx = len(elem)
							}
							args[0] = elem[:idx]
							elem = elem[idx:]

							if len(elem) == 0 {
								break
							}
							switch elem[0] {
							case '/': // Prefix: "/"
								origElem := elem
								if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
									elem = elem[l:]
								} else {
									break
								}

								if len(elem) == 0 {
									break
								}
								switch elem[0] {
								case 'b': // Prefix: "blocks"
									origElem := elem
									if l := len("blocks"); len(elem) >= l && elem[0:l] == "blocks" {
										elem = elem[l:]
									} else {
										break
									}

									if len(elem) == 0 {
										// Leaf node.
										switch r.Method {
										case "GET":
											s.handleGetBlockchainMasterchainBlocksRequest([1]string{
												args[0],
											}, elemIsEscaped, w, r)
										default:
											s.notAllowed(w, r, "GET")
										}

										return
									}

									elem = origElem
								case 'c': // Prefix: "config"
									origElem := elem
									if l := len("config"); len(elem) >= l && elem[0:l] == "config" {
										elem = elem[l:]
									} else {
										break
									}

									if len(elem) == 0 {
										switch r.Method {
										case "GET":
											s.handleGetBlockchainConfigFromBlockRequest([1]string{
												args[0],
											}, elemIsEscaped, w, r)
										default:
											s.notAllowed(w, r, "GET")
										}

										return
									}
									switch elem[0] {
									case '/': // Prefix: "/raw"
										origElem := elem
										if l := len("/raw"); len(elem) >= l && elem[0:l] == "/raw" {
											elem = elem[l:]
										} else {
											break
										}

										if len(elem) == 0 {
											// Leaf node.
											switch r.Method {
											case "GET":
												s.handleGetRawBlockchainConfigFromBlockRequest([1]string{
													args[0],
												}, elemIsEscaped, w, r)
											default:
												s.notAllowed(w, r, "GET")
											}

											return
										}

										elem = origElem
									}

									elem = origElem
								case 's': // Prefix: "shards"
									origElem := elem
									if l := len("shards"); len(elem) >= l && elem[0:l] == "shards" {
										elem = elem[l:]
									} else {
										break
									}

									if len(elem) == 0 {
										// Leaf node.
										switch r.Method {
										case "GET":
											s.handleGetBlockchainMasterchainShardsRequest([1]string{
												args[0],
											}, elemIsEscaped, w, r)
										default:
											s.notAllowed(w, r, "GET")
										}

										return
									}

									elem = origElem
								case 't': // Prefix: "transactions"
									origElem := elem
									if l := len("transactions"); len(elem) >= l && elem[0:l] == "transactions" {
										elem = elem[l:]
									} else {
										break
									}

									if len(elem) == 0 {
										// Leaf node.
										switch r.Method {
										case "GET":
											s.handleGetBlockchainMasterchainTransactionsRequest([1]string{
												args[0],
											}, elemIsEscaped, w, r)
										default:
											s.notAllowed(w, r, "GET")
										}

										return
									}

									elem = origElem
								}

								elem = origElem
							}

							elem = origElem
						}

						elem = origElem
					case 'e': // Prefix: "essage"
						origElem := elem
						if l := len("essage"); len(elem) >= l && elem[0:l] == "essage" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							switch r.Method {
							case "POST":
								s.handleSendBlockchainMessageRequest([0]string{}, elemIsEscaped, w, r)
							default:
								s.notAllowed(w, r, "POST")
							}

							return
						}
						switch elem[0] {
						case 's': // Prefix: "s/"
							origElem := elem
							if l := len("s/"); len(elem) >= l && elem[0:l] == "s/" {
								elem = elem[l:]
							} else {
								break
							}

							// Param: "msg_id"
							// Match until "/"
							idx := strings.IndexByte(elem, '/')
							if idx < 0 {
								idx = len(elem)
							}
							args[0] = elem[:idx]
							elem = elem[idx:]

							if len(elem) == 0 {
								break
							}
							switch elem[0] {
							case '/': // Prefix: "/transaction"
								origElem := elem
								if l := len("/transaction"); len(elem) >= l && elem[0:l] == "/transaction" {
									elem = elem[l:]
								} else {
									break
								}

								if len(elem) == 0 {
									// Leaf node.
									switch r.Method {
									case "GET":
										s.handleGetBlockchainTransactionByMessageHashRequest([1]string{
											args[0],
										}, elemIsEscaped, w, r)
									default:
										s.notAllowed(w, r, "GET")
									}

									return
								}

								elem = origElem
							}

							elem = origElem
						}

						elem = origElem
					}

					elem = origElem
				case 'r': // Prefix: "reduced/blocks"
					origElem := elem
					if l := len("reduced/blocks"); len(elem) >= l && elem[0:l] == "reduced/blocks" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						// Leaf node.
						switch r.Method {
						case "GET":
							s.handleGetReducedBlockchainBlocksRequest([0]string{}, elemIsEscaped, w, r)
						default:
							s.notAllowed(w, r, "GET")
						}

						return
					}

					elem = origElem
				case 't': // Prefix: "transactions/"
					origElem := elem
					if l := len("transactions/"); len(elem) >= l && elem[0:l] == "transactions/" {
						elem = elem[l:]
					} else {
						break
					}

					// Param: "transaction_id"
					// Leaf parameter
					args[0] = elem
					elem = ""

					if len(elem) == 0 {
						// Leaf node.
						switch r.Method {
						case "GET":
							s.handleGetBlockchainTransactionRequest([1]string{
								args[0],
							}, elemIsEscaped, w, r)
						default:
							s.notAllowed(w, r, "GET")
						}

						return
					}

					elem = origElem
				case 'v': // Prefix: "validators"
					origElem := elem
					if l := len("validators"); len(elem) >= l && elem[0:l] == "validators" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						// Leaf node.
						switch r.Method {
						case "GET":
							s.handleGetBlockchainValidatorsRequest([0]string{}, elemIsEscaped, w, r)
						default:
							s.notAllowed(w, r, "GET")
						}

						return
					}

					elem = origElem
				}

				elem = origElem
			case 'd': // Prefix: "dns/"
				origElem := elem
				if l := len("dns/"); len(elem) >= l && elem[0:l] == "dns/" {
					elem = elem[l:]
				} else {
					break
				}

				if len(elem) == 0 {
					break
				}
				switch elem[0] {
				case 'a': // Prefix: "auctions"
					origElem := elem
					if l := len("auctions"); len(elem) >= l && elem[0:l] == "auctions" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						// Leaf node.
						switch r.Method {
						case "GET":
							s.handleGetAllAuctionsRequest([0]string{}, elemIsEscaped, w, r)
						default:
							s.notAllowed(w, r, "GET")
						}

						return
					}

					elem = origElem
				}
				// Param: "domain_name"
				// Match until "/"
				idx := strings.IndexByte(elem, '/')
				if idx < 0 {
					idx = len(elem)
				}
				args[0] = elem[:idx]
				elem = elem[idx:]

				if len(elem) == 0 {
					switch r.Method {
					case "GET":
						s.handleGetDnsInfoRequest([1]string{
							args[0],
						}, elemIsEscaped, w, r)
					default:
						s.notAllowed(w, r, "GET")
					}

					return
				}
				switch elem[0] {
				case '/': // Prefix: "/"
					origElem := elem
					if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						break
					}
					switch elem[0] {
					case 'b': // Prefix: "bids"
						origElem := elem
						if l := len("bids"); len(elem) >= l && elem[0:l] == "bids" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							// Leaf node.
							switch r.Method {
							case "GET":
								s.handleGetDomainBidsRequest([1]string{
									args[0],
								}, elemIsEscaped, w, r)
							default:
								s.notAllowed(w, r, "GET")
							}

							return
						}

						elem = origElem
					case 'r': // Prefix: "resolve"
						origElem := elem
						if l := len("resolve"); len(elem) >= l && elem[0:l] == "resolve" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							// Leaf node.
							switch r.Method {
							case "GET":
								s.handleDnsResolveRequest([1]string{
									args[0],
								}, elemIsEscaped, w, r)
							default:
								s.notAllowed(w, r, "GET")
							}

							return
						}

						elem = origElem
					}

					elem = origElem
				}

				elem = origElem
			case 'e': // Prefix: "e"
				origElem := elem
				if l := len("e"); len(elem) >= l && elem[0:l] == "e" {
					elem = elem[l:]
				} else {
					break
				}

				if len(elem) == 0 {
					break
				}
				switch elem[0] {
				case 'v': // Prefix: "vents/"
					origElem := elem
					if l := len("vents/"); len(elem) >= l && elem[0:l] == "vents/" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						break
					}
					switch elem[0] {
					case 'e': // Prefix: "emulate"
						origElem := elem
						if l := len("emulate"); len(elem) >= l && elem[0:l] == "emulate" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							// Leaf node.
							switch r.Method {
							case "POST":
								s.handleEmulateMessageToEventRequest([0]string{}, elemIsEscaped, w, r)
							default:
								s.notAllowed(w, r, "POST")
							}

							return
						}

						elem = origElem
					}
					// Param: "event_id"
					// Match until "/"
					idx := strings.IndexByte(elem, '/')
					if idx < 0 {
						idx = len(elem)
					}
					args[0] = elem[:idx]
					elem = elem[idx:]

					if len(elem) == 0 {
						switch r.Method {
						case "GET":
							s.handleGetEventRequest([1]string{
								args[0],
							}, elemIsEscaped, w, r)
						default:
							s.notAllowed(w, r, "GET")
						}

						return
					}
					switch elem[0] {
					case '/': // Prefix: "/jettons"
						origElem := elem
						if l := len("/jettons"); len(elem) >= l && elem[0:l] == "/jettons" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							// Leaf node.
							switch r.Method {
							case "GET":
								s.handleGetJettonsEventsRequest([1]string{
									args[0],
								}, elemIsEscaped, w, r)
							default:
								s.notAllowed(w, r, "GET")
							}

							return
						}

						elem = origElem
					}

					elem = origElem
				case 'x': // Prefix: "x"
					origElem := elem
					if l := len("x"); len(elem) >= l && elem[0:l] == "x" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						break
					}
					switch elem[0] {
					case 'p': // Prefix: "perimental/"
						origElem := elem
						if l := len("perimental/"); len(elem) >= l && elem[0:l] == "perimental/" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							break
						}
						switch elem[0] {
						case 'a': // Prefix: "accounts/"
							origElem := elem
							if l := len("accounts/"); len(elem) >= l && elem[0:l] == "accounts/" {
								elem = elem[l:]
							} else {
								break
							}

							// Param: "account_id"
							// Match until "/"
							idx := strings.IndexByte(elem, '/')
							if idx < 0 {
								idx = len(elem)
							}
							args[0] = elem[:idx]
							elem = elem[idx:]

							if len(elem) == 0 {
								break
							}
							switch elem[0] {
							case '/': // Prefix: "/inscriptions"
								origElem := elem
								if l := len("/inscriptions"); len(elem) >= l && elem[0:l] == "/inscriptions" {
									elem = elem[l:]
								} else {
									break
								}

								if len(elem) == 0 {
									switch r.Method {
									case "GET":
										s.handleGetAccountInscriptionsRequest([1]string{
											args[0],
										}, elemIsEscaped, w, r)
									default:
										s.notAllowed(w, r, "GET")
									}

									return
								}
								switch elem[0] {
								case '/': // Prefix: "/"
									origElem := elem
									if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
										elem = elem[l:]
									} else {
										break
									}

									if len(elem) == 0 {
										break
									}
									switch elem[0] {
									case 'h': // Prefix: "history"
										origElem := elem
										if l := len("history"); len(elem) >= l && elem[0:l] == "history" {
											elem = elem[l:]
										} else {
											break
										}

										if len(elem) == 0 {
											// Leaf node.
											switch r.Method {
											case "GET":
												s.handleGetAccountInscriptionsHistoryRequest([1]string{
													args[0],
												}, elemIsEscaped, w, r)
											default:
												s.notAllowed(w, r, "GET")
											}

											return
										}

										elem = origElem
									}
									// Param: "ticker"
									// Match until "/"
									idx := strings.IndexByte(elem, '/')
									if idx < 0 {
										idx = len(elem)
									}
									args[1] = elem[:idx]
									elem = elem[idx:]

									if len(elem) == 0 {
										break
									}
									switch elem[0] {
									case '/': // Prefix: "/history"
										origElem := elem
										if l := len("/history"); len(elem) >= l && elem[0:l] == "/history" {
											elem = elem[l:]
										} else {
											break
										}

										if len(elem) == 0 {
											// Leaf node.
											switch r.Method {
											case "GET":
												s.handleGetAccountInscriptionsHistoryByTickerRequest([2]string{
													args[0],
													args[1],
												}, elemIsEscaped, w, r)
											default:
												s.notAllowed(w, r, "GET")
											}

											return
										}

										elem = origElem
									}

									elem = origElem
								}

								elem = origElem
							}

							elem = origElem
						case 'i': // Prefix: "inscriptions/op-template"
							origElem := elem
							if l := len("inscriptions/op-template"); len(elem) >= l && elem[0:l] == "inscriptions/op-template" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								// Leaf node.
								switch r.Method {
								case "GET":
									s.handleGetInscriptionOpTemplateRequest([0]string{}, elemIsEscaped, w, r)
								default:
									s.notAllowed(w, r, "GET")
								}

								return
							}

							elem = origElem
						}

						elem = origElem
					case 't': // Prefix: "tra-currency/"
						origElem := elem
						if l := len("tra-currency/"); len(elem) >= l && elem[0:l] == "tra-currency/" {
							elem = elem[l:]
						} else {
							break
						}

						// Param: "id"
						// Leaf parameter
						args[0] = elem
						elem = ""

						if len(elem) == 0 {
							// Leaf node.
							switch r.Method {
							case "GET":
								s.handleGetExtraCurrencyInfoRequest([1]string{
									args[0],
								}, elemIsEscaped, w, r)
							default:
								s.notAllowed(w, r, "GET")
							}

							return
						}

						elem = origElem
					}

					elem = origElem
				}

				elem = origElem
			case 'g': // Prefix: "gasless/"
				origElem := elem
				if l := len("gasless/"); len(elem) >= l && elem[0:l] == "gasless/" {
					elem = elem[l:]
				} else {
					break
				}

				if len(elem) == 0 {
					break
				}
				switch elem[0] {
				case 'c': // Prefix: "config"
					origElem := elem
					if l := len("config"); len(elem) >= l && elem[0:l] == "config" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						// Leaf node.
						switch r.Method {
						case "GET":
							s.handleGaslessConfigRequest([0]string{}, elemIsEscaped, w, r)
						default:
							s.notAllowed(w, r, "GET")
						}

						return
					}

					elem = origElem
				case 'e': // Prefix: "estimate/"
					origElem := elem
					if l := len("estimate/"); len(elem) >= l && elem[0:l] == "estimate/" {
						elem = elem[l:]
					} else {
						break
					}

					// Param: "master_id"
					// Leaf parameter
					args[0] = elem
					elem = ""

					if len(elem) == 0 {
						// Leaf node.
						switch r.Method {
						case "POST":
							s.handleGaslessEstimateRequest([1]string{
								args[0],
							}, elemIsEscaped, w, r)
						default:
							s.notAllowed(w, r, "POST")
						}

						return
					}

					elem = origElem
				case 's': // Prefix: "send"
					origElem := elem
					if l := len("send"); len(elem) >= l && elem[0:l] == "send" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						// Leaf node.
						switch r.Method {
						case "POST":
							s.handleGaslessSendRequest([0]string{}, elemIsEscaped, w, r)
						default:
							s.notAllowed(w, r, "POST")
						}

						return
					}

					elem = origElem
				}

				elem = origElem
			case 'j': // Prefix: "jettons"
				origElem := elem
				if l := len("jettons"); len(elem) >= l && elem[0:l] == "jettons" {
					elem = elem[l:]
				} else {
					break
				}

				if len(elem) == 0 {
					switch r.Method {
					case "GET":
						s.handleGetJettonsRequest([0]string{}, elemIsEscaped, w, r)
					default:
						s.notAllowed(w, r, "GET")
					}

					return
				}
				switch elem[0] {
				case '/': // Prefix: "/"
					origElem := elem
					if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						break
					}
					switch elem[0] {
					case '_': // Prefix: "_bulk"
						origElem := elem
						if l := len("_bulk"); len(elem) >= l && elem[0:l] == "_bulk" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							// Leaf node.
							switch r.Method {
							case "POST":
								s.handleGetJettonInfosByAddressesRequest([0]string{}, elemIsEscaped, w, r)
							default:
								s.notAllowed(w, r, "POST")
							}

							return
						}

						elem = origElem
					}
					// Param: "account_id"
					// Match until "/"
					idx := strings.IndexByte(elem, '/')
					if idx < 0 {
						idx = len(elem)
					}
					args[0] = elem[:idx]
					elem = elem[idx:]

					if len(elem) == 0 {
						switch r.Method {
						case "GET":
							s.handleGetJettonInfoRequest([1]string{
								args[0],
							}, elemIsEscaped, w, r)
						default:
							s.notAllowed(w, r, "GET")
						}

						return
					}
					switch elem[0] {
					case '/': // Prefix: "/"
						origElem := elem
						if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							break
						}
						switch elem[0] {
						case 'h': // Prefix: "holders"
							origElem := elem
							if l := len("holders"); len(elem) >= l && elem[0:l] == "holders" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								// Leaf node.
								switch r.Method {
								case "GET":
									s.handleGetJettonHoldersRequest([1]string{
										args[0],
									}, elemIsEscaped, w, r)
								default:
									s.notAllowed(w, r, "GET")
								}

								return
							}

							elem = origElem
						case 't': // Prefix: "transfer/"
							origElem := elem
							if l := len("transfer/"); len(elem) >= l && elem[0:l] == "transfer/" {
								elem = elem[l:]
							} else {
								break
							}

							// Param: "account_id"
							// Match until "/"
							idx := strings.IndexByte(elem, '/')
							if idx < 0 {
								idx = len(elem)
							}
							args[1] = elem[:idx]
							elem = elem[idx:]

							if len(elem) == 0 {
								break
							}
							switch elem[0] {
							case '/': // Prefix: "/payload"
								origElem := elem
								if l := len("/payload"); len(elem) >= l && elem[0:l] == "/payload" {
									elem = elem[l:]
								} else {
									break
								}

								if len(elem) == 0 {
									// Leaf node.
									switch r.Method {
									case "GET":
										s.handleGetJettonTransferPayloadRequest([2]string{
											args[0],
											args[1],
										}, elemIsEscaped, w, r)
									default:
										s.notAllowed(w, r, "GET")
									}

									return
								}

								elem = origElem
							}

							elem = origElem
						}

						elem = origElem
					}

					elem = origElem
				}

				elem = origElem
			case 'l': // Prefix: "liteserver/"
				origElem := elem
				if l := len("liteserver/"); len(elem) >= l && elem[0:l] == "liteserver/" {
					elem = elem[l:]
				} else {
					break
				}

				if len(elem) == 0 {
					break
				}
				switch elem[0] {
				case 'g': // Prefix: "get_"
					origElem := elem
					if l := len("get_"); len(elem) >= l && elem[0:l] == "get_" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						break
					}
					switch elem[0] {
					case 'a': // Prefix: "a"
						origElem := elem
						if l := len("a"); len(elem) >= l && elem[0:l] == "a" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							break
						}
						switch elem[0] {
						case 'c': // Prefix: "ccount_state/"
							origElem := elem
							if l := len("ccount_state/"); len(elem) >= l && elem[0:l] == "ccount_state/" {
								elem = elem[l:]
							} else {
								break
							}

							// Param: "account_id"
							// Leaf parameter
							args[0] = elem
							elem = ""

							if len(elem) == 0 {
								// Leaf node.
								switch r.Method {
								case "GET":
									s.handleGetRawAccountStateRequest([1]string{
										args[0],
									}, elemIsEscaped, w, r)
								default:
									s.notAllowed(w, r, "GET")
								}

								return
							}

							elem = origElem
						case 'l': // Prefix: "ll_shards_info/"
							origElem := elem
							if l := len("ll_shards_info/"); len(elem) >= l && elem[0:l] == "ll_shards_info/" {
								elem = elem[l:]
							} else {
								break
							}

							// Param: "block_id"
							// Leaf parameter
							args[0] = elem
							elem = ""

							if len(elem) == 0 {
								// Leaf node.
								switch r.Method {
								case "GET":
									s.handleGetAllRawShardsInfoRequest([1]string{
										args[0],
									}, elemIsEscaped, w, r)
								default:
									s.notAllowed(w, r, "GET")
								}

								return
							}

							elem = origElem
						}

						elem = origElem
					case 'b': // Prefix: "block"
						origElem := elem
						if l := len("block"); len(elem) >= l && elem[0:l] == "block" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							break
						}
						switch elem[0] {
						case '/': // Prefix: "/"
							origElem := elem
							if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
								elem = elem[l:]
							} else {
								break
							}

							// Param: "block_id"
							// Leaf parameter
							args[0] = elem
							elem = ""

							if len(elem) == 0 {
								// Leaf node.
								switch r.Method {
								case "GET":
									s.handleGetRawBlockchainBlockRequest([1]string{
										args[0],
									}, elemIsEscaped, w, r)
								default:
									s.notAllowed(w, r, "GET")
								}

								return
							}

							elem = origElem
						case '_': // Prefix: "_"
							origElem := elem
							if l := len("_"); len(elem) >= l && elem[0:l] == "_" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								break
							}
							switch elem[0] {
							case 'h': // Prefix: "header/"
								origElem := elem
								if l := len("header/"); len(elem) >= l && elem[0:l] == "header/" {
									elem = elem[l:]
								} else {
									break
								}

								// Param: "block_id"
								// Leaf parameter
								args[0] = elem
								elem = ""

								if len(elem) == 0 {
									// Leaf node.
									switch r.Method {
									case "GET":
										s.handleGetRawBlockchainBlockHeaderRequest([1]string{
											args[0],
										}, elemIsEscaped, w, r)
									default:
										s.notAllowed(w, r, "GET")
									}

									return
								}

								elem = origElem
							case 'p': // Prefix: "proof"
								origElem := elem
								if l := len("proof"); len(elem) >= l && elem[0:l] == "proof" {
									elem = elem[l:]
								} else {
									break
								}

								if len(elem) == 0 {
									// Leaf node.
									switch r.Method {
									case "GET":
										s.handleGetRawBlockProofRequest([0]string{}, elemIsEscaped, w, r)
									default:
										s.notAllowed(w, r, "GET")
									}

									return
								}

								elem = origElem
							}

							elem = origElem
						}

						elem = origElem
					case 'c': // Prefix: "config_all/"
						origElem := elem
						if l := len("config_all/"); len(elem) >= l && elem[0:l] == "config_all/" {
							elem = elem[l:]
						} else {
							break
						}

						// Param: "block_id"
						// Leaf parameter
						args[0] = elem
						elem = ""

						if len(elem) == 0 {
							// Leaf node.
							switch r.Method {
							case "GET":
								s.handleGetRawConfigRequest([1]string{
									args[0],
								}, elemIsEscaped, w, r)
							default:
								s.notAllowed(w, r, "GET")
							}

							return
						}

						elem = origElem
					case 'm': // Prefix: "masterchain_info"
						origElem := elem
						if l := len("masterchain_info"); len(elem) >= l && elem[0:l] == "masterchain_info" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							switch r.Method {
							case "GET":
								s.handleGetRawMasterchainInfoRequest([0]string{}, elemIsEscaped, w, r)
							default:
								s.notAllowed(w, r, "GET")
							}

							return
						}
						switch elem[0] {
						case '_': // Prefix: "_ext"
							origElem := elem
							if l := len("_ext"); len(elem) >= l && elem[0:l] == "_ext" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								// Leaf node.
								switch r.Method {
								case "GET":
									s.handleGetRawMasterchainInfoExtRequest([0]string{}, elemIsEscaped, w, r)
								default:
									s.notAllowed(w, r, "GET")
								}

								return
							}

							elem = origElem
						}

						elem = origElem
					case 'o': // Prefix: "out_msg_queue_sizes"
						origElem := elem
						if l := len("out_msg_queue_sizes"); len(elem) >= l && elem[0:l] == "out_msg_queue_sizes" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							// Leaf node.
							switch r.Method {
							case "GET":
								s.handleGetOutMsgQueueSizesRequest([0]string{}, elemIsEscaped, w, r)
							default:
								s.notAllowed(w, r, "GET")
							}

							return
						}

						elem = origElem
					case 's': // Prefix: "s"
						origElem := elem
						if l := len("s"); len(elem) >= l && elem[0:l] == "s" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							break
						}
						switch elem[0] {
						case 'h': // Prefix: "hard_"
							origElem := elem
							if l := len("hard_"); len(elem) >= l && elem[0:l] == "hard_" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								break
							}
							switch elem[0] {
							case 'b': // Prefix: "block_proof/"
								origElem := elem
								if l := len("block_proof/"); len(elem) >= l && elem[0:l] == "block_proof/" {
									elem = elem[l:]
								} else {
									break
								}

								// Param: "block_id"
								// Leaf parameter
								args[0] = elem
								elem = ""

								if len(elem) == 0 {
									// Leaf node.
									switch r.Method {
									case "GET":
										s.handleGetRawShardBlockProofRequest([1]string{
											args[0],
										}, elemIsEscaped, w, r)
									default:
										s.notAllowed(w, r, "GET")
									}

									return
								}

								elem = origElem
							case 'i': // Prefix: "info/"
								origElem := elem
								if l := len("info/"); len(elem) >= l && elem[0:l] == "info/" {
									elem = elem[l:]
								} else {
									break
								}

								// Param: "block_id"
								// Leaf parameter
								args[0] = elem
								elem = ""

								if len(elem) == 0 {
									// Leaf node.
									switch r.Method {
									case "GET":
										s.handleGetRawShardInfoRequest([1]string{
											args[0],
										}, elemIsEscaped, w, r)
									default:
										s.notAllowed(w, r, "GET")
									}

									return
								}

								elem = origElem
							}

							elem = origElem
						case 't': // Prefix: "tate/"
							origElem := elem
							if l := len("tate/"); len(elem) >= l && elem[0:l] == "tate/" {
								elem = elem[l:]
							} else {
								break
							}

							// Param: "block_id"
							// Leaf parameter
							args[0] = elem
							elem = ""

							if len(elem) == 0 {
								// Leaf node.
								switch r.Method {
								case "GET":
									s.handleGetRawBlockchainBlockStateRequest([1]string{
										args[0],
									}, elemIsEscaped, w, r)
								default:
									s.notAllowed(w, r, "GET")
								}

								return
							}

							elem = origElem
						}

						elem = origElem
					case 't': // Prefix: "t"
						origElem := elem
						if l := len("t"); len(elem) >= l && elem[0:l] == "t" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							break
						}
						switch elem[0] {
						case 'i': // Prefix: "ime"
							origElem := elem
							if l := len("ime"); len(elem) >= l && elem[0:l] == "ime" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								// Leaf node.
								switch r.Method {
								case "GET":
									s.handleGetRawTimeRequest([0]string{}, elemIsEscaped, w, r)
								default:
									s.notAllowed(w, r, "GET")
								}

								return
							}

							elem = origElem
						case 'r': // Prefix: "ransactions/"
							origElem := elem
							if l := len("ransactions/"); len(elem) >= l && elem[0:l] == "ransactions/" {
								elem = elem[l:]
							} else {
								break
							}

							// Param: "account_id"
							// Leaf parameter
							args[0] = elem
							elem = ""

							if len(elem) == 0 {
								// Leaf node.
								switch r.Method {
								case "GET":
									s.handleGetRawTransactionsRequest([1]string{
										args[0],
									}, elemIsEscaped, w, r)
								default:
									s.notAllowed(w, r, "GET")
								}

								return
							}

							elem = origElem
						}

						elem = origElem
					}

					elem = origElem
				case 'l': // Prefix: "list_block_transactions/"
					origElem := elem
					if l := len("list_block_transactions/"); len(elem) >= l && elem[0:l] == "list_block_transactions/" {
						elem = elem[l:]
					} else {
						break
					}

					// Param: "block_id"
					// Leaf parameter
					args[0] = elem
					elem = ""

					if len(elem) == 0 {
						// Leaf node.
						switch r.Method {
						case "GET":
							s.handleGetRawListBlockTransactionsRequest([1]string{
								args[0],
							}, elemIsEscaped, w, r)
						default:
							s.notAllowed(w, r, "GET")
						}

						return
					}

					elem = origElem
				case 's': // Prefix: "send_message"
					origElem := elem
					if l := len("send_message"); len(elem) >= l && elem[0:l] == "send_message" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						// Leaf node.
						switch r.Method {
						case "POST":
							s.handleSendRawMessageRequest([0]string{}, elemIsEscaped, w, r)
						default:
							s.notAllowed(w, r, "POST")
						}

						return
					}

					elem = origElem
				}

				elem = origElem
			case 'm': // Prefix: "m"
				origElem := elem
				if l := len("m"); len(elem) >= l && elem[0:l] == "m" {
					elem = elem[l:]
				} else {
					break
				}

				if len(elem) == 0 {
					break
				}
				switch elem[0] {
				case 'e': // Prefix: "essage/decode"
					origElem := elem
					if l := len("essage/decode"); len(elem) >= l && elem[0:l] == "essage/decode" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						// Leaf node.
						switch r.Method {
						case "POST":
							s.handleDecodeMessageRequest([0]string{}, elemIsEscaped, w, r)
						default:
							s.notAllowed(w, r, "POST")
						}

						return
					}

					elem = origElem
				case 'u': // Prefix: "ultisig/"
					origElem := elem
					if l := len("ultisig/"); len(elem) >= l && elem[0:l] == "ultisig/" {
						elem = elem[l:]
					} else {
						break
					}

					// Param: "account_id"
					// Leaf parameter
					args[0] = elem
					elem = ""

					if len(elem) == 0 {
						// Leaf node.
						switch r.Method {
						case "GET":
							s.handleGetMultisigAccountRequest([1]string{
								args[0],
							}, elemIsEscaped, w, r)
						default:
							s.notAllowed(w, r, "GET")
						}

						return
					}

					elem = origElem
				}

				elem = origElem
			case 'n': // Prefix: "nfts/"
				origElem := elem
				if l := len("nfts/"); len(elem) >= l && elem[0:l] == "nfts/" {
					elem = elem[l:]
				} else {
					break
				}

				if len(elem) == 0 {
					break
				}
				switch elem[0] {
				case '_': // Prefix: "_bulk"
					origElem := elem
					if l := len("_bulk"); len(elem) >= l && elem[0:l] == "_bulk" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						// Leaf node.
						switch r.Method {
						case "POST":
							s.handleGetNftItemsByAddressesRequest([0]string{}, elemIsEscaped, w, r)
						default:
							s.notAllowed(w, r, "POST")
						}

						return
					}

					elem = origElem
				case 'c': // Prefix: "collections"
					origElem := elem
					if l := len("collections"); len(elem) >= l && elem[0:l] == "collections" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						switch r.Method {
						case "GET":
							s.handleGetNftCollectionsRequest([0]string{}, elemIsEscaped, w, r)
						default:
							s.notAllowed(w, r, "GET")
						}

						return
					}
					switch elem[0] {
					case '/': // Prefix: "/"
						origElem := elem
						if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							break
						}
						switch elem[0] {
						case '_': // Prefix: "_bulk"
							origElem := elem
							if l := len("_bulk"); len(elem) >= l && elem[0:l] == "_bulk" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								// Leaf node.
								switch r.Method {
								case "POST":
									s.handleGetNftCollectionItemsByAddressesRequest([0]string{}, elemIsEscaped, w, r)
								default:
									s.notAllowed(w, r, "POST")
								}

								return
							}

							elem = origElem
						}
						// Param: "account_id"
						// Match until "/"
						idx := strings.IndexByte(elem, '/')
						if idx < 0 {
							idx = len(elem)
						}
						args[0] = elem[:idx]
						elem = elem[idx:]

						if len(elem) == 0 {
							switch r.Method {
							case "GET":
								s.handleGetNftCollectionRequest([1]string{
									args[0],
								}, elemIsEscaped, w, r)
							default:
								s.notAllowed(w, r, "GET")
							}

							return
						}
						switch elem[0] {
						case '/': // Prefix: "/items"
							origElem := elem
							if l := len("/items"); len(elem) >= l && elem[0:l] == "/items" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								// Leaf node.
								switch r.Method {
								case "GET":
									s.handleGetItemsFromCollectionRequest([1]string{
										args[0],
									}, elemIsEscaped, w, r)
								default:
									s.notAllowed(w, r, "GET")
								}

								return
							}

							elem = origElem
						}

						elem = origElem
					}

					elem = origElem
				}
				// Param: "account_id"
				// Match until "/"
				idx := strings.IndexByte(elem, '/')
				if idx < 0 {
					idx = len(elem)
				}
				args[0] = elem[:idx]
				elem = elem[idx:]

				if len(elem) == 0 {
					switch r.Method {
					case "GET":
						s.handleGetNftItemByAddressRequest([1]string{
							args[0],
						}, elemIsEscaped, w, r)
					default:
						s.notAllowed(w, r, "GET")
					}

					return
				}
				switch elem[0] {
				case '/': // Prefix: "/history"
					origElem := elem
					if l := len("/history"); len(elem) >= l && elem[0:l] == "/history" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						// Leaf node.
						switch r.Method {
						case "GET":
							s.handleGetNftHistoryByIDRequest([1]string{
								args[0],
							}, elemIsEscaped, w, r)
						default:
							s.notAllowed(w, r, "GET")
						}

						return
					}

					elem = origElem
				}

				elem = origElem
			case 'o': // Prefix: "openapi."
				origElem := elem
				if l := len("openapi."); len(elem) >= l && elem[0:l] == "openapi." {
					elem = elem[l:]
				} else {
					break
				}

				if len(elem) == 0 {
					break
				}
				switch elem[0] {
				case 'j': // Prefix: "json"
					origElem := elem
					if l := len("json"); len(elem) >= l && elem[0:l] == "json" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						// Leaf node.
						switch r.Method {
						case "GET":
							s.handleGetOpenapiJsonRequest([0]string{}, elemIsEscaped, w, r)
						default:
							s.notAllowed(w, r, "GET")
						}

						return
					}

					elem = origElem
				case 'y': // Prefix: "yml"
					origElem := elem
					if l := len("yml"); len(elem) >= l && elem[0:l] == "yml" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						// Leaf node.
						switch r.Method {
						case "GET":
							s.handleGetOpenapiYmlRequest([0]string{}, elemIsEscaped, w, r)
						default:
							s.notAllowed(w, r, "GET")
						}

						return
					}

					elem = origElem
				}

				elem = origElem
			case 'p': // Prefix: "pubkeys/"
				origElem := elem
				if l := len("pubkeys/"); len(elem) >= l && elem[0:l] == "pubkeys/" {
					elem = elem[l:]
				} else {
					break
				}

				// Param: "public_key"
				// Match until "/"
				idx := strings.IndexByte(elem, '/')
				if idx < 0 {
					idx = len(elem)
				}
				args[0] = elem[:idx]
				elem = elem[idx:]

				if len(elem) == 0 {
					break
				}
				switch elem[0] {
				case '/': // Prefix: "/wallets"
					origElem := elem
					if l := len("/wallets"); len(elem) >= l && elem[0:l] == "/wallets" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						// Leaf node.
						switch r.Method {
						case "GET":
							s.handleGetWalletsByPublicKeyRequest([1]string{
								args[0],
							}, elemIsEscaped, w, r)
						default:
							s.notAllowed(w, r, "GET")
						}

						return
					}

					elem = origElem
				}

				elem = origElem
			case 'r': // Prefix: "rates"
				origElem := elem
				if l := len("rates"); len(elem) >= l && elem[0:l] == "rates" {
					elem = elem[l:]
				} else {
					break
				}

				if len(elem) == 0 {
					switch r.Method {
					case "GET":
						s.handleGetRatesRequest([0]string{}, elemIsEscaped, w, r)
					default:
						s.notAllowed(w, r, "GET")
					}

					return
				}
				switch elem[0] {
				case '/': // Prefix: "/"
					origElem := elem
					if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						break
					}
					switch elem[0] {
					case 'c': // Prefix: "chart"
						origElem := elem
						if l := len("chart"); len(elem) >= l && elem[0:l] == "chart" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							// Leaf node.
							switch r.Method {
							case "GET":
								s.handleGetChartRatesRequest([0]string{}, elemIsEscaped, w, r)
							default:
								s.notAllowed(w, r, "GET")
							}

							return
						}

						elem = origElem
					case 'm': // Prefix: "markets"
						origElem := elem
						if l := len("markets"); len(elem) >= l && elem[0:l] == "markets" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							// Leaf node.
							switch r.Method {
							case "GET":
								s.handleGetMarketsRatesRequest([0]string{}, elemIsEscaped, w, r)
							default:
								s.notAllowed(w, r, "GET")
							}

							return
						}

						elem = origElem
					}

					elem = origElem
				}

				elem = origElem
			case 's': // Prefix: "st"
				origElem := elem
				if l := len("st"); len(elem) >= l && elem[0:l] == "st" {
					elem = elem[l:]
				} else {
					break
				}

				if len(elem) == 0 {
					break
				}
				switch elem[0] {
				case 'a': // Prefix: "a"
					origElem := elem
					if l := len("a"); len(elem) >= l && elem[0:l] == "a" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						break
					}
					switch elem[0] {
					case 'k': // Prefix: "king/"
						origElem := elem
						if l := len("king/"); len(elem) >= l && elem[0:l] == "king/" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							break
						}
						switch elem[0] {
						case 'n': // Prefix: "nominator/"
							origElem := elem
							if l := len("nominator/"); len(elem) >= l && elem[0:l] == "nominator/" {
								elem = elem[l:]
							} else {
								break
							}

							// Param: "account_id"
							// Match until "/"
							idx := strings.IndexByte(elem, '/')
							if idx < 0 {
								idx = len(elem)
							}
							args[0] = elem[:idx]
							elem = elem[idx:]

							if len(elem) == 0 {
								break
							}
							switch elem[0] {
							case '/': // Prefix: "/pools"
								origElem := elem
								if l := len("/pools"); len(elem) >= l && elem[0:l] == "/pools" {
									elem = elem[l:]
								} else {
									break
								}

								if len(elem) == 0 {
									// Leaf node.
									switch r.Method {
									case "GET":
										s.handleGetAccountNominatorsPoolsRequest([1]string{
											args[0],
										}, elemIsEscaped, w, r)
									default:
										s.notAllowed(w, r, "GET")
									}

									return
								}

								elem = origElem
							}

							elem = origElem
						case 'p': // Prefix: "pool"
							origElem := elem
							if l := len("pool"); len(elem) >= l && elem[0:l] == "pool" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								break
							}
							switch elem[0] {
							case '/': // Prefix: "/"
								origElem := elem
								if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
									elem = elem[l:]
								} else {
									break
								}

								// Param: "account_id"
								// Match until "/"
								idx := strings.IndexByte(elem, '/')
								if idx < 0 {
									idx = len(elem)
								}
								args[0] = elem[:idx]
								elem = elem[idx:]

								if len(elem) == 0 {
									switch r.Method {
									case "GET":
										s.handleGetStakingPoolInfoRequest([1]string{
											args[0],
										}, elemIsEscaped, w, r)
									default:
										s.notAllowed(w, r, "GET")
									}

									return
								}
								switch elem[0] {
								case '/': // Prefix: "/history"
									origElem := elem
									if l := len("/history"); len(elem) >= l && elem[0:l] == "/history" {
										elem = elem[l:]
									} else {
										break
									}

									if len(elem) == 0 {
										// Leaf node.
										switch r.Method {
										case "GET":
											s.handleGetStakingPoolHistoryRequest([1]string{
												args[0],
											}, elemIsEscaped, w, r)
										default:
											s.notAllowed(w, r, "GET")
										}

										return
									}

									elem = origElem
								}

								elem = origElem
							case 's': // Prefix: "s"
								origElem := elem
								if l := len("s"); len(elem) >= l && elem[0:l] == "s" {
									elem = elem[l:]
								} else {
									break
								}

								if len(elem) == 0 {
									// Leaf node.
									switch r.Method {
									case "GET":
										s.handleGetStakingPoolsRequest([0]string{}, elemIsEscaped, w, r)
									default:
										s.notAllowed(w, r, "GET")
									}

									return
								}

								elem = origElem
							}

							elem = origElem
						}

						elem = origElem
					case 't': // Prefix: "tus"
						origElem := elem
						if l := len("tus"); len(elem) >= l && elem[0:l] == "tus" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							// Leaf node.
							switch r.Method {
							case "GET":
								s.handleStatusRequest([0]string{}, elemIsEscaped, w, r)
							default:
								s.notAllowed(w, r, "GET")
							}

							return
						}

						elem = origElem
					}

					elem = origElem
				case 'o': // Prefix: "orage/providers"
					origElem := elem
					if l := len("orage/providers"); len(elem) >= l && elem[0:l] == "orage/providers" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						// Leaf node.
						switch r.Method {
						case "GET":
							s.handleGetStorageProvidersRequest([0]string{}, elemIsEscaped, w, r)
						default:
							s.notAllowed(w, r, "GET")
						}

						return
					}

					elem = origElem
				}

				elem = origElem
			case 't': // Prefix: "t"
				origElem := elem
				if l := len("t"); len(elem) >= l && elem[0:l] == "t" {
					elem = elem[l:]
				} else {
					break
				}

				if len(elem) == 0 {
					break
				}
				switch elem[0] {
				case 'o': // Prefix: "onconnect/"
					origElem := elem
					if l := len("onconnect/"); len(elem) >= l && elem[0:l] == "onconnect/" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						break
					}
					switch elem[0] {
					case 'p': // Prefix: "payload"
						origElem := elem
						if l := len("payload"); len(elem) >= l && elem[0:l] == "payload" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							// Leaf node.
							switch r.Method {
							case "GET":
								s.handleGetTonConnectPayloadRequest([0]string{}, elemIsEscaped, w, r)
							default:
								s.notAllowed(w, r, "GET")
							}

							return
						}

						elem = origElem
					case 's': // Prefix: "stateinit"
						origElem := elem
						if l := len("stateinit"); len(elem) >= l && elem[0:l] == "stateinit" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							// Leaf node.
							switch r.Method {
							case "POST":
								s.handleGetAccountInfoByStateInitRequest([0]string{}, elemIsEscaped, w, r)
							default:
								s.notAllowed(w, r, "POST")
							}

							return
						}

						elem = origElem
					}

					elem = origElem
				case 'r': // Prefix: "races/"
					origElem := elem
					if l := len("races/"); len(elem) >= l && elem[0:l] == "races/" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						break
					}
					switch elem[0] {
					case 'e': // Prefix: "emulate"
						origElem := elem
						if l := len("emulate"); len(elem) >= l && elem[0:l] == "emulate" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							// Leaf node.
							switch r.Method {
							case "POST":
								s.handleEmulateMessageToTraceRequest([0]string{}, elemIsEscaped, w, r)
							default:
								s.notAllowed(w, r, "POST")
							}

							return
						}

						elem = origElem
					}
					// Param: "trace_id"
					// Leaf parameter
					args[0] = elem
					elem = ""

					if len(elem) == 0 {
						// Leaf node.
						switch r.Method {
						case "GET":
							s.handleGetTraceRequest([1]string{
								args[0],
							}, elemIsEscaped, w, r)
						default:
							s.notAllowed(w, r, "GET")
						}

						return
					}

					elem = origElem
				}

				elem = origElem
			case 'w': // Prefix: "wallet/"
				origElem := elem
				if l := len("wallet/"); len(elem) >= l && elem[0:l] == "wallet/" {
					elem = elem[l:]
				} else {
					break
				}

				if len(elem) == 0 {
					break
				}
				switch elem[0] {
				case 'a': // Prefix: "auth/proof"
					origElem := elem
					if l := len("auth/proof"); len(elem) >= l && elem[0:l] == "auth/proof" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						// Leaf node.
						switch r.Method {
						case "POST":
							s.handleTonConnectProofRequest([0]string{}, elemIsEscaped, w, r)
						default:
							s.notAllowed(w, r, "POST")
						}

						return
					}

					elem = origElem
				case 'e': // Prefix: "emulate"
					origElem := elem
					if l := len("emulate"); len(elem) >= l && elem[0:l] == "emulate" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						// Leaf node.
						switch r.Method {
						case "POST":
							s.handleEmulateMessageToWalletRequest([0]string{}, elemIsEscaped, w, r)
						default:
							s.notAllowed(w, r, "POST")
						}

						return
					}

					elem = origElem
				}
				// Param: "account_id"
				// Match until "/"
				idx := strings.IndexByte(elem, '/')
				if idx < 0 {
					idx = len(elem)
				}
				args[0] = elem[:idx]
				elem = elem[idx:]

				if len(elem) == 0 {
					break
				}
				switch elem[0] {
				case '/': // Prefix: "/seqno"
					origElem := elem
					if l := len("/seqno"); len(elem) >= l && elem[0:l] == "/seqno" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						// Leaf node.
						switch r.Method {
						case "GET":
							s.handleGetAccountSeqnoRequest([1]string{
								args[0],
							}, elemIsEscaped, w, r)
						default:
							s.notAllowed(w, r, "GET")
						}

						return
					}

					elem = origElem
				}

				elem = origElem
			}

			elem = origElem
		}
	}
	s.notFound(w, r)
}

// Route is route object.
type Route struct {
	name        string
	summary     string
	operationID string
	pathPattern string
	count       int
	args        [2]string
}

// Name returns ogen operation name.
//
// It is guaranteed to be unique and not empty.
func (r Route) Name() string {
	return r.name
}

// Summary returns OpenAPI summary.
func (r Route) Summary() string {
	return r.summary
}

// OperationID returns OpenAPI operationId.
func (r Route) OperationID() string {
	return r.operationID
}

// PathPattern returns OpenAPI path.
func (r Route) PathPattern() string {
	return r.pathPattern
}

// Args returns parsed arguments.
func (r Route) Args() []string {
	return r.args[:r.count]
}

// FindRoute finds Route for given method and path.
//
// Note: this method does not unescape path or handle reserved characters in path properly. Use FindPath instead.
func (s *Server) FindRoute(method, path string) (Route, bool) {
	return s.FindPath(method, &url.URL{Path: path})
}

// FindPath finds Route for given method and URL.
func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) {
	var (
		elem = u.Path
		args = r.args
	)
	if rawPath := u.RawPath; rawPath != "" {
		if normalized, ok := uri.NormalizeEscapedPath(rawPath); ok {
			elem = normalized
		}
		defer func() {
			for i, arg := range r.args[:r.count] {
				if unescaped, err := url.PathUnescape(arg); err == nil {
					r.args[i] = unescaped
				}
			}
		}()
	}

	elem, ok := s.cutPrefix(elem)
	if !ok {
		return r, false
	}

	// Static code generated router with unwrapped path search.
	switch {
	default:
		if len(elem) == 0 {
			break
		}
		switch elem[0] {
		case '/': // Prefix: "/v2/"
			origElem := elem
			if l := len("/v2/"); len(elem) >= l && elem[0:l] == "/v2/" {
				elem = elem[l:]
			} else {
				break
			}

			if len(elem) == 0 {
				break
			}
			switch elem[0] {
			case 'a': // Prefix: "a"
				origElem := elem
				if l := len("a"); len(elem) >= l && elem[0:l] == "a" {
					elem = elem[l:]
				} else {
					break
				}

				if len(elem) == 0 {
					break
				}
				switch elem[0] {
				case 'c': // Prefix: "ccounts/"
					origElem := elem
					if l := len("ccounts/"); len(elem) >= l && elem[0:l] == "ccounts/" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						break
					}
					switch elem[0] {
					case '_': // Prefix: "_bulk"
						origElem := elem
						if l := len("_bulk"); len(elem) >= l && elem[0:l] == "_bulk" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							switch method {
							case "POST":
								// Leaf: GetAccounts
								r.name = "GetAccounts"
								r.summary = ""
								r.operationID = "getAccounts"
								r.pathPattern = "/v2/accounts/_bulk"
								r.args = args
								r.count = 0
								return r, true
							default:
								return
							}
						}

						elem = origElem
					case 's': // Prefix: "search"
						origElem := elem
						if l := len("search"); len(elem) >= l && elem[0:l] == "search" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							switch method {
							case "GET":
								// Leaf: SearchAccounts
								r.name = "SearchAccounts"
								r.summary = ""
								r.operationID = "searchAccounts"
								r.pathPattern = "/v2/accounts/search"
								r.args = args
								r.count = 0
								return r, true
							default:
								return
							}
						}

						elem = origElem
					}
					// Param: "account_id"
					// Match until "/"
					idx := strings.IndexByte(elem, '/')
					if idx < 0 {
						idx = len(elem)
					}
					args[0] = elem[:idx]
					elem = elem[idx:]

					if len(elem) == 0 {
						switch method {
						case "GET":
							r.name = "GetAccount"
							r.summary = ""
							r.operationID = "getAccount"
							r.pathPattern = "/v2/accounts/{account_id}"
							r.args = args
							r.count = 1
							return r, true
						default:
							return
						}
					}
					switch elem[0] {
					case '/': // Prefix: "/"
						origElem := elem
						if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							break
						}
						switch elem[0] {
						case 'd': // Prefix: "d"
							origElem := elem
							if l := len("d"); len(elem) >= l && elem[0:l] == "d" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								break
							}
							switch elem[0] {
							case 'i': // Prefix: "iff"
								origElem := elem
								if l := len("iff"); len(elem) >= l && elem[0:l] == "iff" {
									elem = elem[l:]
								} else {
									break
								}

								if len(elem) == 0 {
									switch method {
									case "GET":
										// Leaf: GetAccountDiff
										r.name = "GetAccountDiff"
										r.summary = ""
										r.operationID = "getAccountDiff"
										r.pathPattern = "/v2/accounts/{account_id}/diff"
										r.args = args
										r.count = 1
										return r, true
									default:
										return
									}
								}

								elem = origElem
							case 'n': // Prefix: "ns/"
								origElem := elem
								if l := len("ns/"); len(elem) >= l && elem[0:l] == "ns/" {
									elem = elem[l:]
								} else {
									break
								}

								if len(elem) == 0 {
									break
								}
								switch elem[0] {
								case 'b': // Prefix: "backresolve"
									origElem := elem
									if l := len("backresolve"); len(elem) >= l && elem[0:l] == "backresolve" {
										elem = elem[l:]
									} else {
										break
									}

									if len(elem) == 0 {
										switch method {
										case "GET":
											// Leaf: AccountDnsBackResolve
											r.name = "AccountDnsBackResolve"
											r.summary = ""
											r.operationID = "accountDnsBackResolve"
											r.pathPattern = "/v2/accounts/{account_id}/dns/backresolve"
											r.args = args
											r.count = 1
											return r, true
										default:
											return
										}
									}

									elem = origElem
								case 'e': // Prefix: "expiring"
									origElem := elem
									if l := len("expiring"); len(elem) >= l && elem[0:l] == "expiring" {
										elem = elem[l:]
									} else {
										break
									}

									if len(elem) == 0 {
										switch method {
										case "GET":
											// Leaf: GetAccountDnsExpiring
											r.name = "GetAccountDnsExpiring"
											r.summary = ""
											r.operationID = "getAccountDnsExpiring"
											r.pathPattern = "/v2/accounts/{account_id}/dns/expiring"
											r.args = args
											r.count = 1
											return r, true
										default:
											return
										}
									}

									elem = origElem
								}

								elem = origElem
							}

							elem = origElem
						case 'e': // Prefix: "e"
							origElem := elem
							if l := len("e"); len(elem) >= l && elem[0:l] == "e" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								break
							}
							switch elem[0] {
							case 'v': // Prefix: "vents"
								origElem := elem
								if l := len("vents"); len(elem) >= l && elem[0:l] == "vents" {
									elem = elem[l:]
								} else {
									break
								}

								if len(elem) == 0 {
									switch method {
									case "GET":
										r.name = "GetAccountEvents"
										r.summary = ""
										r.operationID = "getAccountEvents"
										r.pathPattern = "/v2/accounts/{account_id}/events"
										r.args = args
										r.count = 1
										return r, true
									default:
										return
									}
								}
								switch elem[0] {
								case '/': // Prefix: "/"
									origElem := elem
									if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
										elem = elem[l:]
									} else {
										break
									}

									if len(elem) == 0 {
										break
									}
									switch elem[0] {
									case 'e': // Prefix: "emulate"
										origElem := elem
										if l := len("emulate"); len(elem) >= l && elem[0:l] == "emulate" {
											elem = elem[l:]
										} else {
											break
										}

										if len(elem) == 0 {
											switch method {
											case "POST":
												// Leaf: EmulateMessageToAccountEvent
												r.name = "EmulateMessageToAccountEvent"
												r.summary = ""
												r.operationID = "emulateMessageToAccountEvent"
												r.pathPattern = "/v2/accounts/{account_id}/events/emulate"
												r.args = args
												r.count = 1
												return r, true
											default:
												return
											}
										}

										elem = origElem
									}
									// Param: "event_id"
									// Leaf parameter
									args[1] = elem
									elem = ""

									if len(elem) == 0 {
										switch method {
										case "GET":
											// Leaf: GetAccountEvent
											r.name = "GetAccountEvent"
											r.summary = ""
											r.operationID = "getAccountEvent"
											r.pathPattern = "/v2/accounts/{account_id}/events/{event_id}"
											r.args = args
											r.count = 2
											return r, true
										default:
											return
										}
									}

									elem = origElem
								}

								elem = origElem
							case 'x': // Prefix: "xtra-currency/"
								origElem := elem
								if l := len("xtra-currency/"); len(elem) >= l && elem[0:l] == "xtra-currency/" {
									elem = elem[l:]
								} else {
									break
								}

								// Param: "id"
								// Match until "/"
								idx := strings.IndexByte(elem, '/')
								if idx < 0 {
									idx = len(elem)
								}
								args[1] = elem[:idx]
								elem = elem[idx:]

								if len(elem) == 0 {
									break
								}
								switch elem[0] {
								case '/': // Prefix: "/history"
									origElem := elem
									if l := len("/history"); len(elem) >= l && elem[0:l] == "/history" {
										elem = elem[l:]
									} else {
										break
									}

									if len(elem) == 0 {
										switch method {
										case "GET":
											// Leaf: GetAccountExtraCurrencyHistoryByID
											r.name = "GetAccountExtraCurrencyHistoryByID"
											r.summary = ""
											r.operationID = "getAccountExtraCurrencyHistoryByID"
											r.pathPattern = "/v2/accounts/{account_id}/extra-currency/{id}/history"
											r.args = args
											r.count = 2
											return r, true
										default:
											return
										}
									}

									elem = origElem
								}

								elem = origElem
							}

							elem = origElem
						case 'j': // Prefix: "jettons"
							origElem := elem
							if l := len("jettons"); len(elem) >= l && elem[0:l] == "jettons" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								switch method {
								case "GET":
									r.name = "GetAccountJettonsBalances"
									r.summary = ""
									r.operationID = "getAccountJettonsBalances"
									r.pathPattern = "/v2/accounts/{account_id}/jettons"
									r.args = args
									r.count = 1
									return r, true
								default:
									return
								}
							}
							switch elem[0] {
							case '/': // Prefix: "/"
								origElem := elem
								if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
									elem = elem[l:]
								} else {
									break
								}

								if len(elem) == 0 {
									break
								}
								switch elem[0] {
								case 'h': // Prefix: "history"
									origElem := elem
									if l := len("history"); len(elem) >= l && elem[0:l] == "history" {
										elem = elem[l:]
									} else {
										break
									}

									if len(elem) == 0 {
										switch method {
										case "GET":
											// Leaf: GetAccountJettonsHistory
											r.name = "GetAccountJettonsHistory"
											r.summary = ""
											r.operationID = "getAccountJettonsHistory"
											r.pathPattern = "/v2/accounts/{account_id}/jettons/history"
											r.args = args
											r.count = 1
											return r, true
										default:
											return
										}
									}

									elem = origElem
								}
								// Param: "jetton_id"
								// Match until "/"
								idx := strings.IndexByte(elem, '/')
								if idx < 0 {
									idx = len(elem)
								}
								args[1] = elem[:idx]
								elem = elem[idx:]

								if len(elem) == 0 {
									switch method {
									case "GET":
										r.name = "GetAccountJettonBalance"
										r.summary = ""
										r.operationID = "getAccountJettonBalance"
										r.pathPattern = "/v2/accounts/{account_id}/jettons/{jetton_id}"
										r.args = args
										r.count = 2
										return r, true
									default:
										return
									}
								}
								switch elem[0] {
								case '/': // Prefix: "/history"
									origElem := elem
									if l := len("/history"); len(elem) >= l && elem[0:l] == "/history" {
										elem = elem[l:]
									} else {
										break
									}

									if len(elem) == 0 {
										switch method {
										case "GET":
											// Leaf: GetAccountJettonHistoryByID
											r.name = "GetAccountJettonHistoryByID"
											r.summary = ""
											r.operationID = "getAccountJettonHistoryByID"
											r.pathPattern = "/v2/accounts/{account_id}/jettons/{jetton_id}/history"
											r.args = args
											r.count = 2
											return r, true
										default:
											return
										}
									}

									elem = origElem
								}

								elem = origElem
							}

							elem = origElem
						case 'm': // Prefix: "multisigs"
							origElem := elem
							if l := len("multisigs"); len(elem) >= l && elem[0:l] == "multisigs" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								switch method {
								case "GET":
									// Leaf: GetAccountMultisigs
									r.name = "GetAccountMultisigs"
									r.summary = ""
									r.operationID = "getAccountMultisigs"
									r.pathPattern = "/v2/accounts/{account_id}/multisigs"
									r.args = args
									r.count = 1
									return r, true
								default:
									return
								}
							}

							elem = origElem
						case 'n': // Prefix: "nfts"
							origElem := elem
							if l := len("nfts"); len(elem) >= l && elem[0:l] == "nfts" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								switch method {
								case "GET":
									r.name = "GetAccountNftItems"
									r.summary = ""
									r.operationID = "getAccountNftItems"
									r.pathPattern = "/v2/accounts/{account_id}/nfts"
									r.args = args
									r.count = 1
									return r, true
								default:
									return
								}
							}
							switch elem[0] {
							case '/': // Prefix: "/history"
								origElem := elem
								if l := len("/history"); len(elem) >= l && elem[0:l] == "/history" {
									elem = elem[l:]
								} else {
									break
								}

								if len(elem) == 0 {
									switch method {
									case "GET":
										// Leaf: GetAccountNftHistory
										r.name = "GetAccountNftHistory"
										r.summary = ""
										r.operationID = "getAccountNftHistory"
										r.pathPattern = "/v2/accounts/{account_id}/nfts/history"
										r.args = args
										r.count = 1
										return r, true
									default:
										return
									}
								}

								elem = origElem
							}

							elem = origElem
						case 'p': // Prefix: "publickey"
							origElem := elem
							if l := len("publickey"); len(elem) >= l && elem[0:l] == "publickey" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								switch method {
								case "GET":
									// Leaf: GetAccountPublicKey
									r.name = "GetAccountPublicKey"
									r.summary = ""
									r.operationID = "getAccountPublicKey"
									r.pathPattern = "/v2/accounts/{account_id}/publickey"
									r.args = args
									r.count = 1
									return r, true
								default:
									return
								}
							}

							elem = origElem
						case 'r': // Prefix: "reindex"
							origElem := elem
							if l := len("reindex"); len(elem) >= l && elem[0:l] == "reindex" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								switch method {
								case "POST":
									// Leaf: ReindexAccount
									r.name = "ReindexAccount"
									r.summary = ""
									r.operationID = "reindexAccount"
									r.pathPattern = "/v2/accounts/{account_id}/reindex"
									r.args = args
									r.count = 1
									return r, true
								default:
									return
								}
							}

							elem = origElem
						case 's': // Prefix: "subscriptions"
							origElem := elem
							if l := len("subscriptions"); len(elem) >= l && elem[0:l] == "subscriptions" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								switch method {
								case "GET":
									// Leaf: GetAccountSubscriptions
									r.name = "GetAccountSubscriptions"
									r.summary = ""
									r.operationID = "getAccountSubscriptions"
									r.pathPattern = "/v2/accounts/{account_id}/subscriptions"
									r.args = args
									r.count = 1
									return r, true
								default:
									return
								}
							}

							elem = origElem
						case 't': // Prefix: "traces"
							origElem := elem
							if l := len("traces"); len(elem) >= l && elem[0:l] == "traces" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								switch method {
								case "GET":
									// Leaf: GetAccountTraces
									r.name = "GetAccountTraces"
									r.summary = ""
									r.operationID = "getAccountTraces"
									r.pathPattern = "/v2/accounts/{account_id}/traces"
									r.args = args
									r.count = 1
									return r, true
								default:
									return
								}
							}

							elem = origElem
						}

						elem = origElem
					}

					elem = origElem
				case 'd': // Prefix: "ddress/"
					origElem := elem
					if l := len("ddress/"); len(elem) >= l && elem[0:l] == "ddress/" {
						elem = elem[l:]
					} else {
						break
					}

					// Param: "account_id"
					// Match until "/"
					idx := strings.IndexByte(elem, '/')
					if idx < 0 {
						idx = len(elem)
					}
					args[0] = elem[:idx]
					elem = elem[idx:]

					if len(elem) == 0 {
						break
					}
					switch elem[0] {
					case '/': // Prefix: "/parse"
						origElem := elem
						if l := len("/parse"); len(elem) >= l && elem[0:l] == "/parse" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							switch method {
							case "GET":
								// Leaf: AddressParse
								r.name = "AddressParse"
								r.summary = ""
								r.operationID = "addressParse"
								r.pathPattern = "/v2/address/{account_id}/parse"
								r.args = args
								r.count = 1
								return r, true
							default:
								return
							}
						}

						elem = origElem
					}

					elem = origElem
				}

				elem = origElem
			case 'b': // Prefix: "blockchain/"
				origElem := elem
				if l := len("blockchain/"); len(elem) >= l && elem[0:l] == "blockchain/" {
					elem = elem[l:]
				} else {
					break
				}

				if len(elem) == 0 {
					break
				}
				switch elem[0] {
				case 'a': // Prefix: "accounts/"
					origElem := elem
					if l := len("accounts/"); len(elem) >= l && elem[0:l] == "accounts/" {
						elem = elem[l:]
					} else {
						break
					}

					// Param: "account_id"
					// Match until "/"
					idx := strings.IndexByte(elem, '/')
					if idx < 0 {
						idx = len(elem)
					}
					args[0] = elem[:idx]
					elem = elem[idx:]

					if len(elem) == 0 {
						switch method {
						case "GET":
							r.name = "GetBlockchainRawAccount"
							r.summary = ""
							r.operationID = "getBlockchainRawAccount"
							r.pathPattern = "/v2/blockchain/accounts/{account_id}"
							r.args = args
							r.count = 1
							return r, true
						default:
							return
						}
					}
					switch elem[0] {
					case '/': // Prefix: "/"
						origElem := elem
						if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							break
						}
						switch elem[0] {
						case 'i': // Prefix: "inspect"
							origElem := elem
							if l := len("inspect"); len(elem) >= l && elem[0:l] == "inspect" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								switch method {
								case "GET":
									// Leaf: BlockchainAccountInspect
									r.name = "BlockchainAccountInspect"
									r.summary = ""
									r.operationID = "blockchainAccountInspect"
									r.pathPattern = "/v2/blockchain/accounts/{account_id}/inspect"
									r.args = args
									r.count = 1
									return r, true
								default:
									return
								}
							}

							elem = origElem
						case 'm': // Prefix: "methods/"
							origElem := elem
							if l := len("methods/"); len(elem) >= l && elem[0:l] == "methods/" {
								elem = elem[l:]
							} else {
								break
							}

							// Param: "method_name"
							// Leaf parameter
							args[1] = elem
							elem = ""

							if len(elem) == 0 {
								switch method {
								case "GET":
									// Leaf: ExecGetMethodForBlockchainAccount
									r.name = "ExecGetMethodForBlockchainAccount"
									r.summary = ""
									r.operationID = "execGetMethodForBlockchainAccount"
									r.pathPattern = "/v2/blockchain/accounts/{account_id}/methods/{method_name}"
									r.args = args
									r.count = 2
									return r, true
								default:
									return
								}
							}

							elem = origElem
						case 't': // Prefix: "transactions"
							origElem := elem
							if l := len("transactions"); len(elem) >= l && elem[0:l] == "transactions" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								switch method {
								case "GET":
									// Leaf: GetBlockchainAccountTransactions
									r.name = "GetBlockchainAccountTransactions"
									r.summary = ""
									r.operationID = "getBlockchainAccountTransactions"
									r.pathPattern = "/v2/blockchain/accounts/{account_id}/transactions"
									r.args = args
									r.count = 1
									return r, true
								default:
									return
								}
							}

							elem = origElem
						}

						elem = origElem
					}

					elem = origElem
				case 'b': // Prefix: "blocks/"
					origElem := elem
					if l := len("blocks/"); len(elem) >= l && elem[0:l] == "blocks/" {
						elem = elem[l:]
					} else {
						break
					}

					// Param: "block_id"
					// Match until "/"
					idx := strings.IndexByte(elem, '/')
					if idx < 0 {
						idx = len(elem)
					}
					args[0] = elem[:idx]
					elem = elem[idx:]

					if len(elem) == 0 {
						switch method {
						case "GET":
							r.name = "GetBlockchainBlock"
							r.summary = ""
							r.operationID = "getBlockchainBlock"
							r.pathPattern = "/v2/blockchain/blocks/{block_id}"
							r.args = args
							r.count = 1
							return r, true
						default:
							return
						}
					}
					switch elem[0] {
					case '/': // Prefix: "/"
						origElem := elem
						if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							break
						}
						switch elem[0] {
						case 'b': // Prefix: "boc"
							origElem := elem
							if l := len("boc"); len(elem) >= l && elem[0:l] == "boc" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								switch method {
								case "GET":
									// Leaf: DownloadBlockchainBlockBoc
									r.name = "DownloadBlockchainBlockBoc"
									r.summary = ""
									r.operationID = "downloadBlockchainBlockBoc"
									r.pathPattern = "/v2/blockchain/blocks/{block_id}/boc"
									r.args = args
									r.count = 1
									return r, true
								default:
									return
								}
							}

							elem = origElem
						case 't': // Prefix: "transactions"
							origElem := elem
							if l := len("transactions"); len(elem) >= l && elem[0:l] == "transactions" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								switch method {
								case "GET":
									// Leaf: GetBlockchainBlockTransactions
									r.name = "GetBlockchainBlockTransactions"
									r.summary = ""
									r.operationID = "getBlockchainBlockTransactions"
									r.pathPattern = "/v2/blockchain/blocks/{block_id}/transactions"
									r.args = args
									r.count = 1
									return r, true
								default:
									return
								}
							}

							elem = origElem
						}

						elem = origElem
					}

					elem = origElem
				case 'c': // Prefix: "config"
					origElem := elem
					if l := len("config"); len(elem) >= l && elem[0:l] == "config" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						switch method {
						case "GET":
							r.name = "GetBlockchainConfig"
							r.summary = ""
							r.operationID = "getBlockchainConfig"
							r.pathPattern = "/v2/blockchain/config"
							r.args = args
							r.count = 0
							return r, true
						default:
							return
						}
					}
					switch elem[0] {
					case '/': // Prefix: "/raw"
						origElem := elem
						if l := len("/raw"); len(elem) >= l && elem[0:l] == "/raw" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							switch method {
							case "GET":
								// Leaf: GetRawBlockchainConfig
								r.name = "GetRawBlockchainConfig"
								r.summary = ""
								r.operationID = "getRawBlockchainConfig"
								r.pathPattern = "/v2/blockchain/config/raw"
								r.args = args
								r.count = 0
								return r, true
							default:
								return
							}
						}

						elem = origElem
					}

					elem = origElem
				case 'm': // Prefix: "m"
					origElem := elem
					if l := len("m"); len(elem) >= l && elem[0:l] == "m" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						break
					}
					switch elem[0] {
					case 'a': // Prefix: "asterchain"
						origElem := elem
						if l := len("asterchain"); len(elem) >= l && elem[0:l] == "asterchain" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							break
						}
						switch elem[0] {
						case '-': // Prefix: "-head"
							origElem := elem
							if l := len("-head"); len(elem) >= l && elem[0:l] == "-head" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								switch method {
								case "GET":
									// Leaf: GetBlockchainMasterchainHead
									r.name = "GetBlockchainMasterchainHead"
									r.summary = ""
									r.operationID = "getBlockchainMasterchainHead"
									r.pathPattern = "/v2/blockchain/masterchain-head"
									r.args = args
									r.count = 0
									return r, true
								default:
									return
								}
							}

							elem = origElem
						case '/': // Prefix: "/"
							origElem := elem
							if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
								elem = elem[l:]
							} else {
								break
							}

							// Param: "masterchain_seqno"
							// Match until "/"
							idx := strings.IndexByte(elem, '/')
							if idx < 0 {
								idx = len(elem)
							}
							args[0] = elem[:idx]
							elem = elem[idx:]

							if len(elem) == 0 {
								break
							}
							switch elem[0] {
							case '/': // Prefix: "/"
								origElem := elem
								if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
									elem = elem[l:]
								} else {
									break
								}

								if len(elem) == 0 {
									break
								}
								switch elem[0] {
								case 'b': // Prefix: "blocks"
									origElem := elem
									if l := len("blocks"); len(elem) >= l && elem[0:l] == "blocks" {
										elem = elem[l:]
									} else {
										break
									}

									if len(elem) == 0 {
										switch method {
										case "GET":
											// Leaf: GetBlockchainMasterchainBlocks
											r.name = "GetBlockchainMasterchainBlocks"
											r.summary = ""
											r.operationID = "getBlockchainMasterchainBlocks"
											r.pathPattern = "/v2/blockchain/masterchain/{masterchain_seqno}/blocks"
											r.args = args
											r.count = 1
											return r, true
										default:
											return
										}
									}

									elem = origElem
								case 'c': // Prefix: "config"
									origElem := elem
									if l := len("config"); len(elem) >= l && elem[0:l] == "config" {
										elem = elem[l:]
									} else {
										break
									}

									if len(elem) == 0 {
										switch method {
										case "GET":
											r.name = "GetBlockchainConfigFromBlock"
											r.summary = ""
											r.operationID = "getBlockchainConfigFromBlock"
											r.pathPattern = "/v2/blockchain/masterchain/{masterchain_seqno}/config"
											r.args = args
											r.count = 1
											return r, true
										default:
											return
										}
									}
									switch elem[0] {
									case '/': // Prefix: "/raw"
										origElem := elem
										if l := len("/raw"); len(elem) >= l && elem[0:l] == "/raw" {
											elem = elem[l:]
										} else {
											break
										}

										if len(elem) == 0 {
											switch method {
											case "GET":
												// Leaf: GetRawBlockchainConfigFromBlock
												r.name = "GetRawBlockchainConfigFromBlock"
												r.summary = ""
												r.operationID = "getRawBlockchainConfigFromBlock"
												r.pathPattern = "/v2/blockchain/masterchain/{masterchain_seqno}/config/raw"
												r.args = args
												r.count = 1
												return r, true
											default:
												return
											}
										}

										elem = origElem
									}

									elem = origElem
								case 's': // Prefix: "shards"
									origElem := elem
									if l := len("shards"); len(elem) >= l && elem[0:l] == "shards" {
										elem = elem[l:]
									} else {
										break
									}

									if len(elem) == 0 {
										switch method {
										case "GET":
											// Leaf: GetBlockchainMasterchainShards
											r.name = "GetBlockchainMasterchainShards"
											r.summary = ""
											r.operationID = "getBlockchainMasterchainShards"
											r.pathPattern = "/v2/blockchain/masterchain/{masterchain_seqno}/shards"
											r.args = args
											r.count = 1
											return r, true
										default:
											return
										}
									}

									elem = origElem
								case 't': // Prefix: "transactions"
									origElem := elem
									if l := len("transactions"); len(elem) >= l && elem[0:l] == "transactions" {
										elem = elem[l:]
									} else {
										break
									}

									if len(elem) == 0 {
										switch method {
										case "GET":
											// Leaf: GetBlockchainMasterchainTransactions
											r.name = "GetBlockchainMasterchainTransactions"
											r.summary = ""
											r.operationID = "getBlockchainMasterchainTransactions"
											r.pathPattern = "/v2/blockchain/masterchain/{masterchain_seqno}/transactions"
											r.args = args
											r.count = 1
											return r, true
										default:
											return
										}
									}

									elem = origElem
								}

								elem = origElem
							}

							elem = origElem
						}

						elem = origElem
					case 'e': // Prefix: "essage"
						origElem := elem
						if l := len("essage"); len(elem) >= l && elem[0:l] == "essage" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							switch method {
							case "POST":
								r.name = "SendBlockchainMessage"
								r.summary = ""
								r.operationID = "sendBlockchainMessage"
								r.pathPattern = "/v2/blockchain/message"
								r.args = args
								r.count = 0
								return r, true
							default:
								return
							}
						}
						switch elem[0] {
						case 's': // Prefix: "s/"
							origElem := elem
							if l := len("s/"); len(elem) >= l && elem[0:l] == "s/" {
								elem = elem[l:]
							} else {
								break
							}

							// Param: "msg_id"
							// Match until "/"
							idx := strings.IndexByte(elem, '/')
							if idx < 0 {
								idx = len(elem)
							}
							args[0] = elem[:idx]
							elem = elem[idx:]

							if len(elem) == 0 {
								break
							}
							switch elem[0] {
							case '/': // Prefix: "/transaction"
								origElem := elem
								if l := len("/transaction"); len(elem) >= l && elem[0:l] == "/transaction" {
									elem = elem[l:]
								} else {
									break
								}

								if len(elem) == 0 {
									switch method {
									case "GET":
										// Leaf: GetBlockchainTransactionByMessageHash
										r.name = "GetBlockchainTransactionByMessageHash"
										r.summary = ""
										r.operationID = "getBlockchainTransactionByMessageHash"
										r.pathPattern = "/v2/blockchain/messages/{msg_id}/transaction"
										r.args = args
										r.count = 1
										return r, true
									default:
										return
									}
								}

								elem = origElem
							}

							elem = origElem
						}

						elem = origElem
					}

					elem = origElem
				case 'r': // Prefix: "reduced/blocks"
					origElem := elem
					if l := len("reduced/blocks"); len(elem) >= l && elem[0:l] == "reduced/blocks" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						switch method {
						case "GET":
							// Leaf: GetReducedBlockchainBlocks
							r.name = "GetReducedBlockchainBlocks"
							r.summary = ""
							r.operationID = "getReducedBlockchainBlocks"
							r.pathPattern = "/v2/blockchain/reduced/blocks"
							r.args = args
							r.count = 0
							return r, true
						default:
							return
						}
					}

					elem = origElem
				case 't': // Prefix: "transactions/"
					origElem := elem
					if l := len("transactions/"); len(elem) >= l && elem[0:l] == "transactions/" {
						elem = elem[l:]
					} else {
						break
					}

					// Param: "transaction_id"
					// Leaf parameter
					args[0] = elem
					elem = ""

					if len(elem) == 0 {
						switch method {
						case "GET":
							// Leaf: GetBlockchainTransaction
							r.name = "GetBlockchainTransaction"
							r.summary = ""
							r.operationID = "getBlockchainTransaction"
							r.pathPattern = "/v2/blockchain/transactions/{transaction_id}"
							r.args = args
							r.count = 1
							return r, true
						default:
							return
						}
					}

					elem = origElem
				case 'v': // Prefix: "validators"
					origElem := elem
					if l := len("validators"); len(elem) >= l && elem[0:l] == "validators" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						switch method {
						case "GET":
							// Leaf: GetBlockchainValidators
							r.name = "GetBlockchainValidators"
							r.summary = ""
							r.operationID = "getBlockchainValidators"
							r.pathPattern = "/v2/blockchain/validators"
							r.args = args
							r.count = 0
							return r, true
						default:
							return
						}
					}

					elem = origElem
				}

				elem = origElem
			case 'd': // Prefix: "dns/"
				origElem := elem
				if l := len("dns/"); len(elem) >= l && elem[0:l] == "dns/" {
					elem = elem[l:]
				} else {
					break
				}

				if len(elem) == 0 {
					break
				}
				switch elem[0] {
				case 'a': // Prefix: "auctions"
					origElem := elem
					if l := len("auctions"); len(elem) >= l && elem[0:l] == "auctions" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						switch method {
						case "GET":
							// Leaf: GetAllAuctions
							r.name = "GetAllAuctions"
							r.summary = ""
							r.operationID = "getAllAuctions"
							r.pathPattern = "/v2/dns/auctions"
							r.args = args
							r.count = 0
							return r, true
						default:
							return
						}
					}

					elem = origElem
				}
				// Param: "domain_name"
				// Match until "/"
				idx := strings.IndexByte(elem, '/')
				if idx < 0 {
					idx = len(elem)
				}
				args[0] = elem[:idx]
				elem = elem[idx:]

				if len(elem) == 0 {
					switch method {
					case "GET":
						r.name = "GetDnsInfo"
						r.summary = ""
						r.operationID = "getDnsInfo"
						r.pathPattern = "/v2/dns/{domain_name}"
						r.args = args
						r.count = 1
						return r, true
					default:
						return
					}
				}
				switch elem[0] {
				case '/': // Prefix: "/"
					origElem := elem
					if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						break
					}
					switch elem[0] {
					case 'b': // Prefix: "bids"
						origElem := elem
						if l := len("bids"); len(elem) >= l && elem[0:l] == "bids" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							switch method {
							case "GET":
								// Leaf: GetDomainBids
								r.name = "GetDomainBids"
								r.summary = ""
								r.operationID = "getDomainBids"
								r.pathPattern = "/v2/dns/{domain_name}/bids"
								r.args = args
								r.count = 1
								return r, true
							default:
								return
							}
						}

						elem = origElem
					case 'r': // Prefix: "resolve"
						origElem := elem
						if l := len("resolve"); len(elem) >= l && elem[0:l] == "resolve" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							switch method {
							case "GET":
								// Leaf: DnsResolve
								r.name = "DnsResolve"
								r.summary = ""
								r.operationID = "dnsResolve"
								r.pathPattern = "/v2/dns/{domain_name}/resolve"
								r.args = args
								r.count = 1
								return r, true
							default:
								return
							}
						}

						elem = origElem
					}

					elem = origElem
				}

				elem = origElem
			case 'e': // Prefix: "e"
				origElem := elem
				if l := len("e"); len(elem) >= l && elem[0:l] == "e" {
					elem = elem[l:]
				} else {
					break
				}

				if len(elem) == 0 {
					break
				}
				switch elem[0] {
				case 'v': // Prefix: "vents/"
					origElem := elem
					if l := len("vents/"); len(elem) >= l && elem[0:l] == "vents/" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						break
					}
					switch elem[0] {
					case 'e': // Prefix: "emulate"
						origElem := elem
						if l := len("emulate"); len(elem) >= l && elem[0:l] == "emulate" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							switch method {
							case "POST":
								// Leaf: EmulateMessageToEvent
								r.name = "EmulateMessageToEvent"
								r.summary = ""
								r.operationID = "emulateMessageToEvent"
								r.pathPattern = "/v2/events/emulate"
								r.args = args
								r.count = 0
								return r, true
							default:
								return
							}
						}

						elem = origElem
					}
					// Param: "event_id"
					// Match until "/"
					idx := strings.IndexByte(elem, '/')
					if idx < 0 {
						idx = len(elem)
					}
					args[0] = elem[:idx]
					elem = elem[idx:]

					if len(elem) == 0 {
						switch method {
						case "GET":
							r.name = "GetEvent"
							r.summary = ""
							r.operationID = "getEvent"
							r.pathPattern = "/v2/events/{event_id}"
							r.args = args
							r.count = 1
							return r, true
						default:
							return
						}
					}
					switch elem[0] {
					case '/': // Prefix: "/jettons"
						origElem := elem
						if l := len("/jettons"); len(elem) >= l && elem[0:l] == "/jettons" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							switch method {
							case "GET":
								// Leaf: GetJettonsEvents
								r.name = "GetJettonsEvents"
								r.summary = ""
								r.operationID = "getJettonsEvents"
								r.pathPattern = "/v2/events/{event_id}/jettons"
								r.args = args
								r.count = 1
								return r, true
							default:
								return
							}
						}

						elem = origElem
					}

					elem = origElem
				case 'x': // Prefix: "x"
					origElem := elem
					if l := len("x"); len(elem) >= l && elem[0:l] == "x" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						break
					}
					switch elem[0] {
					case 'p': // Prefix: "perimental/"
						origElem := elem
						if l := len("perimental/"); len(elem) >= l && elem[0:l] == "perimental/" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							break
						}
						switch elem[0] {
						case 'a': // Prefix: "accounts/"
							origElem := elem
							if l := len("accounts/"); len(elem) >= l && elem[0:l] == "accounts/" {
								elem = elem[l:]
							} else {
								break
							}

							// Param: "account_id"
							// Match until "/"
							idx := strings.IndexByte(elem, '/')
							if idx < 0 {
								idx = len(elem)
							}
							args[0] = elem[:idx]
							elem = elem[idx:]

							if len(elem) == 0 {
								break
							}
							switch elem[0] {
							case '/': // Prefix: "/inscriptions"
								origElem := elem
								if l := len("/inscriptions"); len(elem) >= l && elem[0:l] == "/inscriptions" {
									elem = elem[l:]
								} else {
									break
								}

								if len(elem) == 0 {
									switch method {
									case "GET":
										r.name = "GetAccountInscriptions"
										r.summary = ""
										r.operationID = "getAccountInscriptions"
										r.pathPattern = "/v2/experimental/accounts/{account_id}/inscriptions"
										r.args = args
										r.count = 1
										return r, true
									default:
										return
									}
								}
								switch elem[0] {
								case '/': // Prefix: "/"
									origElem := elem
									if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
										elem = elem[l:]
									} else {
										break
									}

									if len(elem) == 0 {
										break
									}
									switch elem[0] {
									case 'h': // Prefix: "history"
										origElem := elem
										if l := len("history"); len(elem) >= l && elem[0:l] == "history" {
											elem = elem[l:]
										} else {
											break
										}

										if len(elem) == 0 {
											switch method {
											case "GET":
												// Leaf: GetAccountInscriptionsHistory
												r.name = "GetAccountInscriptionsHistory"
												r.summary = ""
												r.operationID = "getAccountInscriptionsHistory"
												r.pathPattern = "/v2/experimental/accounts/{account_id}/inscriptions/history"
												r.args = args
												r.count = 1
												return r, true
											default:
												return
											}
										}

										elem = origElem
									}
									// Param: "ticker"
									// Match until "/"
									idx := strings.IndexByte(elem, '/')
									if idx < 0 {
										idx = len(elem)
									}
									args[1] = elem[:idx]
									elem = elem[idx:]

									if len(elem) == 0 {
										break
									}
									switch elem[0] {
									case '/': // Prefix: "/history"
										origElem := elem
										if l := len("/history"); len(elem) >= l && elem[0:l] == "/history" {
											elem = elem[l:]
										} else {
											break
										}

										if len(elem) == 0 {
											switch method {
											case "GET":
												// Leaf: GetAccountInscriptionsHistoryByTicker
												r.name = "GetAccountInscriptionsHistoryByTicker"
												r.summary = ""
												r.operationID = "getAccountInscriptionsHistoryByTicker"
												r.pathPattern = "/v2/experimental/accounts/{account_id}/inscriptions/{ticker}/history"
												r.args = args
												r.count = 2
												return r, true
											default:
												return
											}
										}

										elem = origElem
									}

									elem = origElem
								}

								elem = origElem
							}

							elem = origElem
						case 'i': // Prefix: "inscriptions/op-template"
							origElem := elem
							if l := len("inscriptions/op-template"); len(elem) >= l && elem[0:l] == "inscriptions/op-template" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								switch method {
								case "GET":
									// Leaf: GetInscriptionOpTemplate
									r.name = "GetInscriptionOpTemplate"
									r.summary = ""
									r.operationID = "getInscriptionOpTemplate"
									r.pathPattern = "/v2/experimental/inscriptions/op-template"
									r.args = args
									r.count = 0
									return r, true
								default:
									return
								}
							}

							elem = origElem
						}

						elem = origElem
					case 't': // Prefix: "tra-currency/"
						origElem := elem
						if l := len("tra-currency/"); len(elem) >= l && elem[0:l] == "tra-currency/" {
							elem = elem[l:]
						} else {
							break
						}

						// Param: "id"
						// Leaf parameter
						args[0] = elem
						elem = ""

						if len(elem) == 0 {
							switch method {
							case "GET":
								// Leaf: GetExtraCurrencyInfo
								r.name = "GetExtraCurrencyInfo"
								r.summary = ""
								r.operationID = "getExtraCurrencyInfo"
								r.pathPattern = "/v2/extra-currency/{id}"
								r.args = args
								r.count = 1
								return r, true
							default:
								return
							}
						}

						elem = origElem
					}

					elem = origElem
				}

				elem = origElem
			case 'g': // Prefix: "gasless/"
				origElem := elem
				if l := len("gasless/"); len(elem) >= l && elem[0:l] == "gasless/" {
					elem = elem[l:]
				} else {
					break
				}

				if len(elem) == 0 {
					break
				}
				switch elem[0] {
				case 'c': // Prefix: "config"
					origElem := elem
					if l := len("config"); len(elem) >= l && elem[0:l] == "config" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						switch method {
						case "GET":
							// Leaf: GaslessConfig
							r.name = "GaslessConfig"
							r.summary = ""
							r.operationID = "gaslessConfig"
							r.pathPattern = "/v2/gasless/config"
							r.args = args
							r.count = 0
							return r, true
						default:
							return
						}
					}

					elem = origElem
				case 'e': // Prefix: "estimate/"
					origElem := elem
					if l := len("estimate/"); len(elem) >= l && elem[0:l] == "estimate/" {
						elem = elem[l:]
					} else {
						break
					}

					// Param: "master_id"
					// Leaf parameter
					args[0] = elem
					elem = ""

					if len(elem) == 0 {
						switch method {
						case "POST":
							// Leaf: GaslessEstimate
							r.name = "GaslessEstimate"
							r.summary = ""
							r.operationID = "gaslessEstimate"
							r.pathPattern = "/v2/gasless/estimate/{master_id}"
							r.args = args
							r.count = 1
							return r, true
						default:
							return
						}
					}

					elem = origElem
				case 's': // Prefix: "send"
					origElem := elem
					if l := len("send"); len(elem) >= l && elem[0:l] == "send" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						switch method {
						case "POST":
							// Leaf: GaslessSend
							r.name = "GaslessSend"
							r.summary = ""
							r.operationID = "gaslessSend"
							r.pathPattern = "/v2/gasless/send"
							r.args = args
							r.count = 0
							return r, true
						default:
							return
						}
					}

					elem = origElem
				}

				elem = origElem
			case 'j': // Prefix: "jettons"
				origElem := elem
				if l := len("jettons"); len(elem) >= l && elem[0:l] == "jettons" {
					elem = elem[l:]
				} else {
					break
				}

				if len(elem) == 0 {
					switch method {
					case "GET":
						r.name = "GetJettons"
						r.summary = ""
						r.operationID = "getJettons"
						r.pathPattern = "/v2/jettons"
						r.args = args
						r.count = 0
						return r, true
					default:
						return
					}
				}
				switch elem[0] {
				case '/': // Prefix: "/"
					origElem := elem
					if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						break
					}
					switch elem[0] {
					case '_': // Prefix: "_bulk"
						origElem := elem
						if l := len("_bulk"); len(elem) >= l && elem[0:l] == "_bulk" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							switch method {
							case "POST":
								// Leaf: GetJettonInfosByAddresses
								r.name = "GetJettonInfosByAddresses"
								r.summary = ""
								r.operationID = "getJettonInfosByAddresses"
								r.pathPattern = "/v2/jettons/_bulk"
								r.args = args
								r.count = 0
								return r, true
							default:
								return
							}
						}

						elem = origElem
					}
					// Param: "account_id"
					// Match until "/"
					idx := strings.IndexByte(elem, '/')
					if idx < 0 {
						idx = len(elem)
					}
					args[0] = elem[:idx]
					elem = elem[idx:]

					if len(elem) == 0 {
						switch method {
						case "GET":
							r.name = "GetJettonInfo"
							r.summary = ""
							r.operationID = "getJettonInfo"
							r.pathPattern = "/v2/jettons/{account_id}"
							r.args = args
							r.count = 1
							return r, true
						default:
							return
						}
					}
					switch elem[0] {
					case '/': // Prefix: "/"
						origElem := elem
						if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							break
						}
						switch elem[0] {
						case 'h': // Prefix: "holders"
							origElem := elem
							if l := len("holders"); len(elem) >= l && elem[0:l] == "holders" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								switch method {
								case "GET":
									// Leaf: GetJettonHolders
									r.name = "GetJettonHolders"
									r.summary = ""
									r.operationID = "getJettonHolders"
									r.pathPattern = "/v2/jettons/{account_id}/holders"
									r.args = args
									r.count = 1
									return r, true
								default:
									return
								}
							}

							elem = origElem
						case 't': // Prefix: "transfer/"
							origElem := elem
							if l := len("transfer/"); len(elem) >= l && elem[0:l] == "transfer/" {
								elem = elem[l:]
							} else {
								break
							}

							// Param: "account_id"
							// Match until "/"
							idx := strings.IndexByte(elem, '/')
							if idx < 0 {
								idx = len(elem)
							}
							args[1] = elem[:idx]
							elem = elem[idx:]

							if len(elem) == 0 {
								break
							}
							switch elem[0] {
							case '/': // Prefix: "/payload"
								origElem := elem
								if l := len("/payload"); len(elem) >= l && elem[0:l] == "/payload" {
									elem = elem[l:]
								} else {
									break
								}

								if len(elem) == 0 {
									switch method {
									case "GET":
										// Leaf: GetJettonTransferPayload
										r.name = "GetJettonTransferPayload"
										r.summary = ""
										r.operationID = "getJettonTransferPayload"
										r.pathPattern = "/v2/jettons/{jetton_id}/transfer/{account_id}/payload"
										r.args = args
										r.count = 2
										return r, true
									default:
										return
									}
								}

								elem = origElem
							}

							elem = origElem
						}

						elem = origElem
					}

					elem = origElem
				}

				elem = origElem
			case 'l': // Prefix: "liteserver/"
				origElem := elem
				if l := len("liteserver/"); len(elem) >= l && elem[0:l] == "liteserver/" {
					elem = elem[l:]
				} else {
					break
				}

				if len(elem) == 0 {
					break
				}
				switch elem[0] {
				case 'g': // Prefix: "get_"
					origElem := elem
					if l := len("get_"); len(elem) >= l && elem[0:l] == "get_" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						break
					}
					switch elem[0] {
					case 'a': // Prefix: "a"
						origElem := elem
						if l := len("a"); len(elem) >= l && elem[0:l] == "a" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							break
						}
						switch elem[0] {
						case 'c': // Prefix: "ccount_state/"
							origElem := elem
							if l := len("ccount_state/"); len(elem) >= l && elem[0:l] == "ccount_state/" {
								elem = elem[l:]
							} else {
								break
							}

							// Param: "account_id"
							// Leaf parameter
							args[0] = elem
							elem = ""

							if len(elem) == 0 {
								switch method {
								case "GET":
									// Leaf: GetRawAccountState
									r.name = "GetRawAccountState"
									r.summary = ""
									r.operationID = "getRawAccountState"
									r.pathPattern = "/v2/liteserver/get_account_state/{account_id}"
									r.args = args
									r.count = 1
									return r, true
								default:
									return
								}
							}

							elem = origElem
						case 'l': // Prefix: "ll_shards_info/"
							origElem := elem
							if l := len("ll_shards_info/"); len(elem) >= l && elem[0:l] == "ll_shards_info/" {
								elem = elem[l:]
							} else {
								break
							}

							// Param: "block_id"
							// Leaf parameter
							args[0] = elem
							elem = ""

							if len(elem) == 0 {
								switch method {
								case "GET":
									// Leaf: GetAllRawShardsInfo
									r.name = "GetAllRawShardsInfo"
									r.summary = ""
									r.operationID = "getAllRawShardsInfo"
									r.pathPattern = "/v2/liteserver/get_all_shards_info/{block_id}"
									r.args = args
									r.count = 1
									return r, true
								default:
									return
								}
							}

							elem = origElem
						}

						elem = origElem
					case 'b': // Prefix: "block"
						origElem := elem
						if l := len("block"); len(elem) >= l && elem[0:l] == "block" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							break
						}
						switch elem[0] {
						case '/': // Prefix: "/"
							origElem := elem
							if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
								elem = elem[l:]
							} else {
								break
							}

							// Param: "block_id"
							// Leaf parameter
							args[0] = elem
							elem = ""

							if len(elem) == 0 {
								switch method {
								case "GET":
									// Leaf: GetRawBlockchainBlock
									r.name = "GetRawBlockchainBlock"
									r.summary = ""
									r.operationID = "getRawBlockchainBlock"
									r.pathPattern = "/v2/liteserver/get_block/{block_id}"
									r.args = args
									r.count = 1
									return r, true
								default:
									return
								}
							}

							elem = origElem
						case '_': // Prefix: "_"
							origElem := elem
							if l := len("_"); len(elem) >= l && elem[0:l] == "_" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								break
							}
							switch elem[0] {
							case 'h': // Prefix: "header/"
								origElem := elem
								if l := len("header/"); len(elem) >= l && elem[0:l] == "header/" {
									elem = elem[l:]
								} else {
									break
								}

								// Param: "block_id"
								// Leaf parameter
								args[0] = elem
								elem = ""

								if len(elem) == 0 {
									switch method {
									case "GET":
										// Leaf: GetRawBlockchainBlockHeader
										r.name = "GetRawBlockchainBlockHeader"
										r.summary = ""
										r.operationID = "getRawBlockchainBlockHeader"
										r.pathPattern = "/v2/liteserver/get_block_header/{block_id}"
										r.args = args
										r.count = 1
										return r, true
									default:
										return
									}
								}

								elem = origElem
							case 'p': // Prefix: "proof"
								origElem := elem
								if l := len("proof"); len(elem) >= l && elem[0:l] == "proof" {
									elem = elem[l:]
								} else {
									break
								}

								if len(elem) == 0 {
									switch method {
									case "GET":
										// Leaf: GetRawBlockProof
										r.name = "GetRawBlockProof"
										r.summary = ""
										r.operationID = "getRawBlockProof"
										r.pathPattern = "/v2/liteserver/get_block_proof"
										r.args = args
										r.count = 0
										return r, true
									default:
										return
									}
								}

								elem = origElem
							}

							elem = origElem
						}

						elem = origElem
					case 'c': // Prefix: "config_all/"
						origElem := elem
						if l := len("config_all/"); len(elem) >= l && elem[0:l] == "config_all/" {
							elem = elem[l:]
						} else {
							break
						}

						// Param: "block_id"
						// Leaf parameter
						args[0] = elem
						elem = ""

						if len(elem) == 0 {
							switch method {
							case "GET":
								// Leaf: GetRawConfig
								r.name = "GetRawConfig"
								r.summary = ""
								r.operationID = "getRawConfig"
								r.pathPattern = "/v2/liteserver/get_config_all/{block_id}"
								r.args = args
								r.count = 1
								return r, true
							default:
								return
							}
						}

						elem = origElem
					case 'm': // Prefix: "masterchain_info"
						origElem := elem
						if l := len("masterchain_info"); len(elem) >= l && elem[0:l] == "masterchain_info" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							switch method {
							case "GET":
								r.name = "GetRawMasterchainInfo"
								r.summary = ""
								r.operationID = "getRawMasterchainInfo"
								r.pathPattern = "/v2/liteserver/get_masterchain_info"
								r.args = args
								r.count = 0
								return r, true
							default:
								return
							}
						}
						switch elem[0] {
						case '_': // Prefix: "_ext"
							origElem := elem
							if l := len("_ext"); len(elem) >= l && elem[0:l] == "_ext" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								switch method {
								case "GET":
									// Leaf: GetRawMasterchainInfoExt
									r.name = "GetRawMasterchainInfoExt"
									r.summary = ""
									r.operationID = "getRawMasterchainInfoExt"
									r.pathPattern = "/v2/liteserver/get_masterchain_info_ext"
									r.args = args
									r.count = 0
									return r, true
								default:
									return
								}
							}

							elem = origElem
						}

						elem = origElem
					case 'o': // Prefix: "out_msg_queue_sizes"
						origElem := elem
						if l := len("out_msg_queue_sizes"); len(elem) >= l && elem[0:l] == "out_msg_queue_sizes" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							switch method {
							case "GET":
								// Leaf: GetOutMsgQueueSizes
								r.name = "GetOutMsgQueueSizes"
								r.summary = ""
								r.operationID = "getOutMsgQueueSizes"
								r.pathPattern = "/v2/liteserver/get_out_msg_queue_sizes"
								r.args = args
								r.count = 0
								return r, true
							default:
								return
							}
						}

						elem = origElem
					case 's': // Prefix: "s"
						origElem := elem
						if l := len("s"); len(elem) >= l && elem[0:l] == "s" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							break
						}
						switch elem[0] {
						case 'h': // Prefix: "hard_"
							origElem := elem
							if l := len("hard_"); len(elem) >= l && elem[0:l] == "hard_" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								break
							}
							switch elem[0] {
							case 'b': // Prefix: "block_proof/"
								origElem := elem
								if l := len("block_proof/"); len(elem) >= l && elem[0:l] == "block_proof/" {
									elem = elem[l:]
								} else {
									break
								}

								// Param: "block_id"
								// Leaf parameter
								args[0] = elem
								elem = ""

								if len(elem) == 0 {
									switch method {
									case "GET":
										// Leaf: GetRawShardBlockProof
										r.name = "GetRawShardBlockProof"
										r.summary = ""
										r.operationID = "getRawShardBlockProof"
										r.pathPattern = "/v2/liteserver/get_shard_block_proof/{block_id}"
										r.args = args
										r.count = 1
										return r, true
									default:
										return
									}
								}

								elem = origElem
							case 'i': // Prefix: "info/"
								origElem := elem
								if l := len("info/"); len(elem) >= l && elem[0:l] == "info/" {
									elem = elem[l:]
								} else {
									break
								}

								// Param: "block_id"
								// Leaf parameter
								args[0] = elem
								elem = ""

								if len(elem) == 0 {
									switch method {
									case "GET":
										// Leaf: GetRawShardInfo
										r.name = "GetRawShardInfo"
										r.summary = ""
										r.operationID = "getRawShardInfo"
										r.pathPattern = "/v2/liteserver/get_shard_info/{block_id}"
										r.args = args
										r.count = 1
										return r, true
									default:
										return
									}
								}

								elem = origElem
							}

							elem = origElem
						case 't': // Prefix: "tate/"
							origElem := elem
							if l := len("tate/"); len(elem) >= l && elem[0:l] == "tate/" {
								elem = elem[l:]
							} else {
								break
							}

							// Param: "block_id"
							// Leaf parameter
							args[0] = elem
							elem = ""

							if len(elem) == 0 {
								switch method {
								case "GET":
									// Leaf: GetRawBlockchainBlockState
									r.name = "GetRawBlockchainBlockState"
									r.summary = ""
									r.operationID = "getRawBlockchainBlockState"
									r.pathPattern = "/v2/liteserver/get_state/{block_id}"
									r.args = args
									r.count = 1
									return r, true
								default:
									return
								}
							}

							elem = origElem
						}

						elem = origElem
					case 't': // Prefix: "t"
						origElem := elem
						if l := len("t"); len(elem) >= l && elem[0:l] == "t" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							break
						}
						switch elem[0] {
						case 'i': // Prefix: "ime"
							origElem := elem
							if l := len("ime"); len(elem) >= l && elem[0:l] == "ime" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								switch method {
								case "GET":
									// Leaf: GetRawTime
									r.name = "GetRawTime"
									r.summary = ""
									r.operationID = "getRawTime"
									r.pathPattern = "/v2/liteserver/get_time"
									r.args = args
									r.count = 0
									return r, true
								default:
									return
								}
							}

							elem = origElem
						case 'r': // Prefix: "ransactions/"
							origElem := elem
							if l := len("ransactions/"); len(elem) >= l && elem[0:l] == "ransactions/" {
								elem = elem[l:]
							} else {
								break
							}

							// Param: "account_id"
							// Leaf parameter
							args[0] = elem
							elem = ""

							if len(elem) == 0 {
								switch method {
								case "GET":
									// Leaf: GetRawTransactions
									r.name = "GetRawTransactions"
									r.summary = ""
									r.operationID = "getRawTransactions"
									r.pathPattern = "/v2/liteserver/get_transactions/{account_id}"
									r.args = args
									r.count = 1
									return r, true
								default:
									return
								}
							}

							elem = origElem
						}

						elem = origElem
					}

					elem = origElem
				case 'l': // Prefix: "list_block_transactions/"
					origElem := elem
					if l := len("list_block_transactions/"); len(elem) >= l && elem[0:l] == "list_block_transactions/" {
						elem = elem[l:]
					} else {
						break
					}

					// Param: "block_id"
					// Leaf parameter
					args[0] = elem
					elem = ""

					if len(elem) == 0 {
						switch method {
						case "GET":
							// Leaf: GetRawListBlockTransactions
							r.name = "GetRawListBlockTransactions"
							r.summary = ""
							r.operationID = "getRawListBlockTransactions"
							r.pathPattern = "/v2/liteserver/list_block_transactions/{block_id}"
							r.args = args
							r.count = 1
							return r, true
						default:
							return
						}
					}

					elem = origElem
				case 's': // Prefix: "send_message"
					origElem := elem
					if l := len("send_message"); len(elem) >= l && elem[0:l] == "send_message" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						switch method {
						case "POST":
							// Leaf: SendRawMessage
							r.name = "SendRawMessage"
							r.summary = ""
							r.operationID = "sendRawMessage"
							r.pathPattern = "/v2/liteserver/send_message"
							r.args = args
							r.count = 0
							return r, true
						default:
							return
						}
					}

					elem = origElem
				}

				elem = origElem
			case 'm': // Prefix: "m"
				origElem := elem
				if l := len("m"); len(elem) >= l && elem[0:l] == "m" {
					elem = elem[l:]
				} else {
					break
				}

				if len(elem) == 0 {
					break
				}
				switch elem[0] {
				case 'e': // Prefix: "essage/decode"
					origElem := elem
					if l := len("essage/decode"); len(elem) >= l && elem[0:l] == "essage/decode" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						switch method {
						case "POST":
							// Leaf: DecodeMessage
							r.name = "DecodeMessage"
							r.summary = ""
							r.operationID = "decodeMessage"
							r.pathPattern = "/v2/message/decode"
							r.args = args
							r.count = 0
							return r, true
						default:
							return
						}
					}

					elem = origElem
				case 'u': // Prefix: "ultisig/"
					origElem := elem
					if l := len("ultisig/"); len(elem) >= l && elem[0:l] == "ultisig/" {
						elem = elem[l:]
					} else {
						break
					}

					// Param: "account_id"
					// Leaf parameter
					args[0] = elem
					elem = ""

					if len(elem) == 0 {
						switch method {
						case "GET":
							// Leaf: GetMultisigAccount
							r.name = "GetMultisigAccount"
							r.summary = ""
							r.operationID = "getMultisigAccount"
							r.pathPattern = "/v2/multisig/{account_id}"
							r.args = args
							r.count = 1
							return r, true
						default:
							return
						}
					}

					elem = origElem
				}

				elem = origElem
			case 'n': // Prefix: "nfts/"
				origElem := elem
				if l := len("nfts/"); len(elem) >= l && elem[0:l] == "nfts/" {
					elem = elem[l:]
				} else {
					break
				}

				if len(elem) == 0 {
					break
				}
				switch elem[0] {
				case '_': // Prefix: "_bulk"
					origElem := elem
					if l := len("_bulk"); len(elem) >= l && elem[0:l] == "_bulk" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						switch method {
						case "POST":
							// Leaf: GetNftItemsByAddresses
							r.name = "GetNftItemsByAddresses"
							r.summary = ""
							r.operationID = "getNftItemsByAddresses"
							r.pathPattern = "/v2/nfts/_bulk"
							r.args = args
							r.count = 0
							return r, true
						default:
							return
						}
					}

					elem = origElem
				case 'c': // Prefix: "collections"
					origElem := elem
					if l := len("collections"); len(elem) >= l && elem[0:l] == "collections" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						switch method {
						case "GET":
							r.name = "GetNftCollections"
							r.summary = ""
							r.operationID = "getNftCollections"
							r.pathPattern = "/v2/nfts/collections"
							r.args = args
							r.count = 0
							return r, true
						default:
							return
						}
					}
					switch elem[0] {
					case '/': // Prefix: "/"
						origElem := elem
						if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							break
						}
						switch elem[0] {
						case '_': // Prefix: "_bulk"
							origElem := elem
							if l := len("_bulk"); len(elem) >= l && elem[0:l] == "_bulk" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								switch method {
								case "POST":
									// Leaf: GetNftCollectionItemsByAddresses
									r.name = "GetNftCollectionItemsByAddresses"
									r.summary = ""
									r.operationID = "getNftCollectionItemsByAddresses"
									r.pathPattern = "/v2/nfts/collections/_bulk"
									r.args = args
									r.count = 0
									return r, true
								default:
									return
								}
							}

							elem = origElem
						}
						// Param: "account_id"
						// Match until "/"
						idx := strings.IndexByte(elem, '/')
						if idx < 0 {
							idx = len(elem)
						}
						args[0] = elem[:idx]
						elem = elem[idx:]

						if len(elem) == 0 {
							switch method {
							case "GET":
								r.name = "GetNftCollection"
								r.summary = ""
								r.operationID = "getNftCollection"
								r.pathPattern = "/v2/nfts/collections/{account_id}"
								r.args = args
								r.count = 1
								return r, true
							default:
								return
							}
						}
						switch elem[0] {
						case '/': // Prefix: "/items"
							origElem := elem
							if l := len("/items"); len(elem) >= l && elem[0:l] == "/items" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								switch method {
								case "GET":
									// Leaf: GetItemsFromCollection
									r.name = "GetItemsFromCollection"
									r.summary = ""
									r.operationID = "getItemsFromCollection"
									r.pathPattern = "/v2/nfts/collections/{account_id}/items"
									r.args = args
									r.count = 1
									return r, true
								default:
									return
								}
							}

							elem = origElem
						}

						elem = origElem
					}

					elem = origElem
				}
				// Param: "account_id"
				// Match until "/"
				idx := strings.IndexByte(elem, '/')
				if idx < 0 {
					idx = len(elem)
				}
				args[0] = elem[:idx]
				elem = elem[idx:]

				if len(elem) == 0 {
					switch method {
					case "GET":
						r.name = "GetNftItemByAddress"
						r.summary = ""
						r.operationID = "getNftItemByAddress"
						r.pathPattern = "/v2/nfts/{account_id}"
						r.args = args
						r.count = 1
						return r, true
					default:
						return
					}
				}
				switch elem[0] {
				case '/': // Prefix: "/history"
					origElem := elem
					if l := len("/history"); len(elem) >= l && elem[0:l] == "/history" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						switch method {
						case "GET":
							// Leaf: GetNftHistoryByID
							r.name = "GetNftHistoryByID"
							r.summary = ""
							r.operationID = "getNftHistoryByID"
							r.pathPattern = "/v2/nfts/{account_id}/history"
							r.args = args
							r.count = 1
							return r, true
						default:
							return
						}
					}

					elem = origElem
				}

				elem = origElem
			case 'o': // Prefix: "openapi."
				origElem := elem
				if l := len("openapi."); len(elem) >= l && elem[0:l] == "openapi." {
					elem = elem[l:]
				} else {
					break
				}

				if len(elem) == 0 {
					break
				}
				switch elem[0] {
				case 'j': // Prefix: "json"
					origElem := elem
					if l := len("json"); len(elem) >= l && elem[0:l] == "json" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						switch method {
						case "GET":
							// Leaf: GetOpenapiJson
							r.name = "GetOpenapiJson"
							r.summary = ""
							r.operationID = "getOpenapiJson"
							r.pathPattern = "/v2/openapi.json"
							r.args = args
							r.count = 0
							return r, true
						default:
							return
						}
					}

					elem = origElem
				case 'y': // Prefix: "yml"
					origElem := elem
					if l := len("yml"); len(elem) >= l && elem[0:l] == "yml" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						switch method {
						case "GET":
							// Leaf: GetOpenapiYml
							r.name = "GetOpenapiYml"
							r.summary = ""
							r.operationID = "getOpenapiYml"
							r.pathPattern = "/v2/openapi.yml"
							r.args = args
							r.count = 0
							return r, true
						default:
							return
						}
					}

					elem = origElem
				}

				elem = origElem
			case 'p': // Prefix: "pubkeys/"
				origElem := elem
				if l := len("pubkeys/"); len(elem) >= l && elem[0:l] == "pubkeys/" {
					elem = elem[l:]
				} else {
					break
				}

				// Param: "public_key"
				// Match until "/"
				idx := strings.IndexByte(elem, '/')
				if idx < 0 {
					idx = len(elem)
				}
				args[0] = elem[:idx]
				elem = elem[idx:]

				if len(elem) == 0 {
					break
				}
				switch elem[0] {
				case '/': // Prefix: "/wallets"
					origElem := elem
					if l := len("/wallets"); len(elem) >= l && elem[0:l] == "/wallets" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						switch method {
						case "GET":
							// Leaf: GetWalletsByPublicKey
							r.name = "GetWalletsByPublicKey"
							r.summary = ""
							r.operationID = "getWalletsByPublicKey"
							r.pathPattern = "/v2/pubkeys/{public_key}/wallets"
							r.args = args
							r.count = 1
							return r, true
						default:
							return
						}
					}

					elem = origElem
				}

				elem = origElem
			case 'r': // Prefix: "rates"
				origElem := elem
				if l := len("rates"); len(elem) >= l && elem[0:l] == "rates" {
					elem = elem[l:]
				} else {
					break
				}

				if len(elem) == 0 {
					switch method {
					case "GET":
						r.name = "GetRates"
						r.summary = ""
						r.operationID = "getRates"
						r.pathPattern = "/v2/rates"
						r.args = args
						r.count = 0
						return r, true
					default:
						return
					}
				}
				switch elem[0] {
				case '/': // Prefix: "/"
					origElem := elem
					if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						break
					}
					switch elem[0] {
					case 'c': // Prefix: "chart"
						origElem := elem
						if l := len("chart"); len(elem) >= l && elem[0:l] == "chart" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							switch method {
							case "GET":
								// Leaf: GetChartRates
								r.name = "GetChartRates"
								r.summary = ""
								r.operationID = "getChartRates"
								r.pathPattern = "/v2/rates/chart"
								r.args = args
								r.count = 0
								return r, true
							default:
								return
							}
						}

						elem = origElem
					case 'm': // Prefix: "markets"
						origElem := elem
						if l := len("markets"); len(elem) >= l && elem[0:l] == "markets" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							switch method {
							case "GET":
								// Leaf: GetMarketsRates
								r.name = "GetMarketsRates"
								r.summary = ""
								r.operationID = "getMarketsRates"
								r.pathPattern = "/v2/rates/markets"
								r.args = args
								r.count = 0
								return r, true
							default:
								return
							}
						}

						elem = origElem
					}

					elem = origElem
				}

				elem = origElem
			case 's': // Prefix: "st"
				origElem := elem
				if l := len("st"); len(elem) >= l && elem[0:l] == "st" {
					elem = elem[l:]
				} else {
					break
				}

				if len(elem) == 0 {
					break
				}
				switch elem[0] {
				case 'a': // Prefix: "a"
					origElem := elem
					if l := len("a"); len(elem) >= l && elem[0:l] == "a" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						break
					}
					switch elem[0] {
					case 'k': // Prefix: "king/"
						origElem := elem
						if l := len("king/"); len(elem) >= l && elem[0:l] == "king/" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							break
						}
						switch elem[0] {
						case 'n': // Prefix: "nominator/"
							origElem := elem
							if l := len("nominator/"); len(elem) >= l && elem[0:l] == "nominator/" {
								elem = elem[l:]
							} else {
								break
							}

							// Param: "account_id"
							// Match until "/"
							idx := strings.IndexByte(elem, '/')
							if idx < 0 {
								idx = len(elem)
							}
							args[0] = elem[:idx]
							elem = elem[idx:]

							if len(elem) == 0 {
								break
							}
							switch elem[0] {
							case '/': // Prefix: "/pools"
								origElem := elem
								if l := len("/pools"); len(elem) >= l && elem[0:l] == "/pools" {
									elem = elem[l:]
								} else {
									break
								}

								if len(elem) == 0 {
									switch method {
									case "GET":
										// Leaf: GetAccountNominatorsPools
										r.name = "GetAccountNominatorsPools"
										r.summary = ""
										r.operationID = "getAccountNominatorsPools"
										r.pathPattern = "/v2/staking/nominator/{account_id}/pools"
										r.args = args
										r.count = 1
										return r, true
									default:
										return
									}
								}

								elem = origElem
							}

							elem = origElem
						case 'p': // Prefix: "pool"
							origElem := elem
							if l := len("pool"); len(elem) >= l && elem[0:l] == "pool" {
								elem = elem[l:]
							} else {
								break
							}

							if len(elem) == 0 {
								break
							}
							switch elem[0] {
							case '/': // Prefix: "/"
								origElem := elem
								if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
									elem = elem[l:]
								} else {
									break
								}

								// Param: "account_id"
								// Match until "/"
								idx := strings.IndexByte(elem, '/')
								if idx < 0 {
									idx = len(elem)
								}
								args[0] = elem[:idx]
								elem = elem[idx:]

								if len(elem) == 0 {
									switch method {
									case "GET":
										r.name = "GetStakingPoolInfo"
										r.summary = ""
										r.operationID = "getStakingPoolInfo"
										r.pathPattern = "/v2/staking/pool/{account_id}"
										r.args = args
										r.count = 1
										return r, true
									default:
										return
									}
								}
								switch elem[0] {
								case '/': // Prefix: "/history"
									origElem := elem
									if l := len("/history"); len(elem) >= l && elem[0:l] == "/history" {
										elem = elem[l:]
									} else {
										break
									}

									if len(elem) == 0 {
										switch method {
										case "GET":
											// Leaf: GetStakingPoolHistory
											r.name = "GetStakingPoolHistory"
											r.summary = ""
											r.operationID = "getStakingPoolHistory"
											r.pathPattern = "/v2/staking/pool/{account_id}/history"
											r.args = args
											r.count = 1
											return r, true
										default:
											return
										}
									}

									elem = origElem
								}

								elem = origElem
							case 's': // Prefix: "s"
								origElem := elem
								if l := len("s"); len(elem) >= l && elem[0:l] == "s" {
									elem = elem[l:]
								} else {
									break
								}

								if len(elem) == 0 {
									switch method {
									case "GET":
										// Leaf: GetStakingPools
										r.name = "GetStakingPools"
										r.summary = ""
										r.operationID = "getStakingPools"
										r.pathPattern = "/v2/staking/pools"
										r.args = args
										r.count = 0
										return r, true
									default:
										return
									}
								}

								elem = origElem
							}

							elem = origElem
						}

						elem = origElem
					case 't': // Prefix: "tus"
						origElem := elem
						if l := len("tus"); len(elem) >= l && elem[0:l] == "tus" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							switch method {
							case "GET":
								// Leaf: Status
								r.name = "Status"
								r.summary = ""
								r.operationID = "status"
								r.pathPattern = "/v2/status"
								r.args = args
								r.count = 0
								return r, true
							default:
								return
							}
						}

						elem = origElem
					}

					elem = origElem
				case 'o': // Prefix: "orage/providers"
					origElem := elem
					if l := len("orage/providers"); len(elem) >= l && elem[0:l] == "orage/providers" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						switch method {
						case "GET":
							// Leaf: GetStorageProviders
							r.name = "GetStorageProviders"
							r.summary = ""
							r.operationID = "getStorageProviders"
							r.pathPattern = "/v2/storage/providers"
							r.args = args
							r.count = 0
							return r, true
						default:
							return
						}
					}

					elem = origElem
				}

				elem = origElem
			case 't': // Prefix: "t"
				origElem := elem
				if l := len("t"); len(elem) >= l && elem[0:l] == "t" {
					elem = elem[l:]
				} else {
					break
				}

				if len(elem) == 0 {
					break
				}
				switch elem[0] {
				case 'o': // Prefix: "onconnect/"
					origElem := elem
					if l := len("onconnect/"); len(elem) >= l && elem[0:l] == "onconnect/" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						break
					}
					switch elem[0] {
					case 'p': // Prefix: "payload"
						origElem := elem
						if l := len("payload"); len(elem) >= l && elem[0:l] == "payload" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							switch method {
							case "GET":
								// Leaf: GetTonConnectPayload
								r.name = "GetTonConnectPayload"
								r.summary = ""
								r.operationID = "getTonConnectPayload"
								r.pathPattern = "/v2/tonconnect/payload"
								r.args = args
								r.count = 0
								return r, true
							default:
								return
							}
						}

						elem = origElem
					case 's': // Prefix: "stateinit"
						origElem := elem
						if l := len("stateinit"); len(elem) >= l && elem[0:l] == "stateinit" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							switch method {
							case "POST":
								// Leaf: GetAccountInfoByStateInit
								r.name = "GetAccountInfoByStateInit"
								r.summary = ""
								r.operationID = "getAccountInfoByStateInit"
								r.pathPattern = "/v2/tonconnect/stateinit"
								r.args = args
								r.count = 0
								return r, true
							default:
								return
							}
						}

						elem = origElem
					}

					elem = origElem
				case 'r': // Prefix: "races/"
					origElem := elem
					if l := len("races/"); len(elem) >= l && elem[0:l] == "races/" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						break
					}
					switch elem[0] {
					case 'e': // Prefix: "emulate"
						origElem := elem
						if l := len("emulate"); len(elem) >= l && elem[0:l] == "emulate" {
							elem = elem[l:]
						} else {
							break
						}

						if len(elem) == 0 {
							switch method {
							case "POST":
								// Leaf: EmulateMessageToTrace
								r.name = "EmulateMessageToTrace"
								r.summary = ""
								r.operationID = "emulateMessageToTrace"
								r.pathPattern = "/v2/traces/emulate"
								r.args = args
								r.count = 0
								return r, true
							default:
								return
							}
						}

						elem = origElem
					}
					// Param: "trace_id"
					// Leaf parameter
					args[0] = elem
					elem = ""

					if len(elem) == 0 {
						switch method {
						case "GET":
							// Leaf: GetTrace
							r.name = "GetTrace"
							r.summary = ""
							r.operationID = "getTrace"
							r.pathPattern = "/v2/traces/{trace_id}"
							r.args = args
							r.count = 1
							return r, true
						default:
							return
						}
					}

					elem = origElem
				}

				elem = origElem
			case 'w': // Prefix: "wallet/"
				origElem := elem
				if l := len("wallet/"); len(elem) >= l && elem[0:l] == "wallet/" {
					elem = elem[l:]
				} else {
					break
				}

				if len(elem) == 0 {
					break
				}
				switch elem[0] {
				case 'a': // Prefix: "auth/proof"
					origElem := elem
					if l := len("auth/proof"); len(elem) >= l && elem[0:l] == "auth/proof" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						switch method {
						case "POST":
							// Leaf: TonConnectProof
							r.name = "TonConnectProof"
							r.summary = ""
							r.operationID = "tonConnectProof"
							r.pathPattern = "/v2/wallet/auth/proof"
							r.args = args
							r.count = 0
							return r, true
						default:
							return
						}
					}

					elem = origElem
				case 'e': // Prefix: "emulate"
					origElem := elem
					if l := len("emulate"); len(elem) >= l && elem[0:l] == "emulate" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						switch method {
						case "POST":
							// Leaf: EmulateMessageToWallet
							r.name = "EmulateMessageToWallet"
							r.summary = ""
							r.operationID = "emulateMessageToWallet"
							r.pathPattern = "/v2/wallet/emulate"
							r.args = args
							r.count = 0
							return r, true
						default:
							return
						}
					}

					elem = origElem
				}
				// Param: "account_id"
				// Match until "/"
				idx := strings.IndexByte(elem, '/')
				if idx < 0 {
					idx = len(elem)
				}
				args[0] = elem[:idx]
				elem = elem[idx:]

				if len(elem) == 0 {
					break
				}
				switch elem[0] {
				case '/': // Prefix: "/seqno"
					origElem := elem
					if l := len("/seqno"); len(elem) >= l && elem[0:l] == "/seqno" {
						elem = elem[l:]
					} else {
						break
					}

					if len(elem) == 0 {
						switch method {
						case "GET":
							// Leaf: GetAccountSeqno
							r.name = "GetAccountSeqno"
							r.summary = ""
							r.operationID = "getAccountSeqno"
							r.pathPattern = "/v2/wallet/{account_id}/seqno"
							r.args = args
							r.count = 1
							return r, true
						default:
							return
						}
					}

					elem = origElem
				}

				elem = origElem
			}

			elem = origElem
		}
	}
	return r, false
}