// Code generated by protoc-gen-twirp v8.1.3, DO NOT EDIT.
// source: livekit_sip.proto

package livekit

import context "context"
import fmt "fmt"
import http "net/http"
import io "io"
import json "encoding/json"
import strconv "strconv"
import strings "strings"

import protojson "google.golang.org/protobuf/encoding/protojson"
import proto "google.golang.org/protobuf/proto"
import twirp "github.com/twitchtv/twirp"
import ctxsetters "github.com/twitchtv/twirp/ctxsetters"

import google_protobuf4 "google.golang.org/protobuf/types/known/emptypb"

// Version compatibility assertion.
// If the constant is not defined in the package, that likely means
// the package needs to be updated to work with this generated code.
// See https://twitchtv.github.io/twirp/docs/version_matrix.html
const _ = twirp.TwirpPackageMinVersion_8_1_0

// =============
// SIP Interface
// =============

type SIP interface {
	ListSIPTrunk(context.Context, *ListSIPTrunkRequest) (*ListSIPTrunkResponse, error)

	CreateSIPInboundTrunk(context.Context, *CreateSIPInboundTrunkRequest) (*SIPInboundTrunkInfo, error)

	CreateSIPOutboundTrunk(context.Context, *CreateSIPOutboundTrunkRequest) (*SIPOutboundTrunkInfo, error)

	UpdateSIPInboundTrunk(context.Context, *UpdateSIPInboundTrunkRequest) (*SIPInboundTrunkInfo, error)

	UpdateSIPOutboundTrunk(context.Context, *UpdateSIPOutboundTrunkRequest) (*SIPOutboundTrunkInfo, error)

	GetSIPInboundTrunk(context.Context, *GetSIPInboundTrunkRequest) (*GetSIPInboundTrunkResponse, error)

	GetSIPOutboundTrunk(context.Context, *GetSIPOutboundTrunkRequest) (*GetSIPOutboundTrunkResponse, error)

	ListSIPInboundTrunk(context.Context, *ListSIPInboundTrunkRequest) (*ListSIPInboundTrunkResponse, error)

	ListSIPOutboundTrunk(context.Context, *ListSIPOutboundTrunkRequest) (*ListSIPOutboundTrunkResponse, error)

	DeleteSIPTrunk(context.Context, *DeleteSIPTrunkRequest) (*SIPTrunkInfo, error)

	CreateSIPDispatchRule(context.Context, *CreateSIPDispatchRuleRequest) (*SIPDispatchRuleInfo, error)

	UpdateSIPDispatchRule(context.Context, *UpdateSIPDispatchRuleRequest) (*SIPDispatchRuleInfo, error)

	ListSIPDispatchRule(context.Context, *ListSIPDispatchRuleRequest) (*ListSIPDispatchRuleResponse, error)

	DeleteSIPDispatchRule(context.Context, *DeleteSIPDispatchRuleRequest) (*SIPDispatchRuleInfo, error)

	CreateSIPParticipant(context.Context, *CreateSIPParticipantRequest) (*SIPParticipantInfo, error)

	TransferSIPParticipant(context.Context, *TransferSIPParticipantRequest) (*google_protobuf4.Empty, error)
}

// ===================
// SIP Protobuf Client
// ===================

type sIPProtobufClient struct {
	client      HTTPClient
	urls        [16]string
	interceptor twirp.Interceptor
	opts        twirp.ClientOptions
}

// NewSIPProtobufClient creates a Protobuf client that implements the SIP interface.
// It communicates using Protobuf and can be configured with a custom HTTPClient.
func NewSIPProtobufClient(baseURL string, client HTTPClient, opts ...twirp.ClientOption) SIP {
	if c, ok := client.(*http.Client); ok {
		client = withoutRedirects(c)
	}

	clientOpts := twirp.ClientOptions{}
	for _, o := range opts {
		o(&clientOpts)
	}

	// Using ReadOpt allows backwards and forwards compatibility with new options in the future
	literalURLs := false
	_ = clientOpts.ReadOpt("literalURLs", &literalURLs)
	var pathPrefix string
	if ok := clientOpts.ReadOpt("pathPrefix", &pathPrefix); !ok {
		pathPrefix = "/twirp" // default prefix
	}

	// Build method URLs: <baseURL>[<prefix>]/<package>.<Service>/<Method>
	serviceURL := sanitizeBaseURL(baseURL)
	serviceURL += baseServicePath(pathPrefix, "livekit", "SIP")
	urls := [16]string{
		serviceURL + "ListSIPTrunk",
		serviceURL + "CreateSIPInboundTrunk",
		serviceURL + "CreateSIPOutboundTrunk",
		serviceURL + "UpdateSIPInboundTrunk",
		serviceURL + "UpdateSIPOutboundTrunk",
		serviceURL + "GetSIPInboundTrunk",
		serviceURL + "GetSIPOutboundTrunk",
		serviceURL + "ListSIPInboundTrunk",
		serviceURL + "ListSIPOutboundTrunk",
		serviceURL + "DeleteSIPTrunk",
		serviceURL + "CreateSIPDispatchRule",
		serviceURL + "UpdateSIPDispatchRule",
		serviceURL + "ListSIPDispatchRule",
		serviceURL + "DeleteSIPDispatchRule",
		serviceURL + "CreateSIPParticipant",
		serviceURL + "TransferSIPParticipant",
	}

	return &sIPProtobufClient{
		client:      client,
		urls:        urls,
		interceptor: twirp.ChainInterceptors(clientOpts.Interceptors...),
		opts:        clientOpts,
	}
}

func (c *sIPProtobufClient) ListSIPTrunk(ctx context.Context, in *ListSIPTrunkRequest) (*ListSIPTrunkResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "SIP")
	ctx = ctxsetters.WithMethodName(ctx, "ListSIPTrunk")
	caller := c.callListSIPTrunk
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *ListSIPTrunkRequest) (*ListSIPTrunkResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ListSIPTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ListSIPTrunkRequest) when calling interceptor")
					}
					return c.callListSIPTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ListSIPTrunkResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ListSIPTrunkResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *sIPProtobufClient) callListSIPTrunk(ctx context.Context, in *ListSIPTrunkRequest) (*ListSIPTrunkResponse, error) {
	out := new(ListSIPTrunkResponse)
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[0], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *sIPProtobufClient) CreateSIPInboundTrunk(ctx context.Context, in *CreateSIPInboundTrunkRequest) (*SIPInboundTrunkInfo, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "SIP")
	ctx = ctxsetters.WithMethodName(ctx, "CreateSIPInboundTrunk")
	caller := c.callCreateSIPInboundTrunk
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *CreateSIPInboundTrunkRequest) (*SIPInboundTrunkInfo, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*CreateSIPInboundTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*CreateSIPInboundTrunkRequest) when calling interceptor")
					}
					return c.callCreateSIPInboundTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SIPInboundTrunkInfo)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SIPInboundTrunkInfo) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *sIPProtobufClient) callCreateSIPInboundTrunk(ctx context.Context, in *CreateSIPInboundTrunkRequest) (*SIPInboundTrunkInfo, error) {
	out := new(SIPInboundTrunkInfo)
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[1], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *sIPProtobufClient) CreateSIPOutboundTrunk(ctx context.Context, in *CreateSIPOutboundTrunkRequest) (*SIPOutboundTrunkInfo, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "SIP")
	ctx = ctxsetters.WithMethodName(ctx, "CreateSIPOutboundTrunk")
	caller := c.callCreateSIPOutboundTrunk
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *CreateSIPOutboundTrunkRequest) (*SIPOutboundTrunkInfo, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*CreateSIPOutboundTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*CreateSIPOutboundTrunkRequest) when calling interceptor")
					}
					return c.callCreateSIPOutboundTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SIPOutboundTrunkInfo)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SIPOutboundTrunkInfo) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *sIPProtobufClient) callCreateSIPOutboundTrunk(ctx context.Context, in *CreateSIPOutboundTrunkRequest) (*SIPOutboundTrunkInfo, error) {
	out := new(SIPOutboundTrunkInfo)
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[2], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *sIPProtobufClient) UpdateSIPInboundTrunk(ctx context.Context, in *UpdateSIPInboundTrunkRequest) (*SIPInboundTrunkInfo, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "SIP")
	ctx = ctxsetters.WithMethodName(ctx, "UpdateSIPInboundTrunk")
	caller := c.callUpdateSIPInboundTrunk
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *UpdateSIPInboundTrunkRequest) (*SIPInboundTrunkInfo, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*UpdateSIPInboundTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*UpdateSIPInboundTrunkRequest) when calling interceptor")
					}
					return c.callUpdateSIPInboundTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SIPInboundTrunkInfo)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SIPInboundTrunkInfo) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *sIPProtobufClient) callUpdateSIPInboundTrunk(ctx context.Context, in *UpdateSIPInboundTrunkRequest) (*SIPInboundTrunkInfo, error) {
	out := new(SIPInboundTrunkInfo)
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[3], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *sIPProtobufClient) UpdateSIPOutboundTrunk(ctx context.Context, in *UpdateSIPOutboundTrunkRequest) (*SIPOutboundTrunkInfo, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "SIP")
	ctx = ctxsetters.WithMethodName(ctx, "UpdateSIPOutboundTrunk")
	caller := c.callUpdateSIPOutboundTrunk
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *UpdateSIPOutboundTrunkRequest) (*SIPOutboundTrunkInfo, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*UpdateSIPOutboundTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*UpdateSIPOutboundTrunkRequest) when calling interceptor")
					}
					return c.callUpdateSIPOutboundTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SIPOutboundTrunkInfo)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SIPOutboundTrunkInfo) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *sIPProtobufClient) callUpdateSIPOutboundTrunk(ctx context.Context, in *UpdateSIPOutboundTrunkRequest) (*SIPOutboundTrunkInfo, error) {
	out := new(SIPOutboundTrunkInfo)
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[4], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *sIPProtobufClient) GetSIPInboundTrunk(ctx context.Context, in *GetSIPInboundTrunkRequest) (*GetSIPInboundTrunkResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "SIP")
	ctx = ctxsetters.WithMethodName(ctx, "GetSIPInboundTrunk")
	caller := c.callGetSIPInboundTrunk
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *GetSIPInboundTrunkRequest) (*GetSIPInboundTrunkResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*GetSIPInboundTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*GetSIPInboundTrunkRequest) when calling interceptor")
					}
					return c.callGetSIPInboundTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*GetSIPInboundTrunkResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*GetSIPInboundTrunkResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *sIPProtobufClient) callGetSIPInboundTrunk(ctx context.Context, in *GetSIPInboundTrunkRequest) (*GetSIPInboundTrunkResponse, error) {
	out := new(GetSIPInboundTrunkResponse)
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[5], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *sIPProtobufClient) GetSIPOutboundTrunk(ctx context.Context, in *GetSIPOutboundTrunkRequest) (*GetSIPOutboundTrunkResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "SIP")
	ctx = ctxsetters.WithMethodName(ctx, "GetSIPOutboundTrunk")
	caller := c.callGetSIPOutboundTrunk
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *GetSIPOutboundTrunkRequest) (*GetSIPOutboundTrunkResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*GetSIPOutboundTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*GetSIPOutboundTrunkRequest) when calling interceptor")
					}
					return c.callGetSIPOutboundTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*GetSIPOutboundTrunkResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*GetSIPOutboundTrunkResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *sIPProtobufClient) callGetSIPOutboundTrunk(ctx context.Context, in *GetSIPOutboundTrunkRequest) (*GetSIPOutboundTrunkResponse, error) {
	out := new(GetSIPOutboundTrunkResponse)
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[6], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *sIPProtobufClient) ListSIPInboundTrunk(ctx context.Context, in *ListSIPInboundTrunkRequest) (*ListSIPInboundTrunkResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "SIP")
	ctx = ctxsetters.WithMethodName(ctx, "ListSIPInboundTrunk")
	caller := c.callListSIPInboundTrunk
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *ListSIPInboundTrunkRequest) (*ListSIPInboundTrunkResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ListSIPInboundTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ListSIPInboundTrunkRequest) when calling interceptor")
					}
					return c.callListSIPInboundTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ListSIPInboundTrunkResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ListSIPInboundTrunkResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *sIPProtobufClient) callListSIPInboundTrunk(ctx context.Context, in *ListSIPInboundTrunkRequest) (*ListSIPInboundTrunkResponse, error) {
	out := new(ListSIPInboundTrunkResponse)
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[7], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *sIPProtobufClient) ListSIPOutboundTrunk(ctx context.Context, in *ListSIPOutboundTrunkRequest) (*ListSIPOutboundTrunkResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "SIP")
	ctx = ctxsetters.WithMethodName(ctx, "ListSIPOutboundTrunk")
	caller := c.callListSIPOutboundTrunk
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *ListSIPOutboundTrunkRequest) (*ListSIPOutboundTrunkResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ListSIPOutboundTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ListSIPOutboundTrunkRequest) when calling interceptor")
					}
					return c.callListSIPOutboundTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ListSIPOutboundTrunkResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ListSIPOutboundTrunkResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *sIPProtobufClient) callListSIPOutboundTrunk(ctx context.Context, in *ListSIPOutboundTrunkRequest) (*ListSIPOutboundTrunkResponse, error) {
	out := new(ListSIPOutboundTrunkResponse)
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[8], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *sIPProtobufClient) DeleteSIPTrunk(ctx context.Context, in *DeleteSIPTrunkRequest) (*SIPTrunkInfo, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "SIP")
	ctx = ctxsetters.WithMethodName(ctx, "DeleteSIPTrunk")
	caller := c.callDeleteSIPTrunk
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *DeleteSIPTrunkRequest) (*SIPTrunkInfo, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*DeleteSIPTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*DeleteSIPTrunkRequest) when calling interceptor")
					}
					return c.callDeleteSIPTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SIPTrunkInfo)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SIPTrunkInfo) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *sIPProtobufClient) callDeleteSIPTrunk(ctx context.Context, in *DeleteSIPTrunkRequest) (*SIPTrunkInfo, error) {
	out := new(SIPTrunkInfo)
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[9], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *sIPProtobufClient) CreateSIPDispatchRule(ctx context.Context, in *CreateSIPDispatchRuleRequest) (*SIPDispatchRuleInfo, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "SIP")
	ctx = ctxsetters.WithMethodName(ctx, "CreateSIPDispatchRule")
	caller := c.callCreateSIPDispatchRule
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *CreateSIPDispatchRuleRequest) (*SIPDispatchRuleInfo, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*CreateSIPDispatchRuleRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*CreateSIPDispatchRuleRequest) when calling interceptor")
					}
					return c.callCreateSIPDispatchRule(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SIPDispatchRuleInfo)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SIPDispatchRuleInfo) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *sIPProtobufClient) callCreateSIPDispatchRule(ctx context.Context, in *CreateSIPDispatchRuleRequest) (*SIPDispatchRuleInfo, error) {
	out := new(SIPDispatchRuleInfo)
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[10], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *sIPProtobufClient) UpdateSIPDispatchRule(ctx context.Context, in *UpdateSIPDispatchRuleRequest) (*SIPDispatchRuleInfo, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "SIP")
	ctx = ctxsetters.WithMethodName(ctx, "UpdateSIPDispatchRule")
	caller := c.callUpdateSIPDispatchRule
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *UpdateSIPDispatchRuleRequest) (*SIPDispatchRuleInfo, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*UpdateSIPDispatchRuleRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*UpdateSIPDispatchRuleRequest) when calling interceptor")
					}
					return c.callUpdateSIPDispatchRule(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SIPDispatchRuleInfo)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SIPDispatchRuleInfo) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *sIPProtobufClient) callUpdateSIPDispatchRule(ctx context.Context, in *UpdateSIPDispatchRuleRequest) (*SIPDispatchRuleInfo, error) {
	out := new(SIPDispatchRuleInfo)
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[11], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *sIPProtobufClient) ListSIPDispatchRule(ctx context.Context, in *ListSIPDispatchRuleRequest) (*ListSIPDispatchRuleResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "SIP")
	ctx = ctxsetters.WithMethodName(ctx, "ListSIPDispatchRule")
	caller := c.callListSIPDispatchRule
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *ListSIPDispatchRuleRequest) (*ListSIPDispatchRuleResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ListSIPDispatchRuleRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ListSIPDispatchRuleRequest) when calling interceptor")
					}
					return c.callListSIPDispatchRule(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ListSIPDispatchRuleResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ListSIPDispatchRuleResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *sIPProtobufClient) callListSIPDispatchRule(ctx context.Context, in *ListSIPDispatchRuleRequest) (*ListSIPDispatchRuleResponse, error) {
	out := new(ListSIPDispatchRuleResponse)
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[12], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *sIPProtobufClient) DeleteSIPDispatchRule(ctx context.Context, in *DeleteSIPDispatchRuleRequest) (*SIPDispatchRuleInfo, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "SIP")
	ctx = ctxsetters.WithMethodName(ctx, "DeleteSIPDispatchRule")
	caller := c.callDeleteSIPDispatchRule
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *DeleteSIPDispatchRuleRequest) (*SIPDispatchRuleInfo, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*DeleteSIPDispatchRuleRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*DeleteSIPDispatchRuleRequest) when calling interceptor")
					}
					return c.callDeleteSIPDispatchRule(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SIPDispatchRuleInfo)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SIPDispatchRuleInfo) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *sIPProtobufClient) callDeleteSIPDispatchRule(ctx context.Context, in *DeleteSIPDispatchRuleRequest) (*SIPDispatchRuleInfo, error) {
	out := new(SIPDispatchRuleInfo)
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[13], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *sIPProtobufClient) CreateSIPParticipant(ctx context.Context, in *CreateSIPParticipantRequest) (*SIPParticipantInfo, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "SIP")
	ctx = ctxsetters.WithMethodName(ctx, "CreateSIPParticipant")
	caller := c.callCreateSIPParticipant
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *CreateSIPParticipantRequest) (*SIPParticipantInfo, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*CreateSIPParticipantRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*CreateSIPParticipantRequest) when calling interceptor")
					}
					return c.callCreateSIPParticipant(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SIPParticipantInfo)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SIPParticipantInfo) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *sIPProtobufClient) callCreateSIPParticipant(ctx context.Context, in *CreateSIPParticipantRequest) (*SIPParticipantInfo, error) {
	out := new(SIPParticipantInfo)
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[14], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *sIPProtobufClient) TransferSIPParticipant(ctx context.Context, in *TransferSIPParticipantRequest) (*google_protobuf4.Empty, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "SIP")
	ctx = ctxsetters.WithMethodName(ctx, "TransferSIPParticipant")
	caller := c.callTransferSIPParticipant
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *TransferSIPParticipantRequest) (*google_protobuf4.Empty, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*TransferSIPParticipantRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*TransferSIPParticipantRequest) when calling interceptor")
					}
					return c.callTransferSIPParticipant(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*google_protobuf4.Empty)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*google_protobuf4.Empty) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *sIPProtobufClient) callTransferSIPParticipant(ctx context.Context, in *TransferSIPParticipantRequest) (*google_protobuf4.Empty, error) {
	out := new(google_protobuf4.Empty)
	ctx, err := doProtobufRequest(ctx, c.client, c.opts.Hooks, c.urls[15], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

// ===============
// SIP JSON Client
// ===============

type sIPJSONClient struct {
	client      HTTPClient
	urls        [16]string
	interceptor twirp.Interceptor
	opts        twirp.ClientOptions
}

// NewSIPJSONClient creates a JSON client that implements the SIP interface.
// It communicates using JSON and can be configured with a custom HTTPClient.
func NewSIPJSONClient(baseURL string, client HTTPClient, opts ...twirp.ClientOption) SIP {
	if c, ok := client.(*http.Client); ok {
		client = withoutRedirects(c)
	}

	clientOpts := twirp.ClientOptions{}
	for _, o := range opts {
		o(&clientOpts)
	}

	// Using ReadOpt allows backwards and forwards compatibility with new options in the future
	literalURLs := false
	_ = clientOpts.ReadOpt("literalURLs", &literalURLs)
	var pathPrefix string
	if ok := clientOpts.ReadOpt("pathPrefix", &pathPrefix); !ok {
		pathPrefix = "/twirp" // default prefix
	}

	// Build method URLs: <baseURL>[<prefix>]/<package>.<Service>/<Method>
	serviceURL := sanitizeBaseURL(baseURL)
	serviceURL += baseServicePath(pathPrefix, "livekit", "SIP")
	urls := [16]string{
		serviceURL + "ListSIPTrunk",
		serviceURL + "CreateSIPInboundTrunk",
		serviceURL + "CreateSIPOutboundTrunk",
		serviceURL + "UpdateSIPInboundTrunk",
		serviceURL + "UpdateSIPOutboundTrunk",
		serviceURL + "GetSIPInboundTrunk",
		serviceURL + "GetSIPOutboundTrunk",
		serviceURL + "ListSIPInboundTrunk",
		serviceURL + "ListSIPOutboundTrunk",
		serviceURL + "DeleteSIPTrunk",
		serviceURL + "CreateSIPDispatchRule",
		serviceURL + "UpdateSIPDispatchRule",
		serviceURL + "ListSIPDispatchRule",
		serviceURL + "DeleteSIPDispatchRule",
		serviceURL + "CreateSIPParticipant",
		serviceURL + "TransferSIPParticipant",
	}

	return &sIPJSONClient{
		client:      client,
		urls:        urls,
		interceptor: twirp.ChainInterceptors(clientOpts.Interceptors...),
		opts:        clientOpts,
	}
}

func (c *sIPJSONClient) ListSIPTrunk(ctx context.Context, in *ListSIPTrunkRequest) (*ListSIPTrunkResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "SIP")
	ctx = ctxsetters.WithMethodName(ctx, "ListSIPTrunk")
	caller := c.callListSIPTrunk
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *ListSIPTrunkRequest) (*ListSIPTrunkResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ListSIPTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ListSIPTrunkRequest) when calling interceptor")
					}
					return c.callListSIPTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ListSIPTrunkResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ListSIPTrunkResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *sIPJSONClient) callListSIPTrunk(ctx context.Context, in *ListSIPTrunkRequest) (*ListSIPTrunkResponse, error) {
	out := new(ListSIPTrunkResponse)
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[0], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *sIPJSONClient) CreateSIPInboundTrunk(ctx context.Context, in *CreateSIPInboundTrunkRequest) (*SIPInboundTrunkInfo, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "SIP")
	ctx = ctxsetters.WithMethodName(ctx, "CreateSIPInboundTrunk")
	caller := c.callCreateSIPInboundTrunk
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *CreateSIPInboundTrunkRequest) (*SIPInboundTrunkInfo, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*CreateSIPInboundTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*CreateSIPInboundTrunkRequest) when calling interceptor")
					}
					return c.callCreateSIPInboundTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SIPInboundTrunkInfo)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SIPInboundTrunkInfo) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *sIPJSONClient) callCreateSIPInboundTrunk(ctx context.Context, in *CreateSIPInboundTrunkRequest) (*SIPInboundTrunkInfo, error) {
	out := new(SIPInboundTrunkInfo)
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[1], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *sIPJSONClient) CreateSIPOutboundTrunk(ctx context.Context, in *CreateSIPOutboundTrunkRequest) (*SIPOutboundTrunkInfo, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "SIP")
	ctx = ctxsetters.WithMethodName(ctx, "CreateSIPOutboundTrunk")
	caller := c.callCreateSIPOutboundTrunk
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *CreateSIPOutboundTrunkRequest) (*SIPOutboundTrunkInfo, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*CreateSIPOutboundTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*CreateSIPOutboundTrunkRequest) when calling interceptor")
					}
					return c.callCreateSIPOutboundTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SIPOutboundTrunkInfo)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SIPOutboundTrunkInfo) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *sIPJSONClient) callCreateSIPOutboundTrunk(ctx context.Context, in *CreateSIPOutboundTrunkRequest) (*SIPOutboundTrunkInfo, error) {
	out := new(SIPOutboundTrunkInfo)
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[2], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *sIPJSONClient) UpdateSIPInboundTrunk(ctx context.Context, in *UpdateSIPInboundTrunkRequest) (*SIPInboundTrunkInfo, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "SIP")
	ctx = ctxsetters.WithMethodName(ctx, "UpdateSIPInboundTrunk")
	caller := c.callUpdateSIPInboundTrunk
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *UpdateSIPInboundTrunkRequest) (*SIPInboundTrunkInfo, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*UpdateSIPInboundTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*UpdateSIPInboundTrunkRequest) when calling interceptor")
					}
					return c.callUpdateSIPInboundTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SIPInboundTrunkInfo)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SIPInboundTrunkInfo) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *sIPJSONClient) callUpdateSIPInboundTrunk(ctx context.Context, in *UpdateSIPInboundTrunkRequest) (*SIPInboundTrunkInfo, error) {
	out := new(SIPInboundTrunkInfo)
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[3], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *sIPJSONClient) UpdateSIPOutboundTrunk(ctx context.Context, in *UpdateSIPOutboundTrunkRequest) (*SIPOutboundTrunkInfo, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "SIP")
	ctx = ctxsetters.WithMethodName(ctx, "UpdateSIPOutboundTrunk")
	caller := c.callUpdateSIPOutboundTrunk
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *UpdateSIPOutboundTrunkRequest) (*SIPOutboundTrunkInfo, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*UpdateSIPOutboundTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*UpdateSIPOutboundTrunkRequest) when calling interceptor")
					}
					return c.callUpdateSIPOutboundTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SIPOutboundTrunkInfo)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SIPOutboundTrunkInfo) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *sIPJSONClient) callUpdateSIPOutboundTrunk(ctx context.Context, in *UpdateSIPOutboundTrunkRequest) (*SIPOutboundTrunkInfo, error) {
	out := new(SIPOutboundTrunkInfo)
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[4], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *sIPJSONClient) GetSIPInboundTrunk(ctx context.Context, in *GetSIPInboundTrunkRequest) (*GetSIPInboundTrunkResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "SIP")
	ctx = ctxsetters.WithMethodName(ctx, "GetSIPInboundTrunk")
	caller := c.callGetSIPInboundTrunk
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *GetSIPInboundTrunkRequest) (*GetSIPInboundTrunkResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*GetSIPInboundTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*GetSIPInboundTrunkRequest) when calling interceptor")
					}
					return c.callGetSIPInboundTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*GetSIPInboundTrunkResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*GetSIPInboundTrunkResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *sIPJSONClient) callGetSIPInboundTrunk(ctx context.Context, in *GetSIPInboundTrunkRequest) (*GetSIPInboundTrunkResponse, error) {
	out := new(GetSIPInboundTrunkResponse)
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[5], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *sIPJSONClient) GetSIPOutboundTrunk(ctx context.Context, in *GetSIPOutboundTrunkRequest) (*GetSIPOutboundTrunkResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "SIP")
	ctx = ctxsetters.WithMethodName(ctx, "GetSIPOutboundTrunk")
	caller := c.callGetSIPOutboundTrunk
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *GetSIPOutboundTrunkRequest) (*GetSIPOutboundTrunkResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*GetSIPOutboundTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*GetSIPOutboundTrunkRequest) when calling interceptor")
					}
					return c.callGetSIPOutboundTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*GetSIPOutboundTrunkResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*GetSIPOutboundTrunkResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *sIPJSONClient) callGetSIPOutboundTrunk(ctx context.Context, in *GetSIPOutboundTrunkRequest) (*GetSIPOutboundTrunkResponse, error) {
	out := new(GetSIPOutboundTrunkResponse)
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[6], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *sIPJSONClient) ListSIPInboundTrunk(ctx context.Context, in *ListSIPInboundTrunkRequest) (*ListSIPInboundTrunkResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "SIP")
	ctx = ctxsetters.WithMethodName(ctx, "ListSIPInboundTrunk")
	caller := c.callListSIPInboundTrunk
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *ListSIPInboundTrunkRequest) (*ListSIPInboundTrunkResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ListSIPInboundTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ListSIPInboundTrunkRequest) when calling interceptor")
					}
					return c.callListSIPInboundTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ListSIPInboundTrunkResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ListSIPInboundTrunkResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *sIPJSONClient) callListSIPInboundTrunk(ctx context.Context, in *ListSIPInboundTrunkRequest) (*ListSIPInboundTrunkResponse, error) {
	out := new(ListSIPInboundTrunkResponse)
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[7], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *sIPJSONClient) ListSIPOutboundTrunk(ctx context.Context, in *ListSIPOutboundTrunkRequest) (*ListSIPOutboundTrunkResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "SIP")
	ctx = ctxsetters.WithMethodName(ctx, "ListSIPOutboundTrunk")
	caller := c.callListSIPOutboundTrunk
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *ListSIPOutboundTrunkRequest) (*ListSIPOutboundTrunkResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ListSIPOutboundTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ListSIPOutboundTrunkRequest) when calling interceptor")
					}
					return c.callListSIPOutboundTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ListSIPOutboundTrunkResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ListSIPOutboundTrunkResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *sIPJSONClient) callListSIPOutboundTrunk(ctx context.Context, in *ListSIPOutboundTrunkRequest) (*ListSIPOutboundTrunkResponse, error) {
	out := new(ListSIPOutboundTrunkResponse)
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[8], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *sIPJSONClient) DeleteSIPTrunk(ctx context.Context, in *DeleteSIPTrunkRequest) (*SIPTrunkInfo, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "SIP")
	ctx = ctxsetters.WithMethodName(ctx, "DeleteSIPTrunk")
	caller := c.callDeleteSIPTrunk
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *DeleteSIPTrunkRequest) (*SIPTrunkInfo, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*DeleteSIPTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*DeleteSIPTrunkRequest) when calling interceptor")
					}
					return c.callDeleteSIPTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SIPTrunkInfo)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SIPTrunkInfo) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *sIPJSONClient) callDeleteSIPTrunk(ctx context.Context, in *DeleteSIPTrunkRequest) (*SIPTrunkInfo, error) {
	out := new(SIPTrunkInfo)
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[9], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *sIPJSONClient) CreateSIPDispatchRule(ctx context.Context, in *CreateSIPDispatchRuleRequest) (*SIPDispatchRuleInfo, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "SIP")
	ctx = ctxsetters.WithMethodName(ctx, "CreateSIPDispatchRule")
	caller := c.callCreateSIPDispatchRule
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *CreateSIPDispatchRuleRequest) (*SIPDispatchRuleInfo, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*CreateSIPDispatchRuleRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*CreateSIPDispatchRuleRequest) when calling interceptor")
					}
					return c.callCreateSIPDispatchRule(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SIPDispatchRuleInfo)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SIPDispatchRuleInfo) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *sIPJSONClient) callCreateSIPDispatchRule(ctx context.Context, in *CreateSIPDispatchRuleRequest) (*SIPDispatchRuleInfo, error) {
	out := new(SIPDispatchRuleInfo)
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[10], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *sIPJSONClient) UpdateSIPDispatchRule(ctx context.Context, in *UpdateSIPDispatchRuleRequest) (*SIPDispatchRuleInfo, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "SIP")
	ctx = ctxsetters.WithMethodName(ctx, "UpdateSIPDispatchRule")
	caller := c.callUpdateSIPDispatchRule
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *UpdateSIPDispatchRuleRequest) (*SIPDispatchRuleInfo, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*UpdateSIPDispatchRuleRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*UpdateSIPDispatchRuleRequest) when calling interceptor")
					}
					return c.callUpdateSIPDispatchRule(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SIPDispatchRuleInfo)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SIPDispatchRuleInfo) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *sIPJSONClient) callUpdateSIPDispatchRule(ctx context.Context, in *UpdateSIPDispatchRuleRequest) (*SIPDispatchRuleInfo, error) {
	out := new(SIPDispatchRuleInfo)
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[11], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *sIPJSONClient) ListSIPDispatchRule(ctx context.Context, in *ListSIPDispatchRuleRequest) (*ListSIPDispatchRuleResponse, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "SIP")
	ctx = ctxsetters.WithMethodName(ctx, "ListSIPDispatchRule")
	caller := c.callListSIPDispatchRule
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *ListSIPDispatchRuleRequest) (*ListSIPDispatchRuleResponse, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ListSIPDispatchRuleRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ListSIPDispatchRuleRequest) when calling interceptor")
					}
					return c.callListSIPDispatchRule(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ListSIPDispatchRuleResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ListSIPDispatchRuleResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *sIPJSONClient) callListSIPDispatchRule(ctx context.Context, in *ListSIPDispatchRuleRequest) (*ListSIPDispatchRuleResponse, error) {
	out := new(ListSIPDispatchRuleResponse)
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[12], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *sIPJSONClient) DeleteSIPDispatchRule(ctx context.Context, in *DeleteSIPDispatchRuleRequest) (*SIPDispatchRuleInfo, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "SIP")
	ctx = ctxsetters.WithMethodName(ctx, "DeleteSIPDispatchRule")
	caller := c.callDeleteSIPDispatchRule
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *DeleteSIPDispatchRuleRequest) (*SIPDispatchRuleInfo, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*DeleteSIPDispatchRuleRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*DeleteSIPDispatchRuleRequest) when calling interceptor")
					}
					return c.callDeleteSIPDispatchRule(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SIPDispatchRuleInfo)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SIPDispatchRuleInfo) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *sIPJSONClient) callDeleteSIPDispatchRule(ctx context.Context, in *DeleteSIPDispatchRuleRequest) (*SIPDispatchRuleInfo, error) {
	out := new(SIPDispatchRuleInfo)
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[13], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *sIPJSONClient) CreateSIPParticipant(ctx context.Context, in *CreateSIPParticipantRequest) (*SIPParticipantInfo, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "SIP")
	ctx = ctxsetters.WithMethodName(ctx, "CreateSIPParticipant")
	caller := c.callCreateSIPParticipant
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *CreateSIPParticipantRequest) (*SIPParticipantInfo, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*CreateSIPParticipantRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*CreateSIPParticipantRequest) when calling interceptor")
					}
					return c.callCreateSIPParticipant(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SIPParticipantInfo)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SIPParticipantInfo) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *sIPJSONClient) callCreateSIPParticipant(ctx context.Context, in *CreateSIPParticipantRequest) (*SIPParticipantInfo, error) {
	out := new(SIPParticipantInfo)
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[14], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

func (c *sIPJSONClient) TransferSIPParticipant(ctx context.Context, in *TransferSIPParticipantRequest) (*google_protobuf4.Empty, error) {
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "SIP")
	ctx = ctxsetters.WithMethodName(ctx, "TransferSIPParticipant")
	caller := c.callTransferSIPParticipant
	if c.interceptor != nil {
		caller = func(ctx context.Context, req *TransferSIPParticipantRequest) (*google_protobuf4.Empty, error) {
			resp, err := c.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*TransferSIPParticipantRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*TransferSIPParticipantRequest) when calling interceptor")
					}
					return c.callTransferSIPParticipant(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*google_protobuf4.Empty)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*google_protobuf4.Empty) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}
	return caller(ctx, in)
}

func (c *sIPJSONClient) callTransferSIPParticipant(ctx context.Context, in *TransferSIPParticipantRequest) (*google_protobuf4.Empty, error) {
	out := new(google_protobuf4.Empty)
	ctx, err := doJSONRequest(ctx, c.client, c.opts.Hooks, c.urls[15], in, out)
	if err != nil {
		twerr, ok := err.(twirp.Error)
		if !ok {
			twerr = twirp.InternalErrorWith(err)
		}
		callClientError(ctx, c.opts.Hooks, twerr)
		return nil, err
	}

	callClientResponseReceived(ctx, c.opts.Hooks)

	return out, nil
}

// ==================
// SIP Server Handler
// ==================

type sIPServer struct {
	SIP
	interceptor      twirp.Interceptor
	hooks            *twirp.ServerHooks
	pathPrefix       string // prefix for routing
	jsonSkipDefaults bool   // do not include unpopulated fields (default values) in the response
	jsonCamelCase    bool   // JSON fields are serialized as lowerCamelCase rather than keeping the original proto names
}

// NewSIPServer builds a TwirpServer that can be used as an http.Handler to handle
// HTTP requests that are routed to the right method in the provided svc implementation.
// The opts are twirp.ServerOption modifiers, for example twirp.WithServerHooks(hooks).
func NewSIPServer(svc SIP, opts ...interface{}) TwirpServer {
	serverOpts := newServerOpts(opts)

	// Using ReadOpt allows backwards and forwards compatibility with new options in the future
	jsonSkipDefaults := false
	_ = serverOpts.ReadOpt("jsonSkipDefaults", &jsonSkipDefaults)
	jsonCamelCase := false
	_ = serverOpts.ReadOpt("jsonCamelCase", &jsonCamelCase)
	var pathPrefix string
	if ok := serverOpts.ReadOpt("pathPrefix", &pathPrefix); !ok {
		pathPrefix = "/twirp" // default prefix
	}

	return &sIPServer{
		SIP:              svc,
		hooks:            serverOpts.Hooks,
		interceptor:      twirp.ChainInterceptors(serverOpts.Interceptors...),
		pathPrefix:       pathPrefix,
		jsonSkipDefaults: jsonSkipDefaults,
		jsonCamelCase:    jsonCamelCase,
	}
}

// writeError writes an HTTP response with a valid Twirp error format, and triggers hooks.
// If err is not a twirp.Error, it will get wrapped with twirp.InternalErrorWith(err)
func (s *sIPServer) writeError(ctx context.Context, resp http.ResponseWriter, err error) {
	writeError(ctx, resp, err, s.hooks)
}

// handleRequestBodyError is used to handle error when the twirp server cannot read request
func (s *sIPServer) handleRequestBodyError(ctx context.Context, resp http.ResponseWriter, msg string, err error) {
	if context.Canceled == ctx.Err() {
		s.writeError(ctx, resp, twirp.NewError(twirp.Canceled, "failed to read request: context canceled"))
		return
	}
	if context.DeadlineExceeded == ctx.Err() {
		s.writeError(ctx, resp, twirp.NewError(twirp.DeadlineExceeded, "failed to read request: deadline exceeded"))
		return
	}
	s.writeError(ctx, resp, twirp.WrapError(malformedRequestError(msg), err))
}

// SIPPathPrefix is a convenience constant that may identify URL paths.
// Should be used with caution, it only matches routes generated by Twirp Go clients,
// with the default "/twirp" prefix and default CamelCase service and method names.
// More info: https://twitchtv.github.io/twirp/docs/routing.html
const SIPPathPrefix = "/twirp/livekit.SIP/"

func (s *sIPServer) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
	ctx := req.Context()
	ctx = ctxsetters.WithPackageName(ctx, "livekit")
	ctx = ctxsetters.WithServiceName(ctx, "SIP")
	ctx = ctxsetters.WithResponseWriter(ctx, resp)

	var err error
	ctx, err = callRequestReceived(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	if req.Method != "POST" {
		msg := fmt.Sprintf("unsupported method %q (only POST is allowed)", req.Method)
		s.writeError(ctx, resp, badRouteError(msg, req.Method, req.URL.Path))
		return
	}

	// Verify path format: [<prefix>]/<package>.<Service>/<Method>
	prefix, pkgService, method := parseTwirpPath(req.URL.Path)
	if pkgService != "livekit.SIP" {
		msg := fmt.Sprintf("no handler for path %q", req.URL.Path)
		s.writeError(ctx, resp, badRouteError(msg, req.Method, req.URL.Path))
		return
	}
	if prefix != s.pathPrefix {
		msg := fmt.Sprintf("invalid path prefix %q, expected %q, on path %q", prefix, s.pathPrefix, req.URL.Path)
		s.writeError(ctx, resp, badRouteError(msg, req.Method, req.URL.Path))
		return
	}

	switch method {
	case "ListSIPTrunk":
		s.serveListSIPTrunk(ctx, resp, req)
		return
	case "CreateSIPInboundTrunk":
		s.serveCreateSIPInboundTrunk(ctx, resp, req)
		return
	case "CreateSIPOutboundTrunk":
		s.serveCreateSIPOutboundTrunk(ctx, resp, req)
		return
	case "UpdateSIPInboundTrunk":
		s.serveUpdateSIPInboundTrunk(ctx, resp, req)
		return
	case "UpdateSIPOutboundTrunk":
		s.serveUpdateSIPOutboundTrunk(ctx, resp, req)
		return
	case "GetSIPInboundTrunk":
		s.serveGetSIPInboundTrunk(ctx, resp, req)
		return
	case "GetSIPOutboundTrunk":
		s.serveGetSIPOutboundTrunk(ctx, resp, req)
		return
	case "ListSIPInboundTrunk":
		s.serveListSIPInboundTrunk(ctx, resp, req)
		return
	case "ListSIPOutboundTrunk":
		s.serveListSIPOutboundTrunk(ctx, resp, req)
		return
	case "DeleteSIPTrunk":
		s.serveDeleteSIPTrunk(ctx, resp, req)
		return
	case "CreateSIPDispatchRule":
		s.serveCreateSIPDispatchRule(ctx, resp, req)
		return
	case "UpdateSIPDispatchRule":
		s.serveUpdateSIPDispatchRule(ctx, resp, req)
		return
	case "ListSIPDispatchRule":
		s.serveListSIPDispatchRule(ctx, resp, req)
		return
	case "DeleteSIPDispatchRule":
		s.serveDeleteSIPDispatchRule(ctx, resp, req)
		return
	case "CreateSIPParticipant":
		s.serveCreateSIPParticipant(ctx, resp, req)
		return
	case "TransferSIPParticipant":
		s.serveTransferSIPParticipant(ctx, resp, req)
		return
	default:
		msg := fmt.Sprintf("no handler for path %q", req.URL.Path)
		s.writeError(ctx, resp, badRouteError(msg, req.Method, req.URL.Path))
		return
	}
}

func (s *sIPServer) serveListSIPTrunk(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	header := req.Header.Get("Content-Type")
	i := strings.Index(header, ";")
	if i == -1 {
		i = len(header)
	}
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
	case "application/json":
		s.serveListSIPTrunkJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveListSIPTrunkProtobuf(ctx, resp, req)
	default:
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
		twerr := badRouteError(msg, req.Method, req.URL.Path)
		s.writeError(ctx, resp, twerr)
	}
}

func (s *sIPServer) serveListSIPTrunkJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "ListSIPTrunk")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	d := json.NewDecoder(req.Body)
	rawReqBody := json.RawMessage{}
	if err := d.Decode(&rawReqBody); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}
	reqContent := new(ListSIPTrunkRequest)
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}

	handler := s.SIP.ListSIPTrunk
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *ListSIPTrunkRequest) (*ListSIPTrunkResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ListSIPTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ListSIPTrunkRequest) when calling interceptor")
					}
					return s.SIP.ListSIPTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ListSIPTrunkResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ListSIPTrunkResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *ListSIPTrunkResponse
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *ListSIPTrunkResponse and nil error while calling ListSIPTrunk. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
	respBytes, err := marshaler.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/json")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)

	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *sIPServer) serveListSIPTrunkProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "ListSIPTrunk")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	buf, err := io.ReadAll(req.Body)
	if err != nil {
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
		return
	}
	reqContent := new(ListSIPTrunkRequest)
	if err = proto.Unmarshal(buf, reqContent); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

	handler := s.SIP.ListSIPTrunk
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *ListSIPTrunkRequest) (*ListSIPTrunkResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ListSIPTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ListSIPTrunkRequest) when calling interceptor")
					}
					return s.SIP.ListSIPTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ListSIPTrunkResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ListSIPTrunkResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *ListSIPTrunkResponse
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *ListSIPTrunkResponse and nil error while calling ListSIPTrunk. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := proto.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/protobuf")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)
	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *sIPServer) serveCreateSIPInboundTrunk(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	header := req.Header.Get("Content-Type")
	i := strings.Index(header, ";")
	if i == -1 {
		i = len(header)
	}
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
	case "application/json":
		s.serveCreateSIPInboundTrunkJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveCreateSIPInboundTrunkProtobuf(ctx, resp, req)
	default:
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
		twerr := badRouteError(msg, req.Method, req.URL.Path)
		s.writeError(ctx, resp, twerr)
	}
}

func (s *sIPServer) serveCreateSIPInboundTrunkJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "CreateSIPInboundTrunk")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	d := json.NewDecoder(req.Body)
	rawReqBody := json.RawMessage{}
	if err := d.Decode(&rawReqBody); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}
	reqContent := new(CreateSIPInboundTrunkRequest)
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}

	handler := s.SIP.CreateSIPInboundTrunk
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *CreateSIPInboundTrunkRequest) (*SIPInboundTrunkInfo, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*CreateSIPInboundTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*CreateSIPInboundTrunkRequest) when calling interceptor")
					}
					return s.SIP.CreateSIPInboundTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SIPInboundTrunkInfo)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SIPInboundTrunkInfo) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *SIPInboundTrunkInfo
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *SIPInboundTrunkInfo and nil error while calling CreateSIPInboundTrunk. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
	respBytes, err := marshaler.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/json")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)

	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *sIPServer) serveCreateSIPInboundTrunkProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "CreateSIPInboundTrunk")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	buf, err := io.ReadAll(req.Body)
	if err != nil {
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
		return
	}
	reqContent := new(CreateSIPInboundTrunkRequest)
	if err = proto.Unmarshal(buf, reqContent); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

	handler := s.SIP.CreateSIPInboundTrunk
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *CreateSIPInboundTrunkRequest) (*SIPInboundTrunkInfo, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*CreateSIPInboundTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*CreateSIPInboundTrunkRequest) when calling interceptor")
					}
					return s.SIP.CreateSIPInboundTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SIPInboundTrunkInfo)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SIPInboundTrunkInfo) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *SIPInboundTrunkInfo
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *SIPInboundTrunkInfo and nil error while calling CreateSIPInboundTrunk. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := proto.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/protobuf")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)
	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *sIPServer) serveCreateSIPOutboundTrunk(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	header := req.Header.Get("Content-Type")
	i := strings.Index(header, ";")
	if i == -1 {
		i = len(header)
	}
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
	case "application/json":
		s.serveCreateSIPOutboundTrunkJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveCreateSIPOutboundTrunkProtobuf(ctx, resp, req)
	default:
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
		twerr := badRouteError(msg, req.Method, req.URL.Path)
		s.writeError(ctx, resp, twerr)
	}
}

func (s *sIPServer) serveCreateSIPOutboundTrunkJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "CreateSIPOutboundTrunk")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	d := json.NewDecoder(req.Body)
	rawReqBody := json.RawMessage{}
	if err := d.Decode(&rawReqBody); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}
	reqContent := new(CreateSIPOutboundTrunkRequest)
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}

	handler := s.SIP.CreateSIPOutboundTrunk
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *CreateSIPOutboundTrunkRequest) (*SIPOutboundTrunkInfo, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*CreateSIPOutboundTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*CreateSIPOutboundTrunkRequest) when calling interceptor")
					}
					return s.SIP.CreateSIPOutboundTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SIPOutboundTrunkInfo)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SIPOutboundTrunkInfo) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *SIPOutboundTrunkInfo
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *SIPOutboundTrunkInfo and nil error while calling CreateSIPOutboundTrunk. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
	respBytes, err := marshaler.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/json")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)

	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *sIPServer) serveCreateSIPOutboundTrunkProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "CreateSIPOutboundTrunk")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	buf, err := io.ReadAll(req.Body)
	if err != nil {
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
		return
	}
	reqContent := new(CreateSIPOutboundTrunkRequest)
	if err = proto.Unmarshal(buf, reqContent); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

	handler := s.SIP.CreateSIPOutboundTrunk
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *CreateSIPOutboundTrunkRequest) (*SIPOutboundTrunkInfo, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*CreateSIPOutboundTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*CreateSIPOutboundTrunkRequest) when calling interceptor")
					}
					return s.SIP.CreateSIPOutboundTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SIPOutboundTrunkInfo)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SIPOutboundTrunkInfo) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *SIPOutboundTrunkInfo
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *SIPOutboundTrunkInfo and nil error while calling CreateSIPOutboundTrunk. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := proto.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/protobuf")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)
	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *sIPServer) serveUpdateSIPInboundTrunk(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	header := req.Header.Get("Content-Type")
	i := strings.Index(header, ";")
	if i == -1 {
		i = len(header)
	}
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
	case "application/json":
		s.serveUpdateSIPInboundTrunkJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveUpdateSIPInboundTrunkProtobuf(ctx, resp, req)
	default:
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
		twerr := badRouteError(msg, req.Method, req.URL.Path)
		s.writeError(ctx, resp, twerr)
	}
}

func (s *sIPServer) serveUpdateSIPInboundTrunkJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "UpdateSIPInboundTrunk")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	d := json.NewDecoder(req.Body)
	rawReqBody := json.RawMessage{}
	if err := d.Decode(&rawReqBody); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}
	reqContent := new(UpdateSIPInboundTrunkRequest)
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}

	handler := s.SIP.UpdateSIPInboundTrunk
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *UpdateSIPInboundTrunkRequest) (*SIPInboundTrunkInfo, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*UpdateSIPInboundTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*UpdateSIPInboundTrunkRequest) when calling interceptor")
					}
					return s.SIP.UpdateSIPInboundTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SIPInboundTrunkInfo)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SIPInboundTrunkInfo) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *SIPInboundTrunkInfo
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *SIPInboundTrunkInfo and nil error while calling UpdateSIPInboundTrunk. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
	respBytes, err := marshaler.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/json")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)

	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *sIPServer) serveUpdateSIPInboundTrunkProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "UpdateSIPInboundTrunk")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	buf, err := io.ReadAll(req.Body)
	if err != nil {
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
		return
	}
	reqContent := new(UpdateSIPInboundTrunkRequest)
	if err = proto.Unmarshal(buf, reqContent); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

	handler := s.SIP.UpdateSIPInboundTrunk
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *UpdateSIPInboundTrunkRequest) (*SIPInboundTrunkInfo, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*UpdateSIPInboundTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*UpdateSIPInboundTrunkRequest) when calling interceptor")
					}
					return s.SIP.UpdateSIPInboundTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SIPInboundTrunkInfo)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SIPInboundTrunkInfo) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *SIPInboundTrunkInfo
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *SIPInboundTrunkInfo and nil error while calling UpdateSIPInboundTrunk. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := proto.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/protobuf")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)
	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *sIPServer) serveUpdateSIPOutboundTrunk(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	header := req.Header.Get("Content-Type")
	i := strings.Index(header, ";")
	if i == -1 {
		i = len(header)
	}
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
	case "application/json":
		s.serveUpdateSIPOutboundTrunkJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveUpdateSIPOutboundTrunkProtobuf(ctx, resp, req)
	default:
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
		twerr := badRouteError(msg, req.Method, req.URL.Path)
		s.writeError(ctx, resp, twerr)
	}
}

func (s *sIPServer) serveUpdateSIPOutboundTrunkJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "UpdateSIPOutboundTrunk")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	d := json.NewDecoder(req.Body)
	rawReqBody := json.RawMessage{}
	if err := d.Decode(&rawReqBody); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}
	reqContent := new(UpdateSIPOutboundTrunkRequest)
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}

	handler := s.SIP.UpdateSIPOutboundTrunk
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *UpdateSIPOutboundTrunkRequest) (*SIPOutboundTrunkInfo, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*UpdateSIPOutboundTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*UpdateSIPOutboundTrunkRequest) when calling interceptor")
					}
					return s.SIP.UpdateSIPOutboundTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SIPOutboundTrunkInfo)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SIPOutboundTrunkInfo) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *SIPOutboundTrunkInfo
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *SIPOutboundTrunkInfo and nil error while calling UpdateSIPOutboundTrunk. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
	respBytes, err := marshaler.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/json")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)

	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *sIPServer) serveUpdateSIPOutboundTrunkProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "UpdateSIPOutboundTrunk")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	buf, err := io.ReadAll(req.Body)
	if err != nil {
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
		return
	}
	reqContent := new(UpdateSIPOutboundTrunkRequest)
	if err = proto.Unmarshal(buf, reqContent); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

	handler := s.SIP.UpdateSIPOutboundTrunk
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *UpdateSIPOutboundTrunkRequest) (*SIPOutboundTrunkInfo, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*UpdateSIPOutboundTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*UpdateSIPOutboundTrunkRequest) when calling interceptor")
					}
					return s.SIP.UpdateSIPOutboundTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SIPOutboundTrunkInfo)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SIPOutboundTrunkInfo) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *SIPOutboundTrunkInfo
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *SIPOutboundTrunkInfo and nil error while calling UpdateSIPOutboundTrunk. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := proto.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/protobuf")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)
	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *sIPServer) serveGetSIPInboundTrunk(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	header := req.Header.Get("Content-Type")
	i := strings.Index(header, ";")
	if i == -1 {
		i = len(header)
	}
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
	case "application/json":
		s.serveGetSIPInboundTrunkJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveGetSIPInboundTrunkProtobuf(ctx, resp, req)
	default:
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
		twerr := badRouteError(msg, req.Method, req.URL.Path)
		s.writeError(ctx, resp, twerr)
	}
}

func (s *sIPServer) serveGetSIPInboundTrunkJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "GetSIPInboundTrunk")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	d := json.NewDecoder(req.Body)
	rawReqBody := json.RawMessage{}
	if err := d.Decode(&rawReqBody); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}
	reqContent := new(GetSIPInboundTrunkRequest)
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}

	handler := s.SIP.GetSIPInboundTrunk
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *GetSIPInboundTrunkRequest) (*GetSIPInboundTrunkResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*GetSIPInboundTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*GetSIPInboundTrunkRequest) when calling interceptor")
					}
					return s.SIP.GetSIPInboundTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*GetSIPInboundTrunkResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*GetSIPInboundTrunkResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *GetSIPInboundTrunkResponse
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *GetSIPInboundTrunkResponse and nil error while calling GetSIPInboundTrunk. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
	respBytes, err := marshaler.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/json")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)

	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *sIPServer) serveGetSIPInboundTrunkProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "GetSIPInboundTrunk")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	buf, err := io.ReadAll(req.Body)
	if err != nil {
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
		return
	}
	reqContent := new(GetSIPInboundTrunkRequest)
	if err = proto.Unmarshal(buf, reqContent); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

	handler := s.SIP.GetSIPInboundTrunk
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *GetSIPInboundTrunkRequest) (*GetSIPInboundTrunkResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*GetSIPInboundTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*GetSIPInboundTrunkRequest) when calling interceptor")
					}
					return s.SIP.GetSIPInboundTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*GetSIPInboundTrunkResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*GetSIPInboundTrunkResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *GetSIPInboundTrunkResponse
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *GetSIPInboundTrunkResponse and nil error while calling GetSIPInboundTrunk. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := proto.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/protobuf")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)
	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *sIPServer) serveGetSIPOutboundTrunk(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	header := req.Header.Get("Content-Type")
	i := strings.Index(header, ";")
	if i == -1 {
		i = len(header)
	}
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
	case "application/json":
		s.serveGetSIPOutboundTrunkJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveGetSIPOutboundTrunkProtobuf(ctx, resp, req)
	default:
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
		twerr := badRouteError(msg, req.Method, req.URL.Path)
		s.writeError(ctx, resp, twerr)
	}
}

func (s *sIPServer) serveGetSIPOutboundTrunkJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "GetSIPOutboundTrunk")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	d := json.NewDecoder(req.Body)
	rawReqBody := json.RawMessage{}
	if err := d.Decode(&rawReqBody); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}
	reqContent := new(GetSIPOutboundTrunkRequest)
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}

	handler := s.SIP.GetSIPOutboundTrunk
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *GetSIPOutboundTrunkRequest) (*GetSIPOutboundTrunkResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*GetSIPOutboundTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*GetSIPOutboundTrunkRequest) when calling interceptor")
					}
					return s.SIP.GetSIPOutboundTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*GetSIPOutboundTrunkResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*GetSIPOutboundTrunkResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *GetSIPOutboundTrunkResponse
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *GetSIPOutboundTrunkResponse and nil error while calling GetSIPOutboundTrunk. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
	respBytes, err := marshaler.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/json")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)

	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *sIPServer) serveGetSIPOutboundTrunkProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "GetSIPOutboundTrunk")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	buf, err := io.ReadAll(req.Body)
	if err != nil {
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
		return
	}
	reqContent := new(GetSIPOutboundTrunkRequest)
	if err = proto.Unmarshal(buf, reqContent); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

	handler := s.SIP.GetSIPOutboundTrunk
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *GetSIPOutboundTrunkRequest) (*GetSIPOutboundTrunkResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*GetSIPOutboundTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*GetSIPOutboundTrunkRequest) when calling interceptor")
					}
					return s.SIP.GetSIPOutboundTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*GetSIPOutboundTrunkResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*GetSIPOutboundTrunkResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *GetSIPOutboundTrunkResponse
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *GetSIPOutboundTrunkResponse and nil error while calling GetSIPOutboundTrunk. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := proto.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/protobuf")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)
	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *sIPServer) serveListSIPInboundTrunk(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	header := req.Header.Get("Content-Type")
	i := strings.Index(header, ";")
	if i == -1 {
		i = len(header)
	}
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
	case "application/json":
		s.serveListSIPInboundTrunkJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveListSIPInboundTrunkProtobuf(ctx, resp, req)
	default:
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
		twerr := badRouteError(msg, req.Method, req.URL.Path)
		s.writeError(ctx, resp, twerr)
	}
}

func (s *sIPServer) serveListSIPInboundTrunkJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "ListSIPInboundTrunk")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	d := json.NewDecoder(req.Body)
	rawReqBody := json.RawMessage{}
	if err := d.Decode(&rawReqBody); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}
	reqContent := new(ListSIPInboundTrunkRequest)
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}

	handler := s.SIP.ListSIPInboundTrunk
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *ListSIPInboundTrunkRequest) (*ListSIPInboundTrunkResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ListSIPInboundTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ListSIPInboundTrunkRequest) when calling interceptor")
					}
					return s.SIP.ListSIPInboundTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ListSIPInboundTrunkResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ListSIPInboundTrunkResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *ListSIPInboundTrunkResponse
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *ListSIPInboundTrunkResponse and nil error while calling ListSIPInboundTrunk. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
	respBytes, err := marshaler.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/json")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)

	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *sIPServer) serveListSIPInboundTrunkProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "ListSIPInboundTrunk")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	buf, err := io.ReadAll(req.Body)
	if err != nil {
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
		return
	}
	reqContent := new(ListSIPInboundTrunkRequest)
	if err = proto.Unmarshal(buf, reqContent); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

	handler := s.SIP.ListSIPInboundTrunk
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *ListSIPInboundTrunkRequest) (*ListSIPInboundTrunkResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ListSIPInboundTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ListSIPInboundTrunkRequest) when calling interceptor")
					}
					return s.SIP.ListSIPInboundTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ListSIPInboundTrunkResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ListSIPInboundTrunkResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *ListSIPInboundTrunkResponse
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *ListSIPInboundTrunkResponse and nil error while calling ListSIPInboundTrunk. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := proto.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/protobuf")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)
	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *sIPServer) serveListSIPOutboundTrunk(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	header := req.Header.Get("Content-Type")
	i := strings.Index(header, ";")
	if i == -1 {
		i = len(header)
	}
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
	case "application/json":
		s.serveListSIPOutboundTrunkJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveListSIPOutboundTrunkProtobuf(ctx, resp, req)
	default:
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
		twerr := badRouteError(msg, req.Method, req.URL.Path)
		s.writeError(ctx, resp, twerr)
	}
}

func (s *sIPServer) serveListSIPOutboundTrunkJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "ListSIPOutboundTrunk")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	d := json.NewDecoder(req.Body)
	rawReqBody := json.RawMessage{}
	if err := d.Decode(&rawReqBody); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}
	reqContent := new(ListSIPOutboundTrunkRequest)
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}

	handler := s.SIP.ListSIPOutboundTrunk
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *ListSIPOutboundTrunkRequest) (*ListSIPOutboundTrunkResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ListSIPOutboundTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ListSIPOutboundTrunkRequest) when calling interceptor")
					}
					return s.SIP.ListSIPOutboundTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ListSIPOutboundTrunkResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ListSIPOutboundTrunkResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *ListSIPOutboundTrunkResponse
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *ListSIPOutboundTrunkResponse and nil error while calling ListSIPOutboundTrunk. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
	respBytes, err := marshaler.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/json")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)

	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *sIPServer) serveListSIPOutboundTrunkProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "ListSIPOutboundTrunk")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	buf, err := io.ReadAll(req.Body)
	if err != nil {
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
		return
	}
	reqContent := new(ListSIPOutboundTrunkRequest)
	if err = proto.Unmarshal(buf, reqContent); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

	handler := s.SIP.ListSIPOutboundTrunk
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *ListSIPOutboundTrunkRequest) (*ListSIPOutboundTrunkResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ListSIPOutboundTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ListSIPOutboundTrunkRequest) when calling interceptor")
					}
					return s.SIP.ListSIPOutboundTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ListSIPOutboundTrunkResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ListSIPOutboundTrunkResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *ListSIPOutboundTrunkResponse
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *ListSIPOutboundTrunkResponse and nil error while calling ListSIPOutboundTrunk. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := proto.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/protobuf")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)
	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *sIPServer) serveDeleteSIPTrunk(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	header := req.Header.Get("Content-Type")
	i := strings.Index(header, ";")
	if i == -1 {
		i = len(header)
	}
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
	case "application/json":
		s.serveDeleteSIPTrunkJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveDeleteSIPTrunkProtobuf(ctx, resp, req)
	default:
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
		twerr := badRouteError(msg, req.Method, req.URL.Path)
		s.writeError(ctx, resp, twerr)
	}
}

func (s *sIPServer) serveDeleteSIPTrunkJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "DeleteSIPTrunk")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	d := json.NewDecoder(req.Body)
	rawReqBody := json.RawMessage{}
	if err := d.Decode(&rawReqBody); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}
	reqContent := new(DeleteSIPTrunkRequest)
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}

	handler := s.SIP.DeleteSIPTrunk
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *DeleteSIPTrunkRequest) (*SIPTrunkInfo, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*DeleteSIPTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*DeleteSIPTrunkRequest) when calling interceptor")
					}
					return s.SIP.DeleteSIPTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SIPTrunkInfo)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SIPTrunkInfo) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *SIPTrunkInfo
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *SIPTrunkInfo and nil error while calling DeleteSIPTrunk. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
	respBytes, err := marshaler.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/json")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)

	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *sIPServer) serveDeleteSIPTrunkProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "DeleteSIPTrunk")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	buf, err := io.ReadAll(req.Body)
	if err != nil {
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
		return
	}
	reqContent := new(DeleteSIPTrunkRequest)
	if err = proto.Unmarshal(buf, reqContent); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

	handler := s.SIP.DeleteSIPTrunk
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *DeleteSIPTrunkRequest) (*SIPTrunkInfo, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*DeleteSIPTrunkRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*DeleteSIPTrunkRequest) when calling interceptor")
					}
					return s.SIP.DeleteSIPTrunk(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SIPTrunkInfo)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SIPTrunkInfo) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *SIPTrunkInfo
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *SIPTrunkInfo and nil error while calling DeleteSIPTrunk. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := proto.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/protobuf")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)
	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *sIPServer) serveCreateSIPDispatchRule(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	header := req.Header.Get("Content-Type")
	i := strings.Index(header, ";")
	if i == -1 {
		i = len(header)
	}
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
	case "application/json":
		s.serveCreateSIPDispatchRuleJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveCreateSIPDispatchRuleProtobuf(ctx, resp, req)
	default:
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
		twerr := badRouteError(msg, req.Method, req.URL.Path)
		s.writeError(ctx, resp, twerr)
	}
}

func (s *sIPServer) serveCreateSIPDispatchRuleJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "CreateSIPDispatchRule")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	d := json.NewDecoder(req.Body)
	rawReqBody := json.RawMessage{}
	if err := d.Decode(&rawReqBody); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}
	reqContent := new(CreateSIPDispatchRuleRequest)
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}

	handler := s.SIP.CreateSIPDispatchRule
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *CreateSIPDispatchRuleRequest) (*SIPDispatchRuleInfo, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*CreateSIPDispatchRuleRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*CreateSIPDispatchRuleRequest) when calling interceptor")
					}
					return s.SIP.CreateSIPDispatchRule(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SIPDispatchRuleInfo)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SIPDispatchRuleInfo) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *SIPDispatchRuleInfo
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *SIPDispatchRuleInfo and nil error while calling CreateSIPDispatchRule. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
	respBytes, err := marshaler.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/json")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)

	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *sIPServer) serveCreateSIPDispatchRuleProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "CreateSIPDispatchRule")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	buf, err := io.ReadAll(req.Body)
	if err != nil {
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
		return
	}
	reqContent := new(CreateSIPDispatchRuleRequest)
	if err = proto.Unmarshal(buf, reqContent); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

	handler := s.SIP.CreateSIPDispatchRule
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *CreateSIPDispatchRuleRequest) (*SIPDispatchRuleInfo, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*CreateSIPDispatchRuleRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*CreateSIPDispatchRuleRequest) when calling interceptor")
					}
					return s.SIP.CreateSIPDispatchRule(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SIPDispatchRuleInfo)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SIPDispatchRuleInfo) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *SIPDispatchRuleInfo
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *SIPDispatchRuleInfo and nil error while calling CreateSIPDispatchRule. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := proto.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/protobuf")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)
	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *sIPServer) serveUpdateSIPDispatchRule(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	header := req.Header.Get("Content-Type")
	i := strings.Index(header, ";")
	if i == -1 {
		i = len(header)
	}
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
	case "application/json":
		s.serveUpdateSIPDispatchRuleJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveUpdateSIPDispatchRuleProtobuf(ctx, resp, req)
	default:
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
		twerr := badRouteError(msg, req.Method, req.URL.Path)
		s.writeError(ctx, resp, twerr)
	}
}

func (s *sIPServer) serveUpdateSIPDispatchRuleJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "UpdateSIPDispatchRule")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	d := json.NewDecoder(req.Body)
	rawReqBody := json.RawMessage{}
	if err := d.Decode(&rawReqBody); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}
	reqContent := new(UpdateSIPDispatchRuleRequest)
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}

	handler := s.SIP.UpdateSIPDispatchRule
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *UpdateSIPDispatchRuleRequest) (*SIPDispatchRuleInfo, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*UpdateSIPDispatchRuleRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*UpdateSIPDispatchRuleRequest) when calling interceptor")
					}
					return s.SIP.UpdateSIPDispatchRule(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SIPDispatchRuleInfo)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SIPDispatchRuleInfo) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *SIPDispatchRuleInfo
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *SIPDispatchRuleInfo and nil error while calling UpdateSIPDispatchRule. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
	respBytes, err := marshaler.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/json")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)

	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *sIPServer) serveUpdateSIPDispatchRuleProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "UpdateSIPDispatchRule")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	buf, err := io.ReadAll(req.Body)
	if err != nil {
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
		return
	}
	reqContent := new(UpdateSIPDispatchRuleRequest)
	if err = proto.Unmarshal(buf, reqContent); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

	handler := s.SIP.UpdateSIPDispatchRule
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *UpdateSIPDispatchRuleRequest) (*SIPDispatchRuleInfo, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*UpdateSIPDispatchRuleRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*UpdateSIPDispatchRuleRequest) when calling interceptor")
					}
					return s.SIP.UpdateSIPDispatchRule(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SIPDispatchRuleInfo)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SIPDispatchRuleInfo) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *SIPDispatchRuleInfo
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *SIPDispatchRuleInfo and nil error while calling UpdateSIPDispatchRule. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := proto.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/protobuf")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)
	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *sIPServer) serveListSIPDispatchRule(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	header := req.Header.Get("Content-Type")
	i := strings.Index(header, ";")
	if i == -1 {
		i = len(header)
	}
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
	case "application/json":
		s.serveListSIPDispatchRuleJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveListSIPDispatchRuleProtobuf(ctx, resp, req)
	default:
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
		twerr := badRouteError(msg, req.Method, req.URL.Path)
		s.writeError(ctx, resp, twerr)
	}
}

func (s *sIPServer) serveListSIPDispatchRuleJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "ListSIPDispatchRule")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	d := json.NewDecoder(req.Body)
	rawReqBody := json.RawMessage{}
	if err := d.Decode(&rawReqBody); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}
	reqContent := new(ListSIPDispatchRuleRequest)
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}

	handler := s.SIP.ListSIPDispatchRule
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *ListSIPDispatchRuleRequest) (*ListSIPDispatchRuleResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ListSIPDispatchRuleRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ListSIPDispatchRuleRequest) when calling interceptor")
					}
					return s.SIP.ListSIPDispatchRule(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ListSIPDispatchRuleResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ListSIPDispatchRuleResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *ListSIPDispatchRuleResponse
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *ListSIPDispatchRuleResponse and nil error while calling ListSIPDispatchRule. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
	respBytes, err := marshaler.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/json")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)

	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *sIPServer) serveListSIPDispatchRuleProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "ListSIPDispatchRule")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	buf, err := io.ReadAll(req.Body)
	if err != nil {
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
		return
	}
	reqContent := new(ListSIPDispatchRuleRequest)
	if err = proto.Unmarshal(buf, reqContent); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

	handler := s.SIP.ListSIPDispatchRule
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *ListSIPDispatchRuleRequest) (*ListSIPDispatchRuleResponse, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*ListSIPDispatchRuleRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*ListSIPDispatchRuleRequest) when calling interceptor")
					}
					return s.SIP.ListSIPDispatchRule(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*ListSIPDispatchRuleResponse)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*ListSIPDispatchRuleResponse) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *ListSIPDispatchRuleResponse
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *ListSIPDispatchRuleResponse and nil error while calling ListSIPDispatchRule. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := proto.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/protobuf")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)
	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *sIPServer) serveDeleteSIPDispatchRule(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	header := req.Header.Get("Content-Type")
	i := strings.Index(header, ";")
	if i == -1 {
		i = len(header)
	}
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
	case "application/json":
		s.serveDeleteSIPDispatchRuleJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveDeleteSIPDispatchRuleProtobuf(ctx, resp, req)
	default:
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
		twerr := badRouteError(msg, req.Method, req.URL.Path)
		s.writeError(ctx, resp, twerr)
	}
}

func (s *sIPServer) serveDeleteSIPDispatchRuleJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "DeleteSIPDispatchRule")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	d := json.NewDecoder(req.Body)
	rawReqBody := json.RawMessage{}
	if err := d.Decode(&rawReqBody); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}
	reqContent := new(DeleteSIPDispatchRuleRequest)
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}

	handler := s.SIP.DeleteSIPDispatchRule
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *DeleteSIPDispatchRuleRequest) (*SIPDispatchRuleInfo, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*DeleteSIPDispatchRuleRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*DeleteSIPDispatchRuleRequest) when calling interceptor")
					}
					return s.SIP.DeleteSIPDispatchRule(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SIPDispatchRuleInfo)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SIPDispatchRuleInfo) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *SIPDispatchRuleInfo
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *SIPDispatchRuleInfo and nil error while calling DeleteSIPDispatchRule. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
	respBytes, err := marshaler.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/json")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)

	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *sIPServer) serveDeleteSIPDispatchRuleProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "DeleteSIPDispatchRule")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	buf, err := io.ReadAll(req.Body)
	if err != nil {
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
		return
	}
	reqContent := new(DeleteSIPDispatchRuleRequest)
	if err = proto.Unmarshal(buf, reqContent); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

	handler := s.SIP.DeleteSIPDispatchRule
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *DeleteSIPDispatchRuleRequest) (*SIPDispatchRuleInfo, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*DeleteSIPDispatchRuleRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*DeleteSIPDispatchRuleRequest) when calling interceptor")
					}
					return s.SIP.DeleteSIPDispatchRule(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SIPDispatchRuleInfo)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SIPDispatchRuleInfo) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *SIPDispatchRuleInfo
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *SIPDispatchRuleInfo and nil error while calling DeleteSIPDispatchRule. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := proto.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/protobuf")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)
	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *sIPServer) serveCreateSIPParticipant(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	header := req.Header.Get("Content-Type")
	i := strings.Index(header, ";")
	if i == -1 {
		i = len(header)
	}
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
	case "application/json":
		s.serveCreateSIPParticipantJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveCreateSIPParticipantProtobuf(ctx, resp, req)
	default:
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
		twerr := badRouteError(msg, req.Method, req.URL.Path)
		s.writeError(ctx, resp, twerr)
	}
}

func (s *sIPServer) serveCreateSIPParticipantJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "CreateSIPParticipant")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	d := json.NewDecoder(req.Body)
	rawReqBody := json.RawMessage{}
	if err := d.Decode(&rawReqBody); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}
	reqContent := new(CreateSIPParticipantRequest)
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}

	handler := s.SIP.CreateSIPParticipant
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *CreateSIPParticipantRequest) (*SIPParticipantInfo, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*CreateSIPParticipantRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*CreateSIPParticipantRequest) when calling interceptor")
					}
					return s.SIP.CreateSIPParticipant(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SIPParticipantInfo)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SIPParticipantInfo) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *SIPParticipantInfo
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *SIPParticipantInfo and nil error while calling CreateSIPParticipant. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
	respBytes, err := marshaler.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/json")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)

	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *sIPServer) serveCreateSIPParticipantProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "CreateSIPParticipant")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	buf, err := io.ReadAll(req.Body)
	if err != nil {
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
		return
	}
	reqContent := new(CreateSIPParticipantRequest)
	if err = proto.Unmarshal(buf, reqContent); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

	handler := s.SIP.CreateSIPParticipant
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *CreateSIPParticipantRequest) (*SIPParticipantInfo, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*CreateSIPParticipantRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*CreateSIPParticipantRequest) when calling interceptor")
					}
					return s.SIP.CreateSIPParticipant(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*SIPParticipantInfo)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*SIPParticipantInfo) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *SIPParticipantInfo
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *SIPParticipantInfo and nil error while calling CreateSIPParticipant. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := proto.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/protobuf")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)
	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *sIPServer) serveTransferSIPParticipant(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	header := req.Header.Get("Content-Type")
	i := strings.Index(header, ";")
	if i == -1 {
		i = len(header)
	}
	switch strings.TrimSpace(strings.ToLower(header[:i])) {
	case "application/json":
		s.serveTransferSIPParticipantJSON(ctx, resp, req)
	case "application/protobuf":
		s.serveTransferSIPParticipantProtobuf(ctx, resp, req)
	default:
		msg := fmt.Sprintf("unexpected Content-Type: %q", req.Header.Get("Content-Type"))
		twerr := badRouteError(msg, req.Method, req.URL.Path)
		s.writeError(ctx, resp, twerr)
	}
}

func (s *sIPServer) serveTransferSIPParticipantJSON(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "TransferSIPParticipant")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	d := json.NewDecoder(req.Body)
	rawReqBody := json.RawMessage{}
	if err := d.Decode(&rawReqBody); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}
	reqContent := new(TransferSIPParticipantRequest)
	unmarshaler := protojson.UnmarshalOptions{DiscardUnknown: true}
	if err = unmarshaler.Unmarshal(rawReqBody, reqContent); err != nil {
		s.handleRequestBodyError(ctx, resp, "the json request could not be decoded", err)
		return
	}

	handler := s.SIP.TransferSIPParticipant
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *TransferSIPParticipantRequest) (*google_protobuf4.Empty, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*TransferSIPParticipantRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*TransferSIPParticipantRequest) when calling interceptor")
					}
					return s.SIP.TransferSIPParticipant(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*google_protobuf4.Empty)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*google_protobuf4.Empty) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *google_protobuf4.Empty
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *google_protobuf4.Empty and nil error while calling TransferSIPParticipant. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	marshaler := &protojson.MarshalOptions{UseProtoNames: !s.jsonCamelCase, EmitUnpopulated: !s.jsonSkipDefaults}
	respBytes, err := marshaler.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal json response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/json")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)

	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *sIPServer) serveTransferSIPParticipantProtobuf(ctx context.Context, resp http.ResponseWriter, req *http.Request) {
	var err error
	ctx = ctxsetters.WithMethodName(ctx, "TransferSIPParticipant")
	ctx, err = callRequestRouted(ctx, s.hooks)
	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}

	buf, err := io.ReadAll(req.Body)
	if err != nil {
		s.handleRequestBodyError(ctx, resp, "failed to read request body", err)
		return
	}
	reqContent := new(TransferSIPParticipantRequest)
	if err = proto.Unmarshal(buf, reqContent); err != nil {
		s.writeError(ctx, resp, malformedRequestError("the protobuf request could not be decoded"))
		return
	}

	handler := s.SIP.TransferSIPParticipant
	if s.interceptor != nil {
		handler = func(ctx context.Context, req *TransferSIPParticipantRequest) (*google_protobuf4.Empty, error) {
			resp, err := s.interceptor(
				func(ctx context.Context, req interface{}) (interface{}, error) {
					typedReq, ok := req.(*TransferSIPParticipantRequest)
					if !ok {
						return nil, twirp.InternalError("failed type assertion req.(*TransferSIPParticipantRequest) when calling interceptor")
					}
					return s.SIP.TransferSIPParticipant(ctx, typedReq)
				},
			)(ctx, req)
			if resp != nil {
				typedResp, ok := resp.(*google_protobuf4.Empty)
				if !ok {
					return nil, twirp.InternalError("failed type assertion resp.(*google_protobuf4.Empty) when calling interceptor")
				}
				return typedResp, err
			}
			return nil, err
		}
	}

	// Call service method
	var respContent *google_protobuf4.Empty
	func() {
		defer ensurePanicResponses(ctx, resp, s.hooks)
		respContent, err = handler(ctx, reqContent)
	}()

	if err != nil {
		s.writeError(ctx, resp, err)
		return
	}
	if respContent == nil {
		s.writeError(ctx, resp, twirp.InternalError("received a nil *google_protobuf4.Empty and nil error while calling TransferSIPParticipant. nil responses are not supported"))
		return
	}

	ctx = callResponsePrepared(ctx, s.hooks)

	respBytes, err := proto.Marshal(respContent)
	if err != nil {
		s.writeError(ctx, resp, wrapInternal(err, "failed to marshal proto response"))
		return
	}

	ctx = ctxsetters.WithStatusCode(ctx, http.StatusOK)
	resp.Header().Set("Content-Type", "application/protobuf")
	resp.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
	resp.WriteHeader(http.StatusOK)
	if n, err := resp.Write(respBytes); err != nil {
		msg := fmt.Sprintf("failed to write response, %d of %d bytes written: %s", n, len(respBytes), err.Error())
		twerr := twirp.NewError(twirp.Unknown, msg)
		ctx = callError(ctx, s.hooks, twerr)
	}
	callResponseSent(ctx, s.hooks)
}

func (s *sIPServer) ServiceDescriptor() ([]byte, int) {
	return twirpFileDescriptor4, 0
}

func (s *sIPServer) ProtocGenTwirpVersion() string {
	return "v8.1.3"
}

// PathPrefix returns the base service path, in the form: "/<prefix>/<package>.<Service>/"
// that is everything in a Twirp route except for the <Method>. This can be used for routing,
// for example to identify the requests that are targeted to this service in a mux.
func (s *sIPServer) PathPrefix() string {
	return baseServicePath(s.pathPrefix, "livekit", "SIP")
}

var twirpFileDescriptor4 = []byte{
	// 5249 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x7c, 0x6b, 0x8c, 0x23, 0xcb,
	0x55, 0xf0, 0xda, 0xed, 0x79, 0x1d, 0xcf, 0xa3, 0xa7, 0xe6, 0xb1, 0xde, 0xd9, 0x67, 0xbc, 0x77,
	0xf7, 0xee, 0xce, 0xbd, 0xdf, 0xec, 0xcd, 0xde, 0x8f, 0xe4, 0x66, 0xf3, 0x6c, 0xbb, 0x6b, 0x66,
	0x3a, 0xeb, 0xe9, 0xf6, 0xad, 0x6e, 0xef, 0xee, 0x44, 0x81, 0xc6, 0x6b, 0xf7, 0xce, 0x76, 0xd6,
	0xe3, 0x36, 0x76, 0x7b, 0xef, 0x9d, 0x84, 0x2b, 0xc4, 0xbf, 0xe5, 0x4f, 0x44, 0x02, 0xe1, 0x4d,
	0x20, 0x12, 0x09, 0x10, 0x6e, 0x22, 0x45, 0xca, 0x83, 0x5f, 0x48, 0xfc, 0x02, 0x21, 0xf8, 0x09,
	0x44, 0x02, 0x85, 0x10, 0x02, 0x04, 0x08, 0xf9, 0x81, 0x78, 0x4a, 0x48, 0xa0, 0xaa, 0xae, 0x6e,
	0x57, 0xb7, 0xdb, 0x9e, 0xc7, 0xee, 0x15, 0x11, 0xfc, 0x73, 0x9f, 0x3a, 0x75, 0xea, 0xd4, 0xa9,
	0xf3, 0xaa, 0x53, 0x55, 0x86, 0xc5, 0x96, 0xfb, 0xd8, 0x79, 0xe4, 0xfa, 0x76, 0xcf, 0xed, 0x6c,
	0x74, 0xba, 0x9e, 0xef, 0xa1, 0x29, 0x0e, 0x5a, 0x3b, 0xb3, 0xe7, 0x79, 0x7b, 0x2d, 0xe7, 0x06,
	0x03, 0xdf, 0xef, 0x3f, 0xb8, 0x51, 0x6f, 0x1f, 0x04, 0x38, 0x6b, 0x17, 0x92, 0x4d, 0xcd, 0x7e,
	0xb7, 0xee, 0xbb, 0x5e, 0x9b, 0xb7, 0x9f, 0x4d, 0xb6, 0x3b, 0xfb, 0x1d, 0x3f, 0xec, 0xbc, 0x1c,
	0x8e, 0xb9, 0xef, 0x35, 0x9d, 0x56, 0x8f, 0x43, 0x51, 0x08, 0xed, 0x7a, 0xde, 0x7e, 0x84, 0xe9,
	0xed, 0xed, 0x39, 0xdd, 0x1b, 0x5e, 0x87, 0xd2, 0xe6, 0x98, 0x45, 0x03, 0x66, 0x4c, 0xad, 0x6a,
	0xfa, 0x75, 0xbf, 0xdf, 0x43, 0xeb, 0x90, 0x6b, 0x78, 0x4d, 0xa7, 0x90, 0xb9, 0x94, 0xb9, 0x36,
	0x7f, 0x73, 0x75, 0x83, 0x53, 0xd9, 0x88, 0x30, 0xca, 0x5e, 0xd3, 0x21, 0x0c, 0x07, 0xad, 0xc2,
	0x64, 0x8f, 0xc1, 0x0a, 0xd9, 0x4b, 0x99, 0x6b, 0x33, 0x84, 0x7f, 0x15, 0x3f, 0x3b, 0x01, 0x2b,
	0xe5, 0xae, 0x53, 0xf7, 0x1d, 0x53, 0xab, 0x5a, 0xdd, 0x7e, 0xfb, 0x11, 0x71, 0x7e, 0xa4, 0xef,
	0xf4, 0x7c, 0xf4, 0x02, 0x2c, 0xba, 0xed, 0xfb, 0x5e, 0xbf, 0xdd, 0xb4, 0xeb, 0xcd, 0x66, 0xd7,
	0xe9, 0xf5, 0x9c, 0x5e, 0x21, 0x73, 0x49, 0xba, 0x36, 0x43, 0x64, 0xde, 0xa0, 0x84, 0x70, 0x74,
	0x1d, 0x64, 0xaf, 0xef, 0xc7, 0xb0, 0xf9, 0x40, 0x0b, 0x21, 0x9c, 0x23, 0xa3, 0xe7, 0x21, 0x02,
	0xd9, 0xed, 0xfe, 0xfe, 0x7d, 0xa7, 0x5b, 0x90, 0x18, 0xe6, 0x7c, 0x08, 0xd6, 0x19, 0x14, 0xbd,
	0x03, 0x56, 0x42, 0x06, 0x02, 0xbc, 0x9e, 0xdd, 0x75, 0xf6, 0x9c, 0xd7, 0x0b, 0x39, 0xca, 0x44,
	0x29, 0x5b, 0xc8, 0x90, 0x25, 0x8e, 0x10, 0xf4, 0xe8, 0x11, 0xda, 0x4c, 0x07, 0x48, 0xf4, 0x2b,
	0xcc, 0x30, 0xb6, 0xe7, 0xe3, 0xd8, 0xe8, 0x55, 0x08, 0x27, 0x62, 0xf7, 0x7b, 0x4e, 0xb7, 0x5d,
	0xdf, 0x77, 0x0a, 0x13, 0x94, 0x95, 0xd2, 0xd5, 0x27, 0xdf, 0x7d, 0x31, 0xf3, 0xc9, 0xef, 0xbe,
	0x78, 0xe1, 0x3d, 0x5d, 0xa7, 0x59, 0x6f, 0xf8, 0x4e, 0xf3, 0xd2, 0xb5, 0x8f, 0x7d, 0xec, 0xd2,
	0x86, 0xe9, 0x7e, 0xd4, 0xb9, 0xf4, 0xc6, 0x1b, 0x97, 0xee, 0x1f, 0xf8, 0x4e, 0xef, 0xfa, 0xfb,
	0x48, 0x38, 0x50, 0x8d, 0x77, 0x17, 0x49, 0x76, 0xea, 0xbd, 0xde, 0x6b, 0x5e, 0xb7, 0x59, 0x98,
	0x3c, 0x11, 0xc9, 0x2a, 0xef, 0x8e, 0x4c, 0x58, 0x8c, 0xe4, 0x15, 0xb1, 0x39, 0x75, 0x2c, 0x9a,
	0xd1, 0xda, 0x44, 0x7c, 0x8a, 0x44, 0x23, 0x46, 0xa7, 0x4f, 0x46, 0x34, 0xe2, 0x14, 0x41, 0x8e,
	0x31, 0x07, 0x6c, 0x39, 0xd9, 0x6f, 0x54, 0x82, 0xe9, 0x7d, 0xc7, 0xaf, 0x37, 0xeb, 0x7e, 0xbd,
	0x90, 0x3f, 0x16, 0xfd, 0xa8, 0xdf, 0xad, 0x6c, 0x21, 0x53, 0x7c, 0x92, 0x81, 0xd9, 0x6a, 0xd7,
	0x7b, 0xec, 0x36, 0x9d, 0xae, 0xd6, 0x7e, 0xe0, 0xa1, 0x79, 0xc8, 0xba, 0x4d, 0xa6, 0xfa, 0x33,
	0x24, 0xeb, 0x0e, 0x06, 0xcf, 0x0a, 0x83, 0x5f, 0x87, 0x9c, 0x7f, 0xd0, 0x71, 0x98, 0x7e, 0xcd,
	0xdf, 0x5c, 0x89, 0x0c, 0x24, 0x24, 0x64, 0x1d, 0x74, 0x1c, 0xc2, 0x50, 0xa8, 0x02, 0x77, 0xba,
	0xce, 0x63, 0xa7, 0xed, 0xdb, 0x7e, 0xb7, 0xde, 0xee, 0x3d, 0x70, 0xba, 0x85, 0xdc, 0xa5, 0xcc,
	0xb5, 0x69, 0xb2, 0xc0, 0xe1, 0x16, 0x07, 0x17, 0xbf, 0x37, 0x09, 0xb3, 0xa1, 0xb1, 0x30, 0x56,
	0x2e, 0xc1, 0x6c, 0xcf, 0xed, 0xd8, 0x3e, 0x05, 0xd8, 0x11, 0x53, 0xd0, 0x73, 0x3b, 0x01, 0x4e,
	0x13, 0xbd, 0x0c, 0xb9, 0x47, 0x6e, 0xbb, 0x59, 0x98, 0x67, 0x8c, 0x5c, 0x14, 0x2d, 0x35, 0x22,
	0xb3, 0xc1, 0x7e, 0xdd, 0x76, 0xdb, 0x4d, 0xc2, 0x90, 0xd3, 0x0d, 0x30, 0x7b, 0x0c, 0x03, 0x94,
	0x8e, 0x6c, 0x80, 0xb9, 0x54, 0x03, 0x7c, 0x19, 0x66, 0x98, 0x2c, 0x3a, 0x5e, 0xd7, 0x2f, 0xcc,
	0x25, 0x64, 0xc8, 0x58, 0xe7, 0x8d, 0x64, 0x80, 0x37, 0xda, 0x6a, 0x27, 0x8e, 0x6d, 0xb5, 0x70,
	0x64, 0xab, 0x9d, 0x7c, 0xf6, 0x56, 0x3b, 0xf5, 0x16, 0x58, 0xed, 0xf4, 0x5b, 0x61, 0xb5, 0x33,
	0xcf, 0xc8, 0x6a, 0xf3, 0x23, 0xac, 0x76, 0xf6, 0x64, 0x56, 0x5b, 0x54, 0x61, 0x26, 0xd2, 0x68,
	0x24, 0xc3, 0xac, 0x45, 0x6a, 0xfa, 0x6d, 0xbb, 0x82, 0xb7, 0x94, 0xf2, 0xae, 0x7c, 0x0a, 0x2d,
	0xc2, 0x5c, 0x00, 0xd1, 0xf4, 0x92, 0x51, 0xd3, 0x55, 0x39, 0x83, 0x10, 0xcc, 0x07, 0x20, 0xa3,
	0x66, 0x05, 0xb0, 0x2c, 0xb3, 0x7d, 0x02, 0xe7, 0xa2, 0x10, 0xa5, 0x05, 0x72, 0x8e, 0x45, 0xaa,
	0x9b, 0x30, 0xc1, 0x6c, 0x8f, 0x19, 0x5e, 0xfe, 0xe6, 0x39, 0x51, 0x47, 0x45, 0x7c, 0x6a, 0x65,
	0x24, 0x40, 0x2d, 0xfe, 0x4e, 0x06, 0xce, 0xd5, 0x3a, 0xcd, 0xd1, 0x44, 0x0f, 0x37, 0xea, 0x57,
	0x60, 0xaa, 0xeb, 0x74, 0x5a, 0xf5, 0x46, 0xe0, 0x74, 0x0e, 0x19, 0x78, 0xfb, 0x14, 0x09, 0xd1,
	0xd1, 0x2b, 0x30, 0xd9, 0x67, 0x63, 0x33, 0x13, 0xcd, 0xdf, 0xbc, 0x30, 0xaa, 0x63, 0xc0, 0xe1,
	0xf6, 0x29, 0xc2, 0xf1, 0x4b, 0xd3, 0x30, 0x59, 0x6f, 0xd0, 0x84, 0xa0, 0xf8, 0xed, 0x19, 0x58,
	0x4a, 0x19, 0xe6, 0x08, 0x7c, 0xa7, 0x79, 0x4a, 0x71, 0xc1, 0xa5, 0x93, 0x2d, 0x38, 0x2a, 0xc0,
	0x54, 0x68, 0xb9, 0x2c, 0x42, 0x93, 0xf0, 0x93, 0x7a, 0xb2, 0x7a, 0xab, 0xe5, 0xbd, 0xe6, 0x88,
	0x9e, 0x6c, 0x22, 0xf0, 0x64, 0xbc, 0x61, 0xe0, 0xc9, 0x9e, 0x87, 0x85, 0x10, 0x39, 0x24, 0x37,
	0x19, 0x38, 0x02, 0x0e, 0x0e, 0x1d, 0xc1, 0x6d, 0x98, 0xab, 0xf7, 0xfd, 0x87, 0x27, 0x0d, 0x8a,
	0xb3, 0xb4, 0x73, 0x64, 0x5a, 0x21, 0xb1, 0x13, 0x06, 0x43, 0x46, 0x2c, 0x32, 0xa9, 0x47, 0x30,
	0xf5, 0xd0, 0xa9, 0x37, 0xc3, 0xcc, 0x23, 0x7f, 0xf3, 0xfa, 0x38, 0xcd, 0xd8, 0xd8, 0x0e, 0x70,
	0x71, 0xdb, 0xef, 0x1e, 0x1c, 0x79, 0xc4, 0x70, 0x04, 0xe4, 0xc2, 0x0a, 0xff, 0x69, 0xfb, 0x9e,
	0x5d, 0xf7, 0xfd, 0xae, 0x7b, 0xbf, 0xef, 0x3b, 0x81, 0xfb, 0xcc, 0xdf, 0xfc, 0x81, 0xa3, 0x0c,
	0x6d, 0x79, 0x4a, 0xd4, 0x8f, 0xb1, 0x41, 0x96, 0x1e, 0x0e, 0xb7, 0xd0, 0xa1, 0x06, 0xf4, 0xe9,
	0x68, 0xe1, 0x2c, 0xe7, 0x8f, 0x30, 0xd4, 0x80, 0x8e, 0xe5, 0x89, 0x33, 0x26, 0x4b, 0xf5, 0xe1,
	0x16, 0x54, 0xa2, 0xe1, 0xa0, 0xd1, 0xea, 0x37, 0x9d, 0x68, 0x90, 0x05, 0x16, 0x81, 0xce, 0x88,
	0x83, 0x04, 0xd8, 0x46, 0x90, 0x22, 0xd3, 0x48, 0xc1, 0x7a, 0x08, 0x34, 0xba, 0x6e, 0x7b, 0xcf,
	0x6d, 0xef, 0xd9, 0xbe, 0xbb, 0xef, 0x78, 0x7d, 0x9f, 0x39, 0xb9, 0xfc, 0xcd, 0x33, 0x1b, 0x41,
	0x8e, 0xbe, 0x11, 0xe6, 0xe8, 0x1b, 0x2a, 0xcf, 0xe1, 0xc9, 0x3c, 0xef, 0x61, 0x05, 0x1d, 0x10,
	0x86, 0xc5, 0xfd, 0xfa, 0xeb, 0x76, 0xa3, 0xde, 0x6a, 0xd9, 0x61, 0xa2, 0xcf, 0x5c, 0xe2, 0x58,
	0x2a, 0x0b, 0xfb, 0xf5, 0xd7, 0xcb, 0xf5, 0x56, 0x2b, 0x04, 0xa0, 0xcb, 0x30, 0xf7, 0xa8, 0xeb,
	0xf6, 0x3a, 0xb6, 0xd3, 0xae, 0xdf, 0x6f, 0x39, 0x4d, 0x16, 0x4e, 0xa7, 0xc9, 0x2c, 0x03, 0xe2,
	0x00, 0x86, 0x36, 0x41, 0xde, 0x77, 0x9a, 0x6e, 0xdd, 0x76, 0xda, 0x8d, 0xee, 0x01, 0x9b, 0x54,
	0x41, 0x66, 0x93, 0x3e, 0x2b, 0x4e, 0x7a, 0x87, 0xe2, 0xe0, 0x08, 0x85, 0x2c, 0xec, 0xc7, 0x01,
	0x6b, 0xb7, 0x60, 0x56, 0x14, 0x30, 0x92, 0x41, 0x7a, 0xe4, 0x1c, 0x70, 0x4f, 0x40, 0x7f, 0xa2,
	0x65, 0x98, 0x78, 0x5c, 0x6f, 0xf5, 0x43, 0x1f, 0x10, 0x7c, 0xdc, 0xca, 0xbe, 0x92, 0x59, 0xdb,
	0x84, 0xc2, 0x28, 0x9d, 0x38, 0x2e, 0x9d, 0x51, 0x0b, 0x7e, 0x1c, 0x3a, 0xc5, 0xef, 0xe4, 0x60,
	0x25, 0xd5, 0x29, 0xa2, 0xff, 0x37, 0x70, 0x37, 0x81, 0xdf, 0x5f, 0x8a, 0x84, 0x54, 0x71, 0x7b,
	0x7e, 0x80, 0x35, 0xf0, 0x41, 0x1f, 0x48, 0xf3, 0x41, 0xd9, 0xd1, 0x1d, 0x87, 0x1d, 0xd3, 0x7b,
	0x86, 0x1d, 0x93, 0x34, 0xba, 0x7f, 0xd2, 0x5b, 0x55, 0x93, 0xde, 0x2a, 0x77, 0x1c, 0x07, 0xb3,
	0x7d, 0x2a, 0xee, 0xaf, 0x9e, 0x64, 0x32, 0x11, 0xc5, 0xc8, 0x65, 0x1d, 0x6b, 0xef, 0xb2, 0x9d,
	0x89, 0x3b, 0x2d, 0x4a, 0xf1, 0x34, 0x8f, 0x0c, 0x2c, 0x9d, 0xda, 0xce, 0x06, 0xb1, 0x81, 0x36,
	0x6c, 0x09, 0xe1, 0xe1, 0x58, 0x5e, 0x76, 0x5b, 0x1a, 0x04, 0x08, 0x4a, 0xe8, 0x76, 0x8a, 0x8a,
	0x4f, 0x1f, 0xaa, 0xe2, 0xdb, 0xb9, 0x21, 0x25, 0x7f, 0x92, 0xc9, 0x94, 0x64, 0x98, 0xb7, 0x63,
	0x32, 0x1d, 0x40, 0x42, 0x99, 0x94, 0xa6, 0x60, 0xc2, 0x66, 0x4d, 0x79, 0x98, 0xb1, 0x43, 0x4e,
	0x4a, 0x4b, 0xb0, 0x68, 0x27, 0xf9, 0x28, 0x5a, 0x70, 0x3e, 0x4a, 0x33, 0x0c, 0x9e, 0x25, 0xc5,
	0x52, 0x82, 0x97, 0xe3, 0x79, 0xc6, 0x79, 0x91, 0xe3, 0x58, 0x07, 0x31, 0xd1, 0xf8, 0xdd, 0x0c,
	0x9c, 0x8f, 0x12, 0x8d, 0x54, 0xb2, 0x87, 0x47, 0xec, 0x77, 0x25, 0x33, 0x8d, 0xf1, 0x43, 0x8b,
	0xa9, 0xc6, 0xbb, 0x12, 0xa9, 0xc6, 0xc5, 0x91, 0x3d, 0xc7, 0xe4, 0x1a, 0xdf, 0x9a, 0x86, 0xe5,
	0xb4, 0x81, 0xfe, 0x67, 0x93, 0x8d, 0x70, 0x9b, 0x13, 0x6c, 0x5e, 0xc2, 0x4f, 0x74, 0x03, 0x96,
	0x9a, 0x4e, 0xcf, 0x77, 0xdb, 0xcc, 0xf3, 0xda, 0x0d, 0xaf, 0x4f, 0x9d, 0x0e, 0xdb, 0x7a, 0xcd,
	0x10, 0x24, 0x34, 0x95, 0x83, 0x96, 0xf8, 0x36, 0x67, 0xe2, 0x88, 0xdb, 0x1c, 0x21, 0xd9, 0x99,
	0x8c, 0x27, 0x3b, 0xdf, 0xbf, 0x69, 0x49, 0x2b, 0x99, 0x96, 0xac, 0x8f, 0x55, 0xa3, 0xa7, 0xcc,
	0x4b, 0x3e, 0x32, 0x3e, 0x2f, 0x79, 0xc7, 0x91, 0xc6, 0x3e, 0x62, 0x62, 0xf2, 0x91, 0x51, 0x89,
	0x49, 0xfe, 0x28, 0x63, 0x3d, 0x75, 0x66, 0x32, 0x7b, 0xdc, 0xcc, 0x24, 0x2d, 0xd2, 0xcf, 0xfd,
	0x1f, 0x8f, 0xf4, 0x9f, 0x9f, 0x80, 0xd5, 0x74, 0x9f, 0x84, 0xce, 0x0f, 0x8c, 0x9d, 0x91, 0xa2,
	0x0e, 0x8e, 0x03, 0x68, 0x50, 0x79, 0x45, 0x34, 0xe0, 0xec, 0x18, 0x03, 0xde, 0xce, 0x08, 0x26,
	0x4c, 0x7b, 0xfe, 0xff, 0x74, 0x5f, 0x31, 0xc3, 0xe3, 0x5f, 0x8a, 0xb7, 0xa0, 0xbd, 0x84, 0xcc,
	0x43, 0x3a, 0x42, 0xe6, 0xf1, 0x94, 0x91, 0x5f, 0x7a, 0xe6, 0x91, 0x3f, 0x77, 0x58, 0xe4, 0x9f,
	0x78, 0x16, 0x91, 0x7f, 0xf2, 0x99, 0x44, 0xfe, 0xa9, 0xd4, 0xc8, 0x0f, 0x30, 0x1d, 0x66, 0x71,
	0xa5, 0x59, 0x00, 0x3b, 0x5a, 0xd4, 0xd2, 0x2a, 0x2c, 0xdb, 0x29, 0x4b, 0xfa, 0xac, 0x73, 0x85,
	0xf7, 0xc2, 0x99, 0x2d, 0xc7, 0x3f, 0x69, 0xe9, 0xa0, 0x58, 0x85, 0xb5, 0xb4, 0xee, 0xbd, 0x8e,
	0xd7, 0xee, 0x39, 0x27, 0xaa, 0x67, 0xbc, 0x2f, 0xa4, 0x78, 0xb2, 0x14, 0xa3, 0x48, 0xe0, 0x6c,
	0x6a, 0x7f, 0xce, 0xd2, 0x89, 0x52, 0x9f, 0x12, 0x2c, 0x51, 0x7b, 0x48, 0x1e, 0x2c, 0x3c, 0x0f,
	0xb9, 0x4e, 0x7d, 0xcf, 0x19, 0xca, 0xda, 0xab, 0xf5, 0x3d, 0xbe, 0x6a, 0x84, 0x21, 0xb0, 0xda,
	0xcf, 0x16, 0x2c, 0xc7, 0x69, 0x70, 0x86, 0x5e, 0x80, 0x09, 0xd7, 0x77, 0xf6, 0x83, 0x13, 0x89,
	0x7c, 0xd2, 0xde, 0x23, 0x46, 0x18, 0x0e, 0x23, 0xf4, 0xa3, 0xb0, 0xc6, 0x09, 0xa5, 0x2d, 0x59,
	0xc8, 0x93, 0x74, 0x08, 0x4f, 0xe8, 0x2c, 0xf5, 0x35, 0x81, 0x14, 0xc3, 0xd3, 0x90, 0x69, 0x3f,
	0x90, 0x61, 0x4f, 0x4c, 0x0a, 0xb2, 0xb1, 0xa4, 0xa0, 0xf8, 0x2a, 0x9c, 0x4d, 0x1d, 0x7d, 0xb0,
	0xe2, 0xe2, 0x6c, 0x0e, 0x59, 0x71, 0x86, 0x5a, 0x7c, 0x23, 0x22, 0x99, 0xba, 0xe4, 0x6f, 0xf5,
	0x8c, 0x4c, 0x38, 0x97, 0x3e, 0xfc, 0x40, 0x63, 0xc4, 0x29, 0x1d, 0xa6, 0x31, 0xc1, 0x9c, 0xde,
	0x05, 0x2b, 0xaa, 0xd3, 0x72, 0x86, 0x0f, 0xa3, 0x0e, 0x57, 0xe0, 0x4d, 0xb6, 0x4f, 0x54, 0xdd,
	0x5e, 0xa7, 0xee, 0x37, 0x1e, 0x92, 0x7e, 0xcb, 0x51, 0xdd, 0xae, 0xd3, 0xf0, 0xe9, 0xfc, 0xba,
	0x9e, 0xb7, 0xcf, 0x2c, 0x9b, 0xf7, 0x9b, 0xa6, 0x00, 0x9d, 0xe6, 0x57, 0x32, 0x48, 0x1d, 0xb7,
	0xcd, 0x83, 0x11, 0xfd, 0x59, 0xd4, 0xe1, 0x4c, 0x82, 0x8e, 0xd6, 0x6e, 0xba, 0x8f, 0xdd, 0x66,
	0xbf, 0xde, 0x42, 0x17, 0x21, 0xcf, 0x68, 0x75, 0xba, 0xce, 0x03, 0xf7, 0xf5, 0x90, 0x0b, 0x0a,
	0xaa, 0x32, 0x48, 0x0a, 0xbd, 0x87, 0x43, 0x7c, 0x95, 0xeb, 0xad, 0x96, 0xe3, 0x9c, 0x80, 0x16,
	0x3a, 0x07, 0x33, 0xdd, 0x7a, 0xbb, 0xe9, 0xed, 0xbb, 0x1f, 0x0d, 0x16, 0x76, 0x9a, 0x0c, 0x00,
	0xc5, 0xcf, 0x64, 0x61, 0x21, 0x31, 0x14, 0x22, 0xb0, 0xdc, 0xe4, 0xdf, 0x76, 0xb7, 0xdf, 0x72,
	0xec, 0x26, 0x13, 0x0a, 0xb7, 0xbd, 0x58, 0xdd, 0x71, 0x58, 0x74, 0xdb, 0xa7, 0x08, 0x6a, 0x0e,
	0x0b, 0xf4, 0x87, 0xa0, 0x10, 0xa7, 0xe9, 0x46, 0x02, 0xe2, 0xdb, 0x93, 0xe2, 0x28, 0xba, 0x03,
	0x51, 0x6e, 0x9f, 0x22, 0xab, 0xcd, 0x74, 0x21, 0x0f, 0xf1, 0xdc, 0x60, 0x02, 0x4b, 0xab, 0x95,
	0x0e, 0x8b, 0x35, 0xc9, 0x73, 0x00, 0x2d, 0x4d, 0x42, 0x8e, 0x92, 0x2a, 0x7e, 0x6a, 0x42, 0xa8,
	0x25, 0x8b, 0xbd, 0x43, 0x45, 0x53, 0x60, 0x2e, 0x36, 0x38, 0x3b, 0xcc, 0x4a, 0x58, 0x64, 0x7c,
	0x46, 0x0f, 0x3c, 0x32, 0x2b, 0x8e, 0x88, 0x5e, 0x0a, 0xc6, 0xe2, 0x32, 0x2e, 0x8c, 0xea, 0xc9,
	0x8e, 0x42, 0x18, 0x26, 0xba, 0x28, 0x9a, 0x60, 0x36, 0x3a, 0x27, 0x19, 0x98, 0xe1, 0x06, 0x2c,
	0x3e, 0x74, 0x9b, 0x8e, 0xdd, 0x79, 0xe8, 0xb5, 0x1d, 0xf1, 0xd4, 0x74, 0x9a, 0x21, 0x2e, 0xd0,
	0xc6, 0x2a, 0x6d, 0xe3, 0x27, 0x37, 0x2f, 0x0c, 0x1f, 0xa6, 0x4c, 0x46, 0x64, 0x93, 0x07, 0x2a,
	0xab, 0x3c, 0xf6, 0x07, 0x69, 0x09, 0xe3, 0x8a, 0xed, 0x3d, 0x54, 0x21, 0xf4, 0x07, 0x09, 0xc6,
	0xb5, 0x42, 0xe6, 0xd8, 0x1b, 0xb5, 0x1f, 0x03, 0x10, 0x72, 0xff, 0xa9, 0x44, 0xa1, 0x70, 0xdc,
	0x5a, 0x6c, 0x24, 0xb2, 0xd2, 0x63, 0x0c, 0x2f, 0x0c, 0x89, 0x2e, 0x0f, 0xec, 0xac, 0xe7, 0xf8,
	0x7c, 0x03, 0x45, 0x67, 0x19, 0xda, 0x5a, 0xcf, 0xf1, 0xd1, 0xfb, 0x39, 0x52, 0xc3, 0x6b, 0x3f,
	0x70, 0xf7, 0x58, 0x02, 0x98, 0xbf, 0xb9, 0x16, 0xb1, 0x49, 0x3c, 0x6f, 0xbf, 0xcc, 0x9a, 0x78,
	0x41, 0x6f, 0x40, 0x20, 0x00, 0xaf, 0xbd, 0x17, 0x16, 0x9e, 0x22, 0x89, 0x2e, 0xfe, 0x91, 0x78,
	0x1c, 0x91, 0xa6, 0x97, 0x37, 0x60, 0x99, 0x3a, 0xc0, 0x84, 0xe1, 0x85, 0x8e, 0x70, 0xb1, 0xe7,
	0x76, 0x62, 0x5a, 0x79, 0xd8, 0xe9, 0x44, 0x52, 0x85, 0x8f, 0x7c, 0x3a, 0x21, 0x76, 0x1c, 0x53,
	0x31, 0xf8, 0xfa, 0x04, 0x3b, 0x9d, 0x48, 0x0e, 0x73, 0xfc, 0x69, 0xbc, 0xc8, 0x8d, 0x29, 0x3b,
	0xde, 0x98, 0xb8, 0x21, 0xc5, 0x62, 0x99, 0x94, 0x88, 0x65, 0xeb, 0x69, 0x46, 0xc4, 0xcf, 0x78,
	0x93, 0x06, 0x94, 0x72, 0x1a, 0x39, 0x95, 0x7a, 0x1a, 0x29, 0x04, 0xc8, 0xb9, 0x78, 0x1d, 0x20,
	0xac, 0x7c, 0x4c, 0x8c, 0xa8, 0x7c, 0x4c, 0x9e, 0xb0, 0xf2, 0xe1, 0xc7, 0x0c, 0x6a, 0x9a, 0x19,
	0xd4, 0x8b, 0xe3, 0xd6, 0x76, 0xc8, 0x8e, 0xae, 0x9e, 0xc0, 0x8a, 0x2e, 0xc6, 0xad, 0x68, 0x26,
	0x16, 0xad, 0xa8, 0x05, 0xbd, 0x3b, 0x6e, 0x41, 0x70, 0x98, 0x05, 0x89, 0xd6, 0x33, 0x5c, 0x1e,
	0xcf, 0x1f, 0xb1, 0x3c, 0x3e, 0x7b, 0x82, 0x4d, 0xf3, 0x53, 0x9a, 0xea, 0x93, 0xdc, 0x50, 0x44,
	0xe7, 0xdb, 0xd4, 0x97, 0xe2, 0x99, 0xd4, 0xc8, 0x9d, 0xe1, 0x40, 0x25, 0x8f, 0xa7, 0xdd, 0xe1,
	0x26, 0x4d, 0xe2, 0x7b, 0xe0, 0xd4, 0x4d, 0x5a, 0xee, 0x98, 0x45, 0xe0, 0xd8, 0x26, 0xed, 0x71,
	0x4c, 0xb7, 0x26, 0x98, 0x6e, 0x6d, 0x8c, 0x37, 0xff, 0x67, 0xa2, 0x5d, 0x69, 0x9b, 0xc3, 0xc9,
	0xc3, 0x37, 0x87, 0xd9, 0xb4, 0xcd, 0xe1, 0x53, 0xae, 0xef, 0x71, 0x76, 0x81, 0x1f, 0xcf, 0x44,
	0x9b, 0x8a, 0x34, 0x9f, 0x7d, 0xe4, 0x14, 0x7c, 0x1d, 0x16, 0x93, 0x1e, 0x31, 0x4c, 0xc5, 0x17,
	0x62, 0x49, 0x52, 0xb3, 0x17, 0x77, 0x71, 0xd9, 0xb8, 0x8b, 0x13, 0xb6, 0x19, 0x71, 0x7e, 0x8e,
	0xb0, 0xcd, 0x18, 0x4a, 0x6a, 0x78, 0x4a, 0x6e, 0xc0, 0xb9, 0x28, 0x25, 0x7f, 0x16, 0x81, 0xa9,
	0xf8, 0x89, 0x09, 0x58, 0x14, 0xf6, 0x00, 0xdc, 0x03, 0xac, 0xc1, 0xf4, 0x43, 0xaf, 0xe7, 0x8b,
	0x49, 0x7a, 0xf8, 0x3d, 0xaa, 0xa2, 0x3b, 0x75, 0xb4, 0x8a, 0x6e, 0xf6, 0x88, 0x15, 0xdd, 0xa1,
	0xba, 0xad, 0xf4, 0x2c, 0xeb, 0xb6, 0xb9, 0xa7, 0xa8, 0xdb, 0xee, 0x8d, 0xaa, 0xa4, 0x06, 0x06,
	0xfa, 0x72, 0xda, 0xd6, 0x2a, 0x10, 0xeb, 0x31, 0xcb, 0xa8, 0x7b, 0xa3, 0xca, 0xa8, 0x93, 0x87,
	0x0e, 0x74, 0xac, 0x1a, 0xea, 0xf7, 0x5d, 0xed, 0xf1, 0x9f, 0xf2, 0x70, 0x36, 0x4a, 0x45, 0xab,
	0xf5, 0xae, 0xef, 0x36, 0xdc, 0x4e, 0xbd, 0xed, 0x1f, 0xfd, 0x88, 0xe6, 0xa5, 0xb0, 0x40, 0xb2,
	0x9c, 0x08, 0x7c, 0x43, 0xa2, 0xe2, 0xd5, 0x11, 0x74, 0x01, 0xf2, 0x94, 0x26, 0x3b, 0x59, 0xf6,
	0x3d, 0xce, 0xd3, 0x4c, 0xcf, 0xed, 0xd0, 0x2d, 0x8b, 0xe5, 0xa1, 0xf3, 0x40, 0xe9, 0x87, 0x79,
	0xca, 0x42, 0xd4, 0xcc, 0x33, 0x94, 0xd8, 0xb6, 0x56, 0x4a, 0x6c, 0x6b, 0xdf, 0x0e, 0xcb, 0x9d,
	0xc1, 0x2c, 0x6c, 0xb7, 0xe9, 0xb4, 0x7d, 0xd7, 0x3f, 0xe0, 0x47, 0x25, 0x4b, 0x42, 0x9b, 0xc6,
	0x9b, 0xd0, 0xab, 0x20, 0x8b, 0x5d, 0x4e, 0x70, 0x72, 0xb1, 0x20, 0xf4, 0x67, 0x5c, 0xec, 0xc6,
	0xb9, 0x88, 0x42, 0xd4, 0xf1, 0xce, 0x30, 0x44, 0x6e, 0x77, 0xc2, 0x24, 0xe8, 0xd3, 0x19, 0x58,
	0x15, 0x69, 0x0b, 0x46, 0x11, 0x1c, 0x6d, 0xbc, 0x7f, 0x78, 0x8b, 0x31, 0xbc, 0xae, 0x1b, 0x02,
	0xe8, 0xa4, 0x61, 0x6c, 0xa5, 0x93, 0x46, 0x83, 0x66, 0x7f, 0x4d, 0x7f, 0xff, 0x41, 0x98, 0xfd,
	0xd1, 0xdf, 0xe8, 0x79, 0x98, 0xeb, 0xb4, 0xea, 0x07, 0x76, 0xd7, 0x6d, 0xef, 0xf9, 0x5e, 0x3b,
	0xa8, 0xb6, 0x06, 0x3b, 0xb8, 0x59, 0xda, 0x40, 0x38, 0x9c, 0xa6, 0x43, 0x0c, 0xb1, 0xe9, 0xd6,
	0x5b, 0x0c, 0x91, 0xdf, 0x16, 0xa0, 0x40, 0x95, 0xc3, 0xd2, 0xd3, 0x59, 0x48, 0x4f, 0x67, 0x7b,
	0x83, 0x93, 0x1f, 0x99, 0x89, 0xe7, 0xed, 0x47, 0x12, 0xcf, 0xd3, 0x1d, 0x00, 0xa5, 0x1c, 0x94,
	0x2c, 0xfe, 0x6f, 0xba, 0xc2, 0x31, 0x7f, 0xc4, 0x1c, 0x15, 0x1d, 0x3f, 0x47, 0x45, 0x1b, 0xb0,
	0xf4, 0x5a, 0xdd, 0xf5, 0xed, 0x7e, 0xdb, 0x77, 0x5b, 0x76, 0xbd, 0xdd, 0x7b, 0xcd, 0xe9, 0x3a,
	0xcd, 0xc2, 0x12, 0x1b, 0x72, 0x91, 0x36, 0xd5, 0x68, 0x8b, 0xc2, 0x1b, 0x90, 0x0e, 0xac, 0x06,
	0x41, 0x95, 0x86, 0x59, 0xee, 0xca, 0x31, 0x2f, 0x17, 0xe4, 0x79, 0x6f, 0x9d, 0x67, 0x94, 0xef,
	0x86, 0xbc, 0x10, 0x57, 0x0b, 0xab, 0x4c, 0x5a, 0xcb, 0xd1, 0x14, 0xd4, 0x41, 0xdb, 0x76, 0x86,
	0x88, 0xa8, 0x34, 0x01, 0xdb, 0x86, 0xb5, 0xd1, 0x86, 0x75, 0x2c, 0xff, 0xfe, 0x14, 0xe7, 0x5b,
	0xa5, 0x05, 0x98, 0xb3, 0x45, 0x99, 0x94, 0xe6, 0x61, 0x56, 0x3c, 0x1a, 0x28, 0xfe, 0x56, 0x06,
	0x50, 0x5c, 0xef, 0xd9, 0x16, 0xf5, 0x0a, 0xcc, 0xc7, 0x7d, 0x27, 0x1f, 0x6e, 0x2e, 0xe6, 0x35,
	0x47, 0xba, 0xd8, 0xec, 0x68, 0x17, 0x3b, 0xd6, 0x65, 0x8b, 0xe1, 0xc0, 0xe5, 0xf9, 0x42, 0x14,
	0x0e, 0xb4, 0x66, 0xf1, 0x4d, 0x09, 0xce, 0x87, 0x57, 0x90, 0xd3, 0x83, 0xd4, 0x28, 0x8e, 0x32,
	0x47, 0xe4, 0x28, 0x9b, 0xe0, 0xe8, 0x22, 0xe4, 0xc3, 0xab, 0xd0, 0x34, 0x40, 0x05, 0x0c, 0x43,
	0x08, 0xb2, 0xbc, 0x61, 0x37, 0x95, 0x4b, 0x71, 0x53, 0xfd, 0x81, 0xeb, 0x49, 0xa6, 0x2b, 0x63,
	0xa7, 0xf3, 0xf4, 0xce, 0x27, 0xe9, 0x38, 0x26, 0x8f, 0xe9, 0x38, 0x9e, 0x46, 0xfb, 0x8a, 0x9f,
	0x03, 0xc8, 0x9b, 0x5a, 0x95, 0x2d, 0x1e, 0xd5, 0xaa, 0xd3, 0x30, 0x15, 0x2e, 0x6d, 0xd0, 0x7f,
	0xb2, 0xc1, 0xd6, 0x15, 0x9d, 0x81, 0xe9, 0x28, 0xad, 0x08, 0xa8, 0x4c, 0xf1, 0x74, 0x1e, 0x5d,
	0x03, 0x79, 0x28, 0xad, 0x96, 0x83, 0x9b, 0xda, 0xf1, 0x5d, 0x01, 0x5a, 0x85, 0xc9, 0xae, 0xb3,
	0x47, 0x2d, 0x75, 0x31, 0x20, 0x1e, 0x7c, 0x8d, 0xd7, 0xb8, 0xd3, 0x30, 0xc5, 0x1a, 0x23, 0x6d,
	0x9b, 0xa4, 0x9f, 0x63, 0x54, 0x7b, 0x62, 0xb4, 0x22, 0x7d, 0x7c, 0x74, 0x3c, 0x46, 0x6c, 0xd5,
	0x6f, 0x88, 0xee, 0x2f, 0x94, 0xca, 0x5b, 0x18, 0x7f, 0xd7, 0x61, 0xfa, 0x41, 0xd7, 0xdb, 0xb7,
	0xfb, 0x5d, 0x97, 0x2f, 0xfc, 0x82, 0xc8, 0x41, 0xad, 0xeb, 0x92, 0x29, 0x8a, 0x50, 0xeb, 0xba,
	0xe8, 0x2a, 0x4c, 0xfa, 0x1e, 0xc3, 0x9c, 0x4a, 0xc7, 0x9c, 0xf0, 0x3d, 0x8a, 0xf7, 0x36, 0x80,
	0x06, 0x8b, 0x96, 0x4d, 0xbb, 0x1e, 0x94, 0x40, 0x24, 0x16, 0xbc, 0x67, 0x38, 0x54, 0xf1, 0x29,
	0x4a, 0xcf, 0xaf, 0x77, 0x39, 0x0a, 0x0c, 0x50, 0x38, 0x54, 0xf1, 0xd1, 0x79, 0x98, 0x76, 0xda,
	0xcd, 0x00, 0x21, 0x1f, 0x21, 0x4c, 0x31, 0x98, 0xe2, 0xa3, 0xf7, 0x81, 0xcc, 0x03, 0x8c, 0xfd,
	0xc0, 0xa9, 0xfb, 0xfd, 0xae, 0x13, 0x5c, 0xaf, 0x9c, 0x17, 0x36, 0x90, 0xa6, 0x56, 0xdd, 0x0c,
	0xda, 0xc8, 0x02, 0x47, 0xe6, 0xdf, 0x3d, 0xf4, 0x01, 0x98, 0x0f, 0x22, 0x1d, 0x2b, 0xd6, 0x53,
	0x95, 0x48, 0xb9, 0x37, 0xc9, 0x02, 0x5b, 0x88, 0x40, 0xe6, 0x1a, 0xe2, 0x27, 0x7a, 0x27, 0xe4,
	0x19, 0x05, 0xfe, 0x5e, 0x68, 0x7a, 0xf8, 0x75, 0x11, 0xed, 0x1e, 0xbc, 0x30, 0x22, 0xd0, 0x88,
	0x7e, 0xa3, 0x22, 0xcc, 0x0d, 0xe4, 0x63, 0xb7, 0x7b, 0x2c, 0x6c, 0x48, 0x24, 0x1f, 0x89, 0x47,
	0x67, 0x38, 0x03, 0x01, 0x51, 0x9c, 0xd3, 0x01, 0x4e, 0x24, 0x1f, 0xbd, 0x47, 0x5d, 0x61, 0x28,
	0x21, 0x8a, 0x51, 0x60, 0x18, 0x33, 0x5c, 0x40, 0x7a, 0x0f, 0x6d, 0xb2, 0xed, 0x72, 0xc3, 0x6b,
	0xb7, 0x9d, 0x86, 0x6f, 0x77, 0x9d, 0x7a, 0x2f, 0xaa, 0x04, 0x0d, 0x66, 0xa9, 0x46, 0x18, 0x84,
	0x21, 0x10, 0xb9, 0x99, 0x80, 0x50, 0xeb, 0x75, 0xba, 0x5d, 0xaf, 0xcb, 0xd2, 0xab, 0x19, 0x12,
	0x7c, 0xa0, 0xf7, 0x80, 0x2c, 0x4c, 0xdf, 0x66, 0x2f, 0xac, 0x96, 0x98, 0x5e, 0xa0, 0xe1, 0x17,
	0x56, 0x64, 0x7e, 0x30, 0xff, 0xb2, 0xd7, 0x64, 0x4e, 0xb3, 0xde, 0x6f, 0xba, 0x1e, 0xeb, 0xd7,
	0x60, 0xbb, 0x81, 0x19, 0x02, 0x0c, 0x44, 0xdb, 0x1b, 0xe8, 0x7a, 0x4a, 0x86, 0xb0, 0x12, 0x3c,
	0xd4, 0x48, 0x26, 0x01, 0xcf, 0xc1, 0x7c, 0xa7, 0x51, 0xef, 0xd8, 0x0f, 0xdc, 0x96, 0x63, 0xb7,
	0xdc, 0xf6, 0xa3, 0xc2, 0x19, 0x86, 0x38, 0x4b, 0xa1, 0x9b, 0x6e, 0xcb, 0xa9, 0xb8, 0xed, 0x47,
	0xe8, 0x9d, 0x30, 0xcb, 0xf8, 0x6d, 0x78, 0x6d, 0xdf, 0x79, 0xdd, 0x2f, 0xac, 0x31, 0x7b, 0x5b,
	0x1e, 0x72, 0x73, 0x4a, 0xfb, 0x80, 0xb0, 0x85, 0x2d, 0x07, 0x88, 0xe8, 0x16, 0xcc, 0x75, 0xf8,
	0x43, 0x18, 0xdb, 0x6d, 0x3f, 0xf0, 0x0a, 0x67, 0xd9, 0x2c, 0x87, 0x9f, 0xc9, 0x04, 0x67, 0x1c,
	0x1d, 0xe1, 0xeb, 0xd9, 0x85, 0xf8, 0xe2, 0x7f, 0x05, 0xa7, 0x56, 0x61, 0x2c, 0x60, 0xce, 0x52,
	0x8c, 0x3c, 0x83, 0xdd, 0x56, 0x08, 0xd2, 0x9a, 0xa2, 0x37, 0xcd, 0xc6, 0xbc, 0xe9, 0xa1, 0x31,
	0xeb, 0x9d, 0x50, 0x18, 0x90, 0x6e, 0xbb, 0xbe, 0x2b, 0xa8, 0x6b, 0x8e, 0x29, 0xda, 0x4a, 0x34,
	0x4e, 0xd8, 0xcc, 0x94, 0x4e, 0xec, 0xd8, 0xf0, 0xf6, 0x3b, 0x2d, 0x67, 0xd0, 0x71, 0x22, 0xde,
	0xb1, 0x1c, 0x36, 0xb3, 0x8e, 0x65, 0x58, 0x88, 0x3a, 0x72, 0x93, 0x0a, 0x4a, 0x5b, 0x6b, 0x43,
	0x25, 0x09, 0x1a, 0x0b, 0xb9, 0x5a, 0xf9, 0xb1, 0xef, 0x81, 0xaa, 0x4e, 0x89, 0xaa, 0xaa, 0xc2,
	0x72, 0x82, 0x74, 0xa0, 0xae, 0xd3, 0x23, 0xd5, 0x15, 0xc5, 0xe9, 0x52, 0x95, 0x2c, 0xfe, 0x44,
	0x06, 0x26, 0x03, 0x47, 0x47, 0x77, 0x2d, 0xfd, 0x9e, 0xd3, 0xe5, 0x12, 0x67, 0xbf, 0x29, 0xec,
	0xa1, 0xd7, 0xf3, 0xc3, 0x1b, 0x7c, 0xf4, 0x37, 0x7b, 0x7c, 0xd5, 0xe1, 0xd2, 0xcd, 0xba, 0x1d,
	0x8a, 0xc3, 0x6a, 0x2d, 0x54, 0x82, 0x73, 0x84, 0xfd, 0x3e, 0xd1, 0xb5, 0xba, 0xa2, 0x09, 0x79,
	0x21, 0xb7, 0xa4, 0x74, 0x1b, 0x83, 0x14, 0x86, 0xfd, 0x46, 0x05, 0x98, 0x0a, 0x2b, 0x40, 0x3c,
	0x5e, 0xf2, 0x4f, 0x21, 0x0a, 0x4a, 0x62, 0x14, 0x5c, 0xff, 0xc6, 0x32, 0xcc, 0xc5, 0xde, 0x44,
	0xa2, 0x55, 0x96, 0xf9, 0xd9, 0xa6, 0xa5, 0x58, 0x35, 0xd3, 0xae, 0xe9, 0xb7, 0x75, 0xe3, 0xae,
	0x2e, 0x9f, 0x42, 0x2b, 0xac, 0x34, 0x15, 0xc2, 0x2d, 0xb2, 0xab, 0xe9, 0x5b, 0x32, 0x55, 0x37,
	0x11, 0x9d, 0x68, 0xfa, 0x16, 0x85, 0x7f, 0x39, 0x83, 0xde, 0x06, 0xe7, 0x84, 0x86, 0xb2, 0x52,
	0xa9, 0xd8, 0x9a, 0x69, 0x6f, 0x1a, 0xe4, 0xae, 0x42, 0x54, 0xac, 0xca, 0x5f, 0xc9, 0xa0, 0xd5,
	0x18, 0xc9, 0x57, 0x6b, 0xb8, 0x86, 0x55, 0xf9, 0xab, 0x19, 0x74, 0x09, 0xce, 0x0a, 0x70, 0x13,
	0x9b, 0xa6, 0x66, 0xe8, 0x76, 0x95, 0x18, 0x5b, 0x04, 0x9b, 0xa6, 0xfc, 0xb5, 0x0c, 0x7a, 0x1e,
	0x8a, 0x02, 0x06, 0x56, 0x48, 0x65, 0xd7, 0x56, 0x35, 0xa5, 0x62, 0x6c, 0xd9, 0x16, 0x26, 0x3b,
	0x9a, 0xae, 0x58, 0x58, 0x95, 0x7f, 0x2f, 0x83, 0x10, 0x9b, 0x5e, 0x88, 0x68, 0xdc, 0x96, 0x7f,
	0x3f, 0x83, 0x0a, 0xec, 0xfc, 0x25, 0x84, 0x29, 0xe5, 0x32, 0xae, 0x52, 0xec, 0x3f, 0xc8, 0xa0,
	0x8b, 0xb0, 0x26, 0xb4, 0xe8, 0x86, 0xad, 0x1b, 0x96, 0xb6, 0xa9, 0x95, 0x15, 0x4b, 0x33, 0x74,
	0xf9, 0x0f, 0x93, 0x9c, 0xed, 0xd4, 0x2a, 0x96, 0x56, 0xad, 0x60, 0xbb, 0xbc, 0x6d, 0x68, 0x65,
	0x6c, 0xca, 0x6f, 0x66, 0x13, 0xd3, 0xde, 0x31, 0xee, 0x60, 0xd5, 0xae, 0x62, 0xb2, 0xa3, 0xe8,
	0x58, 0xb7, 0x2a, 0xbb, 0xf2, 0x17, 0xd2, 0x51, 0x2c, 0xbc, 0x53, 0x35, 0x88, 0x42, 0xb4, 0xca,
	0xae, 0xfc, 0xc5, 0x2c, 0x3a, 0xc3, 0x2e, 0x95, 0x46, 0x8b, 0x60, 0x62, 0x3a, 0xfb, 0x7b, 0xbb,
	0xf2, 0x97, 0xb2, 0xe8, 0x32, 0x5c, 0x10, 0xb9, 0xaf, 0x58, 0x98, 0xe8, 0x8a, 0xa5, 0xdd, 0xc1,
	0xb6, 0x89, 0xc9, 0x1d, 0xad, 0x8c, 0xe5, 0xff, 0xcc, 0xa2, 0xb3, 0xec, 0xbe, 0x58, 0x88, 0x54,
	0x52, 0x54, 0x9b, 0xe0, 0x57, 0x6b, 0xd8, 0xb4, 0xe4, 0x9f, 0x94, 0xd0, 0x39, 0x38, 0x1d, 0x5b,
	0x61, 0xa5, 0x66, 0x6d, 0x1b, 0x44, 0xfb, 0x10, 0x56, 0xe5, 0x4f, 0x48, 0x89, 0x29, 0x56, 0x95,
	0xdd, 0x1d, 0xac, 0x5b, 0xac, 0xbb, 0x46, 0xb0, 0x2a, 0x7f, 0x52, 0x4a, 0x30, 0xb7, 0x69, 0x90,
	0x92, 0xa6, 0xaa, 0x58, 0x97, 0x7f, 0x4a, 0x4a, 0x88, 0x56, 0x37, 0xac, 0x4d, 0xf6, 0x56, 0xe9,
	0xa7, 0x25, 0x54, 0x84, 0xf3, 0xe2, 0xa4, 0xb1, 0xb5, 0x6d, 0xa8, 0x14, 0xc1, 0x56, 0x2a, 0x15,
	0xe3, 0x2e, 0x56, 0xe5, 0x4f, 0x49, 0xe8, 0x02, 0xbb, 0x5f, 0x20, 0xf4, 0xe6, 0x8b, 0xa3, 0x94,
	0x2a, 0x58, 0xfe, 0x19, 0x29, 0x31, 0x75, 0x26, 0x11, 0x9b, 0x32, 0x3f, 0xe0, 0xee, 0x67, 0xa5,
	0xc4, 0x1a, 0xf2, 0x69, 0xdb, 0x96, 0xb6, 0x83, 0x8d, 0x9a, 0x25, 0xff, 0x5c, 0x92, 0xc7, 0xb2,
	0xa1, 0x6f, 0x56, 0xb4, 0xb2, 0x25, 0xff, 0xbc, 0x84, 0x96, 0x99, 0xbb, 0x0d, 0x5b, 0xb6, 0x0c,
	0x1d, 0xcb, 0xbf, 0x90, 0x24, 0x58, 0xc1, 0xfa, 0x96, 0x38, 0xe2, 0x2f, 0x4a, 0x68, 0x1d, 0xae,
	0xc4, 0x09, 0xaa, 0x1a, 0xd5, 0x17, 0xa5, 0x12, 0x8d, 0xbe, 0xa9, 0x68, 0x15, 0xac, 0xca, 0xbf,
	0x24, 0xa1, 0x6b, 0x70, 0x39, 0x85, 0x3b, 0xac, 0x5b, 0x9a, 0xb5, 0x6b, 0x5b, 0x86, 0x61, 0x57,
	0x14, 0xb2, 0x85, 0xe5, 0x5f, 0x96, 0xd0, 0x73, 0x70, 0x31, 0x05, 0xb3, 0x46, 0xb4, 0x00, 0xcd,
	0xd0, 0xb7, 0xe4, 0x4f, 0x4b, 0xe8, 0x2a, 0xbc, 0x2d, 0xb6, 0x96, 0x66, 0xad, 0x5a, 0x35, 0x88,
	0x85, 0x55, 0x7b, 0x07, 0xab, 0x9a, 0x62, 0x5b, 0xbb, 0x55, 0x2c, 0xff, 0x8a, 0x84, 0x6e, 0xc0,
	0xfa, 0x30, 0x35, 0xac, 0xda, 0x44, 0xd1, 0xb7, 0x30, 0x13, 0xb5, 0xa9, 0x58, 0x9a, 0xb9, 0xa9,
	0x31, 0x59, 0xff, 0xaa, 0x84, 0xae, 0xc3, 0x73, 0xc3, 0x6e, 0xc0, 0x26, 0xd8, 0x34, 0x6a, 0xa4,
	0x4c, 0xd5, 0x51, 0x33, 0x88, 0x66, 0xed, 0xca, 0x9f, 0x91, 0xd0, 0x79, 0x28, 0x24, 0x94, 0x0d,
	0xdf, 0xb3, 0xb0, 0x4e, 0x8d, 0x56, 0xfe, 0xb5, 0xe4, 0xca, 0x47, 0x4d, 0x03, 0x11, 0x7e, 0x36,
	0x29, 0xc2, 0xd0, 0xe2, 0x35, 0xdd, 0xc2, 0xe4, 0x8e, 0x52, 0x61, 0x33, 0x36, 0x77, 0x94, 0x4a,
	0x45, 0xfe, 0x5c, 0x92, 0x5e, 0x0c, 0xa7, 0x44, 0x34, 0xbc, 0x29, 0xff, 0x7a, 0x52, 0xcc, 0x94,
	0xa5, 0x8a, 0x11, 0x58, 0xb1, 0xad, 0xe9, 0x9b, 0x06, 0xd9, 0x09, 0x2c, 0xfa, 0x37, 0xa4, 0x84,
	0x31, 0x52, 0x4c, 0xa5, 0x82, 0x89, 0x65, 0xef, 0x60, 0xd3, 0x54, 0xb6, 0xb0, 0xfc, 0x9b, 0x49,
	0xb5, 0xa3, 0xc6, 0xa8, 0xa9, 0x7c, 0xc5, 0xb6, 0xb1, 0xa2, 0x62, 0x22, 0xbf, 0x99, 0x94, 0x57,
	0x95, 0x18, 0x77, 0x34, 0x15, 0xdb, 0x04, 0x6f, 0x62, 0x42, 0x30, 0x89, 0x7a, 0xc8, 0x5f, 0x90,
	0x12, 0xc6, 0xb9, 0x59, 0x31, 0xee, 0x86, 0x0a, 0xf2, 0xc5, 0xe4, 0xb2, 0x2b, 0xba, 0xa1, 0xef,
	0xee, 0xd0, 0x91, 0x54, 0xcd, 0x0c, 0x2d, 0xe5, 0x4b, 0x69, 0x5c, 0x47, 0x2c, 0xd1, 0xf9, 0xc9,
	0x5f, 0x96, 0x12, 0x2e, 0x52, 0xd4, 0x8c, 0x32, 0x26, 0xdc, 0xab, 0x61, 0xf9, 0x2b, 0x49, 0x44,
	0x4d, 0xbf, 0xa3, 0x54, 0x34, 0x75, 0x68, 0x8a, 0x5f, 0x95, 0xd0, 0x4b, 0xf0, 0x82, 0xc8, 0xb7,
	0x46, 0x4c, 0xcb, 0xde, 0x36, 0xaa, 0x76, 0x45, 0x29, 0xdf, 0x36, 0xa3, 0x87, 0x89, 0x36, 0x1f,
	0x48, 0xfe, 0x5a, 0x72, 0x32, 0x3b, 0xca, 0x3d, 0xbb, 0x44, 0xb0, 0xa2, 0x5a, 0xdb, 0x36, 0xbe,
	0x57, 0xc6, 0x98, 0x86, 0x81, 0xdf, 0x4e, 0x7a, 0x1c, 0x36, 0x19, 0x7d, 0xd3, 0xb0, 0xab, 0x4a,
	0xf9, 0x36, 0x5d, 0x81, 0x3f, 0x4e, 0x3a, 0x86, 0xb2, 0xa1, 0x9b, 0xd4, 0x27, 0xe9, 0x01, 0x85,
	0x3f, 0x49, 0x4e, 0x41, 0xf0, 0xa5, 0xd4, 0xbb, 0xdd, 0x51, 0xb4, 0x0a, 0xd3, 0xea, 0x6f, 0x26,
	0xa7, 0xc0, 0x82, 0x92, 0x45, 0x14, 0xdd, 0x54, 0xca, 0x4c, 0x37, 0x54, 0x03, 0x07, 0x7e, 0x07,
	0xdf, 0xd3, 0x4c, 0xcb, 0x94, 0xff, 0x32, 0xa9, 0xdc, 0x15, 0xc3, 0xa8, 0xda, 0x2a, 0xb6, 0x70,
	0x99, 0x46, 0x8c, 0x6f, 0x25, 0x9b, 0xa9, 0x0e, 0xee, 0x28, 0xfa, 0x2e, 0x15, 0x8b, 0x29, 0xff,
	0x55, 0x52, 0x57, 0x15, 0x55, 0xa5, 0x01, 0xcc, 0xd6, 0xf4, 0xb2, 0xb1, 0x53, 0xad, 0x60, 0x0b,
	0xcb, 0xdf, 0x4e, 0xba, 0x53, 0x65, 0xa7, 0xa4, 0x6d, 0xd5, 0x8c, 0x9a, 0x29, 0xff, 0x75, 0xb2,
	0xa9, 0x54, 0x33, 0xe9, 0x72, 0x10, 0x2c, 0xff, 0x4d, 0x92, 0x72, 0xe4, 0xe6, 0x06, 0xc1, 0xef,
	0x6f, 0x93, 0x8a, 0x1b, 0xf7, 0xa7, 0x01, 0xa1, 0xef, 0x0c, 0x8d, 0x41, 0xad, 0xf7, 0x0e, 0xd6,
	0x2d, 0xf9, 0xef, 0x46, 0xb9, 0xd2, 0x2a, 0xd6, 0x55, 0x1a, 0xe3, 0xff, 0x21, 0xb9, 0x2e, 0x35,
	0x5d, 0xc5, 0x65, 0xad, 0xba, 0x8d, 0x09, 0x13, 0xf7, 0x3f, 0x4a, 0xe8, 0x05, 0xb8, 0x1a, 0x33,
	0xeb, 0x72, 0x8d, 0xfa, 0x0c, 0x5b, 0xd9, 0x22, 0x18, 0xc7, 0xc3, 0xca, 0xf7, 0x24, 0x74, 0x05,
	0x2e, 0x25, 0xed, 0x9a, 0xfa, 0x50, 0x1a, 0xd5, 0x30, 0xb1, 0x31, 0x21, 0x06, 0x91, 0xff, 0x59,
	0x1a, 0x8a, 0xd1, 0x96, 0xad, 0x51, 0x59, 0x52, 0x72, 0x58, 0x95, 0xff, 0x45, 0x4a, 0x89, 0x7d,
	0x5b, 0x8a, 0x85, 0xef, 0x2a, 0xbb, 0xf2, 0xbf, 0x26, 0x45, 0xc2, 0x23, 0x66, 0x4c, 0x4b, 0xfe,
	0x2d, 0x39, 0x04, 0xef, 0x1d, 0x85, 0x90, 0x7f, 0x4f, 0xb2, 0x7a, 0x07, 0x13, 0xe6, 0xae, 0x98,
	0x17, 0x0d, 0xad, 0x4c, 0xfe, 0x8f, 0xa4, 0x95, 0x72, 0x8f, 0x22, 0x78, 0xf9, 0x1f, 0xcf, 0x25,
	0xfc, 0xf7, 0x56, 0xc5, 0x28, 0x29, 0x95, 0x60, 0xa1, 0xf1, 0x1d, 0x4c, 0x76, 0xef, 0xb2, 0x55,
	0xfa, 0x7a, 0x2e, 0x21, 0x69, 0x8e, 0xa7, 0xe2, 0x72, 0x45, 0xd3, 0xb1, 0xfc, 0x67, 0x39, 0xb4,
	0x01, 0xd7, 0x53, 0xda, 0x63, 0xea, 0x6c, 0x2b, 0x3a, 0xa7, 0xf7, 0xe7, 0xb9, 0xc4, 0x0c, 0x38,
	0x7e, 0x22, 0xe2, 0x7e, 0x23, 0x97, 0x94, 0x44, 0x80, 0x56, 0xd3, 0xef, 0x2a, 0x4c, 0xd8, 0x7f,
	0x31, 0x02, 0x81, 0xe0, 0x0f, 0x06, 0x06, 0xf2, 0xcd, 0xdc, 0xfa, 0x23, 0xfe, 0x87, 0x00, 0xe1,
	0x51, 0x22, 0x4f, 0x2f, 0x99, 0xd5, 0x51, 0x49, 0xd1, 0x00, 0x6e, 0x0c, 0xd2, 0xcb, 0x01, 0xbc,
	0xa6, 0x56, 0xe5, 0xcc, 0x30, 0xd8, 0x2a, 0x57, 0xe5, 0x6c, 0x0a, 0xb8, 0x62, 0xca, 0xd2, 0xba,
	0x0e, 0x72, 0xb2, 0x6c, 0x8e, 0x10, 0xcc, 0x53, 0x54, 0xdd, 0xe0, 0x9e, 0xcc, 0x0c, 0x1e, 0x58,
	0x53, 0xd8, 0xbd, 0x08, 0x94, 0x41, 0x4b, 0x41, 0xec, 0xa7, 0x1e, 0x21, 0x04, 0x66, 0xd7, 0x3d,
	0xc6, 0x6c, 0xa2, 0x22, 0x8d, 0xce, 0x07, 0x6b, 0x11, 0x04, 0x58, 0xac, 0x97, 0xc9, 0x6e, 0xd5,
	0x62, 0xfe, 0x99, 0x0a, 0xed, 0x14, 0x3a, 0x1b, 0xa4, 0x57, 0xf1, 0x66, 0xe6, 0xbb, 0xe5, 0x4c,
	0x7a, 0x5f, 0x6e, 0x05, 0x72, 0x76, 0xbd, 0x3e, 0xf8, 0x27, 0x07, 0xeb, 0xa0, 0xe3, 0xa0, 0x33,
	0xb0, 0xc2, 0x43, 0x09, 0x61, 0xa1, 0x5c, 0xc8, 0xc7, 0xd7, 0x60, 0x35, 0xde, 0x14, 0x5a, 0x8c,
	0x9c, 0x19, 0x6e, 0xa3, 0x51, 0x97, 0xb5, 0x65, 0xd7, 0x5f, 0x63, 0x73, 0x1f, 0x94, 0x29, 0x98,
	0x2c, 0xcb, 0x61, 0x86, 0x4e, 0x3d, 0x13, 0x35, 0x6e, 0x46, 0x9f, 0x82, 0xab, 0x0a, 0xb1, 0xb4,
	0xb2, 0x56, 0x55, 0x74, 0xcb, 0xfe, 0xa0, 0xa1, 0xe9, 0x58, 0x95, 0x33, 0x68, 0x1e, 0x80, 0xb6,
	0x51, 0xaf, 0x79, 0x07, 0xcb, 0x59, 0xb4, 0x0c, 0x32, 0xfd, 0x56, 0x35, 0xb3, 0x6c, 0xe8, 0x7a,
	0xb0, 0xf6, 0x12, 0x9a, 0x83, 0x19, 0x0a, 0x0d, 0x2c, 0x37, 0xb7, 0xde, 0x60, 0x6b, 0x16, 0xdf,
	0xcc, 0xa1, 0x02, 0x2c, 0x9b, 0x96, 0x19, 0x2c, 0xe4, 0x26, 0x26, 0xb6, 0xa1, 0x6f, 0x19, 0xc1,
	0xf8, 0xa7, 0x61, 0x29, 0xd6, 0xc2, 0x43, 0x64, 0x86, 0xc9, 0x57, 0x6c, 0x30, 0x6b, 0xe5, 0x32,
	0x36, 0xcd, 0xcd, 0x1a, 0x9d, 0xdd, 0x75, 0x80, 0x41, 0x05, 0x08, 0x4d, 0x43, 0x4e, 0xa7, 0x59,
	0x1c, 0x5b, 0xf1, 0xdb, 0x44, 0x33, 0xab, 0x36, 0xd6, 0xe9, 0x32, 0xa9, 0x72, 0x66, 0x7d, 0x93,
	0x29, 0x4b, 0xac, 0xdc, 0x83, 0x16, 0x20, 0x6f, 0x96, 0x55, 0x41, 0xca, 0x1c, 0x30, 0x78, 0x88,
	0x2f, 0xc3, 0x2c, 0x05, 0x0c, 0x9e, 0xe1, 0xdf, 0xfc, 0xd3, 0x3c, 0x48, 0xa6, 0x56, 0x45, 0x55,
	0x98, 0x15, 0xaf, 0x63, 0xa3, 0x73, 0xb1, 0xfb, 0x2d, 0x89, 0x5b, 0xbb, 0x6b, 0xe7, 0x47, 0xb4,
	0x06, 0xd7, 0x11, 0x8a, 0xd2, 0x93, 0x6c, 0x06, 0x7d, 0x58, 0xf8, 0xff, 0x19, 0xf1, 0xaa, 0x33,
	0xba, 0x32, 0x7c, 0x44, 0x95, 0x72, 0x73, 0x7b, 0x6d, 0xec, 0x5d, 0x69, 0x64, 0xc3, 0x6a, 0xfa,
	0x9b, 0x3e, 0x74, 0x75, 0x98, 0x7c, 0xda, 0x3d, 0xea, 0xb5, 0xf1, 0x17, 0x97, 0x29, 0xfb, 0xa9,
	0x7f, 0x23, 0x20, 0xb0, 0x3f, 0xee, 0x6f, 0x06, 0x0e, 0x67, 0x3f, 0xfd, 0xed, 0xa0, 0xc0, 0xfe,
	0xd8, 0xc7, 0x85, 0x87, 0xb1, 0xff, 0x83, 0x80, 0x86, 0x1f, 0x22, 0xa0, 0xc1, 0xfd, 0xdd, 0x91,
	0x8f, 0x1c, 0xd6, 0x2e, 0x8f, 0xc5, 0xe1, 0x17, 0x4e, 0x7e, 0x18, 0x96, 0x52, 0x5e, 0x15, 0xa0,
	0x64, 0xdf, 0x54, 0xce, 0x9f, 0x1b, 0x8f, 0x34, 0x18, 0x21, 0xe5, 0x62, 0xbd, 0x30, 0xc2, 0xe8,
	0x4b, 0xff, 0xc2, 0x08, 0xe3, 0xee, 0xe6, 0x37, 0xa2, 0x17, 0x08, 0xf1, 0x49, 0x0c, 0xf5, 0x4e,
	0x9d, 0xc5, 0x95, 0x43, 0xb0, 0xf8, 0x20, 0x5b, 0x30, 0x1f, 0xbf, 0xf8, 0x8e, 0x2e, 0x08, 0x87,
	0x6d, 0x29, 0x37, 0xe2, 0xd7, 0xd2, 0x5f, 0x3c, 0xc4, 0xcc, 0x29, 0x76, 0x13, 0xfc, 0xca, 0x91,
	0xee, 0xdc, 0xae, 0x8d, 0xbd, 0x13, 0x14, 0xd3, 0xf6, 0x11, 0xd4, 0xc7, 0xdd, 0x62, 0x3d, 0x84,
	0xfa, 0x60, 0x2d, 0x63, 0xb4, 0x87, 0xd6, 0x32, 0x8d, 0xf2, 0x73, 0xe3, 0x91, 0xb8, 0x98, 0x3f,
	0x2c, 0xbc, 0x2f, 0x18, 0xc1, 0xff, 0xb8, 0xcb, 0x4e, 0x87, 0xf0, 0xbf, 0x0b, 0xcb, 0x69, 0xa7,
	0xe9, 0x82, 0xa6, 0x8c, 0x39, 0x6c, 0x5f, 0x8b, 0x1d, 0x10, 0x27, 0x0f, 0x25, 0xef, 0xc1, 0x6a,
	0xfa, 0x69, 0x99, 0xe0, 0x08, 0xc6, 0x1e, 0xa7, 0xad, 0xad, 0x0e, 0x15, 0x84, 0xf1, 0x7e, 0xc7,
	0x3f, 0x28, 0x6d, 0x7e, 0xe8, 0xf2, 0x9e, 0xeb, 0x3f, 0xec, 0xdf, 0xdf, 0x68, 0x78, 0xfb, 0x37,
	0x38, 0xad, 0xe0, 0xcf, 0xcb, 0x1a, 0x5e, 0x2b, 0x04, 0x7c, 0x3e, 0x3b, 0x57, 0x71, 0x1f, 0x3b,
	0xb7, 0x83, 0xaa, 0xb0, 0xef, 0xfd, 0x7d, 0x76, 0x9e, 0x7f, 0xdf, 0xba, 0xc5, 0x00, 0xf7, 0x27,
	0x59, 0x97, 0x97, 0xff, 0x3b, 0x00, 0x00, 0xff, 0xff, 0x39, 0x41, 0x3c, 0x10, 0x56, 0x4d, 0x00,
	0x00,
}
