more china sites

http bug fixes & disable keep-alive

.travis.yml

@@ -1,7 +1,7 @@
 language: go
 
 go:
-  - 1.5.1
+  - 1.5.2
   
 before_install:
   - go get github.com/axw/gocov/gocov
@@ -9,13 +9,15 @@ before_install:
   - go get github.com/mattn/goveralls
 
 script:
-    - go test github.com/v2ray/v2ray-core/...
-    - ./testing/coverage/coverall
+  - go test github.com/v2ray/v2ray-core/...
+  - ./testing/coverage/coverall
 
 env:
   secure: "nnEiGTuS8SsSFRpxUsPh6hmx/OfPDA6AO3OX7IpjPCbkQnjuFEsm3DfPEZOHTiYra00Ea3bNw9ePLPqyWdLAPmcLoUBhWRyfevt9m3jrbyrT8O9MCXNDY6i1ll3E43nx8kxRDF1QbYaSK4jppa8Vu2vyZH5+GiS0JVcw/7CfX8TyUMbDuyaQXYQ1kwixlThQZH43xxQ7u5CFF1pBFdwpkuDm2/wKUE+0CGZOeWzUYI8h1in4eY0Vse4Zt4GqS2eywf4rw12bBysZ21UnT/xu990m5nzAScbUGjloplJNpdZGtD8SBTGujZBMMUzKi/E0zJkdEf37MZ9rsarfv6v9khdwTp/8VoAiZxpG1IDISIu0TClAjw8NYO5hmuF01/oJexMuxqRhMPwbk1nPsustlBKEG3zjvW5yILMkiaRl67Pj+9h21zMGYmwPGka7Ollh9ki2h17RFNuj9Yxm5XX2xvZDIvtxL1a8S50vv7VZTT9rrrFMhGP7ty9gj2opjJ7QBgwi2W/eVGhfshfnZJjJ7Bqf+gl1MDOYcTlqmFe5JvKdIO9mN7gskJizmeFxh31LrZ2sCY71/iicGj7gZJ4e/u2/dI2OVfFWTTbHoiIyCLvvrA18zBF9Sky1Y3QDj85GdRtC0SI6TXJLAIa7jNgF6Nr2mAg044DaX9VW0VH0VnE="
 
-before_deploy: "./release/release.sh"
+before_deploy:
+  - rvm 1.9.3 do gem install mime-types -v 2.6.2
+  - "./release/release.sh"
 
 deploy:
   provider: releases
@@ -29,6 +31,7 @@ deploy:
     - "$GOPATH/bin/v2ray-linux-32.zip"
     - "$GOPATH/bin/v2ray-linux-arm.zip"
     - "$GOPATH/bin/v2ray-linux-arm64.zip"
+    - "$GOPATH/bin/metadata.txt"
   skip_cleanup: true
   on:
     tags: true

LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2015 V2Ray
+Copyright (c) 2015-2016 V2Ray
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -5,11 +5,11 @@
 [![Coverage Status](https://coveralls.io/repos/v2ray/v2ray-core/badge.svg?branch=master&service=github)](https://coveralls.io/github/v2ray/v2ray-core?branch=master)
 [![GoDoc](https://godoc.org/github.com/v2ray/v2ray-core?status.svg)](https://godoc.org/github.com/v2ray/v2ray-core)
 
-[中文](https://github.com/V2Ray/v2ray-core/blob/master/README.md) | [English](https://github.com/V2Ray/v2ray-core/blob/master/spec/en/README.md)
-
 V2Ray 是一个模块化的代理软件包，它的目标是提供常用的代理软件模块，简化网络代理软件的开发。
 
-[官方网站](https://www.v2ray.com/)
+[官方网站](https://www.v2ray.com/) | [Wiki](https://github.com/v2ray/v2ray.github.io/wiki)
+
+V2Ray provides building blocks for network proxy development. Read our [Wiki](https://github.com/v2ray/v2ray.github.io/wiki/en-us:Home) for more information.
 
 ## License
 [The MIT License (MIT)](https://raw.githubusercontent.com/v2ray/v2ray-core/master/LICENSE)

app/controller/controller.go

@@ -0,0 +1,41 @@
+package controller
+
+import (
+	"github.com/v2ray/v2ray-core/app"
+	"github.com/v2ray/v2ray-core/app/internal"
+)
+
+// A SpaceController is supposed to be used by a shell to create Spaces. It should not be used
+// directly by proxies.
+type SpaceController struct {
+	packetDispatcher      internal.PacketDispatcherWithContext
+	dnsCache              internal.DnsCacheWithContext
+	pubsub                internal.PubsubWithContext
+	inboundHandlerManager internal.InboundHandlerManagerWithContext
+}
+
+func New() *SpaceController {
+	return new(SpaceController)
+}
+
+func (this *SpaceController) Bind(object interface{}) {
+	if packetDispatcher, ok := object.(internal.PacketDispatcherWithContext); ok {
+		this.packetDispatcher = packetDispatcher
+	}
+
+	if dnsCache, ok := object.(internal.DnsCacheWithContext); ok {
+		this.dnsCache = dnsCache
+	}
+
+	if pubsub, ok := object.(internal.PubsubWithContext); ok {
+		this.pubsub = pubsub
+	}
+
+	if inboundHandlerManager, ok := object.(internal.InboundHandlerManagerWithContext); ok {
+		this.inboundHandlerManager = inboundHandlerManager
+	}
+}
+
+func (this *SpaceController) ForContext(tag string) app.Space {
+	return internal.NewSpace(tag, this.packetDispatcher, this.dnsCache, this.pubsub, this.inboundHandlerManager)
+}

app/dns.go

@@ -0,0 +1,11 @@
+package app
+
+import (
+	"net"
+)
+
+// A DnsCache is an internal cache of DNS resolutions.
+type DnsCache interface {
+	Get(domain string) net.IP
+	Add(domain string, ip net.IP)
+}

app/dns/config.go

@@ -0,0 +1,5 @@
+package dns
+
+type CacheConfig interface {
+	IsTrustedSource(tag string) bool
+}

app/dns/dns.go

@@ -0,0 +1,62 @@
+package dns
+
+import (
+	"net"
+	"time"
+
+	"github.com/v2ray/v2ray-core/app"
+	"github.com/v2ray/v2ray-core/common/collect"
+	"github.com/v2ray/v2ray-core/common/serial"
+)
+
+type entry struct {
+	domain     string
+	ip         net.IP
+	validUntil time.Time
+}
+
+func newEntry(domain string, ip net.IP) *entry {
+	this := &entry{
+		domain: domain,
+		ip:     ip,
+	}
+	this.Extend()
+	return this
+}
+
+func (this *entry) IsValid() bool {
+	return this.validUntil.After(time.Now())
+}
+
+func (this *entry) Extend() {
+	this.validUntil = time.Now().Add(time.Hour)
+}
+
+type DnsCache struct {
+	cache  *collect.ValidityMap
+	config CacheConfig
+}
+
+func NewCache(config CacheConfig) *DnsCache {
+	cache := &DnsCache{
+		cache:  collect.NewValidityMap(3600),
+		config: config,
+	}
+	return cache
+}
+
+func (this *DnsCache) Add(context app.Context, domain string, ip net.IP) {
+	callerTag := context.CallerTag()
+	if !this.config.IsTrustedSource(callerTag) {
+		return
+	}
+
+	this.cache.Set(serial.StringLiteral(domain), newEntry(domain, ip))
+}
+
+func (this *DnsCache) Get(context app.Context, domain string) net.IP {
+	if value := this.cache.Get(serial.StringLiteral(domain)); value != nil {
+		return value.(*entry).ip
+	}
+	return nil
+}

app/dns/dns_test.go

@@ -0,0 +1,33 @@
+package dns_test
+
+import (
+	"net"
+	"testing"
+
+	"github.com/v2ray/v2ray-core/app/dns"
+	dnstesting "github.com/v2ray/v2ray-core/app/dns/testing"
+	apptesting "github.com/v2ray/v2ray-core/app/testing"
+	netassert "github.com/v2ray/v2ray-core/common/net/testing/assert"
+	v2testing "github.com/v2ray/v2ray-core/testing"
+)
+
+func TestDnsAdd(t *testing.T) {
+	v2testing.Current(t)
+
+	domain := "v2ray.com"
+	cache := dns.NewCache(&dnstesting.CacheConfig{
+		TrustedTags: map[string]bool{
+			"testtag": true,
+		},
+	})
+	ip := cache.Get(&apptesting.Context{}, domain)
+	netassert.IP(ip).IsNil()
+
+	cache.Add(&apptesting.Context{CallerTagValue: "notvalidtag"}, domain, []byte{1, 2, 3, 4})
+	ip = cache.Get(&apptesting.Context{}, domain)
+	netassert.IP(ip).IsNil()
+
+	cache.Add(&apptesting.Context{CallerTagValue: "testtag"}, domain, []byte{1, 2, 3, 4})
+	ip = cache.Get(&apptesting.Context{}, domain)
+	netassert.IP(ip).Equals(net.IP([]byte{1, 2, 3, 4}))
+}

app/dns/json/config.go

@@ -0,0 +1,35 @@
+package json
+
+import (
+	"strings"
+
+	serialjson "github.com/v2ray/v2ray-core/common/serial/json"
+)
+
+type TagList map[string]bool
+
+func NewTagList(tags []string) TagList {
+	list := TagList(make(map[string]bool))
+	for _, tag := range tags {
+		list[strings.TrimSpace(tag)] = true
+	}
+	return list
+}
+
+func (this *TagList) UnmarshalJSON(data []byte) error {
+	tags, err := serialjson.UnmarshalStringList(data)
+	if err != nil {
+		return err
+	}
+	*this = NewTagList(tags)
+	return nil
+}
+
+type CacheConfig struct {
+	TrustedTags TagList `json:"trustedTags"`
+}
+
+func (this *CacheConfig) IsTrustedSource(tag string) bool {
+	_, found := this.TrustedTags[tag]
+	return found
+}

app/dns/testing/config.go

@@ -0,0 +1,10 @@
+package testing
+
+type CacheConfig struct {
+	TrustedTags map[string]bool
+}
+
+func (this *CacheConfig) IsTrustedSource(tag string) bool {
+	_, found := this.TrustedTags[tag]
+	return found
+}

app/handlers.go

@@ -0,0 +1,9 @@
+package app
+
+import (
+	"github.com/v2ray/v2ray-core/proxy"
+)
+
+type InboundHandlerManager interface {
+	GetHandler(tag string) (proxy.InboundConnectionHandler, int)
+}

app/internal/context.go

@@ -0,0 +1,9 @@
+package internal
+
+type contextImpl struct {
+	callerTag string
+}
+
+func (this *contextImpl) CallerTag() string {
+	return this.callerTag
+}

app/internal/dns.go

@@ -0,0 +1,25 @@
+package internal
+
+import (
+	"net"
+
+	"github.com/v2ray/v2ray-core/app"
+)
+
+type DnsCacheWithContext interface {
+	Get(context app.Context, domain string) net.IP
+	Add(contaxt app.Context, domain string, ip net.IP)
+}
+
+type contextedDnsCache struct {
+	context  app.Context
+	dnsCache DnsCacheWithContext
+}
+
+func (this *contextedDnsCache) Get(domain string) net.IP {
+	return this.dnsCache.Get(this.context, domain)
+}
+
+func (this *contextedDnsCache) Add(domain string, ip net.IP) {
+	this.dnsCache.Add(this.context, domain, ip)
+}

app/internal/handlers.go

@@ -0,0 +1,19 @@
+package internal
+
+import (
+	"github.com/v2ray/v2ray-core/app"
+	"github.com/v2ray/v2ray-core/proxy"
+)
+
+type InboundHandlerManagerWithContext interface {
+	GetHandler(context app.Context, tag string) (proxy.InboundConnectionHandler, int)
+}
+
+type inboundHandlerManagerWithContext struct {
+	context app.Context
+	manager InboundHandlerManagerWithContext
+}
+
+func (this *inboundHandlerManagerWithContext) GetHandler(tag string) (proxy.InboundConnectionHandler, int) {
+	return this.manager.GetHandler(this.context, tag)
+}

app/internal/packet_dispatcher.go

@@ -0,0 +1,20 @@
+package internal
+
+import (
+	"github.com/v2ray/v2ray-core/app"
+	v2net "github.com/v2ray/v2ray-core/common/net"
+	"github.com/v2ray/v2ray-core/transport/ray"
+)
+
+type PacketDispatcherWithContext interface {
+	DispatchToOutbound(context app.Context, packet v2net.Packet) ray.InboundRay
+}
+
+type contextedPacketDispatcher struct {
+	context          app.Context
+	packetDispatcher PacketDispatcherWithContext
+}
+
+func (this *contextedPacketDispatcher) DispatchToOutbound(packet v2net.Packet) ray.InboundRay {
+	return this.packetDispatcher.DispatchToOutbound(this.context, packet)
+}

app/internal/pubsub.go

@@ -0,0 +1,23 @@
+package internal
+
+import (
+	"github.com/v2ray/v2ray-core/app"
+)
+
+type PubsubWithContext interface {
+	Publish(context app.Context, topic string, message app.PubsubMessage)
+	Subscribe(context app.Context, topic string, handler app.TopicHandler)
+}
+
+type contextedPubsub struct {
+	context app.Context
+	pubsub  PubsubWithContext
+}
+
+func (this *contextedPubsub) Publish(topic string, message app.PubsubMessage) {
+	this.pubsub.Publish(this.context, topic, message)
+}
+
+func (this *contextedPubsub) Subscribe(topic string, handler app.TopicHandler) {
+	this.pubsub.Subscribe(this.context, topic, handler)
+}

app/internal/space.go

@@ -0,0 +1,75 @@
+package internal
+
+import (
+	"github.com/v2ray/v2ray-core/app"
+)
+
+type Space struct {
+	packetDispatcher      PacketDispatcherWithContext
+	dnsCache              DnsCacheWithContext
+	pubsub                PubsubWithContext
+	inboundHandlerManager InboundHandlerManagerWithContext
+	tag                   string
+}
+
+func NewSpace(tag string, packetDispatcher PacketDispatcherWithContext, dnsCache DnsCacheWithContext, pubsub PubsubWithContext, inboundHandlerManager InboundHandlerManagerWithContext) *Space {
+	return &Space{
+		tag:                   tag,
+		packetDispatcher:      packetDispatcher,
+		dnsCache:              dnsCache,
+		pubsub:                pubsub,
+		inboundHandlerManager: inboundHandlerManager,
+	}
+}
+
+func (this *Space) HasPacketDispatcher() bool {
+	return this.packetDispatcher != nil
+}
+
+func (this *Space) PacketDispatcher() app.PacketDispatcher {
+	return &contextedPacketDispatcher{
+		packetDispatcher: this.packetDispatcher,
+		context: &contextImpl{
+			callerTag: this.tag,
+		},
+	}
+}
+
+func (this *Space) HasDnsCache() bool {
+	return this.dnsCache != nil
+}
+
+func (this *Space) DnsCache() app.DnsCache {
+	return &contextedDnsCache{
+		dnsCache: this.dnsCache,
+		context: &contextImpl{
+			callerTag: this.tag,
+		},
+	}
+}
+
+func (this *Space) HasPubsub() bool {
+	return this.pubsub != nil
+}
+
+func (this *Space) Pubsub() app.Pubsub {
+	return &contextedPubsub{
+		pubsub: this.pubsub,
+		context: &contextImpl{
+			callerTag: this.tag,
+		},
+	}
+}
+
+func (this *Space) HasInboundHandlerManager() bool {
+	return this.inboundHandlerManager != nil
+}
+
+func (this *Space) InboundHandlerManager() app.InboundHandlerManager {
+	return &inboundHandlerManagerWithContext{
+		manager: this.inboundHandlerManager,
+		context: &contextImpl{
+			callerTag: this.tag,
+		},
+	}
+}

app/point/config/config.go

@@ -1,39 +0,0 @@
-package config
-
-import (
-	routerconfig "github.com/v2ray/v2ray-core/app/router/config"
-	v2net "github.com/v2ray/v2ray-core/common/net"
-)
-
-type DetourTag string
-
-type ConnectionConfig interface {
-	Protocol() string
-	Settings() interface{}
-}
-
-type LogConfig interface {
-	AccessLog() string
-}
-
-type InboundDetourConfig interface {
-	Protocol() string
-	PortRange() v2net.PortRange
-	Settings() interface{}
-}
-
-type OutboundDetourConfig interface {
-	Protocol() string
-	Tag() DetourTag
-	Settings() interface{}
-}
-
-type PointConfig interface {
-	Port() uint16
-	LogConfig() LogConfig
-	RouterConfig() routerconfig.RouterConfig
-	InboundConfig() ConnectionConfig
-	OutboundConfig() ConnectionConfig
-	InboundDetours() []InboundDetourConfig
-	OutboundDetours() []OutboundDetourConfig
-}

app/point/config/json/connection.go

@@ -1,36 +0,0 @@
-package json
-
-import (
-	"encoding/json"
-
-	"github.com/v2ray/v2ray-core/common/log"
-	proxyconfig "github.com/v2ray/v2ray-core/proxy/common/config"
-	proxyjson "github.com/v2ray/v2ray-core/proxy/common/config/json"
-)
-
-type ConnectionConfig struct {
-	ProtocolString  string           `json:"protocol"`
-	SettingsMessage json.RawMessage  `json:"settings"`
-	Type            proxyconfig.Type `json:"-"`
-}
-
-func (c *ConnectionConfig) Protocol() string {
-	return c.ProtocolString
-}
-
-func (c *ConnectionConfig) Settings() interface{} {
-	return loadConnectionConfig(c.SettingsMessage, c.Protocol(), c.Type)
-}
-
-func loadConnectionConfig(message json.RawMessage, protocol string, cType proxyconfig.Type) interface{} {
-	configObj := proxyjson.CreateConfig(protocol, cType)
-	if configObj == nil {
-		panic("Unknown protocol " + protocol)
-	}
-	err := json.Unmarshal(message, configObj)
-	if err != nil {
-		log.Error("Unable to parse connection config: %v", err)
-		panic("Failed to parse connection config.")
-	}
-	return configObj
-}

app/point/config/json/inbound_detour.go

@@ -1,27 +0,0 @@
-package json
-
-import (
-	"encoding/json"
-
-	v2net "github.com/v2ray/v2ray-core/common/net"
-	v2netjson "github.com/v2ray/v2ray-core/common/net/json"
-	proxyconfig "github.com/v2ray/v2ray-core/proxy/common/config"
-)
-
-type InboundDetourConfig struct {
-	ProtocolValue  string               `json:"protocol"`
-	PortRangeValue *v2netjson.PortRange `json:"port"`
-	SettingsValue  json.RawMessage      `json:"settings"`
-}
-
-func (this *InboundDetourConfig) Protocol() string {
-	return this.ProtocolValue
-}
-
-func (this *InboundDetourConfig) PortRange() v2net.PortRange {
-	return this.PortRangeValue
-}
-
-func (this *InboundDetourConfig) Settings() interface{} {
-	return loadConnectionConfig(this.SettingsValue, this.ProtocolValue, proxyconfig.TypeInbound)
-}

app/point/config/json/json.go

@@ -1,93 +0,0 @@
-package json
-
-import (
-	"encoding/json"
-	"io/ioutil"
-	"os"
-
-	"github.com/v2ray/v2ray-core/app/point/config"
-	routerconfig "github.com/v2ray/v2ray-core/app/router/config"
-	routerconfigjson "github.com/v2ray/v2ray-core/app/router/config/json"
-	"github.com/v2ray/v2ray-core/common/log"
-	proxyconfig "github.com/v2ray/v2ray-core/proxy/common/config"
-)
-
-// Config is the config for Point server.
-type Config struct {
-	PortValue            uint16                         `json:"port"` // Port of this Point server.
-	LogConfigValue       *LogConfig                     `json:"log"`
-	RouterConfigValue    *routerconfigjson.RouterConfig `json:"routing"`
-	InboundConfigValue   *ConnectionConfig              `json:"inbound"`
-	OutboundConfigValue  *ConnectionConfig              `json:"outbound"`
-	InboundDetoursValue  []*InboundDetourConfig         `json:"inboundDetour"`
-	OutboundDetoursValue []*OutboundDetourConfig        `json:"outboundDetour"`
-}
-
-func (config *Config) Port() uint16 {
-	return config.PortValue
-}
-
-func (config *Config) LogConfig() config.LogConfig {
-	if config.LogConfigValue == nil {
-		return nil
-	}
-	return config.LogConfigValue
-}
-
-func (this *Config) RouterConfig() routerconfig.RouterConfig {
-	if this.RouterConfigValue == nil {
-		return nil
-	}
-	return this.RouterConfigValue
-}
-
-func (config *Config) InboundConfig() config.ConnectionConfig {
-	if config.InboundConfigValue == nil {
-		return nil
-	}
-	return config.InboundConfigValue
-}
-
-func (config *Config) OutboundConfig() config.ConnectionConfig {
-	if config.OutboundConfigValue == nil {
-		return nil
-	}
-	return config.OutboundConfigValue
-}
-
-func (this *Config) InboundDetours() []config.InboundDetourConfig {
-	detours := make([]config.InboundDetourConfig, len(this.InboundDetoursValue))
-	for idx, detour := range this.InboundDetoursValue {
-		detours[idx] = detour
-	}
-	return detours
-}
-
-func (this *Config) OutboundDetours() []config.OutboundDetourConfig {
-	detours := make([]config.OutboundDetourConfig, len(this.OutboundDetoursValue))
-	for idx, detour := range this.OutboundDetoursValue {
-		detours[idx] = detour
-	}
-	return detours
-}
-
-func LoadConfig(file string) (*Config, error) {
-	fixedFile := os.ExpandEnv(file)
-	rawConfig, err := ioutil.ReadFile(fixedFile)
-	if err != nil {
-		log.Error("Failed to read server config file (%s): %v", file, err)
-		return nil, err
-	}
-
-	jsonConfig := &Config{}
-	err = json.Unmarshal(rawConfig, jsonConfig)
-	if err != nil {
-		log.Error("Failed to load server config: %v", err)
-		return nil, err
-	}
-
-	jsonConfig.InboundConfigValue.Type = proxyconfig.TypeInbound
-	jsonConfig.OutboundConfigValue.Type = proxyconfig.TypeOutbound
-
-	return jsonConfig, err
-}

app/point/config/json/json_test.go

@@ -1,73 +0,0 @@
-package json_test
-
-import (
-	"path/filepath"
-	"testing"
-
-	"github.com/v2ray/v2ray-core/app/point/config/json"
-	_ "github.com/v2ray/v2ray-core/proxy/dokodemo/config/json"
-	_ "github.com/v2ray/v2ray-core/proxy/freedom/config/json"
-	_ "github.com/v2ray/v2ray-core/proxy/socks/config/json"
-	_ "github.com/v2ray/v2ray-core/proxy/vmess/config/json"
-
-	"github.com/v2ray/v2ray-core/testing/unit"
-)
-
-func TestClientSampleConfig(t *testing.T) {
-	assert := unit.Assert(t)
-
-	// TODO: fix for Windows
-	baseDir := "$GOPATH/src/github.com/v2ray/v2ray-core/release/config"
-
-	pointConfig, err := json.LoadConfig(filepath.Join(baseDir, "vpoint_socks_vmess.json"))
-	assert.Error(err).IsNil()
-
-	assert.Uint16(pointConfig.Port()).Positive()
-	assert.Pointer(pointConfig.InboundConfig()).IsNotNil()
-	assert.Pointer(pointConfig.OutboundConfig()).IsNotNil()
-
-	assert.String(pointConfig.InboundConfig().Protocol()).Equals("socks")
-	assert.Pointer(pointConfig.InboundConfig().Settings()).IsNotNil()
-
-	assert.String(pointConfig.OutboundConfig().Protocol()).Equals("vmess")
-	assert.Pointer(pointConfig.OutboundConfig().Settings()).IsNotNil()
-}
-
-func TestServerSampleConfig(t *testing.T) {
-	assert := unit.Assert(t)
-
-	// TODO: fix for Windows
-	baseDir := "$GOPATH/src/github.com/v2ray/v2ray-core/release/config"
-
-	pointConfig, err := json.LoadConfig(filepath.Join(baseDir, "vpoint_vmess_freedom.json"))
-	assert.Error(err).IsNil()
-
-	assert.Uint16(pointConfig.Port()).Positive()
-	assert.Pointer(pointConfig.InboundConfig()).IsNotNil()
-	assert.Pointer(pointConfig.OutboundConfig()).IsNotNil()
-
-	assert.String(pointConfig.InboundConfig().Protocol()).Equals("vmess")
-	assert.Pointer(pointConfig.InboundConfig().Settings()).IsNotNil()
-
-	assert.String(pointConfig.OutboundConfig().Protocol()).Equals("freedom")
-	assert.Pointer(pointConfig.OutboundConfig().Settings()).IsNotNil()
-}
-
-func TestDetourConfig(t *testing.T) {
-	assert := unit.Assert(t)
-
-	// TODO: fix for Windows
-	baseDir := "$GOPATH/src/github.com/v2ray/v2ray-core/release/config"
-
-	pointConfig, err := json.LoadConfig(filepath.Join(baseDir, "vpoint_dns_detour.json"))
-	assert.Error(err).IsNil()
-
-	detours := pointConfig.InboundDetours()
-	assert.Int(len(detours)).Equals(1)
-
-	detour := detours[0]
-	assert.String(detour.Protocol()).Equals("dokodemo-door")
-	assert.Uint16(detour.PortRange().From()).Equals(uint16(28394))
-	assert.Uint16(detour.PortRange().To()).Equals(uint16(28394))
-	assert.Pointer(detour.Settings()).IsNotNil()
-}

app/point/config/json/log.go

@@ -1,9 +0,0 @@
-package json
-
-type LogConfig struct {
-	AccessLogValue string `json:"access"`
-}
-
-func (config *LogConfig) AccessLog() string {
-	return config.AccessLogValue
-}

app/point/config/json/outbound_detour.go

@@ -1,26 +0,0 @@
-package json
-
-import (
-	"encoding/json"
-
-	"github.com/v2ray/v2ray-core/app/point/config"
-	proxyconfig "github.com/v2ray/v2ray-core/proxy/common/config"
-)
-
-type OutboundDetourConfig struct {
-	ProtocolValue string          `json:"protocol"`
-	TagValue      string          `json:"tag"`
-	SettingsValue json.RawMessage `json:"settings"`
-}
-
-func (this *OutboundDetourConfig) Protocol() string {
-	return this.ProtocolValue
-}
-
-func (this *OutboundDetourConfig) Tag() config.DetourTag {
-	return config.DetourTag(this.TagValue)
-}
-
-func (this *OutboundDetourConfig) Settings() interface{} {
-	return loadConnectionConfig(this.SettingsValue, this.ProtocolValue, proxyconfig.TypeOutbound)
-}

app/point/config/testing/mocks/config.go

@@ -1,105 +0,0 @@
-package mocks
-
-import (
-	"github.com/v2ray/v2ray-core/app/point/config"
-	routerconfig "github.com/v2ray/v2ray-core/app/router/config"
-	v2net "github.com/v2ray/v2ray-core/common/net"
-)
-
-type ConnectionConfig struct {
-	ProtocolValue string
-	SettingsValue interface{}
-}
-
-func (config *ConnectionConfig) Protocol() string {
-	return config.ProtocolValue
-}
-
-func (config *ConnectionConfig) Settings() interface{} {
-	return config.SettingsValue
-}
-
-type LogConfig struct {
-	AccessLogValue string
-}
-
-type PortRange struct {
-	FromValue uint16
-	ToValue   uint16
-}
-
-func (this *PortRange) From() uint16 {
-	return this.FromValue
-}
-
-func (this *PortRange) To() uint16 {
-	return this.ToValue
-}
-
-type InboundDetourConfig struct {
-	ConnectionConfig
-	PortRangeValue *PortRange
-}
-
-func (this *InboundDetourConfig) PortRange() v2net.PortRange {
-	return this.PortRangeValue
-}
-
-type OutboundDetourConfig struct {
-	ConnectionConfig
-	TagValue config.DetourTag
-}
-
-func (this *OutboundDetourConfig) Tag() config.DetourTag {
-	return this.TagValue
-}
-
-func (config *LogConfig) AccessLog() string {
-	return config.AccessLogValue
-}
-
-type Config struct {
-	PortValue            uint16
-	LogConfigValue       *LogConfig
-	RouterConfigValue    routerconfig.RouterConfig
-	InboundConfigValue   *ConnectionConfig
-	OutboundConfigValue  *ConnectionConfig
-	InboundDetoursValue  []*InboundDetourConfig
-	OutboundDetoursValue []*OutboundDetourConfig
-}
-
-func (config *Config) Port() uint16 {
-	return config.PortValue
-}
-
-func (config *Config) LogConfig() config.LogConfig {
-	return config.LogConfigValue
-}
-
-func (this *Config) RouterConfig() routerconfig.RouterConfig {
-	return this.RouterConfigValue
-}
-
-func (config *Config) InboundConfig() config.ConnectionConfig {
-	return config.InboundConfigValue
-}
-
-func (config *Config) OutboundConfig() config.ConnectionConfig {
-	return config.OutboundConfigValue
-}
-
-func (this *Config) InboundDetours() []config.InboundDetourConfig {
-	detours := make([]config.InboundDetourConfig, len(this.InboundDetoursValue))
-	for idx, detour := range this.InboundDetoursValue {
-		detours[idx] = detour
-	}
-	return detours
-}
-
-func (this *Config) OutboundDetours() []config.OutboundDetourConfig {
-	detours := make([]config.OutboundDetourConfig, len(this.OutboundDetoursValue))
-	for idx, detour := range this.OutboundDetoursValue {
-		detours[idx] = detour
-	}
-	return detours
-}

app/point/point.go

@@ -1,149 +0,0 @@
-package point
-
-import (
-	"github.com/v2ray/v2ray-core/app/point/config"
-	"github.com/v2ray/v2ray-core/app/router"
-	"github.com/v2ray/v2ray-core/common/log"
-	v2net "github.com/v2ray/v2ray-core/common/net"
-	"github.com/v2ray/v2ray-core/common/retry"
-	"github.com/v2ray/v2ray-core/proxy/common/connhandler"
-	"github.com/v2ray/v2ray-core/transport/ray"
-)
-
-// Point is an single server in V2Ray system.
-type Point struct {
-	port   uint16
-	ich    connhandler.InboundConnectionHandler
-	och    connhandler.OutboundConnectionHandler
-	idh    []*InboundDetourHandler
-	odh    map[config.DetourTag]connhandler.OutboundConnectionHandler
-	router router.Router
-}
-
-// NewPoint returns a new Point server based on given configuration.
-// The server is not started at this point.
-func NewPoint(pConfig config.PointConfig) (*Point, error) {
-	var vpoint = new(Point)
-	vpoint.port = pConfig.Port()
-
-	ichFactory := connhandler.GetInboundConnectionHandlerFactory(pConfig.InboundConfig().Protocol())
-	if ichFactory == nil {
-		log.Error("Unknown inbound connection handler factory %s", pConfig.InboundConfig().Protocol())
-		return nil, config.BadConfiguration
-	}
-	ichConfig := pConfig.InboundConfig().Settings()
-	ich, err := ichFactory.Create(vpoint, ichConfig)
-	if err != nil {
-		log.Error("Failed to create inbound connection handler: %v", err)
-		return nil, err
-	}
-	vpoint.ich = ich
-
-	ochFactory := connhandler.GetOutboundConnectionHandlerFactory(pConfig.OutboundConfig().Protocol())
-	if ochFactory == nil {
-		log.Error("Unknown outbound connection handler factory %s", pConfig.OutboundConfig().Protocol())
-		return nil, config.BadConfiguration
-	}
-	ochConfig := pConfig.OutboundConfig().Settings()
-	och, err := ochFactory.Create(ochConfig)
-	if err != nil {
-		log.Error("Failed to create outbound connection handler: %v", err)
-		return nil, err
-	}
-	vpoint.och = och
-
-	detours := pConfig.InboundDetours()
-	if len(detours) > 0 {
-		vpoint.idh = make([]*InboundDetourHandler, len(detours))
-		for idx, detourConfig := range detours {
-			detourHandler := &InboundDetourHandler{
-				point:  vpoint,
-				config: detourConfig,
-			}
-			err := detourHandler.Initialize()
-			if err != nil {
-				return nil, err
-			}
-			vpoint.idh[idx] = detourHandler
-		}
-	}
-
-	outboundDetours := pConfig.OutboundDetours()
-	if len(outboundDetours) > 0 {
-		vpoint.odh = make(map[config.DetourTag]connhandler.OutboundConnectionHandler)
-		for _, detourConfig := range outboundDetours {
-			detourFactory := connhandler.GetOutboundConnectionHandlerFactory(detourConfig.Protocol())
-			if detourFactory == nil {
-				log.Error("Unknown detour outbound connection handler factory %s", detourConfig.Protocol())
-				return nil, config.BadConfiguration
-			}
-			detourHandler, err := detourFactory.Create(detourConfig.Settings())
-			if err != nil {
-				log.Error("Failed to create detour outbound connection handler: %v", err)
-				return nil, err
-			}
-			vpoint.odh[detourConfig.Tag()] = detourHandler
-		}
-	}
-
-	routerConfig := pConfig.RouterConfig()
-	if routerConfig != nil {
-		r, err := router.CreateRouter(routerConfig.Strategy(), routerConfig.Settings())
-		if err != nil {
-			log.Error("Failed to create router: %v", err)
-			return nil, config.BadConfiguration
-		}
-		vpoint.router = r
-	}
-
-	return vpoint, nil
-}
-
-// Start starts the Point server, and return any error during the process.
-// In the case of any errors, the state of the server is unpredicatable.
-func (vp *Point) Start() error {
-	if vp.port <= 0 {
-		log.Error("Invalid port %d", vp.port)
-		return config.BadConfiguration
-	}
-
-	err := retry.Timed(100 /* times */, 100 /* ms */).On(func() error {
-		err := vp.ich.Listen(vp.port)
-		if err != nil {
-			return err
-		}
-		log.Warning("Point server started on port %d", vp.port)
-		return nil
-	})
-	if err != nil {
-		return err
-	}
-
-	for _, detourHandler := range vp.idh {
-		err := detourHandler.Start()
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (p *Point) DispatchToOutbound(packet v2net.Packet) ray.InboundRay {
-	direct := ray.NewRay()
-	dest := packet.Destination()
-
-	if p.router != nil {
-		tag, err := p.router.TakeDetour(dest)
-		if err == nil {
-			handler, found := p.odh[tag]
-			if found {
-				go handler.Dispatch(packet, direct)
-				return direct
-			}
-		}
-	}
-
-	go p.och.Dispatch(packet, direct)
-	return direct
-}

app/pubsub.go

@@ -0,0 +1,9 @@
+package app
+
+type PubsubMessage []byte
+type TopicHandler func(PubsubMessage)
+
+type Pubsub interface {
+	Publish(topic string, message PubsubMessage)
+	Subscribe(topic string, handler TopicHandler)
+}

app/pubsub/pubsub.go

@@ -0,0 +1,64 @@
+package pubsub
+
+import (
+	"sync"
+
+	"github.com/v2ray/v2ray-core/app"
+	"github.com/v2ray/v2ray-core/app/internal"
+)
+
+type TopicHandlerList struct {
+	sync.RWMutex
+	handlers []app.TopicHandler
+}
+
+func NewTopicHandlerList(handlers ...app.TopicHandler) *TopicHandlerList {
+	return &TopicHandlerList{
+		handlers: handlers,
+	}
+}
+
+func (this *TopicHandlerList) Add(handler app.TopicHandler) {
+	this.Lock()
+	this.handlers = append(this.handlers, handler)
+	this.Unlock()
+}
+
+func (this *TopicHandlerList) Dispatch(message app.PubsubMessage) {
+	this.RLock()
+	for _, handler := range this.handlers {
+		go handler(message)
+	}
+	this.RUnlock()
+}
+
+type Pubsub struct {
+	topics map[string]*TopicHandlerList
+	sync.RWMutex
+}
+
+func New() internal.PubsubWithContext {
+	return &Pubsub{
+		topics: make(map[string]*TopicHandlerList),
+	}
+}
+
+func (this *Pubsub) Publish(context app.Context, topic string, message app.PubsubMessage) {
+	this.RLock()
+	list, found := this.topics[topic]
+	this.RUnlock()
+
+	if found {
+		list.Dispatch(message)
+	}
+}
+
+func (this *Pubsub) Subscribe(context app.Context, topic string, handler app.TopicHandler) {
+	this.Lock()
+	defer this.Unlock()
+	if list, found := this.topics[topic]; found {
+		list.Add(handler)
+	} else {
+		this.topics[topic] = NewTopicHandlerList(handler)
+	}
+}

app/pubsub/pubsub_test.go

@@ -0,0 +1,38 @@
+package pubsub_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/v2ray/v2ray-core/app"
+	. "github.com/v2ray/v2ray-core/app/pubsub"
+	apptesting "github.com/v2ray/v2ray-core/app/testing"
+	v2testing "github.com/v2ray/v2ray-core/testing"
+	"github.com/v2ray/v2ray-core/testing/assert"
+)
+
+func TestPubsub(t *testing.T) {
+	v2testing.Current(t)
+
+	messages := make(map[string]app.PubsubMessage)
+
+	pubsub := New()
+	pubsub.Subscribe(&apptesting.Context{}, "t1", func(message app.PubsubMessage) {
+		messages["t1"] = message
+	})
+
+	pubsub.Subscribe(&apptesting.Context{}, "t2", func(message app.PubsubMessage) {
+		messages["t2"] = message
+	})
+
+	message := app.PubsubMessage([]byte("This is a pubsub message."))
+	pubsub.Publish(&apptesting.Context{}, "t2", message)
+	<-time.Tick(time.Second)
+
+	_, found := messages["t1"]
+	assert.Bool(found).IsFalse()
+
+	actualMessage, found := messages["t2"]
+	assert.Bool(found).IsTrue()
+	assert.StringLiteral(string(actualMessage)).Equals(string(message))
+}

app/router/config.go

@@ -1,6 +1,6 @@
-package config
+package router
 
-type RouterConfig interface {
+type Config interface {
 	Strategy() string
 	Settings() interface{}
 }

app/router/router.go

@@ -3,7 +3,6 @@ package router
 import (
 	"errors"
 
-	"github.com/v2ray/v2ray-core/app/point/config"
 	v2net "github.com/v2ray/v2ray-core/common/net"
 )
 
@@ -12,7 +11,7 @@ var (
 )
 
 type Router interface {
-	TakeDetour(v2net.Destination) (config.DetourTag, error)
+	TakeDetour(v2net.Destination) (string, error)
 }
 
 type RouterFactory interface {

app/router/router_test.go

@@ -0,0 +1,31 @@
+package router_test
+
+import (
+	"net"
+	"path/filepath"
+	"testing"
+
+	. "github.com/v2ray/v2ray-core/app/router"
+	_ "github.com/v2ray/v2ray-core/app/router/rules/json"
+	v2net "github.com/v2ray/v2ray-core/common/net"
+	"github.com/v2ray/v2ray-core/shell/point/json"
+	v2testing "github.com/v2ray/v2ray-core/testing"
+	"github.com/v2ray/v2ray-core/testing/assert"
+)
+
+func TestRouter(t *testing.T) {
+	v2testing.Current(t)
+
+	baseDir := "$GOPATH/src/github.com/v2ray/v2ray-core/release/config"
+
+	pointConfig, err := json.LoadConfig(filepath.Join(baseDir, "vpoint_socks_vmess.json"))
+	assert.Error(err).IsNil()
+
+	router, err := CreateRouter(pointConfig.RouterConfig().Strategy(), pointConfig.RouterConfig().Settings())
+	assert.Error(err).IsNil()
+
+	dest := v2net.TCPDestination(v2net.IPAddress(net.ParseIP("120.135.126.1")), 80)
+	tag, err := router.TakeDetour(dest)
+	assert.Error(err).IsNil()
+	assert.StringLiteral(tag).Equals("direct")
+}

app/router/rules/config.go

@@ -1,11 +1,14 @@
-package config
+package rules
 
 import (
-	"github.com/v2ray/v2ray-core/app/point/config"
 	v2net "github.com/v2ray/v2ray-core/common/net"
 )
 
 type Rule interface {
-	Tag() config.DetourTag
+	Tag() string
 	Apply(dest v2net.Destination) bool
 }
+
+type RouterRuleConfig interface {
+	Rules() []Rule
+}

app/router/rules/config/json/fieldrule.go

@@ -1,93 +0,0 @@
-package json
-
-import (
-	"encoding/json"
-	"errors"
-	"net"
-	"strings"
-
-	v2net "github.com/v2ray/v2ray-core/common/net"
-	v2netjson "github.com/v2ray/v2ray-core/common/net/json"
-)
-
-type FieldRule struct {
-	Rule
-	Domain  string
-	IP      *net.IPNet
-	Port    v2net.PortRange
-	Network v2net.NetworkList
-}
-
-func (this *FieldRule) Apply(dest v2net.Destination) bool {
-	address := dest.Address()
-	if len(this.Domain) > 0 {
-		if !address.IsDomain() || !strings.Contains(address.Domain(), this.Domain) {
-			return false
-		}
-	}
-
-	if this.IP != nil {
-		if !(address.IsIPv4() || address.IsIPv6()) || !this.IP.Contains(address.IP()) {
-			return false
-		}
-	}
-
-	if this.Port != nil {
-		port := address.Port()
-		if port < this.Port.From() || port > this.Port.To() {
-			return false
-		}
-	}
-
-	if this.Network != nil {
-		if !this.Network.HasNetwork(v2net.Network(dest.Network())) {
-			return false
-		}
-	}
-
-	return true
-}
-
-func (this *FieldRule) UnmarshalJSON(data []byte) error {
-	type RawFieldRule struct {
-		Rule
-		Domain  string                 `json:"domain"`
-		IP      string                 `json:"ip"`
-		Port    *v2netjson.PortRange   `json:"port"`
-		Network *v2netjson.NetworkList `json:"network"`
-	}
-	rawFieldRule := RawFieldRule{}
-	err := json.Unmarshal(data, &rawFieldRule)
-	if err != nil {
-		return err
-	}
-	this.Type = rawFieldRule.Type
-	this.OutboundTag = rawFieldRule.OutboundTag
-
-	hasField := false
-	if len(rawFieldRule.Domain) > 0 {
-		this.Domain = rawFieldRule.Domain
-		hasField = true
-	}
-
-	if len(rawFieldRule.IP) > 0 {
-		_, ipNet, err := net.ParseCIDR(rawFieldRule.IP)
-		if err != nil {
-			return errors.New("Invalid IP range in router rule: " + err.Error())
-		}
-		this.IP = ipNet
-		hasField = true
-	}
-	if rawFieldRule.Port != nil {
-		this.Port = rawFieldRule.Port
-		hasField = true
-	}
-	if rawFieldRule.Network != nil {
-		this.Network = rawFieldRule.Network
-		hasField = true
-	}
-	if !hasField {
-		return errors.New("This rule has no effective fields.")
-	}
-	return nil
-}

app/router/rules/config/json/fieldrule_test.go

@@ -1,71 +0,0 @@
-package json
-
-import (
-	"testing"
-
-	v2net "github.com/v2ray/v2ray-core/common/net"
-	v2nettesting "github.com/v2ray/v2ray-core/common/net/testing"
-	"github.com/v2ray/v2ray-core/testing/unit"
-)
-
-func TestDomainMatching(t *testing.T) {
-	assert := unit.Assert(t)
-
-	rule := &FieldRule{
-		Domain: "v2ray.com",
-	}
-	dest := v2net.NewTCPDestination(v2net.DomainAddress("www.v2ray.com", 80))
-	assert.Bool(rule.Apply(dest)).IsTrue()
-}
-
-func TestPortMatching(t *testing.T) {
-	assert := unit.Assert(t)
-
-	rule := &FieldRule{
-		Port: &v2nettesting.PortRange{
-			FromValue: 0,
-			ToValue:   100,
-		},
-	}
-	dest := v2net.NewTCPDestination(v2net.DomainAddress("www.v2ray.com", 80))
-	assert.Bool(rule.Apply(dest)).IsTrue()
-}
-
-func TestIPMatching(t *testing.T) {
-	assert := unit.Assert(t)
-
-	rawJson := `{
-    "type": "field",
-    "ip": "10.0.0.0/8",
-    "tag": "test"
-  }`
-	rule := parseRule([]byte(rawJson))
-	dest := v2net.NewTCPDestination(v2net.IPAddress([]byte{10, 0, 0, 1}, 80))
-	assert.Bool(rule.Apply(dest)).IsTrue()
-}
-
-func TestPortNotMatching(t *testing.T) {
-	assert := unit.Assert(t)
-
-	rawJson := `{
-    "type": "field",
-    "port": "80-100",
-    "tag": "test"
-  }`
-	rule := parseRule([]byte(rawJson))
-	dest := v2net.NewTCPDestination(v2net.IPAddress([]byte{10, 0, 0, 1}, 79))
-	assert.Bool(rule.Apply(dest)).IsFalse()
-}
-
-func TestDomainNotMatching(t *testing.T) {
-	assert := unit.Assert(t)
-
-	rawJson := `{
-    "type": "field",
-    "domain": "google.com",
-    "tag": "test"
-  }`
-	rule := parseRule([]byte(rawJson))
-	dest := v2net.NewTCPDestination(v2net.IPAddress([]byte{10, 0, 0, 1}, 79))
-	assert.Bool(rule.Apply(dest)).IsFalse()
-}

app/router/rules/config/json/router.go

@@ -1,47 +0,0 @@
-package json
-
-import (
-	"encoding/json"
-
-	v2routerconfigjson "github.com/v2ray/v2ray-core/app/router/config/json"
-	"github.com/v2ray/v2ray-core/app/router/rules/config"
-	"github.com/v2ray/v2ray-core/common/log"
-)
-
-type RouterRuleConfig struct {
-	RuleList []json.RawMessage `json:"rules"`
-}
-
-func parseRule(msg json.RawMessage) config.Rule {
-	rule := new(Rule)
-	err := json.Unmarshal(msg, rule)
-	if err != nil {
-		log.Error("Invalid router rule: %v", err)
-		return nil
-	}
-	if rule.Type == "field" {
-		fieldrule := new(FieldRule)
-		err = json.Unmarshal(msg, fieldrule)
-		if err != nil {
-			log.Error("Invalid field rule: %v", err)
-			return nil
-		}
-		return fieldrule
-	}
-	log.Error("Unknown router rule type: %s", rule.Type)
-	return nil
-}
-
-func (this *RouterRuleConfig) Rules() []config.Rule {
-	rules := make([]config.Rule, len(this.RuleList))
-	for idx, rawRule := range this.RuleList {
-		rules[idx] = parseRule(rawRule)
-	}
-	return rules
-}
-
-func init() {
-	v2routerconfigjson.RegisterRouterConfig("rules", func() interface{} {
-		return new(RouterRuleConfig)
-	})
-}

app/router/rules/config/router.go

@@ -1,5 +0,0 @@
-package config
-
-type RouterRuleConfig interface {
-	Rules() []Rule
-}

app/router/rules/json/chinaip_test.go

@@ -0,0 +1,26 @@
+package json
+
+import (
+	"net"
+	"testing"
+
+	v2net "github.com/v2ray/v2ray-core/common/net"
+	v2testing "github.com/v2ray/v2ray-core/testing"
+	"github.com/v2ray/v2ray-core/testing/assert"
+)
+
+func makeDestination(ip string) v2net.Destination {
+	return v2net.TCPDestination(v2net.IPAddress(net.ParseIP(ip)), 80)
+}
+
+func TestChinaIP(t *testing.T) {
+	v2testing.Current(t)
+
+	rule := &ChinaIPRule{}
+	assert.Bool(rule.Apply(makeDestination("121.14.1.189"))).IsTrue()    // sina.com.cn
+	assert.Bool(rule.Apply(makeDestination("101.226.103.106"))).IsTrue() // qq.com
+	assert.Bool(rule.Apply(makeDestination("115.239.210.36"))).IsTrue()  // image.baidu.com
+	assert.Bool(rule.Apply(makeDestination("120.135.126.1"))).IsTrue()
+
+	assert.Bool(rule.Apply(makeDestination("8.8.8.8"))).IsFalse()
+}

app/router/rules/json/chinasites.go

@@ -0,0 +1,361 @@
+package json
+
+import (
+	"strings"
+
+	v2net "github.com/v2ray/v2ray-core/common/net"
+)
+
+type ChinaSitesRule struct {
+	Rule
+}
+
+func (this *ChinaSitesRule) Apply(dest v2net.Destination) bool {
+	address := dest.Address()
+	if !address.IsDomain() {
+		return false
+	}
+	domain := strings.ToLower(address.Domain())
+	for _, matcher := range compiledMatchers {
+		if matcher.Match(domain) {
+			return true
+		}
+	}
+	return false
+}
+
+const (
+	anySubDomain = "^(.*\\.)?"
+	dotAm        = "\\.am$"
+	dotCc        = "\\.cc$"
+	dotCn        = "\\.cn$"
+	dotCom       = "\\.com$"
+	dotIo        = "\\.io$"
+	dotLa        = "\\.la$"
+	dotMe        = "\\.me$"
+	dotNet       = "\\.net$"
+	dotOrg       = "\\.org$"
+	dotTv        = "\\.tv$"
+)
+
+var (
+	compiledMatchers []*RegexpDomainMatcher
+)
+
+func init() {
+	compiledMatchers = make([]*RegexpDomainMatcher, 0, 1024)
+
+	regexpDomains := []string{
+		dotCn,
+		"\\.xn--fiqs8s$", /* .中国 */
+
+		anySubDomain + "10010" + dotCom,
+		anySubDomain + "115" + dotCom,
+		anySubDomain + "123juzi" + dotCom,
+		anySubDomain + "123juzi" + dotNet,
+		anySubDomain + "123u" + dotCom,
+		anySubDomain + "126" + dotCom,
+		anySubDomain + "126" + dotNet,
+		anySubDomain + "127" + dotNet,
+		anySubDomain + "163" + dotCom,
+		anySubDomain + "17173" + dotCom,
+		anySubDomain + "17cdn" + dotCom,
+		anySubDomain + "1905" + dotCom,
+		anySubDomain + "21cn" + dotCom,
+		anySubDomain + "2288" + dotOrg,
+		anySubDomain + "2345" + dotCom,
+		anySubDomain + "3322" + dotOrg,
+		anySubDomain + "35" + dotCom,
+		anySubDomain + "360doc" + dotCom,
+		anySubDomain + "360buy" + dotCom,
+		anySubDomain + "360buyimg" + dotCom,
+		anySubDomain + "360safe" + dotCom,
+		anySubDomain + "36kr" + dotCom,
+		anySubDomain + "39" + dotNet,
+		anySubDomain + "4399" + dotCom,
+		anySubDomain + "50bang" + dotOrg,
+		anySubDomain + "51" + dotLa,
+		anySubDomain + "51cto" + dotCom,
+		anySubDomain + "51job" + dotCom,
+		anySubDomain + "51jobcdn" + dotCom,
+		anySubDomain + "55bbs" + dotCom,
+		anySubDomain + "58" + dotCom,
+		anySubDomain + "71" + dotAm,
+		anySubDomain + "7k7k" + dotCom,
+		anySubDomain + "9718" + dotCom,
+		anySubDomain + "abchina" + dotCom,
+		anySubDomain + "acfun" + dotTv,
+		anySubDomain + "aicdn" + dotCom,
+		anySubDomain + "alibaba" + dotCom,
+		anySubDomain + "alicdn" + dotCom,
+		anySubDomain + "aliimg.com" + dotCom,
+		anySubDomain + "alipay" + dotCom,
+		anySubDomain + "alipayobjects" + dotCom,
+		anySubDomain + "aliyun" + dotCom,
+		anySubDomain + "aliyuncdn" + dotCom,
+		anySubDomain + "aliyuncs" + dotCom,
+		anySubDomain + "allyes" + dotCom,
+		anySubDomain + "amap" + dotCom,
+		anySubDomain + "anjuke" + dotCom,
+		anySubDomain + "anquan" + dotOrg,
+		anySubDomain + "appinn" + dotCom,
+		anySubDomain + "babytree" + dotCom,
+		anySubDomain + "baidu" + dotCom,
+		anySubDomain + "baiducontent" + dotCom,
+		anySubDomain + "baidustatic" + dotCom,
+		anySubDomain + "baifendian" + dotCom,
+		anySubDomain + "baifubao" + dotCom,
+		anySubDomain + "baihe" + dotCom,
+		anySubDomain + "baike" + dotCom,
+		anySubDomain + "baixing" + dotCom,
+		anySubDomain + "baixing" + dotNet,
+		anySubDomain + "bankcomm" + dotCom,
+		anySubDomain + "bankofchina" + dotCom,
+		anySubDomain + "bcy" + dotNet,
+		anySubDomain + "bdimg" + dotCom,
+		anySubDomain + "bdstatic" + dotCom,
+		anySubDomain + "bilibili" + dotCom,
+		anySubDomain + "bitauto" + dotCom,
+		anySubDomain + "bitautoimg" + dotCom,
+		anySubDomain + "bobo" + dotCom,
+		anySubDomain + "btcfans" + dotCom,
+		anySubDomain + "ccb" + dotCom,
+		anySubDomain + "cctv" + dotCom,
+		anySubDomain + "cctvpic" + dotCom,
+		anySubDomain + "cdn20" + dotCom,
+		anySubDomain + "ch" + dotCom,
+		anySubDomain + "che168" + dotCom,
+		anySubDomain + "china" + dotCom,
+		anySubDomain + "chinacache" + dotCom,
+		anySubDomain + "chinacache" + dotNet,
+		anySubDomain + "chinahr" + dotCom,
+		anySubDomain + "chinamobile" + dotCom,
+		anySubDomain + "chinaz" + dotCom,
+		anySubDomain + "chouti" + dotCom,
+		anySubDomain + "chuangxin" + dotCom,
+		anySubDomain + "clouddn" + dotCom,
+		anySubDomain + "cloudxns" + dotCom,
+		anySubDomain + "cmbchina" + dotCom,
+		anySubDomain + "cnbeta" + dotCom,
+		anySubDomain + "cnbetacdn" + dotCom,
+		anySubDomain + "cnblogs" + dotCom,
+		anySubDomain + "cnepub" + dotCom,
+		anySubDomain + "cnzz" + dotCom,
+		anySubDomain + "coding" + dotNet,
+		anySubDomain + "csbew" + dotCom,
+		anySubDomain + "csdn" + dotNet,
+		anySubDomain + "ctrip" + dotCom,
+		anySubDomain + "cubead" + dotCom,
+		anySubDomain + "dangdang" + dotCom,
+		anySubDomain + "daocloud" + dotIo,
+		anySubDomain + "dedecms" + dotCom,
+		anySubDomain + "diandian" + dotCom,
+		anySubDomain + "dianping" + dotCom,
+		anySubDomain + "docin" + dotCom,
+		anySubDomain + "donews" + dotCom,
+		anySubDomain + "douban" + dotCom,
+		anySubDomain + "doubanio" + dotCom,
+		anySubDomain + "dpfile" + dotCom,
+		anySubDomain + "duoshuo" + dotCom,
+		anySubDomain + "duowan" + dotCom,
+		anySubDomain + "eastday" + dotCom,
+		anySubDomain + "ecitic" + dotCom,
+		anySubDomain + "emarbox" + dotCom,
+		anySubDomain + "etao" + dotCom,
+		anySubDomain + "fanli" + dotCom,
+		anySubDomain + "fengniao" + dotCom,
+		anySubDomain + "fhldns" + dotCom,
+		anySubDomain + "geekpark" + dotNet,
+		anySubDomain + "getui" + dotCom,
+		anySubDomain + "hao123" + dotCom,
+		anySubDomain + "hao123img" + dotCom,
+		anySubDomain + "haosou" + dotCom,
+		anySubDomain + "hdslb" + dotCom,
+		anySubDomain + "hexun" + dotCom,
+		anySubDomain + "hichina" + dotCom,
+		anySubDomain + "huanqiu" + dotCom,
+		anySubDomain + "hunantv" + dotCom,
+		anySubDomain + "huochepiao" + dotCom,
+		anySubDomain + "hupu" + dotCom,
+		anySubDomain + "huxiu" + dotCom,
+		anySubDomain + "iask" + dotCom,
+		anySubDomain + "iciba" + dotCom,
+		anySubDomain + "idqqimg" + dotCom,
+		anySubDomain + "ifanr" + dotCom,
+		anySubDomain + "ijinshan" + dotCom,
+		anySubDomain + "imedao" + dotCom,
+		anySubDomain + "imgo" + dotTv,
+		anySubDomain + "ipinyou" + dotCom,
+		anySubDomain + "ipip" + dotNet,
+		anySubDomain + "iqiyi" + dotCom,
+		anySubDomain + "it168" + dotCom,
+		anySubDomain + "itjuzi" + dotCom,
+		anySubDomain + "jandan" + dotNet,
+		anySubDomain + "jd" + dotCom,
+		anySubDomain + "jb51" + dotCom,
+		anySubDomain + "jia" + dotCom,
+		anySubDomain + "jianshu" + dotCom,
+		anySubDomain + "jiasuhui" + dotCom,
+		anySubDomain + "jiayuan" + dotCom,
+		anySubDomain + "jisuanke" + dotCom,
+		anySubDomain + "jstv" + dotCom,
+		anySubDomain + "jyimg" + dotCom,
+		anySubDomain + "kaixin001" + dotCom,
+		anySubDomain + "kanimg" + dotCom,
+		anySubDomain + "kankanews" + dotCom,
+		anySubDomain + "kf5" + dotCom,
+		anySubDomain + "kimiss" + dotCom,
+		anySubDomain + "kouclo" + dotCom,
+		anySubDomain + "koudai8" + dotCom,
+		anySubDomain + "ku6" + dotCom,
+		anySubDomain + "ku6cdn" + dotCom,
+		anySubDomain + "ku6img" + dotCom,
+		anySubDomain + "lady8844" + dotCom,
+		anySubDomain + "leiphone" + dotCom,
+		anySubDomain + "leju" + dotCom,
+		anySubDomain + "leturich" + dotOrg,
+		anySubDomain + "letv" + dotCom,
+		anySubDomain + "letvcdn" + dotCom,
+		anySubDomain + "letvimg" + dotCom,
+		anySubDomain + "lietou" + dotCom,
+		anySubDomain + "linkvans" + dotCom,
+		anySubDomain + "lightonus" + dotCom,
+		anySubDomain + "lu" + dotCom,
+		anySubDomain + "lufax" + dotCom,
+		anySubDomain + "lufaxcdn" + dotCom,
+		anySubDomain + "lvmama" + dotCom,
+		anySubDomain + "lxdns" + dotCom,
+		anySubDomain + "ly" + dotCom,
+		anySubDomain + "mechina" + dotOrg,
+		anySubDomain + "mediav" + dotCom,
+		anySubDomain + "meika360" + dotCom,
+		anySubDomain + "meilishuo" + dotCom,
+		anySubDomain + "meishij" + dotNet,
+		anySubDomain + "meituan" + dotCom,
+		anySubDomain + "meizu" + dotCom,
+		anySubDomain + "mgtv" + dotCom,
+		anySubDomain + "mi" + dotCom,
+		anySubDomain + "miaozhen" + dotCom,
+		anySubDomain + "mmstat" + dotCom,
+		anySubDomain + "mop" + dotCom,
+		anySubDomain + "mydrivers" + dotCom,
+		anySubDomain + "netease" + dotCom,
+		anySubDomain + "ngacn" + dotCc,
+		anySubDomain + "ntalker" + dotCom,
+		anySubDomain + "oeeee" + dotCom,
+		anySubDomain + "ol-img" + dotCom,
+		anySubDomain + "onlinesjtu" + dotCom,
+		anySubDomain + "oschina" + dotNet,
+		anySubDomain + "paipai" + dotCom,
+		anySubDomain + "pchome" + dotNet,
+		anySubDomain + "pingan" + dotCom,
+		anySubDomain + "pingplusplus" + dotCom,
+		anySubDomain + "pps" + dotTv,
+		anySubDomain + "pubyun" + dotCom,
+		anySubDomain + "qbox" + dotMe,
+		anySubDomain + "qhimg" + dotCom,
+		anySubDomain + "qidian" + dotCom,
+		anySubDomain + "qingcloud" + dotCom,
+		anySubDomain + "qiniu" + dotCom,
+		anySubDomain + "qiniudn" + dotCom,
+		anySubDomain + "qiniudns" + dotCom,
+		anySubDomain + "qiyi" + dotCom,
+		anySubDomain + "qiyipic" + dotCom,
+		anySubDomain + "qtmojo" + dotCom,
+		anySubDomain + "qq" + dotCom,
+		anySubDomain + "qqmail" + dotCom,
+		anySubDomain + "qunar" + dotCom,
+		anySubDomain + "qunarzz" + dotCom,
+		anySubDomain + "qzone" + dotCom,
+		anySubDomain + "renren" + dotCom,
+		anySubDomain + "ruby-china" + dotOrg,
+		anySubDomain + "sandai" + dotNet,
+		anySubDomain + "sanguosha" + dotCom,
+		anySubDomain + "sanwen" + dotNet,
+		anySubDomain + "segmentfault" + dotCom,
+		anySubDomain + "shutcm" + dotCom,
+		anySubDomain + "sina" + dotCom,
+		anySubDomain + "sinaapp" + dotCom,
+		anySubDomain + "sinaedge" + dotCom,
+		anySubDomain + "sinaimg" + dotCom,
+		anySubDomain + "sinajs" + dotCom,
+		anySubDomain + "szzfgjj" + dotCom,
+		anySubDomain + "smzdm" + dotCom,
+		anySubDomain + "sohu" + dotCom,
+		anySubDomain + "sogou" + dotCom,
+		anySubDomain + "soso" + dotCom,
+		anySubDomain + "sspai" + dotCom,
+		anySubDomain + "staticfile" + dotOrg,
+		anySubDomain + "stockstar" + dotCom,
+		anySubDomain + "suning" + dotCom,
+		anySubDomain + "t1y5" + dotCom,
+		anySubDomain + "tanx" + dotCom,
+		anySubDomain + "tao123" + dotCom,
+		anySubDomain + "taobao" + dotCom,
+		anySubDomain + "taobaocdn" + dotCom,
+		anySubDomain + "tencent" + dotCom,
+		anySubDomain + "tenpay" + dotCom,
+		anySubDomain + "tiexue" + dotNet,
+		anySubDomain + "tmall" + dotCom,
+		anySubDomain + "tmcdn" + dotNet,
+		anySubDomain + "tudou" + dotCom,
+		anySubDomain + "tudouui" + dotCom,
+		anySubDomain + "tuicool" + dotCom,
+		anySubDomain + "u17" + dotCom,
+		anySubDomain + "unionpay" + dotCom,
+		anySubDomain + "unionpaysecure" + dotCom,
+		anySubDomain + "upyun" + dotCom,
+		anySubDomain + "upaiyun" + dotCom,
+		anySubDomain + "v2ex" + dotCom,
+		anySubDomain + "vamaker" + dotCom,
+		anySubDomain + "vancl" + dotCom,
+		anySubDomain + "vip" + dotCom,
+		anySubDomain + "wandoujia" + dotCom,
+		anySubDomain + "wdjimg" + dotCom,
+		anySubDomain + "webterren" + dotCom,
+		anySubDomain + "weibo" + dotCom,
+		anySubDomain + "weiyun" + dotCom,
+		anySubDomain + "wonnder" + dotCom,
+		anySubDomain + "wrating" + dotCom,
+		anySubDomain + "wscdns" + dotCom,
+		anySubDomain + "xiachufang" + dotCom,
+		anySubDomain + "xiami" + dotCom,
+		anySubDomain + "xiaomi" + dotCom,
+		anySubDomain + "xinhuanet" + dotCom,
+		anySubDomain + "xinshipu" + dotCom,
+		anySubDomain + "xnpic" + dotCom,
+		anySubDomain + "xueqiu" + dotCom,
+		anySubDomain + "xunlei" + dotCom,
+		anySubDomain + "xywy" + dotCom,
+		anySubDomain + "yaolan" + dotCom,
+		anySubDomain + "yccdn" + dotCom,
+		anySubDomain + "yesky" + dotCom,
+		anySubDomain + "yigao" + dotCom,
+		anySubDomain + "yihaodian" + dotCom,
+		anySubDomain + "yihaodianimg" + dotCom,
+		anySubDomain + "yingjiesheng" + dotCom,
+		anySubDomain + "yhd" + dotCom,
+		anySubDomain + "youboy" + dotCom,
+		anySubDomain + "youku" + dotCom,
+		anySubDomain + "yunba" + dotIo,
+		anySubDomain + "yunshipei" + dotCom,
+		anySubDomain + "yupoo" + dotCom,
+		anySubDomain + "yy" + dotCom,
+		anySubDomain + "zastatic" + dotCom,
+		anySubDomain + "zbjimg" + dotCom,
+		anySubDomain + "zhenai" + dotCom,
+		anySubDomain + "zhanqi" + dotTv,
+		anySubDomain + "zhihu" + dotCom,
+		anySubDomain + "zhimg" + dotCom,
+		anySubDomain + "zjstv" + dotCom,
+		anySubDomain + "zhubajie" + dotCom,
+	}
+
+	for _, pattern := range regexpDomains {
+		matcher, err := NewRegexpDomainMatcher(pattern)
+		if err != nil {
+			panic(err)
+		}
+		compiledMatchers = append(compiledMatchers, matcher)
+	}
+}

app/router/rules/json/chinasites_test.go

@@ -0,0 +1,25 @@
+package json
+
+import (
+	"testing"
+
+	v2net "github.com/v2ray/v2ray-core/common/net"
+	v2testing "github.com/v2ray/v2ray-core/testing"
+	"github.com/v2ray/v2ray-core/testing/assert"
+)
+
+func makeDomainDestination(domain string) v2net.Destination {
+	return v2net.TCPDestination(v2net.DomainAddress(domain), 80)
+}
+
+func TestChinaSites(t *testing.T) {
+	v2testing.Current(t)
+
+	rule := &ChinaSitesRule{}
+	assert.Bool(rule.Apply(makeDomainDestination("v.qq.com"))).IsTrue()
+	assert.Bool(rule.Apply(makeDomainDestination("www.163.com"))).IsTrue()
+	assert.Bool(rule.Apply(makeDomainDestination("ngacn.cc"))).IsTrue()
+	assert.Bool(rule.Apply(makeDomainDestination("12306.cn"))).IsTrue()
+
+	assert.Bool(rule.Apply(makeDomainDestination("v2ray.com"))).IsFalse()
+}

app/router/rules/json/fieldrule.go

@@ -0,0 +1,197 @@
+package json
+
+import (
+	"encoding/json"
+	"errors"
+	"net"
+	"regexp"
+	"strings"
+
+	v2net "github.com/v2ray/v2ray-core/common/net"
+	v2netjson "github.com/v2ray/v2ray-core/common/net/json"
+)
+
+type StringList []string
+
+func NewStringList(str ...string) *StringList {
+	list := StringList(str)
+	return &list
+}
+
+func (this *StringList) UnmarshalJSON(data []byte) error {
+	var strList []string
+	err := json.Unmarshal(data, &strList)
+	if err == nil {
+		*this = make([]string, len(strList))
+		copy(*this, strList)
+		return nil
+	}
+
+	var str string
+	err = json.Unmarshal(data, &str)
+	if err == nil {
+		*this = make([]string, 0, 1)
+		*this = append(*this, str)
+		return nil
+	}
+
+	return errors.New("Failed to unmarshal string list: " + string(data))
+}
+
+func (this *StringList) Len() int {
+	return len([]string(*this))
+}
+
+type DomainMatcher interface {
+	Match(domain string) bool
+}
+
+type PlainDomainMatcher struct {
+	pattern string
+}
+
+func NewPlainDomainMatcher(pattern string) *PlainDomainMatcher {
+	return &PlainDomainMatcher{
+		pattern: strings.ToLower(pattern),
+	}
+}
+
+func (this *PlainDomainMatcher) Match(domain string) bool {
+	return strings.Contains(strings.ToLower(domain), this.pattern)
+}
+
+type RegexpDomainMatcher struct {
+	pattern *regexp.Regexp
+}
+
+func NewRegexpDomainMatcher(pattern string) (*RegexpDomainMatcher, error) {
+	r, err := regexp.Compile(pattern)
+	if err != nil {
+		return nil, err
+	}
+	return &RegexpDomainMatcher{
+		pattern: r,
+	}, nil
+}
+
+func (this *RegexpDomainMatcher) Match(domain string) bool {
+	return this.pattern.MatchString(strings.ToLower(domain))
+}
+
+type FieldRule struct {
+	Rule
+	Domain  []DomainMatcher
+	IP      []*net.IPNet
+	Port    v2net.PortRange
+	Network v2net.NetworkList
+}
+
+func (this *FieldRule) Apply(dest v2net.Destination) bool {
+	address := dest.Address()
+	if len(this.Domain) > 0 {
+		if !address.IsDomain() {
+			return false
+		}
+		foundMatch := false
+		for _, domain := range this.Domain {
+			if domain.Match(address.Domain()) {
+				foundMatch = true
+				break
+			}
+		}
+		if !foundMatch {
+			return false
+		}
+	}
+
+	if this.IP != nil && len(this.IP) > 0 {
+		if !(address.IsIPv4() || address.IsIPv6()) {
+			return false
+		}
+		foundMatch := false
+		for _, ipnet := range this.IP {
+			if ipnet.Contains(address.IP()) {
+				foundMatch = true
+				break
+			}
+		}
+		if !foundMatch {
+			return false
+		}
+	}
+
+	if this.Port != nil {
+		port := dest.Port()
+		if port.Value() < this.Port.From().Value() || port.Value() > this.Port.To().Value() {
+			return false
+		}
+	}
+
+	if this.Network != nil {
+		if !this.Network.HasNetwork(v2net.Network(dest.Network())) {
+			return false
+		}
+	}
+
+	return true
+}
+
+func (this *FieldRule) UnmarshalJSON(data []byte) error {
+	type RawFieldRule struct {
+		Rule
+		Domain  *StringList            `json:"domain"`
+		IP      *StringList            `json:"ip"`
+		Port    *v2netjson.PortRange   `json:"port"`
+		Network *v2netjson.NetworkList `json:"network"`
+	}
+	rawFieldRule := RawFieldRule{}
+	err := json.Unmarshal(data, &rawFieldRule)
+	if err != nil {
+		return err
+	}
+	this.Type = rawFieldRule.Type
+	this.OutboundTag = rawFieldRule.OutboundTag
+
+	hasField := false
+	if rawFieldRule.Domain != nil && rawFieldRule.Domain.Len() > 0 {
+		this.Domain = make([]DomainMatcher, rawFieldRule.Domain.Len())
+		for idx, rawDomain := range *(rawFieldRule.Domain) {
+			var matcher DomainMatcher
+			if strings.HasPrefix(rawDomain, "regexp:") {
+				rawMatcher, err := NewRegexpDomainMatcher(rawDomain[7:])
+				if err != nil {
+					return err
+				}
+				matcher = rawMatcher
+			} else {
+				matcher = NewPlainDomainMatcher(rawDomain)
+			}
+			this.Domain[idx] = matcher
+		}
+		hasField = true
+	}
+
+	if rawFieldRule.IP != nil && rawFieldRule.IP.Len() > 0 {
+		this.IP = make([]*net.IPNet, 0, rawFieldRule.IP.Len())
+		for _, ipStr := range *(rawFieldRule.IP) {
+			_, ipNet, err := net.ParseCIDR(ipStr)
+			if err != nil {
+				return errors.New("Invalid IP range in router rule: " + err.Error())
+			}
+			this.IP = append(this.IP, ipNet)
+		}
+		hasField = true
+	}
+	if rawFieldRule.Port != nil {
+		this.Port = rawFieldRule.Port
+		hasField = true
+	}
+	if rawFieldRule.Network != nil {
+		this.Network = rawFieldRule.Network
+		hasField = true
+	}
+	if !hasField {
+		return errors.New("This rule has no effective fields.")
+	}
+	return nil
+}

app/router/rules/json/fieldrule_test.go

@@ -0,0 +1,125 @@
+package json
+
+import (
+	"encoding/json"
+	"testing"
+
+	v2net "github.com/v2ray/v2ray-core/common/net"
+	v2nettesting "github.com/v2ray/v2ray-core/common/net/testing"
+	v2testing "github.com/v2ray/v2ray-core/testing"
+	"github.com/v2ray/v2ray-core/testing/assert"
+)
+
+func TestStringListParsingList(t *testing.T) {
+	v2testing.Current(t)
+
+	rawJson := `["a", "b", "c", "d"]`
+	var strList StringList
+	err := json.Unmarshal([]byte(rawJson), &strList)
+	assert.Error(err).IsNil()
+	assert.Int(strList.Len()).Equals(4)
+}
+
+func TestStringListParsingString(t *testing.T) {
+	v2testing.Current(t)
+
+	rawJson := `"abcd"`
+	var strList StringList
+	err := json.Unmarshal([]byte(rawJson), &strList)
+	assert.Error(err).IsNil()
+	assert.Int(strList.Len()).Equals(1)
+}
+
+func TestDomainMatching(t *testing.T) {
+	v2testing.Current(t)
+
+	rawJson := `{
+    "type": "field",
+    "domain": ["google.com", "regexp:v2ray.com$"],
+    "tag": "test"
+  }`
+	rule := parseRule([]byte(rawJson))
+	dest := v2net.TCPDestination(v2net.DomainAddress("www.v2ray.com"), 80)
+	assert.Bool(rule.Apply(dest)).IsTrue()
+}
+
+func TestPortMatching(t *testing.T) {
+	v2testing.Current(t)
+
+	rule := &FieldRule{
+		Port: &v2nettesting.PortRange{
+			FromValue: 0,
+			ToValue:   100,
+		},
+	}
+	dest := v2net.TCPDestination(v2net.DomainAddress("www.v2ray.com"), 80)
+	assert.Bool(rule.Apply(dest)).IsTrue()
+}
+
+func TestIPMatching(t *testing.T) {
+	v2testing.Current(t)
+
+	rawJson := `{
+    "type": "field",
+    "ip": "10.0.0.0/8",
+    "tag": "test"
+  }`
+	rule := parseRule([]byte(rawJson))
+	dest := v2net.TCPDestination(v2net.IPAddress([]byte{10, 0, 0, 1}), 80)
+	assert.Bool(rule.Apply(dest)).IsTrue()
+}
+
+func TestIPListMatching(t *testing.T) {
+	v2testing.Current(t)
+
+	rawJson := `{
+    "type": "field",
+    "ip": ["10.0.0.0/8", "192.168.0.0/16"],
+    "tag": "test"
+  }`
+	rule := parseRule([]byte(rawJson))
+	dest := v2net.TCPDestination(v2net.IPAddress([]byte{192, 168, 1, 1}), 80)
+	assert.Bool(rule.Apply(dest)).IsTrue()
+}
+
+func TestPortNotMatching(t *testing.T) {
+	v2testing.Current(t)
+
+	rawJson := `{
+    "type": "field",
+    "port": "80-100",
+    "tag": "test"
+  }`
+	rule := parseRule([]byte(rawJson))
+	dest := v2net.TCPDestination(v2net.IPAddress([]byte{10, 0, 0, 1}), 79)
+	assert.Bool(rule.Apply(dest)).IsFalse()
+}
+
+func TestDomainNotMatching(t *testing.T) {
+	v2testing.Current(t)
+
+	rawJson := `{
+    "type": "field",
+    "domain": ["google.com", "v2ray.com"],
+    "tag": "test"
+  }`
+	rule := parseRule([]byte(rawJson))
+	dest := v2net.TCPDestination(v2net.IPAddress([]byte{10, 0, 0, 1}), 80)
+	assert.Bool(rule.Apply(dest)).IsFalse()
+}
+
+func TestDomainNotMatchingDomain(t *testing.T) {
+	v2testing.Current(t)
+
+	rawJson := `{
+    "type": "field",
+    "domain": ["google.com", "v2ray.com"],
+    "tag": "test"
+  }`
+	rule := parseRule([]byte(rawJson))
+	dest := v2net.TCPDestination(v2net.DomainAddress("baidu.com"), 80)
+	assert.Bool(rule.Apply(dest)).IsFalse()
+
+	dest = v2net.TCPDestination(v2net.DomainAddress("www.google.com"), 80)
+	assert.Bool(rule.Apply(dest)).IsTrue()
+}

app/router/rules/json/router.go

@@ -0,0 +1,63 @@
+package json
+
+import (
+	"encoding/json"
+
+	v2routerjson "github.com/v2ray/v2ray-core/app/router/json"
+	"github.com/v2ray/v2ray-core/app/router/rules"
+	"github.com/v2ray/v2ray-core/common/log"
+)
+
+type RouterRuleConfig struct {
+	RuleList []json.RawMessage `json:"rules"`
+}
+
+func parseRule(msg json.RawMessage) rules.Rule {
+	rule := new(Rule)
+	err := json.Unmarshal(msg, rule)
+	if err != nil {
+		log.Error("Invalid router rule: %v", err)
+		return nil
+	}
+	if rule.Type == "field" {
+		fieldrule := new(FieldRule)
+		err = json.Unmarshal(msg, fieldrule)
+		if err != nil {
+			log.Error("Invalid field rule: %v", err)
+			return nil
+		}
+		return fieldrule
+	}
+	if rule.Type == "chinaip" {
+		chinaiprule := new(ChinaIPRule)
+		if err := json.Unmarshal(msg, chinaiprule); err != nil {
+			log.Error("Invalid chinaip rule: %v", err)
+			return nil
+		}
+		return chinaiprule
+	}
+	if rule.Type == "chinasites" {
+		chinasitesrule := new(ChinaSitesRule)
+		if err := json.Unmarshal(msg, chinasitesrule); err != nil {
+			log.Error("Invalid chinasites rule: %v", err)
+			return nil
+		}
+		return chinasitesrule
+	}
+	log.Error("Unknown router rule type: %s", rule.Type)
+	return nil
+}
+
+func (this *RouterRuleConfig) Rules() []rules.Rule {
+	rules := make([]rules.Rule, len(this.RuleList))
+	for idx, rawRule := range this.RuleList {
+		rules[idx] = parseRule(rawRule)
+	}
+	return rules
+}
+
+func init() {
+	v2routerjson.RegisterRouterConfig("rules", func() interface{} {
+		return new(RouterRuleConfig)
+	})
+}

app/router/rules/json/rules.go

@@ -1,7 +1,6 @@
 package json
 
 import (
-	"github.com/v2ray/v2ray-core/app/point/config"
 	v2net "github.com/v2ray/v2ray-core/common/net"
 )
 
@@ -10,8 +9,8 @@ type Rule struct {
 	OutboundTag string `json:"outboundTag"`
 }
 
-func (this *Rule) Tag() config.DetourTag {
-	return config.DetourTag(this.OutboundTag)
+func (this *Rule) Tag() string {
+	return this.OutboundTag
 }
 
 func (this *Rule) Apply(dest v2net.Destination) bool {

app/router/rules/router.go

@@ -2,48 +2,92 @@ package rules
 
 import (
 	"errors"
+	"time"
 
-	pointconfig "github.com/v2ray/v2ray-core/app/point/config"
 	"github.com/v2ray/v2ray-core/app/router"
-	"github.com/v2ray/v2ray-core/app/router/rules/config"
-	"github.com/v2ray/v2ray-core/app/router/rules/config/json"
+	"github.com/v2ray/v2ray-core/common/collect"
 	v2net "github.com/v2ray/v2ray-core/common/net"
 )
 
 var (
 	InvalidRule      = errors.New("Invalid Rule")
 	NoRuleApplicable = errors.New("No rule applicable")
-
-	EmptyTag = pointconfig.DetourTag("")
 )
 
-type Router struct {
-	rules []config.Rule
+type cacheEntry struct {
+	tag        string
+	err        error
+	validUntil time.Time
 }
 
-func (this *Router) TakeDetour(dest v2net.Destination) (pointconfig.DetourTag, error) {
+func newCacheEntry(tag string, err error) *cacheEntry {
+	this := &cacheEntry{
+		tag: tag,
+		err: err,
+	}
+	this.Extend()
+	return this
+}
+
+func (this *cacheEntry) IsValid() bool {
+	return this.validUntil.Before(time.Now())
+}
+
+func (this *cacheEntry) Extend() {
+	this.validUntil = time.Now().Add(time.Hour)
+}
+
+type Router struct {
+	rules []Rule
+	cache *collect.ValidityMap
+}
+
+func NewRouter() *Router {
+	return &Router{
+		rules: make([]Rule, 0, 16),
+		cache: collect.NewValidityMap(3600),
+	}
+}
+
+func (this *Router) AddRule(rule Rule) *Router {
+	this.rules = append(this.rules, rule)
+	return this
+}
+
+func (this *Router) takeDetourWithoutCache(dest v2net.Destination) (string, error) {
 	for _, rule := range this.rules {
 		if rule.Apply(dest) {
 			return rule.Tag(), nil
 		}
 	}
-	return EmptyTag, NoRuleApplicable
+	return "", NoRuleApplicable
+}
+
+func (this *Router) TakeDetour(dest v2net.Destination) (string, error) {
+	rawEntry := this.cache.Get(dest)
+	if rawEntry == nil {
+		tag, err := this.takeDetourWithoutCache(dest)
+		this.cache.Set(dest, newCacheEntry(tag, err))
+		return tag, err
+	}
+	entry := rawEntry.(*cacheEntry)
+	return entry.tag, entry.err
 }
 
 type RouterFactory struct {
 }
 
 func (this *RouterFactory) Create(rawConfig interface{}) (router.Router, error) {
-	config := rawConfig.(*json.RouterRuleConfig)
+	config := rawConfig.(RouterRuleConfig)
 	rules := config.Rules()
+	router := NewRouter()
 	for _, rule := range rules {
 		if rule == nil {
 			return nil, InvalidRule
 		}
+		router.AddRule(rule)
 	}
-	return &Router{
-		rules: rules,
-	}, nil
+	return router, nil
 }
 
 func init() {

app/router/rules/router_test.go

@@ -0,0 +1,27 @@
+package rules_test
+
+import (
+	"testing"
+
+	. "github.com/v2ray/v2ray-core/app/router/rules"
+	testinconfig "github.com/v2ray/v2ray-core/app/router/rules/testing"
+	v2net "github.com/v2ray/v2ray-core/common/net"
+	v2testing "github.com/v2ray/v2ray-core/testing"
+	"github.com/v2ray/v2ray-core/testing/assert"
+)
+
+func TestSimpleRouter(t *testing.T) {
+	v2testing.Current(t)
+
+	router := NewRouter().AddRule(
+		&testinconfig.TestRule{
+			TagValue: "test",
+			Function: func(dest v2net.Destination) bool {
+				return dest.IsTCP()
+			},
+		})
+
+	tag, err := router.TakeDetour(v2net.TCPDestination(v2net.DomainAddress("v2ray.com"), 80))
+	assert.Error(err).IsNil()
+	assert.StringLiteral(tag).Equals("test")
+}

app/router/rules/testing/router.go

@@ -0,0 +1,17 @@
+package testing
+
+import (
+	"github.com/v2ray/v2ray-core/app/router/rules"
+)
+
+type RouterRuleConfig struct {
+	RuleList []*TestRule
+}
+
+func (this *RouterRuleConfig) Rules() []rules.Rule {
+	rules := make([]rules.Rule, len(this.RuleList))
+	for idx, rule := range this.RuleList {
+		rules[idx] = rule
+	}
+	return rules
+}

app/router/rules/testing/rule.go

@@ -0,0 +1,18 @@
+package testing
+
+import (
+	v2net "github.com/v2ray/v2ray-core/common/net"
+)
+
+type TestRule struct {
+	Function func(v2net.Destination) bool
+	TagValue string
+}
+
+func (this *TestRule) Apply(dest v2net.Destination) bool {
+	return this.Function(dest)
+}
+
+func (this *TestRule) Tag() string {
+	return this.TagValue
+}

app/router/testing/config.go

@@ -0,0 +1,14 @@
+package testing
+
+type RouterConfig struct {
+	StrategyValue string
+	SettingsValue interface{}
+}
+
+func (this *RouterConfig) Strategy() string {
+	return this.StrategyValue
+}
+
+func (this *RouterConfig) Settings() interface{} {
+	return this.SettingsValue
+}

app/space.go

@@ -0,0 +1,22 @@
+package app
+
+// Context of a function call from proxy to app.
+type Context interface {
+	CallerTag() string
+}
+
+// A Space contains all apps that may be available in a V2Ray runtime.
+// Caller must check the availability of an app by calling HasXXX before getting its instance.
+type Space interface {
+	HasPacketDispatcher() bool
+	PacketDispatcher() PacketDispatcher
+
+	HasDnsCache() bool
+	DnsCache() DnsCache
+
+	HasPubsub() bool
+	Pubsub() Pubsub
+
+	HasInboundHandlerManager() bool
+	InboundHandlerManager() InboundHandlerManager
+}

app/testing/space.go

@@ -0,0 +1,9 @@
+package testing
+
+type Context struct {
+	CallerTagValue string
+}
+
+func (this *Context) CallerTag() string {
+	return this.CallerTagValue
+}

common/alloc/buffer.go

@@ -1,7 +1,7 @@
 package alloc
 
 import (
-	"time"
+	"sync"
 )
 
 // Buffer is a recyclable allocation of a byte array. Buffer.Release() recycles
@@ -40,6 +40,10 @@ func (b *Buffer) Append(data []byte) *Buffer {
 	return b
 }
 
+func (b *Buffer) Bytes() []byte {
+	return b.Value
+}
+
 // Slice cuts the buffer at the given position.
 func (b *Buffer) Slice(from, to int) *Buffer {
 	b.Value = b.Value[from:to]
@@ -69,21 +73,20 @@ func (b *Buffer) Write(data []byte) (int, error) {
 }
 
 type bufferPool struct {
-	chain        chan []byte
-	bufferSize   int
-	buffers2Keep int
+	chain     chan []byte
+	allocator *sync.Pool
 }
 
-func newBufferPool(bufferSize, buffers2Keep, poolSize int) *bufferPool {
+func newBufferPool(bufferSize, poolSize int) *bufferPool {
 	pool := &bufferPool{
-		chain:        make(chan []byte, poolSize),
-		bufferSize:   bufferSize,
-		buffers2Keep: buffers2Keep,
+		chain: make(chan []byte, poolSize),
+		allocator: &sync.Pool{
+			New: func() interface{} { return make([]byte, bufferSize) },
+		},
 	}
-	for i := 0; i < buffers2Keep; i++ {
+	for i := 0; i < poolSize; i++ {
 		pool.chain <- make([]byte, bufferSize)
 	}
-	go pool.cleanup(time.Tick(1 * time.Second))
 	return pool
 }
 
@@ -92,7 +95,7 @@ func (p *bufferPool) allocate() *Buffer {
 	select {
 	case b = <-p.chain:
 	default:
-		b = make([]byte, p.bufferSize)
+		b = p.allocator.Get().([]byte)
 	}
 	return &Buffer{
 		head:  b,
@@ -105,28 +108,13 @@ func (p *bufferPool) free(buffer *Buffer) {
 	select {
 	case p.chain <- buffer.head:
 	default:
+		p.allocator.Put(buffer.head)
 	}
 }
 
-func (p *bufferPool) cleanup(tick <-chan time.Time) {
-	for range tick {
-		pSize := len(p.chain)
-		if pSize > p.buffers2Keep {
-			<-p.chain
-			continue
-		}
-		for delta := p.buffers2Keep - pSize; delta > 0; delta-- {
-			select {
-			case p.chain <- make([]byte, p.bufferSize):
-			default:
-			}
-		}
-	}
-}
-
-var smallPool = newBufferPool(1024, 64, 512)
-var mediumPool = newBufferPool(8*1024, 256, 2048)
-var largePool = newBufferPool(64*1024, 128, 1024)
+var smallPool = newBufferPool(1024, 256)
+var mediumPool = newBufferPool(8*1024, 512)
+var largePool = newBufferPool(64*1024, 128)
 
 // NewSmallBuffer creates a Buffer with 1K bytes of arbitrary content.
 func NewSmallBuffer() *Buffer {

common/alloc/buffer_test.go

@@ -3,11 +3,12 @@ package alloc
 import (
 	"testing"
 
-	"github.com/v2ray/v2ray-core/testing/unit"
+	v2testing "github.com/v2ray/v2ray-core/testing"
+	"github.com/v2ray/v2ray-core/testing/assert"
 )
 
 func TestBufferClear(t *testing.T) {
-	assert := unit.Assert(t)
+	v2testing.Current(t)
 
 	buffer := NewBuffer().Clear()
 	defer buffer.Release()
@@ -21,7 +22,7 @@ func TestBufferClear(t *testing.T) {
 }
 
 func TestBufferIsFull(t *testing.T) {
-	assert := unit.Assert(t)
+	v2testing.Current(t)
 
 	buffer := NewBuffer()
 	defer buffer.Release()

common/collect/timed_queue.go

@@ -39,56 +39,67 @@ func (queue *timedQueueImpl) Pop() interface{} {
 	return v
 }
 
+// TimedQueue is a priority queue that entries with oldest timestamp get removed first.
 type TimedQueue struct {
-	queue   timedQueueImpl
-	access  sync.RWMutex
-	removed chan interface{}
+	queue           timedQueueImpl
+	access          sync.Mutex
+	removedCallback func(interface{})
 }
 
-func NewTimedQueue(updateInterval int) *TimedQueue {
+func NewTimedQueue(updateInterval int, removedCallback func(interface{})) *TimedQueue {
 	queue := &TimedQueue{
-		queue:   make([]*timedQueueEntry, 0, 256),
-		removed: make(chan interface{}, 16),
-		access:  sync.RWMutex{},
+		queue:           make([]*timedQueueEntry, 0, 256),
+		removedCallback: removedCallback,
+		access:          sync.Mutex{},
 	}
 	go queue.cleanup(time.Tick(time.Duration(updateInterval) * time.Second))
 	return queue
 }
 
 func (queue *TimedQueue) Add(value interface{}, time2Remove int64) {
-	queue.access.Lock()
-	heap.Push(&queue.queue, &timedQueueEntry{
+	newEntry := &timedQueueEntry{
 		timeSec: time2Remove,
 		value:   value,
-	})
+	}
+	var removedEntry *timedQueueEntry
+	queue.access.Lock()
+	nowSec := time.Now().Unix()
+	if queue.queue.Len() > 0 && queue.queue[0].timeSec < nowSec {
+		removedEntry = queue.queue[0]
+		queue.queue[0] = newEntry
+		heap.Fix(&queue.queue, 0)
+	} else {
+		heap.Push(&queue.queue, newEntry)
+	}
 	queue.access.Unlock()
-}
-
-func (queue *TimedQueue) RemovedEntries() <-chan interface{} {
-	return queue.removed
+	if removedEntry != nil {
+		queue.removedCallback(removedEntry.value)
+	}
 }
 
 func (queue *TimedQueue) cleanup(tick <-chan time.Time) {
 	for now := range tick {
 		nowSec := now.Unix()
-		for {
-			queue.access.RLock()
-			queueLen := queue.queue.Len()
-			queue.access.RUnlock()
-			if queueLen == 0 {
+		removedEntries := make([]*timedQueueEntry, 0, 128)
+		queue.access.Lock()
+		changed := false
+		for i := 0; i < queue.queue.Len(); i++ {
+			entry := queue.queue[i]
+			if entry.timeSec < nowSec {
+				removedEntries = append(removedEntries, entry)
+				queue.queue.Swap(i, queue.queue.Len()-1)
+				queue.queue.Pop()
+				changed = true
+			} else {
 				break
 			}
-			queue.access.RLock()
-			entry := queue.queue[0]
-			queue.access.RUnlock()
-			if entry.timeSec > nowSec {
-				break
-			}
-			queue.access.Lock()
-			heap.Pop(&queue.queue)
-			queue.access.Unlock()
-
-			queue.removed <- entry.value
+		}
+		if changed {
+			heap.Init(&queue.queue)
+		}
+		queue.access.Unlock()
+		for _, entry := range removedEntries {
+			queue.removedCallback(entry.value)
 		}
 	}
 }

common/collect/timed_queue_test.go

@@ -4,23 +4,19 @@ import (
 	"testing"
 	"time"
 
-	"github.com/v2ray/v2ray-core/testing/unit"
+	v2testing "github.com/v2ray/v2ray-core/testing"
+	"github.com/v2ray/v2ray-core/testing/assert"
 )
 
 func TestTimedQueue(t *testing.T) {
-	assert := unit.Assert(t)
+	v2testing.Current(t)
 
 	removed := make(map[string]bool)
 
 	nowSec := time.Now().Unix()
-	q := NewTimedQueue(2)
-
-	go func() {
-		for {
-			entry := <-q.RemovedEntries()
-			removed[entry.(string)] = true
-		}
-	}()
+	q := NewTimedQueue(2, func(v interface{}) {
+		removed[v.(string)] = true
+	})
 
 	q.Add("Value1", nowSec)
 	q.Add("Value2", nowSec+5)

common/collect/validity_map.go

@@ -0,0 +1,71 @@
+package collect
+
+import (
+	"sync"
+	"time"
+
+	"github.com/v2ray/v2ray-core/common/serial"
+)
+
+type Validity interface {
+	IsValid() bool
+}
+
+type entry struct {
+	key   string
+	value Validity
+}
+
+type ValidityMap struct {
+	sync.RWMutex
+	cache              map[string]Validity
+	cleanupIntervalSec int
+}
+
+func NewValidityMap(cleanupIntervalSec int) *ValidityMap {
+	instance := &ValidityMap{
+		cache:              make(map[string]Validity),
+		cleanupIntervalSec: cleanupIntervalSec,
+	}
+	go instance.cleanup()
+	return instance
+}
+
+func (this *ValidityMap) cleanup() {
+	for range time.Tick(time.Duration(this.cleanupIntervalSec) * time.Second) {
+		entry2Remove := make([]entry, 0, 128)
+		this.RLock()
+		for key, value := range this.cache {
+			if !value.IsValid() {
+				entry2Remove = append(entry2Remove, entry{
+					key:   key,
+					value: value,
+				})
+			}
+		}
+		this.RUnlock()
+
+		for _, entry := range entry2Remove {
+			if !entry.value.IsValid() {
+				this.Lock()
+				delete(this.cache, entry.key)
+				this.Unlock()
+			}
+		}
+	}
+}
+
+func (this *ValidityMap) Set(key serial.String, value Validity) {
+	this.Lock()
+	this.cache[key.String()] = value
+	this.Unlock()
+}
+
+func (this *ValidityMap) Get(key serial.String) Validity {
+	this.RLock()
+	defer this.RUnlock()
+	if value, found := this.cache[key.String()]; found {
+		return value
+	}
+	return nil
+}

common/log/access.go

@@ -1,12 +1,5 @@
 package log
 
-import (
-	"log"
-	"os"
-
-	"github.com/v2ray/v2ray-core/common/platform"
-)
-
 // AccessStatus is the status of an access request from clients.
 type AccessStatus string
 
@@ -15,16 +8,9 @@ const (
 	AccessRejected = AccessStatus("rejected")
 )
 
-type accessLogger interface {
-	Log(from, to string, status AccessStatus, reason string)
-}
-
-type noOpAccessLogger struct {
-}
-
-func (logger *noOpAccessLogger) Log(from, to string, status AccessStatus, reason string) {
-	// Swallow
-}
+var (
+	accessLoggerInstance logWriter = &noOpLogWriter{}
+)
 
 type accessLog struct {
 	From   string
@@ -33,60 +19,27 @@ type accessLog struct {
 	Reason string
 }
 
-type fileAccessLogger struct {
-	queue  chan *accessLog
-	logger *log.Logger
-	file   *os.File
+func (this *accessLog) String() string {
+	return this.From + " " + string(this.Status) + " " + this.To + " " + this.Reason
 }
 
-func (logger *fileAccessLogger) close() {
-	logger.file.Close()
-}
-
-func (logger *fileAccessLogger) Log(from, to string, status AccessStatus, reason string) {
-	select {
-	case logger.queue <- &accessLog{
-		From:   from,
-		To:     to,
-		Status: status,
-		Reason: reason,
-	}:
-	default:
-		// We don't expect this to happen, but don't want to block main thread as well.
-	}
-}
-
-func (logger *fileAccessLogger) Run() {
-	for entry := range logger.queue {
-		logger.logger.Println(entry.From + " " + string(entry.Status) + " " + entry.To + " " + entry.Reason)
-	}
-}
-
-func newFileAccessLogger(path string) accessLogger {
-	file, err := os.OpenFile(path, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0600)
-	if err != nil {
-		log.Printf("Unable to create or open file (%s): %v%s", path, err, platform.LineSeparator())
-		return nil
-	}
-	return &fileAccessLogger{
-		queue:  make(chan *accessLog, 16),
-		logger: log.New(file, "", log.Ldate|log.Ltime),
-		file:   file,
-	}
-}
-
-var accessLoggerInstance accessLogger = &noOpAccessLogger{}
-
 // InitAccessLogger initializes the access logger to write into the give file.
-func InitAccessLogger(file string) {
-	logger := newFileAccessLogger(file)
-	if logger != nil {
-		go logger.(*fileAccessLogger).Run()
-		accessLoggerInstance = logger
+func InitAccessLogger(file string) error {
+	logger, err := newFileLogWriter(file)
+	if err != nil {
+		Error("Failed to create access logger on file (%s): %v", file, err)
+		return err
 	}
+	accessLoggerInstance = logger
+	return nil
 }
 
 // Access writes an access log.
 func Access(from, to string, status AccessStatus, reason string) {
-	accessLoggerInstance.Log(from, to, status, reason)
+	accessLoggerInstance.Log(&accessLog{
+		From:   from,
+		To:     to,
+		Status: status,
+		Reason: reason,
+	})
 }

common/log/access_test.go

@@ -3,15 +3,16 @@ package log
 import (
 	"io/ioutil"
 	"os"
-	"strings"
 	"testing"
 	"time"
 
-	"github.com/v2ray/v2ray-core/testing/unit"
+	"github.com/v2ray/v2ray-core/common/serial"
+	v2testing "github.com/v2ray/v2ray-core/testing"
+	"github.com/v2ray/v2ray-core/testing/assert"
 )
 
 func TestAccessLog(t *testing.T) {
-	assert := unit.Assert(t)
+	v2testing.Current(t)
 
 	filename := "/tmp/test_access_log.log"
 	InitAccessLogger(filename)
@@ -21,14 +22,15 @@ func TestAccessLog(t *testing.T) {
 	Access("test_from", "test_to", AccessAccepted, "test_reason")
 	<-time.After(2 * time.Second)
 
-	accessLoggerInstance.(*fileAccessLogger).close()
-	accessLoggerInstance = &noOpAccessLogger{}
+	accessLoggerInstance.(*fileLogWriter).close()
+	accessLoggerInstance = &noOpLogWriter{}
 
 	content, err := ioutil.ReadFile(filename)
 	assert.Error(err).IsNil()
 
-	assert.Bool(strings.Contains(string(content), "test_from")).IsTrue()
-	assert.Bool(strings.Contains(string(content), "test_to")).IsTrue()
-	assert.Bool(strings.Contains(string(content), "test_reason")).IsTrue()
-	assert.Bool(strings.Contains(string(content), "accepted")).IsTrue()
+	contentStr := serial.StringLiteral(content)
+	assert.String(contentStr).Contains(serial.StringLiteral("test_from"))
+	assert.String(contentStr).Contains(serial.StringLiteral("test_to"))
+	assert.String(contentStr).Contains(serial.StringLiteral("test_reason"))
+	assert.String(contentStr).Contains(serial.StringLiteral("accepted"))
 }

common/log/log.go

@@ -2,10 +2,6 @@ package log
 
 import (
 	"fmt"
-	"io"
-	"os"
-
-	"github.com/v2ray/v2ray-core/common/platform"
 )
 
 const (
@@ -15,41 +11,30 @@ const (
 	ErrorLevel   = LogLevel(3)
 )
 
-type logger interface {
-	WriteLog(prefix, format string, v ...interface{})
+type errorLog struct {
+	prefix string
+	format string
+	values []interface{}
 }
 
-type noOpLogger struct {
-}
-
-func (l *noOpLogger) WriteLog(prefix, format string, v ...interface{}) {
-	// Swallow
-}
-
-type streamLogger struct {
-	writer io.Writer
-}
-
-func (l *streamLogger) WriteLog(prefix, format string, v ...interface{}) {
+func (this *errorLog) String() string {
 	var data string
-	if v == nil || len(v) == 0 {
-		data = format
+	if len(this.values) == 0 {
+		data = this.format
 	} else {
-		data = fmt.Sprintf(format, v...)
+		data = fmt.Sprintf(this.format, this.values...)
 	}
-	l.writer.Write([]byte(prefix + data + platform.LineSeparator()))
+	return this.prefix + data
 }
 
 var (
-	noOpLoggerInstance   logger = &noOpLogger{}
-	streamLoggerInstance logger = &streamLogger{
-		writer: os.Stdout,
-	}
+	noOpLoggerInstance   logWriter = &noOpLogWriter{}
+	streamLoggerInstance logWriter = newStdOutLogWriter()
 
 	debugLogger   = noOpLoggerInstance
 	infoLogger    = noOpLoggerInstance
-	warningLogger = noOpLoggerInstance
-	errorLogger   = noOpLoggerInstance
+	warningLogger = streamLoggerInstance
+	errorLogger   = streamLoggerInstance
 )
 
 type LogLevel int
@@ -76,22 +61,48 @@ func SetLogLevel(level LogLevel) {
 	}
 }
 
+func InitErrorLogger(file string) error {
+	logger, err := newFileLogWriter(file)
+	if err != nil {
+		Error("Failed to create error logger on file (%s): %v", file, err)
+		return err
+	}
+	streamLoggerInstance = logger
+	return nil
+}
+
 // Debug outputs a debug log with given format and optional arguments.
 func Debug(format string, v ...interface{}) {
-	debugLogger.WriteLog("[Debug]", format, v...)
+	debugLogger.Log(&errorLog{
+		prefix: "[Debug]",
+		format: format,
+		values: v,
+	})
 }
 
 // Info outputs an info log with given format and optional arguments.
 func Info(format string, v ...interface{}) {
-	infoLogger.WriteLog("[Info]", format, v...)
+	infoLogger.Log(&errorLog{
+		prefix: "[Info]",
+		format: format,
+		values: v,
+	})
 }
 
 // Warning outputs a warning log with given format and optional arguments.
 func Warning(format string, v ...interface{}) {
-	warningLogger.WriteLog("[Warning]", format, v...)
+	warningLogger.Log(&errorLog{
+		prefix: "[Warning]",
+		format: format,
+		values: v,
+	})
 }
 
 // Error outputs an error log with given format and optional arguments.
 func Error(format string, v ...interface{}) {
-	errorLogger.WriteLog("[Error]", format, v...)
+	errorLogger.Log(&errorLog{
+		prefix: "[Error]",
+		format: format,
+		values: v,
+	})
 }

common/log/log_test.go

@@ -2,13 +2,15 @@ package log
 
 import (
 	"bytes"
+	"log"
 	"testing"
 
-	"github.com/v2ray/v2ray-core/testing/unit"
+	v2testing "github.com/v2ray/v2ray-core/testing"
+	"github.com/v2ray/v2ray-core/testing/assert"
 )
 
 func TestLogLevelSetting(t *testing.T) {
-	assert := unit.Assert(t)
+	v2testing.Current(t)
 
 	assert.Pointer(debugLogger).Equals(noOpLoggerInstance)
 	SetLogLevel(DebugLevel)
@@ -20,16 +22,17 @@ func TestLogLevelSetting(t *testing.T) {
 }
 
 func TestStreamLogger(t *testing.T) {
-	assert := unit.Assert(t)
+	v2testing.Current(t)
 
 	buffer := bytes.NewBuffer(make([]byte, 0, 1024))
-	logger := &streamLogger{
-		writer: buffer,
+	infoLogger = &stdOutLogWriter{
+		logger: log.New(buffer, "", 0),
 	}
-	logger.WriteLog("TestPrefix: ", "Test %s Format", "Stream Logger")
-	assert.Bytes(buffer.Bytes()).Equals([]byte("TestPrefix: Test Stream Logger Format\n"))
+	Info("Test %s Format", "Stream Logger")
+	assert.Bytes(buffer.Bytes()).Equals([]byte("[Info]Test Stream Logger Format\n"))
 
 	buffer.Reset()
-	logger.WriteLog("TestPrefix: ", "Test No Format")
-	assert.Bytes(buffer.Bytes()).Equals([]byte("TestPrefix: Test No Format\n"))
+	errorLogger = infoLogger
+	Error("Test No Format")
+	assert.Bytes(buffer.Bytes()).Equals([]byte("[Error]Test No Format\n"))
 }

common/log/log_writer.go

@@ -0,0 +1,77 @@
+package log
+
+import (
+	"io"
+	"log"
+	"os"
+
+	"github.com/v2ray/v2ray-core/common/platform"
+	"github.com/v2ray/v2ray-core/common/serial"
+)
+
+func createLogger(writer io.Writer) *log.Logger {
+	return log.New(writer, "", log.Ldate|log.Ltime)
+}
+
+type logWriter interface {
+	Log(serial.String)
+}
+
+type noOpLogWriter struct {
+}
+
+func (this *noOpLogWriter) Log(serial.String) {
+	// Swallow
+}
+
+type stdOutLogWriter struct {
+	logger *log.Logger
+}
+
+func newStdOutLogWriter() logWriter {
+	return &stdOutLogWriter{
+		logger: createLogger(os.Stdout),
+	}
+}
+
+func (this *stdOutLogWriter) Log(log serial.String) {
+	this.logger.Print(log.String() + platform.LineSeparator())
+}
+
+type fileLogWriter struct {
+	queue  chan serial.String
+	logger *log.Logger
+	file   *os.File
+}
+
+func (this *fileLogWriter) Log(log serial.String) {
+	select {
+	case this.queue <- log:
+	default:
+		// We don't expect this to happen, but don't want to block main thread as well.
+	}
+}
+
+func (this *fileLogWriter) run() {
+	for entry := range this.queue {
+		this.logger.Print(entry.String() + platform.LineSeparator())
+	}
+}
+
+func (this *fileLogWriter) close() {
+	this.file.Close()
+}
+
+func newFileLogWriter(path string) (*fileLogWriter, error) {
+	file, err := os.OpenFile(path, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0600)
+	if err != nil {
+		return nil, err
+	}
+	logger := &fileLogWriter{
+		queue:  make(chan serial.String, 16),
+		logger: log.New(file, "", log.Ldate|log.Ltime),
+		file:   file,
+	}
+	go logger.run()
+	return logger, nil
+}

common/net/address.go

@@ -2,7 +2,6 @@ package net
 
 import (
 	"net"
-	"strconv"
 
 	"github.com/v2ray/v2ray-core/common/log"
 )
@@ -10,10 +9,8 @@ import (
 // Address represents a network address to be communicated with. It may be an IP address or domain
 // address, not both. This interface doesn't resolve IP address for a given domain.
 type Address interface {
-	IP() net.IP        // IP of this Address
-	Domain() string    // Domain of this Address
-	Port() uint16      // Port of this Address
-	PortBytes() []byte // Port in bytes, network byte order
+	IP() net.IP     // IP of this Address
+	Domain() string // Domain of this Address
 
 	IsIPv4() bool   // True if this Address is an IPv4 address
 	IsIPv6() bool   // True if this Address is an IPv6 address
@@ -32,19 +29,17 @@ func allZeros(data []byte) bool {
 }
 
 // IPAddress creates an Address with given IP and port.
-func IPAddress(ip []byte, port uint16) Address {
+func IPAddress(ip []byte) Address {
 	switch len(ip) {
 	case net.IPv4len:
-		return IPv4Address{
-			PortAddress: PortAddress{port: port},
-			ip:          [4]byte{ip[0], ip[1], ip[2], ip[3]},
+		return &IPv4Address{
+			ip: [4]byte{ip[0], ip[1], ip[2], ip[3]},
 		}
 	case net.IPv6len:
 		if allZeros(ip[0:10]) && ip[10] == 0xff && ip[11] == 0xff {
-			return IPAddress(ip[12:16], port)
+			return IPAddress(ip[12:16])
 		}
-		return IPv6Address{
-			PortAddress: PortAddress{port: port},
+		return &IPv6Address{
 			ip: [16]byte{
 				ip[0], ip[1], ip[2], ip[3],
 				ip[4], ip[5], ip[6], ip[7],
@@ -59,108 +54,95 @@ func IPAddress(ip []byte, port uint16) Address {
 }
 
 // DomainAddress creates an Address with given domain and port.
-func DomainAddress(domain string, port uint16) Address {
-	return DomainAddressImpl{
-		domain:      domain,
-		PortAddress: PortAddress{port: port},
+func DomainAddress(domain string) Address {
+	return &DomainAddressImpl{
+		domain: domain,
 	}
 }
 
-type PortAddress struct {
-	port uint16
-}
-
-func (addr PortAddress) Port() uint16 {
-	return addr.port
-}
-
-func (addr PortAddress) PortBytes() []byte {
-	return []byte{byte(addr.port >> 8), byte(addr.port)}
+type address struct {
 }
 
 type IPv4Address struct {
-	PortAddress
 	ip [4]byte
 }
 
-func (addr IPv4Address) IP() net.IP {
+func (addr *IPv4Address) IP() net.IP {
 	return net.IP(addr.ip[:])
 }
 
-func (addr IPv4Address) Domain() string {
+func (addr *IPv4Address) Domain() string {
 	panic("Calling Domain() on an IPv4Address.")
 }
 
-func (addr IPv4Address) IsIPv4() bool {
+func (addr *IPv4Address) IsIPv4() bool {
 	return true
 }
 
-func (addr IPv4Address) IsIPv6() bool {
+func (addr *IPv4Address) IsIPv6() bool {
 	return false
 }
 
-func (addr IPv4Address) IsDomain() bool {
+func (addr *IPv4Address) IsDomain() bool {
 	return false
 }
 
-func (addr IPv4Address) String() string {
-	return addr.IP().String() + ":" + strconv.Itoa(int(addr.PortAddress.port))
+func (this *IPv4Address) String() string {
+	return this.IP().String()
 }
 
 type IPv6Address struct {
-	PortAddress
 	ip [16]byte
 }
 
-func (addr IPv6Address) IP() net.IP {
+func (addr *IPv6Address) IP() net.IP {
 	return net.IP(addr.ip[:])
 }
 
-func (addr IPv6Address) Domain() string {
+func (addr *IPv6Address) Domain() string {
 	panic("Calling Domain() on an IPv6Address.")
 }
 
-func (addr IPv6Address) IsIPv4() bool {
+func (addr *IPv6Address) IsIPv4() bool {
 	return false
 }
 
-func (addr IPv6Address) IsIPv6() bool {
+func (addr *IPv6Address) IsIPv6() bool {
 	return true
 }
 
-func (addr IPv6Address) IsDomain() bool {
+func (addr *IPv6Address) IsDomain() bool {
 	return false
 }
 
-func (addr IPv6Address) String() string {
-	return "[" + addr.IP().String() + "]:" + strconv.Itoa(int(addr.PortAddress.port))
+func (this *IPv6Address) String() string {
+	return "[" + this.IP().String() + "]"
 }
 
 type DomainAddressImpl struct {
-	PortAddress
 	domain string
 }
 
-func (addr DomainAddressImpl) IP() net.IP {
+func (addr *DomainAddressImpl) IP() net.IP {
 	panic("Calling IP() on a DomainAddress.")
 }
 
-func (addr DomainAddressImpl) Domain() string {
+func (addr *DomainAddressImpl) Domain() string {
 	return addr.domain
 }
 
-func (addr DomainAddressImpl) IsIPv4() bool {
+func (addr *DomainAddressImpl) IsIPv4() bool {
 	return false
 }
 
-func (addr DomainAddressImpl) IsIPv6() bool {
+func (addr *DomainAddressImpl) IsIPv6() bool {
 	return false
 }
 
-func (addr DomainAddressImpl) IsDomain() bool {
+func (addr *DomainAddressImpl) IsDomain() bool {
 	return true
 }
 
-func (addr DomainAddressImpl) String() string {
-	return addr.domain + ":" + strconv.Itoa(int(addr.PortAddress.port))
+func (this *DomainAddressImpl) String() string {
+	return this.domain
 }

common/net/address_test.go

@@ -1,29 +1,30 @@
-package net
+package net_test
 
 import (
 	"net"
 	"testing"
 
-	"github.com/v2ray/v2ray-core/testing/unit"
+	v2net "github.com/v2ray/v2ray-core/common/net"
+	v2netassert "github.com/v2ray/v2ray-core/common/net/testing/assert"
+	v2testing "github.com/v2ray/v2ray-core/testing"
+	"github.com/v2ray/v2ray-core/testing/assert"
 )
 
 func TestIPv4Address(t *testing.T) {
-	assert := unit.Assert(t)
+	v2testing.Current(t)
 
 	ip := []byte{byte(1), byte(2), byte(3), byte(4)}
-	port := uint16(80)
-	addr := IPAddress(ip, port)
+	addr := v2net.IPAddress(ip)
 
-	assert.Bool(addr.IsIPv4()).IsTrue()
-	assert.Bool(addr.IsIPv6()).IsFalse()
-	assert.Bool(addr.IsDomain()).IsFalse()
+	v2netassert.Address(addr).IsIPv4()
+	v2netassert.Address(addr).IsNotIPv6()
+	v2netassert.Address(addr).IsNotDomain()
 	assert.Bytes(addr.IP()).Equals(ip)
-	assert.Uint16(addr.Port()).Equals(port)
-	assert.String(addr.String()).Equals("1.2.3.4:80")
+	assert.String(addr).Equals("1.2.3.4")
 }
 
 func TestIPv6Address(t *testing.T) {
-	assert := unit.Assert(t)
+	v2testing.Current(t)
 
 	ip := []byte{
 		byte(1), byte(2), byte(3), byte(4),
@@ -31,38 +32,33 @@ func TestIPv6Address(t *testing.T) {
 		byte(1), byte(2), byte(3), byte(4),
 		byte(1), byte(2), byte(3), byte(4),
 	}
-	port := uint16(443)
-	addr := IPAddress(ip, port)
+	addr := v2net.IPAddress(ip)
 
-	assert.Bool(addr.IsIPv6()).IsTrue()
-	assert.Bool(addr.IsIPv4()).IsFalse()
-	assert.Bool(addr.IsDomain()).IsFalse()
+	v2netassert.Address(addr).IsIPv6()
+	v2netassert.Address(addr).IsNotIPv4()
+	v2netassert.Address(addr).IsNotDomain()
 	assert.Bytes(addr.IP()).Equals(ip)
-	assert.Uint16(addr.Port()).Equals(port)
-	assert.String(addr.String()).Equals("[102:304:102:304:102:304:102:304]:443")
+	assert.String(addr).Equals("[102:304:102:304:102:304:102:304]")
 }
 
 func TestDomainAddress(t *testing.T) {
-	assert := unit.Assert(t)
+	v2testing.Current(t)
 
 	domain := "v2ray.com"
-	port := uint16(443)
-	addr := DomainAddress(domain, port)
+	addr := v2net.DomainAddress(domain)
 
-	assert.Bool(addr.IsDomain()).IsTrue()
-	assert.Bool(addr.IsIPv4()).IsFalse()
-	assert.Bool(addr.IsIPv6()).IsFalse()
-	assert.String(addr.Domain()).Equals(domain)
-	assert.Uint16(addr.Port()).Equals(port)
-	assert.String(addr.String()).Equals("v2ray.com:443")
+	v2netassert.Address(addr).IsDomain()
+	v2netassert.Address(addr).IsNotIPv6()
+	v2netassert.Address(addr).IsNotIPv4()
+	assert.StringLiteral(addr.Domain()).Equals(domain)
+	assert.String(addr).Equals("v2ray.com")
 }
 
 func TestNetIPv4Address(t *testing.T) {
-	assert := unit.Assert(t)
+	v2testing.Current(t)
 
 	ip := net.IPv4(1, 2, 3, 4)
-	port := uint16(80)
-	addr := IPAddress(ip, port)
-	assert.Bool(addr.IsIPv4()).IsTrue()
-	assert.String(addr.String()).Equals("1.2.3.4:80")
+	addr := v2net.IPAddress(ip)
+	v2netassert.Address(addr).IsIPv4()
+	assert.String(addr).Equals("1.2.3.4")
 }

common/net/destination.go

@@ -4,66 +4,86 @@ package net
 type Destination interface {
 	Network() string  // Protocol of communication (tcp / udp)
 	Address() Address // Address of destination
-	String() string   // String representation of the destination
+	Port() Port
+	String() string // String representation of the destination
+	NetAddr() string
 
 	IsTCP() bool // True if destination is reachable via TCP
 	IsUDP() bool // True if destination is reachable via UDP
 }
 
-// NewTCPDestination creates a TCP destination with given address
-func NewTCPDestination(address Address) Destination {
-	return TCPDestination{address: address}
+// TCPDestination creates a TCP destination with given address
+func TCPDestination(address Address, port Port) Destination {
+	return &tcpDestination{address: address, port: port}
 }
 
-// NewUDPDestination creates a UDP destination with given address
-func NewUDPDestination(address Address) Destination {
-	return UDPDestination{address: address}
+// UDPDestination creates a UDP destination with given address
+func UDPDestination(address Address, port Port) Destination {
+	return &udpDestination{address: address, port: port}
 }
 
-type TCPDestination struct {
+type tcpDestination struct {
 	address Address
+	port    Port
 }
 
-func (dest TCPDestination) Network() string {
+func (dest *tcpDestination) Network() string {
 	return "tcp"
 }
 
-func (dest TCPDestination) Address() Address {
+func (dest *tcpDestination) Address() Address {
 	return dest.address
 }
 
-func (dest TCPDestination) String() string {
-	return "tcp:" + dest.address.String()
+func (dest *tcpDestination) NetAddr() string {
+	return dest.address.String() + ":" + dest.port.String()
 }
 
-func (dest TCPDestination) IsTCP() bool {
+func (dest *tcpDestination) String() string {
+	return "tcp:" + dest.NetAddr()
+}
+
+func (dest *tcpDestination) IsTCP() bool {
 	return true
 }
 
-func (dest TCPDestination) IsUDP() bool {
+func (dest *tcpDestination) IsUDP() bool {
 	return false
 }
 
-type UDPDestination struct {
-	address Address
+func (dest *tcpDestination) Port() Port {
+	return dest.port
 }
 
-func (dest UDPDestination) Network() string {
+type udpDestination struct {
+	address Address
+	port    Port
+}
+
+func (dest *udpDestination) Network() string {
 	return "udp"
 }
 
-func (dest UDPDestination) Address() Address {
+func (dest *udpDestination) Address() Address {
 	return dest.address
 }
 
-func (dest UDPDestination) String() string {
-	return "udp:" + dest.address.String()
+func (dest *udpDestination) NetAddr() string {
+	return dest.address.String() + ":" + dest.port.String()
 }
 
-func (dest UDPDestination) IsTCP() bool {
+func (dest *udpDestination) String() string {
+	return "udp:" + dest.NetAddr()
+}
+
+func (dest *udpDestination) IsTCP() bool {
 	return false
 }
 
-func (dest UDPDestination) IsUDP() bool {
+func (dest *udpDestination) IsUDP() bool {
 	return true
 }
+
+func (dest *udpDestination) Port() Port {
+	return dest.port
+}

common/net/destination_test.go

@@ -1,25 +1,28 @@
-package net
+package net_test
 
 import (
 	"testing"
 
-	"github.com/v2ray/v2ray-core/testing/unit"
+	v2net "github.com/v2ray/v2ray-core/common/net"
+	v2netassert "github.com/v2ray/v2ray-core/common/net/testing/assert"
+	v2testing "github.com/v2ray/v2ray-core/testing"
+	"github.com/v2ray/v2ray-core/testing/assert"
 )
 
 func TestTCPDestination(t *testing.T) {
-	assert := unit.Assert(t)
+	v2testing.Current(t)
 
-	dest := NewTCPDestination(IPAddress([]byte{1, 2, 3, 4}, 80))
-	assert.Bool(dest.IsTCP()).IsTrue()
-	assert.Bool(dest.IsUDP()).IsFalse()
-	assert.String(dest.String()).Equals("tcp:1.2.3.4:80")
+	dest := v2net.TCPDestination(v2net.IPAddress([]byte{1, 2, 3, 4}), 80)
+	v2netassert.Destination(dest).IsTCP()
+	v2netassert.Destination(dest).IsNotUDP()
+	assert.String(dest).Equals("tcp:1.2.3.4:80")
 }
 
 func TestUDPDestination(t *testing.T) {
-	assert := unit.Assert(t)
+	v2testing.Current(t)
 
-	dest := NewUDPDestination(IPAddress([]byte{0x20, 0x01, 0x48, 0x60, 0x48, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0x88}, 53))
-	assert.Bool(dest.IsTCP()).IsFalse()
-	assert.Bool(dest.IsUDP()).IsTrue()
-	assert.String(dest.String()).Equals("udp:[2001:4860:4860::8888]:53")
+	dest := v2net.UDPDestination(v2net.IPAddress([]byte{0x20, 0x01, 0x48, 0x60, 0x48, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0x88}), 53)
+	v2netassert.Destination(dest).IsNotTCP()
+	v2netassert.Destination(dest).IsUDP()
+	assert.String(dest).Equals("udp:[2001:4860:4860::8888]:53")
 }

common/net/ipnet.go

@@ -0,0 +1,97 @@
+package net
+
+import (
+	"net"
+)
+
+var (
+	onesCount = make(map[byte]byte)
+)
+
+type IPNet struct {
+	cache map[uint32]byte
+}
+
+func NewIPNet() *IPNet {
+	return NewIPNetInitialValue(make(map[uint32]byte, 1024))
+}
+
+func NewIPNetInitialValue(data map[uint32]byte) *IPNet {
+	return &IPNet{
+		cache: data,
+	}
+}
+
+func ipToUint32(ip net.IP) uint32 {
+	value := uint32(0)
+	for _, b := range []byte(ip) {
+		value <<= 8
+		value += uint32(b)
+	}
+	return value
+}
+
+func ipMaskToByte(mask net.IPMask) byte {
+	value := byte(0)
+	for _, b := range []byte(mask) {
+		value += onesCount[b]
+	}
+	return value
+}
+
+func (this *IPNet) Add(ipNet *net.IPNet) {
+	ipv4 := ipNet.IP.To4()
+	if ipv4 == nil {
+		// For now, we don't support IPv6
+		return
+	}
+	value := ipToUint32(ipv4)
+	mask := ipMaskToByte(ipNet.Mask)
+	existing, found := this.cache[value]
+	if !found || existing > mask {
+		this.cache[value] = mask
+	}
+}
+
+func (this *IPNet) Contains(ip net.IP) bool {
+	ipv4 := ip.To4()
+	if ipv4 == nil {
+		return false
+	}
+	originalValue := ipToUint32(ipv4)
+
+	if entry, found := this.cache[originalValue]; found {
+		if entry == 0 {
+			return true
+		}
+	}
+
+	mask := uint32(0)
+	for maskbit := byte(1); maskbit <= 32; maskbit++ {
+		mask += 1 << uint32(32-maskbit)
+
+		maskedValue := originalValue & mask
+		if entry, found := this.cache[maskedValue]; found {
+			if entry == maskbit {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func (this *IPNet) Serialize() []uint32 {
+	content := make([]uint32, 0, 2*len(this.cache))
+	for key, value := range this.cache {
+		content = append(content, uint32(key), uint32(value))
+	}
+	return content
+}
+
+func init() {
+	value := byte(0)
+	for mask := byte(1); mask <= 8; mask++ {
+		value += 1 << byte(8-mask)
+		onesCount[value] = mask
+	}
+}

common/net/ipnet_test.go

@@ -0,0 +1,42 @@
+package net_test
+
+import (
+	"net"
+	"testing"
+
+	. "github.com/v2ray/v2ray-core/common/net"
+	v2testing "github.com/v2ray/v2ray-core/testing"
+	"github.com/v2ray/v2ray-core/testing/assert"
+)
+
+func parseCIDR(str string) *net.IPNet {
+	_, ipNet, err := net.ParseCIDR(str)
+	assert.Error(err).IsNil()
+	return ipNet
+}
+
+func TestIPNet(t *testing.T) {
+	v2testing.Current(t)
+
+	ipNet := NewIPNet()
+	ipNet.Add(parseCIDR(("0.0.0.0/8")))
+	ipNet.Add(parseCIDR(("10.0.0.0/8")))
+	ipNet.Add(parseCIDR(("100.64.0.0/10")))
+	ipNet.Add(parseCIDR(("127.0.0.0/8")))
+	ipNet.Add(parseCIDR(("169.254.0.0/16")))
+	ipNet.Add(parseCIDR(("172.16.0.0/12")))
+	ipNet.Add(parseCIDR(("192.0.0.0/24")))
+	ipNet.Add(parseCIDR(("192.0.2.0/24")))
+	ipNet.Add(parseCIDR(("192.168.0.0/16")))
+	ipNet.Add(parseCIDR(("198.18.0.0/15")))
+	ipNet.Add(parseCIDR(("198.51.100.0/24")))
+	ipNet.Add(parseCIDR(("203.0.113.0/24")))
+	ipNet.Add(parseCIDR(("8.8.8.8/32")))
+	assert.Bool(ipNet.Contains(net.ParseIP("192.168.1.1"))).IsTrue()
+	assert.Bool(ipNet.Contains(net.ParseIP("192.0.0.0"))).IsTrue()
+	assert.Bool(ipNet.Contains(net.ParseIP("192.0.1.0"))).IsFalse()
+	assert.Bool(ipNet.Contains(net.ParseIP("0.1.0.0"))).IsTrue()
+	assert.Bool(ipNet.Contains(net.ParseIP("1.0.0.1"))).IsFalse()
+	assert.Bool(ipNet.Contains(net.ParseIP("8.8.8.7"))).IsFalse()
+	assert.Bool(ipNet.Contains(net.ParseIP("8.8.8.8"))).IsTrue()
+}

common/net/json/host.go

@@ -0,0 +1,63 @@
+package json
+
+import (
+	"encoding/json"
+	"net"
+
+	v2net "github.com/v2ray/v2ray-core/common/net"
+)
+
+type Host struct {
+	domain string
+	ip     net.IP
+}
+
+func NewIPHost(ip net.IP) *Host {
+	return &Host{
+		ip: ip,
+	}
+}
+
+func NewDomainHost(domain string) *Host {
+	return &Host{
+		domain: domain,
+	}
+}
+
+func (this *Host) UnmarshalJSON(data []byte) error {
+	var rawStr string
+	if err := json.Unmarshal(data, &rawStr); err != nil {
+		return err
+	}
+	ip := net.ParseIP(rawStr)
+	if ip != nil {
+		this.ip = ip
+	} else {
+		this.domain = rawStr
+	}
+	return nil
+}
+
+func (this *Host) IsIP() bool {
+	return this.ip != nil
+}
+
+func (this *Host) IsDomain() bool {
+	return !this.IsIP()
+}
+
+func (this *Host) IP() net.IP {
+	return this.ip
+}
+
+func (this *Host) Domain() string {
+	return this.domain
+}
+
+func (this *Host) Address() v2net.Address {
+	if this.IsIP() {
+		return v2net.IPAddress(this.IP())
+	} else {
+		return v2net.DomainAddress(this.Domain())
+	}
+}

common/net/json/host_test.go

@@ -0,0 +1,35 @@
+package json_test
+
+import (
+	"encoding/json"
+	"net"
+	"testing"
+
+	. "github.com/v2ray/v2ray-core/common/net/json"
+	v2testing "github.com/v2ray/v2ray-core/testing"
+	"github.com/v2ray/v2ray-core/testing/assert"
+)
+
+func TestIPParsing(t *testing.T) {
+	v2testing.Current(t)
+
+	rawJson := "\"8.8.8.8\""
+	host := &Host{}
+	err := json.Unmarshal([]byte(rawJson), host)
+	assert.Error(err).IsNil()
+	assert.Bool(host.IsIP()).IsTrue()
+	assert.Bool(host.IsDomain()).IsFalse()
+	assert.Bool(host.IP().Equal(net.ParseIP("8.8.8.8"))).IsTrue()
+}
+
+func TestDomainParsing(t *testing.T) {
+	v2testing.Current(t)
+
+	rawJson := "\"v2ray.com\""
+	host := &Host{}
+	err := json.Unmarshal([]byte(rawJson), host)
+	assert.Error(err).IsNil()
+	assert.Bool(host.IsIP()).IsFalse()
+	assert.Bool(host.IsDomain()).IsTrue()
+	assert.StringLiteral(host.Domain()).Equals("v2ray.com")
+}

common/net/json/network.go

@@ -1,11 +1,10 @@
 package json
 
 import (
-	"encoding/json"
-	"errors"
 	"strings"
 
 	v2net "github.com/v2ray/v2ray-core/common/net"
+	serialjson "github.com/v2ray/v2ray-core/common/serial/json"
 )
 
 type NetworkList []string
@@ -19,21 +18,12 @@ func NewNetworkList(networks []string) NetworkList {
 }
 
 func (this *NetworkList) UnmarshalJSON(data []byte) error {
-	var strList []string
-	err := json.Unmarshal(data, &strList)
-	if err == nil {
-		*this = NewNetworkList(strList)
-		return nil
+	strlist, err := serialjson.UnmarshalStringList(data)
+	if err != nil {
+		return err
 	}
-
-	var str string
-	err = json.Unmarshal(data, &str)
-	if err == nil {
-		strList := strings.Split(str, ",")
-		*this = NewNetworkList(strList)
-		return nil
-	}
-	return errors.New("Unknown format of network list: " + string(data))
+	*this = NewNetworkList(strlist)
+	return nil
 }
 
 func (this *NetworkList) HasNetwork(network v2net.Network) bool {

common/net/json/network_test.go

@@ -4,11 +4,12 @@ import (
 	"encoding/json"
 	"testing"
 
-	"github.com/v2ray/v2ray-core/testing/unit"
+	v2testing "github.com/v2ray/v2ray-core/testing"
+	"github.com/v2ray/v2ray-core/testing/assert"
 )
 
 func TestArrayNetworkList(t *testing.T) {
-	assert := unit.Assert(t)
+	v2testing.Current(t)
 
 	var list NetworkList
 	err := json.Unmarshal([]byte("[\"Tcp\"]"), &list)
@@ -18,7 +19,7 @@ func TestArrayNetworkList(t *testing.T) {
 }
 
 func TestStringNetworkList(t *testing.T) {
-	assert := unit.Assert(t)
+	v2testing.Current(t)
 
 	var list NetworkList
 	err := json.Unmarshal([]byte("\"TCP, ip\""), &list)

common/net/json/portrange.go

@@ -7,6 +7,7 @@ import (
 	"strings"
 
 	"github.com/v2ray/v2ray-core/common/log"
+	v2net "github.com/v2ray/v2ray-core/common/net"
 )
 
 var (
@@ -14,15 +15,15 @@ var (
 )
 
 type PortRange struct {
-	from uint16
-	to   uint16
+	from v2net.Port
+	to   v2net.Port
 }
 
-func (this *PortRange) From() uint16 {
+func (this *PortRange) From() v2net.Port {
 	return this.from
 }
 
-func (this *PortRange) To() uint16 {
+func (this *PortRange) To() v2net.Port {
 	return this.to
 }
 
@@ -34,8 +35,8 @@ func (this *PortRange) UnmarshalJSON(data []byte) error {
 			log.Error("Invalid port [%s]", string(data))
 			return InvalidPortRange
 		}
-		this.from = uint16(maybeint)
-		this.to = uint16(maybeint)
+		this.from = v2net.Port(maybeint)
+		this.to = v2net.Port(maybeint)
 		return nil
 	}
 
@@ -49,8 +50,8 @@ func (this *PortRange) UnmarshalJSON(data []byte) error {
 				log.Error("Invalid from port %s", pair[0])
 				return InvalidPortRange
 			}
-			this.from = uint16(value)
-			this.to = uint16(value)
+			this.from = v2net.Port(value)
+			this.to = v2net.Port(value)
 			return nil
 		} else if len(pair) == 2 {
 			from, err := strconv.Atoi(pair[0])
@@ -58,14 +59,14 @@ func (this *PortRange) UnmarshalJSON(data []byte) error {
 				log.Error("Invalid from port %s", pair[0])
 				return InvalidPortRange
 			}
-			this.from = uint16(from)
+			this.from = v2net.Port(from)
 
 			to, err := strconv.Atoi(pair[1])
 			if err != nil || to <= 0 || to >= 65535 {
 				log.Error("Invalid to port %s", pair[1])
 				return InvalidPortRange
 			}
-			this.to = uint16(to)
+			this.to = v2net.Port(to)
 
 			if this.from > this.to {
 				log.Error("Invalid port range %d -> %d", this.from, this.to)

common/net/json/portrange_test.go

@@ -4,22 +4,23 @@ import (
 	"encoding/json"
 	"testing"
 
-	"github.com/v2ray/v2ray-core/testing/unit"
+	v2testing "github.com/v2ray/v2ray-core/testing"
+	"github.com/v2ray/v2ray-core/testing/assert"
 )
 
 func TestIntPort(t *testing.T) {
-	assert := unit.Assert(t)
+	v2testing.Current(t)
 
 	var portRange PortRange
 	err := json.Unmarshal([]byte("1234"), &portRange)
 	assert.Error(err).IsNil()
 
-	assert.Uint16(portRange.from).Equals(uint16(1234))
-	assert.Uint16(portRange.to).Equals(uint16(1234))
+	assert.Uint16(portRange.from.Value()).Equals(uint16(1234))
+	assert.Uint16(portRange.to.Value()).Equals(uint16(1234))
 }
 
 func TestOverRangeIntPort(t *testing.T) {
-	assert := unit.Assert(t)
+	v2testing.Current(t)
 
 	var portRange PortRange
 	err := json.Unmarshal([]byte("70000"), &portRange)
@@ -30,29 +31,29 @@ func TestOverRangeIntPort(t *testing.T) {
 }
 
 func TestSingleStringPort(t *testing.T) {
-	assert := unit.Assert(t)
+	v2testing.Current(t)
 
 	var portRange PortRange
 	err := json.Unmarshal([]byte("\"1234\""), &portRange)
 	assert.Error(err).IsNil()
 
-	assert.Uint16(portRange.from).Equals(uint16(1234))
-	assert.Uint16(portRange.to).Equals(uint16(1234))
+	assert.Uint16(portRange.from.Value()).Equals(uint16(1234))
+	assert.Uint16(portRange.to.Value()).Equals(uint16(1234))
 }
 
 func TestStringPairPort(t *testing.T) {
-	assert := unit.Assert(t)
+	v2testing.Current(t)
 
 	var portRange PortRange
 	err := json.Unmarshal([]byte("\"1234-5678\""), &portRange)
 	assert.Error(err).IsNil()
 
-	assert.Uint16(portRange.from).Equals(uint16(1234))
-	assert.Uint16(portRange.to).Equals(uint16(5678))
+	assert.Uint16(portRange.from.Value()).Equals(uint16(1234))
+	assert.Uint16(portRange.to.Value()).Equals(uint16(5678))
 }
 
 func TestOverRangeStringPort(t *testing.T) {
-	assert := unit.Assert(t)
+	v2testing.Current(t)
 
 	var portRange PortRange
 	err := json.Unmarshal([]byte("\"65536\""), &portRange)

common/net/port.go

@@ -0,0 +1,23 @@
+package net
+
+import (
+	"github.com/v2ray/v2ray-core/common/serial"
+)
+
+type Port serial.Uint16Literal
+
+func PortFromBytes(port []byte) Port {
+	return Port(uint16(port[0])<<8 + uint16(port[1]))
+}
+
+func (this Port) Value() uint16 {
+	return uint16(this)
+}
+
+func (this Port) Bytes() []byte {
+	return []byte{byte(this >> 8), byte(this)}
+}
+
+func (this Port) String() string {
+	return serial.Uint16Literal(this).String()
+}

common/net/portrange.go

@@ -1,6 +1,6 @@
 package net
 
 type PortRange interface {
-	From() uint16
-	To() uint16
+	From() Port
+	To() Port
 }

common/net/testing/assert/address.go

@@ -0,0 +1,73 @@
+package assert
+
+import (
+	v2net "github.com/v2ray/v2ray-core/common/net"
+	"github.com/v2ray/v2ray-core/common/serial"
+	"github.com/v2ray/v2ray-core/testing/assert"
+)
+
+func Address(value v2net.Address) *AddressSubject {
+	return &AddressSubject{value: value}
+}
+
+type AddressSubject struct {
+	assert.Subject
+	value v2net.Address
+}
+
+func (subject *AddressSubject) Named(name string) *AddressSubject {
+	subject.Subject.Named(name)
+	return subject
+}
+
+func (subject *AddressSubject) DisplayString() string {
+	return subject.Subject.DisplayString(subject.value.String())
+}
+
+func (subject *AddressSubject) Equals(another v2net.Address) {
+	if subject.value.IsIPv4() && another.IsIPv4() {
+		IP(subject.value.IP()).Equals(another.IP())
+	} else if subject.value.IsIPv6() && another.IsIPv6() {
+		IP(subject.value.IP()).Equals(another.IP())
+	} else if subject.value.IsDomain() && another.IsDomain() {
+		assert.StringLiteral(subject.value.Domain()).Equals(another.Domain())
+	} else {
+		subject.Fail(subject.DisplayString(), "equals to", another)
+	}
+}
+
+func (subject *AddressSubject) IsIPv4() {
+	if !subject.value.IsIPv4() {
+		subject.Fail(subject.DisplayString(), "is", serial.StringLiteral("an IPv4 address"))
+	}
+}
+
+func (subject *AddressSubject) IsNotIPv4() {
+	if subject.value.IsIPv4() {
+		subject.Fail(subject.DisplayString(), "is not", serial.StringLiteral("an IPv4 address"))
+	}
+}
+
+func (subject *AddressSubject) IsIPv6() {
+	if !subject.value.IsIPv6() {
+		subject.Fail(subject.DisplayString(), "is", serial.StringLiteral("an IPv6 address"))
+	}
+}
+
+func (subject *AddressSubject) IsNotIPv6() {
+	if subject.value.IsIPv6() {
+		subject.Fail(subject.DisplayString(), "is not", serial.StringLiteral("an IPv6 address"))
+	}
+}
+
+func (subject *AddressSubject) IsDomain() {
+	if !subject.value.IsDomain() {
+		subject.Fail(subject.DisplayString(), "is", serial.StringLiteral("a domain address"))
+	}
+}
+
+func (subject *AddressSubject) IsNotDomain() {
+	if subject.value.IsDomain() {
+		subject.Fail(subject.DisplayString(), "is not", serial.StringLiteral("a domain address"))
+	}
+}

common/net/testing/assert/destination.go

@@ -0,0 +1,49 @@
+package assert
+
+import (
+	v2net "github.com/v2ray/v2ray-core/common/net"
+	"github.com/v2ray/v2ray-core/common/serial"
+	"github.com/v2ray/v2ray-core/testing/assert"
+)
+
+func Destination(value v2net.Destination) *DestinationSubject {
+	return &DestinationSubject{value: value}
+}
+
+type DestinationSubject struct {
+	assert.Subject
+	value v2net.Destination
+}
+
+func (this *DestinationSubject) Named(name string) *DestinationSubject {
+	this.Subject.Named(name)
+	return this
+}
+
+func (this *DestinationSubject) DisplayString() string {
+	return this.Subject.DisplayString(this.value.String())
+}
+
+func (this *DestinationSubject) IsTCP() {
+	if !this.value.IsTCP() {
+		this.Fail(this.DisplayString(), "is", serial.StringLiteral("a TCP destination"))
+	}
+}
+
+func (this *DestinationSubject) IsNotTCP() {
+	if this.value.IsTCP() {
+		this.Fail(this.DisplayString(), "is not", serial.StringLiteral("a TCP destination"))
+	}
+}
+
+func (this *DestinationSubject) IsUDP() {
+	if !this.value.IsUDP() {
+		this.Fail(this.DisplayString(), "is", serial.StringLiteral("a UDP destination"))
+	}
+}
+
+func (this *DestinationSubject) IsNotUDP() {
+	if this.value.IsUDP() {
+		this.Fail(this.DisplayString(), "is not", serial.StringLiteral("a UDP destination"))
+	}
+}

common/net/testing/assert/ip.go

@@ -0,0 +1,39 @@
+package assert
+
+import (
+	"bytes"
+	"net"
+
+	"github.com/v2ray/v2ray-core/common/serial"
+	"github.com/v2ray/v2ray-core/testing/assert"
+)
+
+func IP(value net.IP) *IPSubject {
+	return &IPSubject{value: value}
+}
+
+type IPSubject struct {
+	assert.Subject
+	value net.IP
+}
+
+func (subject *IPSubject) Named(name string) *IPSubject {
+	subject.Subject.Named(name)
+	return subject
+}
+
+func (subject *IPSubject) DisplayString() string {
+	return subject.Subject.DisplayString(subject.value.String())
+}
+
+func (subject *IPSubject) IsNil() {
+	if subject.value != nil {
+		subject.Fail(subject.DisplayString(), "is", serial.StringLiteral("nil"))
+	}
+}
+
+func (subject *IPSubject) Equals(ip net.IP) {
+	if !bytes.Equal([]byte(subject.value), []byte(ip)) {
+		subject.Fail(subject.DisplayString(), "equals to", ip)
+	}
+}

common/net/testing/assert/port.go

@@ -0,0 +1,49 @@
+package assert
+
+import (
+	v2net "github.com/v2ray/v2ray-core/common/net"
+	"github.com/v2ray/v2ray-core/common/serial"
+	"github.com/v2ray/v2ray-core/testing/assert"
+)
+
+func Port(value v2net.Port) *PortSubject {
+	return &PortSubject{value: value}
+}
+
+type PortSubject struct {
+	assert.Subject
+	value v2net.Port
+}
+
+func (subject *PortSubject) Named(name string) *PortSubject {
+	subject.Subject.Named(name)
+	return subject
+}
+
+func (subject *PortSubject) DisplayString() string {
+	return subject.Subject.DisplayString(subject.value.String())
+}
+
+func (subject *PortSubject) Equals(expectation v2net.Port) {
+	if subject.value.Value() != expectation.Value() {
+		subject.Fail(subject.DisplayString(), "is equal to", expectation)
+	}
+}
+
+func (subject *PortSubject) GreaterThan(expectation v2net.Port) {
+	if subject.value.Value() <= expectation.Value() {
+		subject.Fail(subject.DisplayString(), "is greater than", expectation)
+	}
+}
+
+func (subject *PortSubject) LessThan(expectation v2net.Port) {
+	if subject.value.Value() >= expectation.Value() {
+		subject.Fail(subject.DisplayString(), "is less than", expectation)
+	}
+}
+
+func (subject *PortSubject) IsValid() {
+	if subject.value == 0 {
+		subject.Fail(subject.DisplayString(), "is", serial.StringLiteral("a valid port"))
+	}
+}

common/net/testing/port.go

@@ -2,12 +2,14 @@ package testing
 
 import (
 	"sync/atomic"
+
+	v2net "github.com/v2ray/v2ray-core/common/net"
 )
 
 var (
 	port = int32(30000)
 )
 
-func PickPort() uint16 {
-	return uint16(atomic.AddInt32(&port, 1))
+func PickPort() v2net.Port {
+	return v2net.Port(atomic.AddInt32(&port, 1))
 }

common/net/testing/portrange.go

@@ -1,14 +1,18 @@
 package testing
 
+import (
+	v2net "github.com/v2ray/v2ray-core/common/net"
+)
+
 type PortRange struct {
-	FromValue uint16
-	ToValue   uint16
+	FromValue v2net.Port
+	ToValue   v2net.Port
 }
 
-func (this *PortRange) From() uint16 {
+func (this *PortRange) From() v2net.Port {
 	return this.FromValue
 }
 
-func (this *PortRange) To() uint16 {
+func (this *PortRange) To() v2net.Port {
 	return this.ToValue
 }

common/net/timed_io.go

@@ -19,6 +19,7 @@ type TimeOutReader struct {
 func NewTimeOutReader(timeout int, connection net.Conn) *TimeOutReader {
 	reader := &TimeOutReader{
 		connection: connection,
+		timeout:    -100,
 	}
 	reader.SetTimeOut(timeout)
 	return reader
@@ -33,6 +34,9 @@ func (reader *TimeOutReader) GetTimeOut() int {
 }
 
 func (reader *TimeOutReader) SetTimeOut(value int) {
+	if value == reader.timeout {
+		return
+	}
 	reader.timeout = value
 	if value > 0 {
 		reader.worker = &timedReaderWorker{

common/net/transport_test.go

@@ -1,4 +1,4 @@
-package net
+package net_test
 
 import (
 	"bytes"
@@ -8,11 +8,13 @@ import (
 	"testing"
 
 	"github.com/v2ray/v2ray-core/common/alloc"
-	"github.com/v2ray/v2ray-core/testing/unit"
+	v2net "github.com/v2ray/v2ray-core/common/net"
+	v2testing "github.com/v2ray/v2ray-core/testing"
+	"github.com/v2ray/v2ray-core/testing/assert"
 )
 
 func TestReaderAndWrite(t *testing.T) {
-	assert := unit.Assert(t)
+	v2testing.Current(t)
 
 	size := 1024 * 1024
 	buffer := make([]byte, size)
@@ -25,11 +27,11 @@ func TestReaderAndWrite(t *testing.T) {
 
 	transportChan := make(chan *alloc.Buffer, 1024)
 
-	err = ReaderToChan(transportChan, readerBuffer)
+	err = v2net.ReaderToChan(transportChan, readerBuffer)
 	assert.Error(err).Equals(io.EOF)
 	close(transportChan)
 
-	err = ChanToWriter(writerBuffer, transportChan)
+	err = v2net.ChanToWriter(writerBuffer, transportChan)
 	assert.Error(err).IsNil()
 
 	assert.Bytes(buffer).Equals(writerBuffer.Bytes())
@@ -127,22 +129,22 @@ func runBenchmarkTransport(size int) {
 	finishB := make(chan bool)
 
 	go func() {
-		ChanToWriter(writerA, transportChanA)
+		v2net.ChanToWriter(writerA, transportChanA)
 		close(finishA)
 	}()
 
 	go func() {
-		ReaderToChan(transportChanA, readerA)
+		v2net.ReaderToChan(transportChanA, readerA)
 		close(transportChanA)
 	}()
 
 	go func() {
-		ChanToWriter(writerB, transportChanB)
+		v2net.ChanToWriter(writerB, transportChanB)
 		close(finishB)
 	}()
 
 	go func() {
-		ReaderToChan(transportChanB, readerB)
+		v2net.ReaderToChan(transportChanB, readerB)
 		close(transportChanB)
 	}()
 

common/retry/retry.go

@@ -6,10 +6,12 @@ import (
 )
 
 var (
-	RetryFailed = errors.New("All retry attempts failed.")
+	errorRetryFailed = errors.New("All retry attempts failed.")
 )
 
-type RetryStrategy interface {
+// Strategy is a way to retry on a specific function.
+type Strategy interface {
+	// On performs a retry on a specific function, until it doesn't return any error.
 	On(func() error) error
 }
 
@@ -17,6 +19,7 @@ type retryer struct {
 	NextDelay func(int) int
 }
 
+// On implements Strategy.On.
 func (r *retryer) On(method func() error) error {
 	attempt := 0
 	for {
@@ -26,14 +29,15 @@ func (r *retryer) On(method func() error) error {
 		}
 		delay := r.NextDelay(attempt)
 		if delay < 0 {
-			return RetryFailed
+			return errorRetryFailed
 		}
 		<-time.After(time.Duration(delay) * time.Millisecond)
 		attempt++
 	}
 }
 
-func Timed(attempts int, delay int) RetryStrategy {
+// Timed returns a retry strategy with fixed interval.
+func Timed(attempts int, delay int) Strategy {
 	return &retryer{
 		NextDelay: func(attempt int) int {
 			if attempt >= attempts {

common/retry/retry_test.go

@@ -5,15 +5,16 @@ import (
 	"testing"
 	"time"
 
-	"github.com/v2ray/v2ray-core/testing/unit"
+	v2testing "github.com/v2ray/v2ray-core/testing"
+	"github.com/v2ray/v2ray-core/testing/assert"
 )
 
 var (
-	TestError = errors.New("This is a fake error.")
+	errorTestOnly = errors.New("This is a fake error.")
 )
 
 func TestNoRetry(t *testing.T) {
-	assert := unit.Assert(t)
+	v2testing.Current(t)
 
 	startTime := time.Now().Unix()
 	err := Timed(10, 100000).On(func() error {
@@ -26,14 +27,14 @@ func TestNoRetry(t *testing.T) {
 }
 
 func TestRetryOnce(t *testing.T) {
-	assert := unit.Assert(t)
+	v2testing.Current(t)
 
 	startTime := time.Now()
 	called := 0
 	err := Timed(10, 1000).On(func() error {
 		if called == 0 {
 			called++
-			return TestError
+			return errorTestOnly
 		}
 		return nil
 	})
@@ -44,14 +45,14 @@ func TestRetryOnce(t *testing.T) {
 }
 
 func TestRetryMultiple(t *testing.T) {
-	assert := unit.Assert(t)
+	v2testing.Current(t)
 
 	startTime := time.Now()
 	called := 0
 	err := Timed(10, 1000).On(func() error {
 		if called < 5 {
 			called++
-			return TestError
+			return errorTestOnly
 		}
 		return nil
 	})
@@ -62,19 +63,19 @@ func TestRetryMultiple(t *testing.T) {
 }
 
 func TestRetryExhausted(t *testing.T) {
-	assert := unit.Assert(t)
+	v2testing.Current(t)
 
 	startTime := time.Now()
 	called := 0
 	err := Timed(2, 1000).On(func() error {
 		if called < 5 {
 			called++
-			return TestError
+			return errorTestOnly
 		}
 		return nil
 	})
 	duration := time.Since(startTime)
 
-	assert.Error(err).Equals(RetryFailed)
+	assert.Error(err).Equals(errorRetryFailed)
 	assert.Int64(int64(duration / time.Millisecond)).AtLeast(1900)
 }

common/serial/bytes.go

@@ -0,0 +1,23 @@
+package serial
+
+type Bytes interface {
+	Bytes() []byte
+}
+
+type BytesLiteral []byte
+
+func (this BytesLiteral) Value() []byte {
+	return []byte(this)
+}
+
+func (this BytesLiteral) Int64Value() int64 {
+	value := this.Value()
+	return int64(value[0])<<56 +
+		int64(value[1])<<48 +
+		int64(value[2])<<40 +
+		int64(value[3])<<32 +
+		int64(value[4])<<24 +
+		int64(value[5])<<16 +
+		int64(value[6])<<8 +
+		int64(value[7])
+}

common/serial/json/string_list.go

@@ -0,0 +1,21 @@
+package json
+
+import (
+	"encoding/json"
+	"errors"
+	"strings"
+)
+
+func UnmarshalStringList(data []byte) ([]string, error) {
+	var strarray []string
+	if err := json.Unmarshal(data, &strarray); err == nil {
+		return strarray, nil
+	}
+
+	var rawstr string
+	if err := json.Unmarshal(data, &rawstr); err == nil {
+		strlist := strings.Split(rawstr, ",")
+		return strlist, nil
+	}
+	return nil, errors.New("Unknown format of a string list: " + string(data))
+}

common/serial/numbers.go

@@ -0,0 +1,57 @@
+package serial
+
+import (
+	"strconv"
+)
+
+type Uint16 interface {
+	Value() uint16
+}
+
+type Uint16Literal uint16
+
+func (this Uint16Literal) String() string {
+	return strconv.Itoa(int(this))
+}
+
+func (this Uint16Literal) Value() uint16 {
+	return uint16(this)
+}
+
+type Int interface {
+	Value() int
+}
+
+type IntLiteral int
+
+func (this IntLiteral) String() string {
+	return strconv.Itoa(int(this))
+}
+
+func (this IntLiteral) Value() int {
+	return int(this)
+}
+
+type Int64Literal int64
+
+func (this Int64Literal) String() string {
+	return strconv.FormatInt(this.Value(), 10)
+}
+
+func (this Int64Literal) Value() int64 {
+	return int64(this)
+}
+
+func (this Int64Literal) Bytes() []byte {
+	value := this.Value()
+	return []byte{
+		byte(value >> 56),
+		byte(value >> 48),
+		byte(value >> 40),
+		byte(value >> 32),
+		byte(value >> 24),
+		byte(value >> 16),
+		byte(value >> 8),
+		byte(value),
+	}
+}

common/serial/string.go

@@ -0,0 +1,12 @@
+package serial
+
+// An interface for any objects that has string presentation.
+type String interface {
+	String() string
+}
+
+type StringLiteral string
+
+func (this StringLiteral) String() string {
+	return string(this)
+}

common/uuid/uuid.go

@@ -0,0 +1,111 @@
+package uuid
+
+import (
+	"bytes"
+	"crypto/md5"
+	"crypto/rand"
+	"encoding/hex"
+	"errors"
+)
+
+var (
+	byteGroups = []int{8, 4, 4, 4, 12}
+
+	InvalidID = errors.New("Invalid ID.")
+)
+
+type UUID struct {
+	byteValue   []byte
+	stringValue string
+}
+
+func (this *UUID) String() string {
+	return this.stringValue
+}
+
+func (this *UUID) Bytes() []byte {
+	return this.byteValue
+}
+
+func (this *UUID) Equals(another *UUID) bool {
+	if this == nil && another == nil {
+		return true
+	}
+	if this == nil || another == nil {
+		return false
+	}
+	return bytes.Equal(this.Bytes(), another.Bytes())
+}
+
+// Next generates a deterministic random UUID based on this UUID.
+func (this *UUID) Next() *UUID {
+	md5hash := md5.New()
+	md5hash.Write(this.Bytes())
+	md5hash.Write([]byte("16167dc8-16b6-4e6d-b8bb-65dd68113a81"))
+	for {
+		newid, _ := ParseBytes(md5hash.Sum(nil))
+		if !newid.Equals(this) {
+			return newid
+		}
+		md5hash.Write([]byte("533eff8a-4113-4b10-b5ce-0f5d76b98cd2"))
+	}
+}
+
+func bytesToString(bytes []byte) string {
+	result := hex.EncodeToString(bytes[0 : byteGroups[0]/2])
+	start := byteGroups[0] / 2
+	for i := 1; i < len(byteGroups); i++ {
+		nBytes := byteGroups[i] / 2
+		result += "-"
+		result += hex.EncodeToString(bytes[start : start+nBytes])
+		start += nBytes
+	}
+	return result
+}
+
+func New() *UUID {
+	bytes := make([]byte, 16)
+	rand.Read(bytes)
+	uuid, _ := ParseBytes(bytes)
+	return uuid
+}
+
+func ParseBytes(bytes []byte) (*UUID, error) {
+	if len(bytes) != 16 {
+		return nil, InvalidID
+	}
+	return &UUID{
+		byteValue:   bytes,
+		stringValue: bytesToString(bytes),
+	}, nil
+}
+
+func ParseString(str string) (*UUID, error) {
+	text := []byte(str)
+	if len(text) < 32 {
+		return nil, InvalidID
+	}
+
+	uuid := &UUID{
+		byteValue:   make([]byte, 16),
+		stringValue: str,
+	}
+	b := uuid.byteValue[:]
+
+	for _, byteGroup := range byteGroups {
+		if text[0] == '-' {
+			text = text[1:]
+		}
+
+		_, err := hex.Decode(b[:byteGroup/2], text[:byteGroup])
+
+		if err != nil {
+			return nil, err
+		}
+
+		text = text[byteGroup:]
+		b = b[byteGroup/2:]
+	}
+
+	return uuid, nil
+}

common/uuid/uuid_test.go

@@ -0,0 +1,61 @@
+package uuid_test
+
+import (
+	"testing"
+
+	. "github.com/v2ray/v2ray-core/common/uuid"
+	v2testing "github.com/v2ray/v2ray-core/testing"
+	"github.com/v2ray/v2ray-core/testing/assert"
+)
+
+func TestParseBytes(t *testing.T) {
+	v2testing.Current(t)
+
+	str := "2418d087-648d-4990-86e8-19dca1d006d3"
+	bytes := []byte{0x24, 0x18, 0xd0, 0x87, 0x64, 0x8d, 0x49, 0x90, 0x86, 0xe8, 0x19, 0xdc, 0xa1, 0xd0, 0x06, 0xd3}
+
+	uuid, err := ParseBytes(bytes)
+	assert.Error(err).IsNil()
+	assert.String(uuid).Equals(str)
+}
+
+func TestParseString(t *testing.T) {
+	v2testing.Current(t)
+
+	str := "2418d087-648d-4990-86e8-19dca1d006d3"
+	expectedBytes := []byte{0x24, 0x18, 0xd0, 0x87, 0x64, 0x8d, 0x49, 0x90, 0x86, 0xe8, 0x19, 0xdc, 0xa1, 0xd0, 0x06, 0xd3}
+
+	uuid, err := ParseString(str)
+	assert.Error(err).IsNil()
+	assert.Bytes(uuid.Bytes()).Equals(expectedBytes)
+}
+
+func TestNewUUID(t *testing.T) {
+	v2testing.Current(t)
+
+	uuid := New()
+	uuid2, err := ParseString(uuid.String())
+
+	assert.Error(err).IsNil()
+	assert.StringLiteral(uuid.String()).Equals(uuid2.String())
+	assert.Bytes(uuid.Bytes()).Equals(uuid2.Bytes())
+}
+
+func TestRandom(t *testing.T) {
+	v2testing.Current(t)
+
+	uuid := New()
+	uuid2 := New()
+
+	assert.StringLiteral(uuid.String()).NotEquals(uuid2.String())
+	assert.Bytes(uuid.Bytes()).NotEquals(uuid2.Bytes())
+}
+
+func TestEquals(t *testing.T) {
+	v2testing.Current(t)
+
+	var uuid *UUID = nil
+	var uuid2 *UUID = nil
+	assert.Bool(uuid.Equals(uuid2)).IsTrue()
+	assert.Bool(uuid.Equals(New())).IsFalse()
+}

core.go

@@ -8,13 +8,256 @@ import (
 )
 
 var (
-	version  = "0.14"
+	version  = "1.3"
 	build    = "Custom"
-	codename = "Post Apocalypse"
-	intro    = "A stable and unbreakable connection for everyone."
+	codename = "New Order"
+	intro    = "An unified platform for anti-censorship."
 )
 
+func Version() string {
+	return version
+}
+
 func PrintVersion() {
 	fmt.Printf("V2Ray %s (%s) %s%s", version, codename, build, platform.LineSeparator())
 	fmt.Printf("%s%s", intro, platform.LineSeparator())
 }
+
+/*
+::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::c:::::::::::::::::::::::ccc:::cccc::::::c:::::cccc::::cc::::::::::::::::::::::::ccccccc::cccccccccc::cc:::;:::::::::::::::::::::::::::ccc:::cccc:ccc::::::c:::::::::::::::::::::::::::cccc:cccccccccccccccccccccc:;;::::::::::::::::::c::::ccc::::::ccc:::ccc::cccccc::::cc:cc:::ccccccccccccccccccccccccccccccccccccccc
+:::;::::::::::::::::::::::::::::::::::::::::::::::cc:::::::::::::::::::::::::::::::::::::ccc::cc:::::c:::::::::::ccc::ccc:::::ccc::::::cc:::::cccc:::::::::::::::::::::cccccccccccccccccccccccccc:::::::::::::::::::::::::cc::ccc::::::::::::::c::c::::::::::::c::::::::c::::::cccccccccccccccccccccccccc:;:::::::::::::::ccc::cccccccc::c:cccc::cc:::cccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
+:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::cc::::::::cc::::::::::::ccccc:::::ccccccccc::cccc::ccccccc:::c::::::::c:c:::::cccccccccccccccccccccccccc::::::::::::::::::::::::cc:::::ccc:::c::::::::::::::::c::::::::::::::::::::::ccccccccccccccccccccccccccc:::::::::::::::::::::cccccc:ccccc::ccccccccc:cccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
+::;;::::::::::::::::::::::::::::::::::::::::::::::::::::::::c:::::::::::::::::::::cc::::::::::::::::c:::cc::::c::::::::cccccc::::cccccccccc::ccccccc::c::::::::c::::::::ccccccccccccccccccccccccc:::::::::::::::::::::::::c::::cccc:::cc:::cc:::::::::::::::::::::::::::c::::::ccccccccccccccccccccccccccc::::::::::::::::::::cccc::cccccc:ccc:cccccccccccccccc:cccccccccccccccccccccccccccccccccccccccccccccccc
+:::::::::::::::::::::::::::::::::::::::::::::::::::::::::cc:::::::::::::::ccc:::::c:::cc::::::::::::::::::::::cc:::c::cccc::::::::::cccccccccccc:ccc::c:::::::ccc:::::::cccccccccccccccccccccccccc:::::::::::::::::::cccccccccccccc::::::::ccc::c::cc:::cc::::::::::::::cc:::::cccccccccccccccccccccccccccc::::::::::::::::::::ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
+::::::::::::::::::::::::::::::::::::::::::::::::::::::c::::::::::::::::::::c::::::::::::::::::::ccccc::::::::::::ccc::cc:::::cccc::::cccccccccccc::::cccccc:::ccccc:::::cccccccccccccccccccccccccc::::::::::::::::::::c:cc:::cc::::::::::::cc::cc:::::::cccc::::::c:::::cc::::::ccccccccccccccccccccccccccc:::::::::ccc::::::ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
+:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::cc:::::::::::::::ccccccc:::::ccccc::ccc::ccccccccccccccccccccccccccccccc:cccc::::cccccc::::cccccccccccccccccccccccccc::::::::::::::::c:::::cc::::::::cc:::cccc::::cc::::ccc:ccc::c:::::::::cccc::::ccccccccccccccccccccccccccc::::::::::cc::::::ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
+::::::::::::::::::::::::::::::::::::::::::::::::::::c::::::::cc::::::::::::::cc:::::::ccccc:::c:::::ccc::cccc:::cccccc:ccccccccccccccccccccccccccccccccccc::::ccccccc:::cccccccccccccccccccccccccc:::::::::cc:::::::::::::cc:::cc::cccccccc::cccccc::ccccccccc:c::::::::ccc:::::cccccccccccccccccccccccccccc:::::::::ccc:::::ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
+::::::::::::::::::::::::::::::::::::::::::::cc:::::::::ccc:::::c::::::cc:::cccc:::c:::ccccc::::ccc::cccccccccc::cccccc::ccccccccccccccccccccccccccccccccccc:ccccccccc::ccccccccccccccccccccccccccc:::::::::::::::::::::::::cc:cccc::cccccccccccc:ccc::cccccc:ccc::::::::cccc:::::ccccccccccccccccccccccccccc:::::::::ccc:::::c:ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
+:::::::::::::::::::::::::::::::::::c:::::::c:::::c:::::cc::::::::::::cccccc::::ccccccccc:::::::ccccccccccccccccccccccc:cccccccccccccccccccccccllccccccccccccccccccccc::cccccccccccccccccccccccccccc:::::::::c:::::::::::ccccccccccccccccccccccc::cc:::::cccccccc:::cc:::ccccc::::ccccccccccccccccccccccccccc:::::::::cccc::::ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
+:::::::::::::::::::::::::::::cc::cc:::::::c:::::::::::::c:::cc:::::::cccccc::::cccccccc:cc:::ccccccccccccccccccccccccccccccccccccccccccccccoxk00Okxddoolllllloodxkkxdoloolccccccccccccccccccccccccc:::::::::c:::::::::cccccccc::cc::ccccc:::cccccc:ccc:ccccccccc:ccccc:::cc:cc:::ccccccccccccccccccccccccccc:::::::::ccccc:::ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
+::::::::::::::::::c::::::::ccc:::cc:::::::c::::cc::c::::c:::ccc:::ccc::::::ccc:::ccccccccccccccccccccccccccccccccccccccccccccloxxkOO0OkkkkOKXK00000000KKK0KKXXNNWWWWNXKKK0kdoolclloooddollccccccccc:::::::::cc:::::cccccccccccc:ccccccccc::cccccccccccccc:cccccc:ccccc:::cc:cc:::cccccccccccccccccccccccccccc:::::::cccccc:::ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
+:::::::::::::::::::::::::::::::::::::::c::ccc:::cc::cc::ccc:::::cc:::cc::::ccc::cccc:cccccccccccccccccccccccccccccccccccccccdkO0KKK0000OOkkOKXXXXXXXXXNNXKXNNNNNNNNNNNXXXXXKKKOO0KKKKKKK0Oxxoolllcc:::::::::cc::::ccc::cccc:cccccccc:ccccccccccccccccccccccccccccccc:cc:::cc:::::ccccccccccccccccccccccccccccc::::::::c::c:::ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
+:::::::::::::::::::::ccc::::c:::c:ccc::c::ccccc:ccc::::ccccccccc:cc:cccccccccccccc:ccccccccccccccccccccccccccccccccccccccclxOOOO00KKKKKKK00KKXXNNNNXNNNNXXXXXNNNNNNNNNXXKKXXXXXXXXXXXKKXXNXXK00KOdl::::::::ccc:::::cccccccccccc:cccc::ccccccccccccccccccccccccccccc::cc:::ccc:cc::ccccccccccccccccccccccccccccc:::::::cccc::::cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
+::::::::::::::::::ccccccccc:cc::cccc::ccc:ccccc:ccc:::ccccccccccccccccccccccccc:ccccccccccccccccccccccccccccccccccclok000O0XNNNNNXK00KKXK0K0xxk000KXXXXXNNNNNNNXNNNNNNXXXXXNNXXXXXKX0dodxxxxddxOOxl::::::::cccc::::ccccccccccccccccccccc::cccccccccccccccccccccccccccccc::cccccc:::cccccccccccccccccccccccccccc::::::::ccccc::cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
+:::::::::::::c::::cccc:::c::ccccccccc::cc:ccccc:ccc::cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccclx0XNNNXNXXXNNNXKKKKXXX0OOxooddoodkKXKKKKXNXXNXXXXKKKKXX00KXKKXXNNXK0kko:;;::cccccc::::::::ccc::::ccccccccccccccccccccccccccccccccccccccccccccccccccccc::cccccc:::cccccccccccccccccccccccccccc::::::::cccccc:::cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
+::::::::::::::cc:ccc::ccccc:cccccccccc::cccccccccccccccccccccccccccccc:cccccccccccccccccccccccccccccccccccccccclxKNNNNXOO0KOkO0KXXNXXXXK0kololllol:lO0kkxkOKXXXXK0kkxddxO000OOkOO0KKXNNNXOxl:::coolc::::::::ccc:::ccccccccccccccccccccccccccccccccccccccccccccccccccccc:::cccccc:::ccccccccccccccccccccccccccccc::::ccccccccc::ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
+:ccc::::::::::cc:c:::cccccccccccccccccccccccccccc:ccccccccccccccccccccccccccccccccccccccccc:ccccccccccccccccccoOXNWWNN0dcllldO0KKXXXXXXXXKxllldkkkxxdlc;;lOK00OOOd:;;;:cdk0OxkxoodxxkOOOOO0Okl,cO0kl::::::::ccc:::ccccccccccccccccccccccccccccccccccccccccccccccccccccccc::cccccc::ccccccccccccccccccccccccccccc:::cc:cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
+::cc:::::::::c::::ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccldO00KNNNXKOddk0KXXXXXXXXXXKK0OOOOO0KKxc;,,.;oxxddxkOx:;,;loddxxolddlc::ccccc:;cooox0KKkl:::::ccccc:::cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc::ccccccccccccccccccccccccccccc:::::cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
+c:cc:::c::cccccc::ccccccccccc:cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccldkkxdxkKK000kxkkOO0000OOOOOkdloOKKO0K0dc,...;ccc:lxO0dccclllccloolllc:;;;:cc:;.,:cok0Okkkl::::cccccc:::ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc::ccccccccccccccccccccccccccccc:::::cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
+ccc::::ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccclx0KK0OxdxOOOxl::codxxdoooolccoxO0K00kdoodl;''',;;;:lxOOdollccc::cc:;;;;,'',;;;;'','';:coxxl::::cccccc:::cccccccccccccccccccccccccccccccccccccccccccccccccccccccc:cccccc::cccccccccccccccccccccccccccccc::c::ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccllccccccccccccccccccccc
+cc:::ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccldxOKXNXKOxxdl:;;,,,,,,,ckOx;:k00Okkxolc;;;:;,''',,'',:ok0kocc::,.',,;;;;,''',;,;,...',;:ccc::::::ccccc:::cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc::ccccclcccclcccccccccccccccccc::ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccllcc
+ccc::ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccooloOKKKK0Oo:;,''..'.. ;xO0OxxOkxdddddoll:;,..,,,,;'.'',:ll:,,,,'..'''',,;;,,,,;;;,',,;;::cc:cccc:ccccc::ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc::ccccllccccccclcclllcccccccclcc::ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccclllccccccccccccc
+cccc:ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccclollxOOOO0Oxl:;'''',;;;cdxodxdoolllldk00Od:,'..,;,;;;,,'.....'',,,,,'''.''''.....,,,''',::ccc:cccc::ccccc:ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc:::cccclcccllcclcccllcccccccclcc:::ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccllcclcclcccccccccccccccc
+ccc:ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccclxkxdddxO0Oxdoc;'',;:ldxdlc:coolcc::ldxolc;;::,..,,;;;;;;'...'';cccc::;,,,,,,,'....,',;:oolccccccccccccccc:cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc::cclcccccllccccclccclcllllclccc:cccccccccccccccccccccccccccccccccccccccccccccccccccccccccclllccccclllcccccccccccccccccccccl
+cc::cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccclxOOxddxkkkdoool:;,.';ccc:::::;::::::cc;;;:cdddo:'''',;;;;;;,,;:codddolc:;;,,,;,,''',,,,;:llllc:cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccclllclllcccccccclllllllllllcccccccccccccccccccccccccccccccccccccccccccccccccccllccllccccccllccccccccccccllcccccccllcccccc
+ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccclxkkkkO00koc;,'.';;,...;;::;::;,,;:::::::;;;::::::;'''',,,,;,;;:loxkkOkxdolc:;;;,,,'...',:lllclccccc::cccccc:ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc:cclllllllclllcccclllllllllllcccccccccccccccccccccccccccccccccccccccccccccccccccllcclllcccccccccccccccccllclccllccclccccccc
+ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccldddkOOO00OOOOxl,.';;'...,;;;;;;,;;;;:::;;::;,'',;;,',,,,,,,,;;:loodxxxxxxxddoolc:;;,...;cdkkdlllc:cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccllllcllllllccclllllllclllllcccccccccccccccccccccccllccccccccccclccclcccllccccllcccccccccccccccllcclllccclccllccccccccccc
+cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccloodOOkkkOOOOOOkxc,;:,.   ..',;;;;;;'',,,,,,,;,...,;,,;;;,,,;;;:clllllcc::clodxxddolc;'',;:ccodlccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc:cclllllllllllllllllllllllllllc:ccccccccccccccccccccllccclllcccccccccllcccccccccccccccccclccccccllcccccccclccccccccccccccc
+ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccclollxOkxxxxxxxddddoc;'....     ..,;;;,'....';,.','.',,;::::;;;;;::cloddddooc:;::cclddolc:;:::::cllllc:cccccccclcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccclccccc:ccllllllllllllllllllllllllcllc:cccccccccccccccccccccccccllccccccccccccccccccccllccccccllllcccccccccccccccccccccccccccccll
+ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccclccdkkxdooollccc:::;'..........  ..,,,;,''',;,.''',,,;:ccc:::::::::::cccclccc::::::cloolllc:ccccccllccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccclccccc::cllllllllllllllllllllllllllllc:cccccccccccccccccccccccccccccccccccccccclllllccccclllccccccccccccccccccccccccccllllllllll
+cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccoxdxkdl::::::cc;,,''..      .....',,,;;,,,,,'',;;:cloodollc::;;;;:;;,,;;;;::::::c:looooolcclllllllcccccccccccccccccccccccccclllcccccccccccccccccccccccccccclccclccccccccccccccccccccccllllllllllllllllllllllllllllc:cccccccccccccccccccccccccccccclllcclllllllllllcccccccccccccccccccccccccclllllllllllllllll
+ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccllllloooc:;,'',;;,,;:.....    ....'',,,,,,,,;;;:ccooddxxxxxdol:;;;:ccc::;;;,;;;;;;clollllllllllllllcccccccccccccccccccclccccclccccccccccccccccccccccclcccccccccllcccclcccccccccccccccccllllllllllllllllllllllllllllccccccccccclcccccccccccclllclllllllllllccclllccccccccccccccccccccccllllllllllllllllllllllll
+cccccccccccccccclccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc::;,,;:;..  ';;';c;'';;'.   ....'',,,;;;;;;:clodddxxxxkkkkkkxdoddxxdol:,,,,;;,;:oxdlllllllllllllllcccccccccccccccclcccccccclccccclllcccccccccllcccclcccccccclllccccccccccccccccccccccclllllllllllllllllllllllllllcccccccccccccccllcccccccccccclcccccccccccccccccccccccccccccclllllllllllllllllllllllllllllll
+ccc::cccccccccccccccccccclccccllcccccccccccclcccccccccccccccccccccccccccccccccccccccccccccccccclccol:;,,''''....','';:;,:;.     ...',,,,;;;;;:ccloddxxxxxkkOOOO000Okxddool;'',,;;:loxOkoclllllllllllllcccccccccclccccccccccccccccclccllllllcccccccclcccccccccccclllcccccccccccccccllccccccllllllllllllllllllllllllllllccccccccccccccllccccccccccccccccccccccccccccccccccllllllllllllllllllllllllllllllllllllllll
+ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccclcccclllccccccccccccccccclllllo:;,,,',,,,,,,,'';::::,.      ..',,;;;::::cccooddxxxxkkkOOO00000Okxolllc;;:::coxkO00dllllllllllllllccccccccccccccccccccccllllcclcclllllllcccccclllccccccccccclcccclcccccccccccccccccccclllllllllllllllllllllllllllllcccccccccllccccccccccccccccccccccccccccclllllllllllllllllllllllllllllllllllllllllllllllll
+ccccccllccllccccccccccccccccccccccccccccccccccccccccclccccccccccccccccccccclllcclccccccllcccclcclccc:;;;,,,,,,;;;::;;:c::;'.  .....',;;:::::ccllloddxxxxxkkkkOOO000000OkxdolooddxkOOO00Oolllllllllllllcccccccccccccccllllcclllllcllcclllllllcllccllllcccccccccccccccccccccccccccccclllcccccllllllllllllllllllllllllllllc:cccccccccccccccccccccccccccccccllllllllllllllllllllllllllllllllllllllllllllllllllllllll
+ccccccccccccccclccllccllllllcccclccccccccccccccccccccccccccccccccccccccclllllllllcccllcclllllllcllcc:::::;;,',;;;:cl::lc:;;,,,,'...,;:::ccclollllooddddddxxxxkkkkOO00000OOOOOOO00OOOOO00xlllllllllllllccccccccccclcccclllcclllclccccclccccccccccccccccccccccccccccccccccccccccllcllllllccccllllllllllllllllllllllllllllc:cccccccccccccccccccccllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll
+ccccccccccccccccccccclcccllcccclllclllclllllccccccccccccccccccccccccccccccccccccccccccccccccccccccccc:::;''...,;;;::;;:clcc:::::;;,;:::cccloooooooooooodddddddxxxkkOOOOO0000000KKKK00O0KOollllllllllllccccccccccccccccccccccccccccccccccccccccccccccccccllllllllllllllllllllcccccclcccccccclllllllllllllllllllllllllllllc:ccccccccccclllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll
+cccccccccccccccccccccccccccccccccccccccccclllclccclcccllllllllcclllccccccccccccccccccccccccccccccccccc:;,.....,;;;:;;,,;;::clllllcc::ccllllllloooooooooooddddddxxkkkOOOOOOOOOOOOOO00K0KKKxllllllllllllcccccccccccccccccccccccccllllcclllllllllllcclllllllllllllcccllccllllllclccccccccccccccllllllllllllllllllllllllllllccllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll
+cccccccccccccccccccccccccccccccccccccccccccccccccccccccllcccccccccccllcccccclllccllllllllllllllllllllcc:;;,..';:::;;,,'.'',,;::cc:::clloooolloddodddoooooddddddxxxkkOOOOOOOkxodxkO00KKKXXOolllllllllllccccccclccclllllllllllcclllcllllcllllllllllllcccccllllcccccccccccccccllcccccccccccc::clllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllool
+llllllllllllccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccllllclllllllcc:;,..,;;;,,,,,''...',,;;;;;:loooooddddddddddddoooddddddxxxkkkkkkkkkxddOKXXXXKKXXXKxllllllllllllcccccccccccccccllcclllcllccclccccccccccccccccccccccccccccccccccccccccccccccccccccccccllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll
+llllllllllllllllllllllllllllcllccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccllccc:,'';:;,,,,,,;,'...',,,,;;;clooddddoodddddddooddooodddddxxxxkkkkkkkOkxkkxdxxkkxxkOkolllllllllllccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccclllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllolllllllllllllllllllllllllllooloooloo
+llllllllllllllllllllllllllllllllllllllllllllllcllcccccccccccccccccccccccccccccccccccccccccccccccccccccc:,.,cllc:;;;;;;;,,'',;;;;;;:llooddddodddddddddddooooodddddxxxkkkkkO0KOdc;..'',:cccoollllllllllllccccccccccccccccccccccccccccccccccccccccccccccccllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllloollllllllllllllollllolooooooooo
+llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllcccccccccccccccccccccccccccccccccc::;;cllol:;;;:::;,'',;;;;;;:clloooodddooddddddoooooodddddddxxxkkOOO00K0ko:;;;:;clllllllllllllllllc:ccccccccccccccccccccclccclllcllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllollllllllllllloooolllllloooooooooollolll
+llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllcllollcccc:;,'',;;,,,,;;;;;:::ccllloooooooooooooooooooodddddddxxkkkkkOO0KK0kdlclolllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllollllllllllllllllllllllllllllllllllllllllllllllllllllllllloooollllloollooolllloooooooollooooooloolllllcc
+llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllollool::;,;;;:;'..',,,,;;;::::::ccclllllllooooooooooooooddddddddxxxxxdddxO0000Oxllollllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllolllllllllllllllllllllllllllllllllllllllllllllllllllllllllllollllllloollloollloooooooooollooollolllllcccc::::::
+lllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllldo:;;:cllll:'...;;;::ccccccccccccccllllllllloooooooooooodddddddddolclooollloollllllllllllllllllllllollllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllooolllloooollllllloooollloooloooooolooooooooolllllcccc::::::::::::::
+llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllc:clooooollcc:;..';::clllllolcccccccccccllllllllllllloooooooooddddxkkkxdxxxxoclllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllloollllloollllllolllllllllllllllollllllllloooolllooooooolllllllloolloolloooloooolllllcccc::::;:::::::::::::::::
+lllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllc:::::::c:::;,',;;:clooooddolcccccccccccccccllllllllloooooooddddxkOOOkdlloddooloollllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllloollllllloolloollllollllllllllllllollooollllllllllloooloooooooolllloollllllloooooolllllllccc::::::;::::::::::::::::cccccccc
+lllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllc:::::::::;;,'''.,:cloodddddolcccccccccccllcclccclllllloooooddxxkOOOOkdoccclooooolollllllllllolllllllllllllllllollllllllllllllllllllllllllllllllllllllllllllllllllllllllllloolllllllllllllollooooooooooooolllloooooollllooooollllloooollooooooooooooooooollllllccccc::::::::::::::::::::::::ccccccclllllllo
+lllllllllllllllllllllllllllllllllllllllllolllllllllllllllllllllllllllllllllllllllllllllllllllllllllllc::;:::;;::cc:;'.,:coodddxxddolc:cccllllllllllllclllllllllooodxxkO000K00kdoooolllllllllollllllllolllllllllolllloolloolllllllllllllllllllllllolllllllllllllllloolllllllllllllloollllooooolloooooooooooooooooooooooooolllloollooooooooooollooooooollllllcccc:::::::;:::::::::::::::::ccccccclllllllllllllllll
+ooollllllllloolllllllllllllllllllllllllooollllllllllllllllllllllllllllllllllllllllllllllllllllllllloolc:;;;:::cclllllc:clodddxxxxxdolc::cccllllllllllllllllllllllooddxkO00KKKKK0kdooollllooloooooollooollllllllloolllllllllllllllllllllllllllllllllllllllllllooolllollllllllllllllllolloollooolooloolooooooooooooooooooooooolooollooooooollllllllccccc::::::::;:::::::::::::::ccccccccllllllllloolllllllllccc:::
+lloooolllollloollllllllllllllllllllllllllooollllllllolllllllllllloolllllllllllolloolllllllllllllllllollc:;;:::::::::cclllodddxxxxxxddlc::::ccccccclllllllllllllllllloodxxkOOOOkkxdolooooooooooooolllooolllllllllooollloolllllllloolllooloollloolllllloollllooooollllollloollloolooloooooolloollooooooloooooooooooooooooooooooooollllllccccc:::::::;::::::::::::::::::::ccccccclllllllllloollllllllcccc::::cccccl
+ooooolllllllllollllllolllllllolllooolllllloooollllllllllllollllllllllolllllllllllllllllllllllllloolllllccc:c::::::;;::lloodddxxxxkkxxdolcc::ccccccclcclllllllllllllllllloooddddoddoooooooooooooooooooooooooooooooloooooollllllllooollllllooollooolllooooooooolllloooooolllllloolllooooolooooollooooooooooooooooooooooooooooolc:::;;;;;;:;;;::::::::::::::::cccccccclllllllllllloollllllllcccc:::::ccccclllllllll
+lllllllloooooolllooooollollooolllooooooolllooooolllllllllloooooooollooooooollooooollllooooolllooolloooolcccccc:::::::clooodddxxxkkkkkxdddoollllcccccclllllllllllloooollllloooooooooooooooooooooooooooooooooooooooollloooooooolllooolllllllllloooooooooooooooollooloooooooooooollloooooolooooooooooooooooooooooooooooooooooool:;,,;;;;;::::::::::cccccccccclllllllllloollolllllllccccc:::::ccccclllllllooolloollo
+:::c:cccccclllllllooooooooooooolloooooollooooooolooolllooooollooolllooooooolooooooolooooollooooooloooooolc::::::;;;:clooooodddxxxxkkkkkkxxxdddolllcccccclllllllloooooooooooddddoooooooooooooooooooooooooooooooooooooooooooooooolooooolooolloooooooooooooooooooooooooooooooooooolloooooooollllllloooooooooooooooooooooooooooolc:;;;;:::::cccccccllllllllllloollllllllllccccc::cc:cccccclllllllloooooooooooooooolo
+::::::::::::::::::cccccccclllllllllllooooooooooooooollloooooolooooooooooooooooooooooooooolooooooooooooool:::::::;;;cllooooodddxxxxkkkkkkkkkxxxddoolllcccllllloooooooodddddddddoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooolllllllllllcccccc::::::cloooooooooooooooooooooooooooolcccccccllllllllllllooolllllllllccccc::::cccccclllllllllooooooooooooooooooooooolooo
+:::::::::::::::::::::::::::::::::::cccccccllllllllllllllllloooooooooooooooooooooooooooooooooooooooooooollc::c::::;:loooooooddddxxxkkkkkkkkkkxxxdddooollccccllllllooodddooooooooooooooooooooooooooooooooooooooooodxxkkOOOkkkkkxdooooooooooooooooooooooolollllllllllccccccc:::::::::::::::::::::::loooooooooooooooooooooooooooolllllllllllllolllllllccccccccccccccccclllllllooollooooolooooooooooooooooloooooooooo
+lllllccccccccc:c:::::::::::::::::::::::::::::::::::::::cccccccccccllllllllllooooooooooooooooooooooooooooolc:::::::clooooooooddddxxxkkkkkkkkkkxxxxxddddoollcclllloooooooooooooooooooooooooooooooooooooooooooodxkO0KKK000OOOOOOOOkkkxolllllllllccccccccc::::::::::::::::::::::::::::::::::::::::::loooooooooooooooooooooooooooollllllllllllool::::::cccccccllllllllooooooooloooooooooooooooooooooooooooooooooooooo
+loolooollollllllllllllccccccccc:::::::::::::::::::::::::::::::::::::::::::::cccccccccccccclllcllllllllllllc::::::cloooooooooddddxxxkkkkkkkkkxxxxxxxxxxxxxddollllooloooooooooooooooooooooooooooooooooooooolloO0OO0KNNNNNXK0OOOOOOOOkkxlc::::::::::::::::::::::::::::::::::::::cccccccccccllllllcclooooooooooooooooooooooooooooolllllllllollolccclllllllooolloooooollloolloooooolooooooooooooooooooooooooooooooooo
+llllooooooooooooooooooooolllllllllllllcccccccccccccccc::c::::::::::::::::::::::::::::::::::::::::::::::::::::::;;:loodddoooooddddxxxkkkkkkkxxxxxxxxxxxxxxxxdolllolcllccccclooooooooooooooooooooooooooooooloxkxdxkO0KXXNNNNX0OxxkOOOOO0ko::::::::::::::ccccccccccccccccccllllllllllllllllolooollllloooooooooooooooooooooooooooolllllllloollollllllloooloooooooooooooooooolooooooooooooooooooooooooooooooooooooooo
+::::ccccccllllllllllllloooloooooooooooloooollllllllllllllllllcccccccccccccccccccccccccccc::::::::::::::::::::::::cloooddoooooddddxxxkkkkkkkxxxxxdxxxxxxxxddddoollccll:::::cooooooooooooooooooooooooooooodddollllodxkkO0KXXNNNK0xddxkO00Odccccccccclllllllllllllllllloooolloooooooolllollllloollllloooooooooooooooooooooooooooollllllllollooolllllloooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
+llccccccccccc::cccccccccccllllllllloooooooooooooooooooooooooooooooolllllllllllllllllllllllllcclccccccccccccccc:::clooddddoooooddddxxxkkkkkkxxxddddxxdddddddddooollclolc:::coooooooooooooooooooooooooooxkkxlllllllllooxkO00KXXNNX0xooddddxdollllllooooooooooooooooooooolloolllllllcclcccclllloollllooooooooooooooooooooooooooooolllloloooooooollooloooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
+lllloooolllllllllllccccccccccccccccccccccclllllllllllllooooooooooooooooooooooooooooooooooooooooooooollllllllollcccooddddddooooodddxxxkkkkkkkxxxxxxxxxdddddddoooollllodollclooooooooooooooooooooooooodxxxxollc:;,;:clllodxkO0KXXNNNKOxdoooxdoolooooooooollllllllllllcccccccc::cc:ccccccccloolllllllooooooooooooooooooooooooooooolllollooooooolllooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
+oooooooooooooooooooooooolllllllllllllcccccccccccccccccccccccccllllllllllllllllooooooooooooooooooooooooooooooooooloodddddddddoooddddxxkkkkkkkkkkkkkkkxxxddooooooolllldxdollloooooooooooooooooooooodddlclll:;:;,'''',;cclllodxO0KXNNNNXKOdoddlclccccccccccccccccccccccccccclllllllllllllllloooooollloooooooooooooooooooooooooooooollllooolooooollooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
+ooooooooooooooooooooooooooooooooooooooooooolllollllllllllllccccccccccccccccccccccccccccccclllllllllllllllllllllloddddddddddddddddddxxkkkkkkkkkkkkkkkkkxxddoooooolllodkxolllooooooooooooooooooooddol::::::::cccc:;,'''',:llloxOO00KKXXXXKOxolcclcclclllllllllllllloooooooooooooooolllllllloooooollllooooooooooooooooooooooooooooolloooooooooooolooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
+ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooolllllllllllllllllllcccclccccccccccccccccldxxddxxxdddddddddddxxkkkkkkkkkkkxxxxxkkkxxddddooooodxkkdlllooooooooooooooooooddolc:ccc:::lxkOkkkxddoc:;,;codk000OOOKKKKXXKOdooooooooooooooooooooooooooooooooooooooooooollooooooolllooooooooooooooooooooooooooooolllooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
+ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooodxxxxxxxxxxdddxddddddxkkOOOkkkxxxxxxxxxxxxxddxxddddddxkkdooodxxdooooooooooooddolcllllccccloxkkkkOO00KKKKK00KKK00000OOKKKKKXXX0kdoooooooooooooooooooooooooooooooooooooooollloooooolllooooooooooooooooooooooooooooolllooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
+ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooxkkkkkxxxxxxxxxxxxddddxkOOOOOkkxxxdddddddddddxxxxxddxxkkOOOkdxO00OOkxxdooooooolllllllllccclloddddxxxkOKKKXXXK0OOO0KKK00KXXKKXXXXKOxoooooooooooooooooooooooooooooooooooooollloooooollloooooooooooooooooooooooooooooollooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
+oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooodxkOkkkkkkkkkkkkkkkxxdddxkOO0OOkxxddddddddooddxkkkkkxxkkkkOO00xloxkO0KKK0Okxollllllllllllcccclodooooooodxxxxk0KK0OOO00KK00KKKKKKXXXXX0kdoooooooooooooooooooooooooooooooooooolloooooollloooooooooooooooooooooooooooooollooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
+oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooodxkOOOOOkkkkkkkOkkkkkkxxdddxOO00OOxxdddooooooddkkkOOOkkkkkOOOOO0Oolooddxkkxxddoollooollllllcc:::clllccclloolccldk0KK00000000O0KKKKKKKKKXX0xooooooooooooooooooooooooooooooooooollooooooollooooooooooooooooddoooooooooooollooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
+ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooodxkOO00000OOOOOOOOOOOOOOkkxxddxkO000OkxddoooooddxkOOOOOOOOOOOOOOOO00d:cooooooooddooooooolllllllccc:::::,,,'':olccccldk00000O000OO00KKKKKKKKKX0xooooooooooooooooooooooooooooooooooolooooooolllooodoooooooodddddooooooooooooolooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
+ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooddxkOO00000000000OOOO0000000OOkkxxxxkO000OkdddddddxkkO00000OOOOOOO00OO000xl:cloddddddddoooollllllllllccc:cclcclodxxollllllodxO0000000OO0KKKKKKKXXXKKOdooooooooooooooooooooooooooooooooolooooooolllodoodoooooooddoooooooddddooooolloooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
+oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooodxkkO00KKKKKKKKKKK00000000000KKK00OkkkxxkO0KK0kxdddxxkOO00KKK00OOOO0000000KK0kdc::coddddddooooolllllllllllccccoddxkkkxxxdoodddddoxO0000000O0KKKKKKKXXXXXK0kdoooooooooooooooooooooooooooooooloooooooollooooddoodddddddddddoodoooooooolloooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooood
+ooooooooooooooooooooooooooooooooodooooooooooooooooooooooooooooooooooooooooooooooooooooooodxkkO0KKKKKKKKKKKKKKKKKKKKKKKKKKKKKXKKK00OOkkxk0KKKOOkkOOO000KKXXKK0OO00KKKKK0KKXK0kol::clooooooolllllllllllllllllllodddoooddxdodddxxdddkO00000000KKKKKXXXXXXKXKOdooooooooooooooooooooooooooooooooooooooollooooodoodddddddddddoodooooodoolloooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
+oooooooooooooooooooooooodoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooodxkO0KKKKKKKKKKKKKKKKKKKKXKKXXKKKKKKKXXXXXXXK00OkkkOKXK00000KKKKKXXXXKKKKKXXXXXXXXXXXXX0kdlccccllllllllllllllllllllllllllcclllllloddxxxdxdddddkO0000000KKKKKXXKXXXKKK0xoooooooooooooooooooooooooooooooooooooollooddddoodddddddddddddddddddddoolodooooooooooooooooooooooooooooooooooooooooooooooooooooooooooodddoooooooooooo
+ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooddddddoodkO0KKKKKKKKKKKKKKKKKKKKKXXXXXXXXXXXXXXXXNNXNNNXKK00OkO0KXKKKXXXXXXXXNNXXXXNNNNNNNNXXXNNNNNX0kddocccccccccclllllllllllllloddoooollllllooxkxxxdddddxkO00000000KKKKKKKKKKKKOdoooooooooooooooooooooooooooooooooooooolooddddddddddooddddddddoddooddooloooooooooooooooooooooooooooooooooooooooooooooooooooooddddooodddooddooooooood
+oooooooooooooooooooooooooooooooooodooooooooooooooooooooooodddooododddddooddooddxkOKXXKXKKKKKKKKKKKKKXXXXXXXXXXXXXXXXNNNNNNNNNNNNNNNNXXXKKKXXXXXXNNXXXXNNNNNNNNNNNNNNNNNNNNNNNNNXK0kdol:;;;:::::ccccccllcccldkkOkxddooooooodxkkkxxxxxxxxkOOOOO00000KKKKKKKKKKOdooooooooooooooooooooooooooooooooooooolloddddddodddooddddddddddddddddooooooooooooooooooooooooooooooooooooooooodddooodddoooddddddddddddddddddooooodd
+oooooodddddoooddoooooddooooooooooooooooodddoooddoooooooooooooddddddoooddxxkkO0KXXXXXXXXXXXXXXKXXXXXXXXXXXXXXXXXXXXNNNNNNNNNNNNNNNNNNNNNNNXXXNNNNNNNNNNNNNNNNNNNWWWNNNNNNNNNNNNNXX0Okdolc;;;;;;::::::ccccccldxxxdoooodddddddxxxxxxxxxxxdxxkkOOOOOOO00000KKKKK0kdoooooooooooooooooooooooooooooooooooolloddddddddddddddddddddddddodddooooooooooooodoooooooooooooddooddoooooooooodooodddooodddddddddddddddddddoodddo
+dooooddoodddddddoooooooodddddooooooooooooooooodoodddoodoodddddoooddxkO0KXXXXXXXXXXXXXXXXXXKKKK00KK00KKKKKXXXXXXXXXXXNNNNNNNNNNWWWWWWNNNNNNNNNNNNNWWNNNNNNNNNNWWNWWWWWWWNNWNNNNNNXK0kxdolc:;;;;;;;;;;:::ccc:codoooollooooddddddddddddddddddxxkkkkkkOOOOO000KKK0xoooooooooooooooooooooooooooooooodooooloddddddddddddddddddddddddddddoolodoooooddddooodoooooooooddoooooddoodoooddddodddddddddddddoddddddddddddddddo
+ddoooooddddddddddddddddddddddddddddddddddoooooddddddooddddddodxkO0KXXXXXXXXXXXXXXXXXXXXXXKKK0Okkkxxk00KKXXXXXXXXNNNNNNNNNWWNNNNWWWWWWWWWWWWWWWNWWWWWNNNNNWWWWNNNWWWWWWWWWWWNNNNNXK0Okxdoolc:;;,,,,,,;;:clldO00OdoooolllllllllllooooooooodoodddxxxxxkkkkOOO0KK0Oxoddooooooooooooooooooooooooooooooooolodddddddddddddddddddddddddddddoooddddddooddooddooooooooooooddodddodddddddddooddddddddddddodddddoddddddddddd
+odddddddddddddddddddddddddddddddddddoodddddddddddddddddddodxO0KXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXKK0000KKKXXXXXXXXNNNNNNNNNNNNNNNWWWWWWWWWWWWWWWWWWWWWWNNNNNNNNNNNWWWWWWWWWWWWWWNNXXXK0Okxxddolc:;;,,,,;cdkO0KXXNX0xoooolllllllllllllllllllollllooddddxxxkkOO000000xoodddooooooooooooooooooooooodddddoolodddddddddddddddddddddddddddddoooddooooooddoooodooddddddddddddddddddddddddddddddddddddddddddddddddddddddddd
+ddddddddddddddddoddddddddddddddoodddoddddddddddddddddddddk0KXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXKKKKXXXXXXXXXNNNNNNNNNNNNNNNNWWWWWWWWWWWNNNNWWWWWWWNNNNNNNNNNNNNNNWWWWWWNNNNNXXXK00Okkxxddolc:;;;;;:okOO0KXXXXKkdooollllllccccccccccccccclllllooddddxxkOOO000KKkdoddooodddoooodddooooooooooddooooolooddddddddddddddddddddddddddddoooddoooooddddooodddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd
+ddddddddddddddddddddddddddddddddoddddddddddddddddddddddk0KKKKXXKXXXXXXKXXXXXXXXXXXXXXXXXXXXXXXXXXXXKKXXXXXXXXXXNNNNNNNNNNNNNNNNNWWWNNNNNNNNNNNNNNNNNNNNNNNXXXXXXNNNNNNNNNNNNNNNNXXXK00OOkkxxxdolc:::::lxkO0KKXXXXX0kdooolllllllccccccccccccccclllloooodddxkkOOO0KKOdoddoooddooooooooooooodoooodoodooooodddddddddddddddddddddddddddddooododddddddddoddddddddodddddddddddddddddddddddddddddddddddddddddddddddddddd
+dddddddddddddddddddddddddddddddddddddddddddddddddddddxO0KKKKKKKKKKKKKKXXXXXXXXXKKXXXXXXXXKKXXXXXXXXKKXXXXXXXXNNNNNNNNNNNNNNNNWNNNWWWWWWWWWWWNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNWWNNNNXXKK000OOkkkxxddolcc:codxO0KKKXKXXKKkdoooollllllcccclccccccccccccclllloodxxkOOOOOOkdodddoddddoooodddooooooooodddddoooodddddddddddddddddddddddddddddooodddddddddddoodddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd
+ddddddddddddddddddddddddddddddddddddddddddddddddddddxO000KKKKKKKKKKKKKKKKKKKKKKKKXXXKKXXXXXXXXXXXXXXXXXXNNNNNNNNNNNNNNNNNNNNNNNNNNWWWWWWWWWWWWWWWWWWWWNNNNNWWWWWWWWWWWNWWWWWWNNNNXXXKK000OOOOkkxxxddolclodxO00KKKKKKKK0kooooolllllcccccccccccccccc:ccllllodxxxxdoodxxdddooddddooddddddddoooooodddddoolodddddddddddddddddddddddddddddooodddddddddddoddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd
+dddddddddddddddddddddddddddddddddddddddddddddddddddxO0000KKKKKKKKKKKKKKKKKKKKKKKKKKKKKXKKXXXXXXXXXXXXNNNNNNNNNNNNNNNNNNNNNNNNNNNNWWWWWWWWWWWWWWWWWWWWWWWWWNWWWWWWWWWWWWWWWWNNNNNNNXXXK0000OOOOkkkkxxddolloxkO0000KKKKKK0Oxdoloollllcccccccccccccc::::cccllllolllccclxxdododddooddddddddooddoooodddddolodddddddddddddddddddddddddddddoooddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd
+ddddddddddddddddddddddddddddddddddddddddddddddddddxkOO00000KKKKKKKKKKKKKKKKKKKKKKKKKKKXXXXXXXXXXXXXXXNNNNNNNNNNNNNNNNNNNNNNNNNNNNNWWWWWWWWWWWWWWWWWWWWWWWWNNNNNNNNNWWWWWWWWNNNNNNNXXXKK0000OOOOkkkkxxddooddxkO00000KKK00Okxxddolllllllllllcccccccccccclllcccc::cccccdkxddddddooodddddddddddoooddddddooodddddddddddddddddddddddddddddolodddddddddddoodddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd
+dddddddddddddddddddddddddddddddddddddddddddddddddxkO000000KKKKKKKKKKKKKKK0KKKKKKKKKKKXXXXXXXXNNXXXXXXNNNNNNNNNNNNNNNNNNNNNNNNNNNNNWWWWWNNNNNNNNNWWWWWWWWNNNNNNNNNNNNNNNNNNNNNNNNNNXXXXKK000OOOOOkkkkkxddoddxkOO00000KKKOkxxkOOkkxdoollllllccccccccccccccc::;;::ccllldxkxddddddodddddddddddddooddddddoooddddddddddddddddddddddddddddddooddddddddddddodddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd
+dddddddddddddddddddddddddddddddddddddddddddddddddxkOO00000KKKKKKKKKKK0000000KKKKKKKXXXXXXXXXXXXXXXXXXNXXXXNNNNNNNNNNNNNNNNNNNNNNNNNNWWNNNNNNNNNNNNNNNNNNNXXXXXXXXXXXXXXNNNNNNNNNNXXXXKKK0000OOOOOkkkkxdddddxkkOO00000KK0kxxkOO000KK0Oxdlllllcccc::::::::;;;;;;;:clooodxxddddddddddddddddddddooddddddoooodddddddddddddddddddddddddddddooddddddddddddodddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd
+ddddddddddddddddddddddddddddddddddddddddddddddddxkOOO000000000000000000000000000KKXXXXXXXXXXXXXXXXXXXXXXXXXXNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNXXXXKKKKKKKKKKKKKKKKXXXXXNNNNNNNNNXXXXXXKKK000OOOOOOkkkxxddddxxkkOO000KKKKOxxkO00KKKKKXXK0kdlllcccc::::;;;;;;;;;;:cloodddxxdddddddddddddddddddooddddddoooodddddddddddddddddddddddddddddooddddddddddddodddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd
+dddddddddddddddddddddddddddddddddddddddddddddddxkkOOO00000000000000000000000000KKKXXXXXXXXXXXXXXXXXXXXXXXXXXXXXNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNXXXKK00O000000KKKXXXXXNNNNNNNNNNXXXXXXXKKK00000OOOkkkkxxxddddxxkOO0000KKK0kkO0KKKKKKXXXXXXKxllccc:::::::;;;;;;;;;:clodddxkkddddddddddddddddddooddddddooooddddddddddddddddddddddddddddddoodddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd
+dddddddddddddddddddddddddddddddddddddddddddddddxkOOOOO000000000000000000000000KKKKXXXXXXXXXXXXXXXXXXXXXXXXXXXNXXXXXXNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNXKKK000KKXXXXNNNNNNNNNNNNNNXXXXXXKKKKK0000OOOOkkkxxxxxdddxkOOO00K000K0O0KKKKKKKXXXXXXXKxllccc::::::::;;;;;;;::coddxxkOkdddddddddddddddddoodddddddoooddddddddddddddddddddddddddddddoodddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd
+ddddddddddddddddddddddddddddddddddddddddddddddxkkOOOOOOO0000000000000000000KKKKKKKKXXXXXXKKKKKKKXXXXXXXXXXXXNNXXXXXNNNNNNNNNNNNNNNNNNNNNNNNNNNNWWWWWWNNXXXXXXXXXXXNNNNNNNNNNNNXXXXXXXXKKKK0000OOOOkkkkxxxxdddxxkOO000000KK00KKKKKKKKKXXXXXNKxlccc:::::::::;;;;;;;:clodxxkkkkdddddddddddddddddoddddddddooddddddddddddddddddddddddddddddoodddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd
+ddddddddddddddddddddddddddddddddddddddddddddddxkkkOOOOO0000000000000000000000000KKKKKKKKKKKKKKKKKKKKXXXXXXXXXXXXXXNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNWWWWNNNNNNXXXXXXXXXXNNNNNXXNNNXXXXXXXXKKKK0000OOOOkkkkkxxxxxxxxkOOO0000000000KKKKKKKKKXXXXXXKxllc:::::::::;;;:;;;;:codxkkkkkkddddddddddddddddoodddddddooddddddddddddddddddddddddddddddoodddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddx
+dddddddddddddddddddddddddddddddddddddddddddddxxkkkkOOOOO000000000000000OO000000000000000KKKKKKKKKKKKXXXXXXXXXXXXXXNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNXXKKKKXXXXXXXXLOVEXYOUXFOREVERK0000OOOOkkkkxxxxxxxxxkkOOOO000000000000KKKKKKXXXXXX0dllc:::::::::;;;;;;;;:lodxkkkkkkxddddddddddddddoodddddddooddddddddddddddddddddddddddddddoodddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd
+dddddddddddddddddddddddddddddddddddddddddddddxxkkkkOOOOO000000000O0OOOOOOOOOOOOOOOOOO00000000000KKKKKKKKXXXXXXXXXXXXXXXXXXXXXXXXXXXXNNNNNNNNNNNNNNNNNNXXNNNXKK00KKKXXXXXXXXXXXXXXXXKKKKKKKK0000OOOkkkkkxxxxxxxxkkOOOOO00000O0000000KKKKKKXXXXKxllcc::::;;;;::::;;;;::codxxxxkOkddddddddddddddoodddddddooddddddddddddddddddddddddddddddooddddddddddddddddddddddddddddddddddddddddddddddddddddddxxdddddddddddddddd
+dddddddddddddddddddddddddddddddddddddddddddddxxkkkOOOOO000000000OOOOOOOOkkkxxkkkkkkkkOOOOOOO000000KKKKKKKKXXXXXXXXXXXXXXXXXXXXXXXXXXXNNNNNNNNNNNNNNNNNXNNNNXKK0KKKXXXXXXXXXXXXXXXXKKKKKKKK00000OOOOkkkkxxxxxxxxkkkOOOOOOOOkkOOOOO0000KKKKKKKKKxllccc::::;;:::;;;;;;;::cloodxxkkxddddddddddddddddddddddooodddddddddddddddddddddddddddddoodddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd
+dddddddddddddddddddddddddddddddddddddddddddddxxxkkOOOOOO0000000OOOOOOOOOkkxdddxxxxddxxkkkOOOOO000000KKKKKKKXXXXXKXXXXXXXXXXXXXXXXXXXXXNNNNNNNNNNNNNNNNNNNNNNXXXXXXXXXXXXXXXXXXXXXXKKKKKKKKK0000OOOOkkkxxxxxxxxxxxkOOkkOkkkddxkkkkOO000000KKKKKklllccc::::::::;;;;;;;;;;:cloddxkkxddddddddddddddddddddddoodddddddddddddddddddddddddxddxdodddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd
+ddddddddddddddddddddddddddddddddddddddddddddddxxkkkkOOOOOO000OOOOOOOOOOkkxollllooolodxxxxkkOOOOO000000KKKKKKKKXKKKKKXXXXXXXXXXXXXXXXXXNNNNNNNNNNNNNNNNNNNNNNNNXXXXXXXXXXXXXXXXXXXKKKKKKKKK0000OOOOOkkkxxxxxdlccoxkkkkkkxxdlldxxxxkkOOO0000000Kkollccc:::::::::::;;;;;;;;;:codxkkkxddddddddddddoddddddddoodddddddddddddddddddddddddxxxxdooddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd
+dddddddddddddddddddddddddddddddddddddddddddddddxxkkkkOOOOOOOOO000000OOOOkkdlcccllccloddxxxkkkkOOO0000000KKKKKKKKKKKKKXXXXXXXXXXXXXXXXXXXXNNNNNNNNNNNNNNNNNNNNXXKKKXXXXXXXXXKKKKKKKKKKKKKKK0000OOOOkkkkxxxxdol:codxkkkkxdo:;clodddxxkkOO0000KKK0dlllcc:::;;:::::::;;;;;;;;;:cldxkOkxdddddddddddoddddddddoodddddddddddddddddddddddddxxxxdooddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd
+dddddddddddxxddddddddddddddddddddddddddddddddddxxxxkkkkOOOOOO000000OOOOOOOkdcccccccloodddxxxkkkkOOOOOO00000KKKKKKKKKKKKKKKKKKKKXXXXXXXXXXXXNNNNNNNNNNNNNNNNNNXXKKKKKKKKXKKKKKKKKKKKKKKKK0000000OOOkkkxxxxxddollodxxxxxdl:',;cclooddxxkkOO000KKKkollccc:::::;;;;::;;;;;;;,;;;cldxkOOkdddddddddddddddddddoodddddddddddddddddddddddddddxxdooddddddddddddddddddddddddddddddxxxxddddddddddddddddddddddddddddddddxxxxx
+ddddddddddddddxxdddddddddddxdddddddxdddddxdooddddxxxkkkkkOOOO000000OOO000OOkocccccclooddddxxxxkkkkkkOOOOO00KKKKKXKKKKKKKKKKKKKXXXXXXXXXXXXXXXXXXNNNNNNNNNNNNXXXKKKKKKKKKKKKKKKKKKKKK000000000OOOOkkkkxxxddxdoooddxxxxdl;'',;;:cclooodxxkkOO000K0dllcccc::::::::;;;;;;;;;;;;;;:ldkO00kddddddddddddddddddoodddxxdxdddddddddddddxxxdddddxdoodxdddddddddxddddddddddddddddddddddddddddddddddddddddddddxxddxxxxxxxxxxx
+dddddddddddddxxdddddddddddddddddddxxdddddddoooodddxxxkkkkkOOOO0000000000000Oxoccc:clllooodddxxxkkkkkkkkkkkkO0KK000000KKKKKKKKKKKKXXXXXXXXXXXXXXXXXXXXXNNXXXNNXKK000KKKKKKKKKKKKKKKK00000000OOOOOkkkkxxddddddoooddddddl;'.',,;::ccllooodxxkkkOO00koccccc::::::::;;;:;;;;;;;;;;;:ldkO00Oxddddddddddddddddooddddxxddddddxxddxddxxxxxxxxdxddodxxdddddddddddddddddddxddddddddddddddddddddddddddxxxxxxxxxxxxxxxxxxxxxx
+xdddxdddxxddddddddddddddddddddxxxxxxdddddxdooooddddxxxxkkkOOOO00000000KKKK00Oxl::ccllllooooodddxxxxxxxkxxxdooooxkkOOO000000KKKKKKKKKKKKXXXXXXXXXXXXXXXXXXXXNNXXK0000000KKKKKKKKKKK00000OOOOOOOOkkkxxxdddddooooooodddl'...',;;;::cccllloodddxxkkOOdlcccc::::::;;;;:::;;;;;;;;;;;:ldkOO0Oxddddddddddddddddodxxdxxdxxxxxxxxxxxxxxxdxxxxxxddodxxddddddddddddddddddddddddddddddddddxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+xxxxxdddxxxxxdddddddddddddddxxxddddddddddddooooodddddxxxkkOOOOO00000KKKKKKK00koc::ccllllllllooodddddxxxxxdoc::ldkOOO000000000KKKKKKKKKKKKKKKKKXXXXXXXXXXXXXXNXXXK00000000000000000000OOOOOOkkkkkkxxdddddoooooooodool,....',;;;;::cccccclllooddxxkxocccc::::::;;;;::;;;;;;;;;;;;;:lxkOOOOkdddddddddddddddoodxdxxxxxdxxxxxxxxxxxxxxxxxxxxdodxxdddddddddddddddddddddddddddddxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+ddddddxxxxxxxxxxxxdxxxxxxxxxxxxxxxxxxxxddddooooooodddxxxkkkkOOOO000KKKKKKKKK00xl:;:ccllccccclllooodddddxxxdlcldkOOO0O00OOOO000000000KKKKKKKKKKKKKKKKKKKKKKXXNNNXKK000OO00000000000000OOOOkkkkkkkxxxdddooooooooooooo:',;''',;;;;:::ccccccccllloddxxocccc::::::::;;:;::;;;;;;;;;;;;:lxkkkOOkxdddddddddddddoodxxxxxxdddxxxxxxxxxxxxxxxxxxxdooxxddddddddddddddddxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+dddddxxxddxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxdolloooooddxxxkkkkkOOO000KKKKKKKKKK0kd:,;:ccccccccccclloooodddddddodxkkkkOOOOOOOOOOOOOO000000000KKKKKKKKKKKKKKKKXXNNNNXXK00OOOOOOOO0OO000OOOOOOkkkkkxxxxdddooooollllloool;':oc;,,;;::::::cccccccccllooddocccc:::::::::;;;;;;;;;;;;;;;;;;coxxkkkOkxddddddddddddoodxdxxxxxxxxxxxxxxxxxxxxxxxxxxxddxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+xxdxxxxxxxxxxxddxxxxxxxxxxxxxxdxxxdxxxxxxxdollooooooddxxxkkkkOOO00KKKKKKKKKKK0Oxc,',:ccccccccccccllllooooooodddxxxxkkkkkkkkkOOOOOO00000000000KKKKKKKKKKKKXNNNNNNNXXXK00OOOOOO0OOOO0000OOOOkkkkkxxxddddooooooolooodl,':ddl:;;;::::::ccccccccllllooolcccccc::::::;;;;;;;;;;;;;;;;;;;:loodxxkkkddxdddddddddoodddxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+xxxxxxxxxxxxxxdxxxxxxxxxxxxxxxdxxxxxxxxxxxdolllooooooddxxxkkOO0000KKKKKKKKKKK0Oxl;..';::ccccccccccccllllloooooddddxxxxxxxkkkkkOOOOO0000000000KKKKKK0KKKXXNNNNNNNNNNNNNXXKKKKKKKKKKKKKK0000OOOOOkkxxddddddooooooodddc,cddddl:;:::::cccccccccclllloolcccccc::::::::;;;;;;;::;;;;;;;;;:ccloddxkxdddddddddddddxxxxxxxxxxxxxxxxxxxxxxxdxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxdxxxxxxxxxdollloooooooddxkOOO000KKKKKKKKKKKK00Oko:,..',;::::ccccccccccccllllooooddddxxxxxxxkkkkOOOOO0000KKKKKKKKXXXXXNNNNNWNNNNNNNNNNNNNXXXXXXXXXXXXXKKKKK0000OOOkkxxxdddddodddddxko:cdxdddoc::::cccccccccccllloddllccccc::::::::;;;;;;;::;;;;;;;;;;::cllodxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxolllooodddddxkO0000KKKKKKKKKKKKKK00Oko:,...'',;;::ccccccccccccccllllooooddddxxxxxkkkOOOO000KKKKXXXXXNNNNNNNNNNNNNNNNNNNNNNNNNNNXXXXXXXXXXXXKKKKKK00000OOkkkxxxxddddxxxkOklcdxdddddlc::cccccccccccclodxdlcccccc:::::::;;:;;;;;;;;;;;;;;;;;;;;:cloodxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxdooooddxxxkkOO000KKKKKKKKKKKK00K000Okdc,...'',,;;:cccccccccccccccccllllloodddxxxkkkOO000KKKKXXXXXXXXNNNNNNNNNNNNNNNNWWNNNNNNNNXXXXXXXXXXXXXKKKKKKK00000OOOkkkkxxxxxxxkkOOdldxdddddddlccccccccccccllodxdlccccc::::;;;;;::;;;;;;;;;;;;;;;;;;;;;:ccloxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxdddddxkkOO00000K0KKKKKKKKKK0K000000Oxdc,...',,,,;;::cccccccccccccccllloooddxxkkOOOO0000KKKKKKKKXXXXXNNNNNNNNNNNNNNNNNNNNNNNNNNNXNNXXXXXXXXKKKKKKK000000OOOOkkkkkkkkkxkkkkxodxxxxxxxxxdlccllccccccllodddlcccccc::::::::::;;;;;;;;;;;;;;;::;;;;;;:codxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxkkkOOO00K00KKKKKKKKKKKK00K00000OOxdc,..''',,,;;::cccccccccclllllooodxxkkOOOO000000000KKKKKKKXXXXNNNNNNNNNWWWWNNNNNNNNXXXNXXXXNNNNNXXXXKKKKKKK000000OOOOOOkkkkkxkkxxxkkddxxxxxxxxxxxxdollllcccccllooolccccccc:::::::::;;;;;;;;;;;;;;;;::;;,,;;:ldxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxkkkOOOO000000KKKKKKKK000000000000Okxoc'..''',,,;;::cccccclllllooodddxkkOOO0000000000KKKKKKXXXXXXNNNNNNNWNNNWWNNNNXXXXXXXKXXXXXXXXXXXXXXXKKKKKKK0000000OOOOOOkkkxxxxxxxxxxdxxxxxxxxxxxxxxdollllcccclllolcccccccc::::::::::::;;;;;;;;;;;;;::;;;;;:cdxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxkkOOOO00000000KKKKKKK0000000000000Okxo:'.''',,,;;:::ccclllooooodddxxkkOOOO000000000KKKKXXXXXXXXXXXNNNNNNNNNNNNNXXXXKKKKKKKK00KKKKKKKKKKKKKKKKKKKKK0000000OOOkkkkxxxxxxxxxxxxxxxxxxxxxxxxxxxdolllcccllllllccccccc:::::::::;;;;;;;;;;;;;;;;;::;;;;:cdxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxkkOO00000000000KKKKKKKKK0000000000OOkxo:'.''',,,;;::cclllooooddddxxxkkkkOOOO0000KKKKKKXXXXXXXXXXXXXXXXXXXXXXXXXXXXKK000OOOO000000K0000KKKKKKKKKKKKKK000000OOOkkkkxxxxxxxxxkkxxxxxxxxxxxxxxxxxxdollllccllllcccccccccc:::::::;;;;;;;;;;;;;;;;:::ccloodxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxkOO0000000000000000K00KK000000000OOkkxl;,'''',,;;::cclloooooddddxxxxxkkkkOOOO000KKKKKKKKXXXXXKKKKKKKKKKKKKKKKKKKKKK0000OOOOO00000KK0000000K000KKKK000000OOOOkkkkkxxxxxxxxxkkxxxxxxxxxxxxxxxxxxxxddolccclccccccccccc:::::::::;;;;;;;;;;;;;;;::clodxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxkkOO000000000000000000000000000000OOOkdl;;,,,,,,;;::ccloooooodddddxxxxxxxkkOOOOO0000000KKKKKKKKKKKKKKKKKK0KKKKKKKK0000KKKK0000KKKKKKKK000000000000000000OOOOOkkkkkkxxxxxxxxkkxxxxxxxxxxxxxxxxxxxxxxxollcccccccccccc:::::::::::::;;;;;;;;;;;;::clloxkxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxkkOO000000000000000000000000000000OOkxdl::;;,,,;;;::cloooooooddddddddxxxxkkkkkOOOO0000000000000000000000000KKKKKKKKKKKKXXKKKKKKKKKKKKKKKK0000000000OOOOOOOOkkkkkkkkkxxxxxxkkkxxxxxxxxxxxxxxxxxxxxxxxxdolccccccccc::::::::::::::::;;;;;;;;;;;;::ccloxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxddddoool
+xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxkOOO000OOOOO00000000000000000000OOOkxdlc::;;;;;;;::clooooooooddddddddddxxkkkkkOOOO0000OOOOOOOOOOOOO000000KKKKKKKXXXXXXXXXXKKKKKKKKKKKKKKKK0000000OOOOOkkkkkkkkkkkkkkxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxdocccccccc::cccc:::::::::;;;;;;;;;;;;;;;;:cloxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxddddooollllllcccc
+xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxddxkkOOOOOOOOOOO0000000000000000000OOOkxdolcc::;;;;;:cllloooddddddxxxxxxxxxxxxkkkkOO0000OOOOOOkkkkkkOOO0000KKKKKKKXXXXXXXXXXXKKKKKKKKKKKKKKKKK0000000OOOOOkkOkkkkkkkkkkkkxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxolccccccccc::::::::::::;;;;;;;;;;,;;;;;;:clodxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxddddoooolllllcccccccccccccl
+xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxdddxkkkOOOOOOOOOO00000000000K000000OOOkxdxdlcc::;;;;:cclloooddddxxxxkkxxxxxxxxkkkOOOOOO000OOOOOkkkOOOO0000KKKKKKKKKKXXXXXXXKKKKKKKKKKK0000000000000000OOOOOOOOOkkkkkkkkkkkkxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxdlccccccc::::::::::::;;;;;;;;;;;;;;;;;;;:coxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxkxxxxxxxxxddddoooolllllllccccccccccclllllllloooo
+xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxooodxxkkkOkkkkOOOOO00000000KK000000OOkxdxxxdocc:::;::ccclllooddxxxkkkkkkkkkkkkkkkkOOOOOOOOOOOOOOOOOO000000000KKKKKKKKKKKKKKKKKKK000000000000000000000OOOOOOkkkkkkkkkkkkkkkkxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxdllccccccc:::::;;;::::;;;;;;;;;;;;;;;;;cdxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxkkxxxxxxxdddddoooolllllccccccccccccllllllllllooooodddooooooo
+xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxooodxxkkkkkkkkkOOOOO00000000000000OOOkxdxxxxxolc::::::ccclloodddxxkkkkkkOOOOOkkkkkkkkkkkkkkkkkkkOOOO00000000000000000KKKKKKKKKK00000000000000000000OOOOOOkkkkkkkkkkxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxdollccc::::::::;;:;:;;;;;;;;;;;;;;;;cdxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxdddddooooolllllllcccccccccccllllllllooooddddddooooooooooooodddd
+kkkkkxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxooodxxkkkkkkkkkOOOOO00000000000000OOOkxdxxxxxxdlc:c:::cccclloodddxxxxkkkOOOOOkkxxxxxxxxxkxxxxxxxkkOOOOOOOOOOO000000000000000000OOkOOOOOOO00000000OOOOOkkkkkxxxxxxxxxxxdddddddxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxolccc::::::::::::::;;;;;;;;;;::;cdxxxxxxxxxxxxxxxxxxxxxxxkxxxxkxxxxxxxxxxddddooooolllllllcccccccccccllllllllloooooodddddooooooooooooooodddxxxkkkkkkkk
+xxxxxxxkkkkkkkkkkkkkkkkkkkkkxxxxxxxxxxxdoddxxkkkkkkkkkOOOOO0000000000000OOOkkxdxxxxxxxxolcc::ccllllloooodddxxxkkkOOOkkxxxddddddddddddxxxkkOOOOOOOOOOOOOOOOOOOOOO000OOkkkxxkkkkOOOOOOOOOOOOOOkkkxxxddoooodddddddoooodddxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxdolccc::::::::::::;;;;;;;;;;::cdxxxxxxxxxkxxxxxxxxxxxxxddddddooooollllllllccccccccccclccllllllllloooodddddddooooooooooooodddddxxxxkkkkkkkkkkkkkkkkkk
+llllooooooddddddddxxxxxxxxkkkkkkkkxkkkxdddxxxkkkkkkkkkOOOOOOO00000000000OOkkxdxxxxxxxxxxdocc:clllllllllooooddxxxxkkkkkxxddoooooooooddxxxkkkkkkkkkkOOOOOkkOOOOOOOOOOOkkkxxxxxxxkkkkkkOOOOOkkkkxxxdddoollooooooooollooodxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxdolc::::::::::::::;;;;;;;;:coxxxxxxxxddddoooooooollllllllcccccccccccclclllllllllllooooddddddooooooooooooooooddddxxxkkkkkkkkkkkkkkkkkkkkkkkkkkxxxdd
+llllllcccclllllllllllooooooooddddddddddddxxxkkkkkkkkkkOOOOOOOO00000000OOOkkkxdxxxxxxxxxxxxoccccllllllllllllooodddxxxxxddooolllllllooddxxxkkkkkkkkkkkkkkkkkkkkkkkOOOOOkkxxxxxxxkkkkkkkkkkkkxxxxdddoooolllllloooooooooodxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxolc:::::::::::::;;::;;;:cloooolllllllccccccccclcclcllccllllllllloooooodddddddooooooooooooooddddddxxxkkkkkkkkkkkkkkkkkkkkkkkkkkkxxxxxddooollcccc
+dddddooooooooollllllllllcccccllllllllooddxxxxkkkkkkkkkOOOOOOOOOO000000OOOOkxdxxxxkkkkkkkkkxoccclcccccllllllllllooooooooolllllcccclloddxxxxkkkkkkkkkkkkkkkkkkkkkkkOOOOOkkkkkkkkkkkkkOOkkkkkxxxdddddoooolllllloooooodddxkkxxxkkxxkkxkkkkxxxxxxxxxxxxxxxxxddddddddddoolcccc::::::::::;;;;;;:cccccccccllllllllllloooooooooodddddddddoooooooooooooodddddddxxxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxxxddddooolllccc::::::::::
+ddddddddxxxxxxxdddddooooooooooooooollodddxxxxkkkkkkkkkOOOOOOOOOOOO000OOkkkxxdoodddddddddddddlcccclcclllllllllllllllllollllllccccclooddxxxxkkkkkkkkkkxkkkkkkkkOOOOOOOOOOOkkkOOOOOOOOOOOOkkkkxxxxdddooodddoooooodddddddxxxxxxxxdddddddddoooooooooooolllllllllllllllclccllcccccccccc:;;::cllooooooooooodddddddddddddooooooooodddodddddddddxxxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxxddddoolllccc::::::::::::::::::::::
+dddddddddddddddddoooodddddddddxxddxxddddxxxxkkkkkkkkkkkOkOOOOOOOOO000OOkkkxxolcllllllllllllllcccclllllllllllooooooooooooooolllcclloodddxxxkkkkkkkkkkkkkOOOOOOOOOOOOOOOOOOOOO000000OOOOOOOOOkkkxxddooddxxxxxdddddddddollllllllllllllllllllllccccllcccllllllllllllloolooooooooooodoooooodxxxddddooooooooooodddddddddddddddxxxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxxxxdddoolllcccc:::::::::::::::::::::::::::::::::
+kkkkkkkkkkkkkxxxxxdddddddddddddddddddoddxxxxkkkkkkkkkkkkkkOOOOOOOOOOOOkkxxxddoooooooooooooollllccclllllllllooooooooddddxddddoolloooddddxxxxxxxkkkkkkkOOOO00O000000000000000KKK000000000OOOOOkkkkxxddddddxxxxddddddddollllllllllooooooooooooooooooooooooodddddddddddddddddddooooooooooooddddddddddddddddxxxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxxxxdddooolllccccc::::::::::::::::::::::::::::::::::::::::::::
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxxxxdddxxxxkkkkOOOkkxxxkkkkkOOOOOOOkkkkxxddddxdddxxxxxxxxxdddolccllllllllooooooodddddddxxdddddddddddddxxxxxxxxkkkOOOO0000000000KK00KKKKKKKKKKKKKKK000000O0OOOOkkkxxddooddddddddddooddddddxxddxxxxxxxxxxddddddddoooddoooooooooodddddddddddddddddddxxxxxxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxxxxdddoooolllcccc::::::::::::::::::::::::::::::::::::::::::::::::::::::::c:
+xxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxdddxxxkkkOOOOOkkkxxxxxkkkkkkkkkkkkkxxddddddddddddddddddddoolccllllllloooooodddddddddddddddddddddddddxxxxxkkOO0000KKKKKKKKKKKKKKKXXKKKKKKKKKKKKK0000000OOOOkkkkxxdololloooooooloddoooooooododdddddddddddddddddddddddxdxxxxxxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxxxdddoooollllcccccc::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::ccccccc::
+cllllloooodddddxxxxxkkkkkkkkkkkkkkkkxdddxxxkkOOOOOOOkkkxxxxxkkkkkkkkxxxxdddxkkkkkkkkkkxxxxxxxxxxdllllloooooooddddddddddddddoooooododdddddxxkkOO00KKKKKKXXXXXXXXXXXXXXXXKKKKKKKKKKKKK000000OOOOOkkkkxxdolllclclllllodddddddddxxxxxxxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxxxxxxdddddooollllccccccc::::::::::::::::::::::::::::::::::::::::::::::::::::::::c:::cccccccccccccccccc::cc::::
+::::::::::::ccccccccclllloooooddddxxdoddxxkOOOOO000OOOkxxxxxxkkkkkkxxxxddddkkkkkkkkkkkkkkkkkkkkkkdolloodddxxxxxxddddddddooooooooddoodddxkkOO00KKKKKKXXXXXXXXXXXXXXXXKKKKKKKXKKKKKKKKK00000OOOOOkkkxxxddoollccccclloxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxxxxxddddoooolllllcccccccc::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::cccccccccccccccccc::::::::::ccccccccc
+::::::::::::::::::::::::::::::::::cclodxxkkOO00000000OOkxxxxxxxkkkkxxxddodxkkkkkkkkkkkkkkkkkkkkkkkxoloddxxxkkkOOkkkkkkkxxxxxxxxxxxxxxkkOO00KKKKKKKKKKKKKXXXXXXXXXXKKKKKKKKKKKKKKKKKKK00000OOOOkkkkxxddoooollccllllokkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxxxxxxxxxddddddoooooolllllccccccc:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::ccc::ccccccccccccccccccccc::::::::cc:::cccccccccccccccc
+:::::::::::::::::::::::::::::::::::clddxkkOO000KKKKKK00OkxxxxxxkkkxxxddolllloolooooooodddddddddxxxxdoodxxkkkO000000000000000000OOkkkkOO000KKKKKKKKKKKKKKKKXXXXXXKKKKKKKKKKKKKKKKKKKKKK0000OOOOkkkxxxddoooolllllllloxxxxxxdddxdddddddddoooolllllllllllccccccccccc:::::::::::::::::c:c::::::::::::::::::::::::::::::::::::::::::::::::::::cccccccccccccccccccccccccccccccc:::::::::::cccccccccccccccccccccccccc:::
+:::::::::::::::::::::::::::::::::::clddxkO000KKKKKKKKKK0Okxxxxxxkkkxxddocc:::::::::::::::::cccccccccldxxkOOO00KKKKKKKKKXXXXXXXKK00OOOO000KKKKKKKXKKKXXXXKKKXXXXKKKKKKKKKKKKKKKKKKKKKKKKK000OOkkkxxxxxdddooollllclccccccccccc:::::cc:::::::::::::c::::::::::::::::cc::::::::::::::::::::::::::::::::::::::::::::::cc:::::::ccccc:ccccccccccccccccccccccccc::::::::ccc::ccccccccccccccccccccccccccc:::::::::::::::
+ccccccccccc::::::c::::::::::::::::ccodxkO0000KKKKKKXXXKK0Okxxxxxxkkxddol:::::::::::::::::::::::::cc:ldxkOO000KKKKKKXXXXXXXXXXXXXKK00000KKKKXXXXXXXXXXXXXXXXXXXXKKKK000KKXXXXXXXXXXXXXKKKKK00Okkkxxxxxxxxxddoollllc::::::ccc::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::cc::c::::cc:ccccccccccccccccccccccccccccccccccc:::ccccccccccccccccccccccccccccccccccccc::cc::::::::::::cccccccccccc
+ccccccccccccccccccccccccccccccccccccodkO00KKKKKXXXXXXXXKK0Okxxxxxkxxdolc:::::::::::::::::::::::::c::lxkOO000KKKKKKXXXXXXXXNNNNNXXXKKKKKKXXXXXXXXXXXXXXXXXXXXXKKKK00000KXXXXXNNNNXXXXXXXXKKK00OOkxxxxkkkkkkxxddoolc:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::ccccccccccccccccccccccccccccccccccccccccccc::ccccccccccccccccccccccccccccccccccccc:cc:ccc:c::::::::cccccccccllllllllllllooo
+cccccc:ccccccc::cccccccccccccccccccloxO0KKKKKXXXXXXXXXXXKKOkkkkkkkxxdoccc:::::::c::c:::::::::::ccc:lxOOO00KKKKKKKXXXXXXXXXXNNNNXXXKKKXXXXXXXXXXXXXXXXNNNNNNNXXXXK0OO0KKXXXXNNNNNNXXXXXXXXKKK00OOkkkkOOOOkkkkxxddocc:::::::::::::c::::::::::::::::c::::::::cc::cccccccccccccccccccccccccccccccccccccccc:ccccccccccccccccccccccccccccccccccccccccccccccccccccc:cc:::c::::::::ccccccccclllclllllllloooooooooooooodd
+cccccccccccccccccccccccccccccccccccldkO00KKKKXXXXXXXXXXXXK0kkkkkkkxxolccccccccccccccccccccccccccccokO0000KKKKKKKXXXXXXXXXXXXNNXXXXKKKKKKXXXXXXXXXXXXXXNNNNNNNNNXXXXXXXXXXXXXNNNNNNNXXXXXXXKKK00OOkkOOOOOOOOkkkxxoccccccccc:ccccccccccccccccccccccccccccccccccccccccccccccccccccccccc::cccccccccccccccccccccccccccccccccccccclcccccccccccccc::cc::c:::cccc::ccccccccccclllllllllllllooooooooooooooddddddddddddddd
+ccccccccccclccllcccllcccccccccccccloxkO000KKKKXXXXXXXXXXXKK0OOOOOkkxocccccccccccccccccccccccccccldkO0000KKKKKKKKXXXXXXXXXXXXXXXXXKKKKKKKKKKKKXXXXXXXXXXXXXNNNXXXXK0OOOO0KXXXXXXXXXXXXXXXXKKKK000OOOO000000OOOkkkdlcccccccccccccccccccccccccccccccccccccccc:cccccccccccccccccccccccccccccccccccccccccllcccccccccccccccccccccccccccccccccccccccc::cccccccclccllllllllloooooooooooooodddddddddddddddddddddxxxxxxxxx
+cccccccccccccccccccccccccccccclcclloxkOO00KKKKXXXXNNXXXXXXXKK0000OOxlcccccccccccccccccccccccccccok0000KKKKKKKKKKXXXXXXXXXXXXXXXXXKKK0KKKKKKKKKKKKKKKXXXXXXXXXXXXXNXOddxkOKXXXXXXXXXXKXXXKKKKK000OOO0000000OOOOOOxocccccccccccccccccccccc:cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccclclllllllllllloooooooooooodddddddddddddddddddxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+llllllllllcccccccccccccccccccccccclooxkO000KKKXXXXXXXXXXXXXXXXXXK0Odlllllcccccccccccccccccccccldk0000KKKKKKKKKXXXXXXXXXXXXXXXXXXXKKKK00KKKK0000KKKKKKKKKKXXXXXNNNNNXKKXNNNNXXXXKKKKKKKKKKKKKK000OOO0000000OOOOOOkdlcccccccclcccccccccccccccccccccccccccclccccccclllcccccccccccccccccccccccccccccccccccccccccccccccllllcclllllllllloooooooooooooooooddddddddddddddddddddxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxk
+ddddddddoooooollolllllllllllllllllllloxkO00KKKKKXXXXXXXXXXXXNNXXK0OdlllllccllccllllllllllllllldO00KKKKKKKXXXXXXXXXXXXXXXXNNNNNXXXXKKKKKK000000000KKKKKKKKKKXXXXXNNNNNNNNNNXXXKKKKKKKKKKKKKKK000OOOO0000000OOOOOOOkolllllllcllllcclllccclcccccccccccccccccccccccccccccccccccccccccccccccccccccccclllllllllllllloooooooooodddooodddddddddddddddddddddxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxkxxxxxkkkkkkkkkkkkkkkkk
+kkxxxxxxxxxxxxxxxxxxdddddddddddoooollldxkO000KKKXXXXXXXXXXXXXXKKKK0dllllllllllllllllllllllllldOO00KKKKKKXXXXXXXXXXXXXNXXNNNNNNNXXXXKKKKK000000000000KKKKKKKKKKXXXXXNNNXXXXXKKKKKKK0KKKKKK00000OOOOO00000000OOOOOkkdlccccccccccccccccccccccccccccccccccccccccccccclllllllllllllllllllllllloooooooooooooooddddddddddddddddddxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxkkxxxkkkkkxkkkkxxkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkxkxkxxxxxxxxxxxxdollodxO0000KKKXXXXXXXXXXXXXXKKK0xoooooooollollllllllllllldkO000000KKKKXXXXXXXXNNNNNNNNNNNNNXXXXXXKKKKK00000000000000000KKKKKKXXXXXXXXXKKKKKKK0000000000000OOOOOO00K00000OOOOOkkxolllllllllllllllllllllllllllllllllllloooooooooooooooooooooddddddddddddddddddddddddxdddxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxkkxxxxxkkxxkkkkkkxkkkkkkkkkxxxxkkkkxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxdooodxkOO000KKKXXXXXXXXXXXXXXKKKOxxxxxxxxddddddddddddddodxkO0000000KKKKXXXXXXXXXNNNNNNNNNNNXXXXXXXKKKKK000000000000000000KKKKKKKKKKKKKKKKK0000000000000OOOOOOOOO00KK0000OOOOOOkkdoooooooooooooooooooodddddddddddddddddddddddddddddddddxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxkkxxxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxdoodxxkkkO000KKKXXXXXXXXXXXXXXKK0OkkkkkkkkxkkxxxxxxxxxxxxkkOOO00000000KKKKKKXXXXXXXXNNNNNNXXXXXXXKKKKKK0000000000000000000000000KKKKKK0000000OOOOOO0OOOOOOOOOOO00KKKK00000OOOOOkxxxxdddddxxxxdxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxkkkkkkxxkkkkkkkkkkkkkkkkxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkddddxxxkkkOO000KKXXXXXXXXXXXXXXXKKOkkkkkkkkkkkkkkkkkkkkkkxkkkOOOOOO000000000KKKKKXXXXXXXXXXXXXXKKKKKKKKKK0000000000000000000000000KK000000000OOOOOOOOOOOOOOOOOOO00KKKKK000000OOOkkxxxxxxxxxxxxxxxxxxxxxxxxxxxxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkx
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkdddxxkkkOOO0000KKKKKXXXXXXXXXXXXXK0kkkkkkkkkkkkkkkkkkkkkxxxkkkkkkkOOOOOOOOOO000KKKKKKKKKXXXXXKKKKKKKKKKKKKKKK00000000000000000000000000000OOOOOOOOOOOOOOOOOOOOOO0KKKKKKK000000OOOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxxxxxxxxxxxdd
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxddxkkkOOOO0000KKKKKKXXXXXXXXXXXXK0kkkkkkkkkkkkkkkkkkkkkxxxxxkkkkkkkOOOOOOOOOOO0000KKKKKKXXXKKKKKKKKKKKKKKKKK0000000000000OO00000000000000OOOOOOOOOOOOOOOOOOOOO000KKKKKK0000000OOOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxxxxxxxxxxdddooooooooooo
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxddxkkOOOO00000KKKKKXXXKKXXXXXXXXXKOkkkkkkkkkkkkkkkkkkkkxddxxxkkkkkkkkkkkkkkkkOOOO00000KKKKKKKK000000000K00000000000000000O00000000000000OOOOOOOOOOOOOOOOOOO000000KKKK000000000OOOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxxxxxxxxxxxxdddooooooooooooooooddddxxxx
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxdxxkkOOO000000KKKKKKKKXKKXXXXXXXXK0OkkkkkkkkkkkkkkkkkkkxxxxxkkkkkkkkkkkkkkkkkkkkkOOOOOO000000000000000000000000000000000000000000000000OOOOOOOOOOOOOOOOOOO000000KKKK0000000000OOOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxxxxxxxxxxxxddddoooooooooooooooooddddxxxxxxxxxxkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkdddxkkOOO0000KKKKKKKXXXXKKKKXXXXXXK0OkkkkkkkkkkkkkkkkkkkkxxkkkkkkkkkkkkkkkkkkxxxdxxxxxxkkkOOOOOOOOOOOO00000000000000OO0000000000000000OOOOOOOOOOOOOOOOOOOO00000000KKK0000000000OOOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxxxxxxxxxddddddooooooddooooooooooddddxxxxxxxxxxxxkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkdodxkkOOOOOO000KKKKXXXXXXKKKKKXXKKKK0kkkkkkkkkkkkkkkkkkkkxkkkkOOOkkkkkkkkkkkkkkxxxdddodddddxxxxkkkOOOOOO00OOOO0OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO00000000000000000000000OOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxxxxxxxxxxxddddddddooooodddddddddddddddddddxxxxxxxxxxxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+xxxxxxxxkkkkkkkkkkkkkkkkkkkkkkkkkxdodxxkkOOOOO0000KKKXXXXXKKKKKKKKKKKK0OkkkkkkkkkkkkkkkkkkxxkkOOOOOOOOOOOkkkkkkkkkkkxxdoooooddxxxxxkkkkkOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO000000000000000000000000OOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxkxxxxxxxxxxxxddddddddoooodddddddddddddddddddddxxxxxxxxxxxxxxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+ddddddddddddddddddddxxxxxxxxxxxxxxdoddxkOOOOOO0000KKKKXXXKKKKKKKKKKKKK0OkkkkkkkkkkkkkkkkkkkkOOOO000000000OOOkkxxxxxxxxddooodddxxxxxxxxkkkkkkkkkkkkkkkkkkkkkkkOOOOOOOOOOOOOkkOOOOOOOOOOOOO00000000OOOOOOO0000000000OOOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxxxkxxxxxxxxxxxxxdddddddddddddddddddddddddddddddddddxxxxxxxxxxxxxxxkxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+xxxxxxxxxxxxxxxdddddddddddddddxdddooodxkOOOOOOO0000KKKKKKKKKKKKKKKKKKK0OkkkkkkkkkkkkkkkkkkkOOOO000000000000OOOkkxxxdddddddddddxxxkkxxxxxxxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOOOOOOOOO0000OOOOOOOO00000000000OOOkxkkkkkkkkkkkkkkkkkkkkkkxxxxxxxxxxxxxxxxxxxxxddddddddddddddddddddddddddddddddddddddddddxxxxxxxxxxxxxxxkxxxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkx
+kkkkkkkkkkkkkkkkkxxxxxxxxxxxxxxxxxdoodxkkOOO0OO000000KKKKKKKKKKKKKKKK00kdddddddddddddxxxxkOOO00000000000000000000OOkkxxxxxxxxxxddxkkxxxxxxxxxxxxxkkkkkxxkxxxxkkkkxxxkkkkkkkkkkkkkkkkkkkOOOOOOOOOOkkkkOO0000000000OOOkkxxxxxxxxdxxxxdddddddddddddddddddddddddddddddddddddddddddddddddxxxxxxxxxxxxxxxxxxxxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxxddddoooolloo
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkdooodxkOOOOOO000000KKKKKKKKKKKKKKK000kxxxxdddddddddddxkkOOO0000000000000000KKKKKK000OOOOOkkkxxddxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxkxxkkkkkkkkOOOOOOOkkkkkkOO000000000OOOkkxxdddddddddddddddddddddddddddddxxxxxxxxxxxxxxxxxxxxxxxxxxxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxxxxddooooollllllloooodddxxx
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxolodxkkOOOO0000000KKKKKKKKKKKKKKK000OkkkkkkkkxkxxkxxxkkOOO0000000000000KKKKKKKKKKKKKKKK000OkxxddddxxddxxddxxxxxxddddddddxddddddxxxxxdddxxxxxxxkkkkkkkkkkkkkkkxxxkkkOOOOOOOOOOkkkkxxxxxxxxxxxxxxxxxxxxxxxxxxxxxkxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxxxdddooooooolllloooooodddxxxxkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxooodxxkkOOO0000000KKKKKKKKKKKKKK000OOkkkkkkkkkkkkkkkkkkOOO00000000000K0000KKKKKKKKKKKKKKKKK0Okxddddddddddddddddddddddddddddddddddddddddddddxxxxxkkkkkkkkkkkkkxxxkkxxxkkkkkkxxxxxxxxxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxxxddddooooooooooolooooooodddxxxxkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkdooodxxkOOO000000KKKKKXXXXKKKKKK000OkkkkkkkkkkkkkkkkkkkOOO0000000000K00000000KKKKKKKKKKKKKKK0Okddooooooooooodddddddddddddddddddddddddddddddddddxxxxxxkkkkkkkkxxxxxdoooooddxxxxxkkxxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxxxdddddoooooooooooooooooddddxxxxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+dxxxxxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkdoooodxkkOOO0000KKKKXXXXXXXKKKKK00OOkkkkkkkkkkkkkkxkkkkOOO000000000KKKKK0000000KKKKKKKKKKKKKK0Okdooooooodoooooddoooodddddddoooooooooooooooooddddddxxxxxxxxxxxxxxxdollllodxkkkkkxxddxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxxxxxddddddoooooooollooooooooddddxxxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+ddddddddddddddddddddddddxxxxxxkkkkkxoooodxxkkOOO000KKKKXXXXXXXKKKKK00OkkkkkkkkkkkkkkkxxkkOOOO000000000KKKKKK00000KKKKKKKKKKKKKKKK0Okddooooooooooooooooooooooooddoooooooooooooooooooddddddxxxxxxdddddollloodxxxxxddddddxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxxxddddddoooooooooooolloooooooooddddxxxxxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkxxxxxxxddddddddddddddddooooddxxkkOO0000KKKKXXXKKKKKKKK00OkkkkkkkkkkkkkkkxxkkOOOO0000000000KKK0000KKKKKXXKKKKK000KKKKK00kxdoooooooooooooooolooooodkOOOOOkkxoooooooooooooooodddddddddddoolllodddddddddxxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxxxxxxxxdddddddddooooooooooooooooooooooooooodddddxxxxxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkdoooodxxkkkOO0000KKKKKKKKKKKKKK0OxddddddddddddddddxkkkOOOO0000000000000000KKKKXXXXXXXXKKKKKKKKK00OxooooooolllllllllloodxkkxO00000kkxdoooooooooooloooooooooooooooodxkkkkkkkkkkkOOOOkxxxdddddddddddddoooooooooooooooooooooooooooooooooddddddddxxxxxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxoooodxxxkkkOOO000KKKKKKKKKKKKK00kkkkkkxxxxxxxxxxdxxkkOOOOO0000000000000000KKKKXXXXXXXXKKKKKKK0000kxoloollllllllllooodxO00kxdodddkkO0Okxolooooollllllllloooooooxk000000O00000000O0Oxdoooooooddddddddddddxxxxxxxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkdlooddxxxkkkkOO00KKKKKKKKKKKK00OkkkkkkkkkkkkkkOkxxkkkOOOOO000000000000000KKKKKKKKKKKKKXXKXXKK0000OkxolllllllllloodxkxdxkOkdlcccldkO0OOOxdoooollllllclllooooodxO000000000000KKK000OOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxoloddxxkkkkkkOO000KKKKKKKKKK00OkkkkkkkkkkkkkkkkxxkkkOOOOOOO000000000000KK00KKKKKKKKKKKKKXXXXK0OkkOkxdlccccloddxxdoodxxk0KKKkddO0KK0OkxxxddoolllllllllllloodxO0000000000KKKKKK0000Okkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkdloodxxkkkkkkOOO00KKKKKKKKKK00OkkkkkkkkkkkkkkkkkkkkkkOOOOOO000000000000000KKKKKKKKK0KKKKKXXXXK0kxkkkkxolcclodxkkkkkkkO0OkkkkxxO000kdodkkkxoollllllllllloodxO0000KKKKKKKKKKKKKK000OOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxooodxkkkkkOOOOOO000KKKKKKKK0OOkkkkkkkkkkkkkkkkkkOOkkkkOOO0000000000000000KKKKKKKKKK000KKKKKXXXKkddxkxxdlclllll::ododxxdolllllodddxddxdodooollllllllllloxkOO000KKKKKKKKKKKKKKK0000Okkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkdlllodkkkOOOOOOOO000KKKKKKK0OOkkkkkkkkkkkkkkkkkOOOOkkkOOO0000000000000000KKKKKKKKKK00KKKKKKKKXXKOxddddddoloooolloolllcccccccclllloocloodxdollllllllodxkOOO0000KKKKKKKKKKKKKKK0000Okkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkoloodkkOOO00000000KKKKKKKK0OkkkkkkkkkkkkkkkkkOOOOOkkkOOO0000000000000000000KKKKKKKKKKKKKKKKKXXXXKOdooooolclloolc:ccccc::;;;::ccccllooolollccclllodxkOOO00000KKKKKKKKKKKKKKKKK000Okkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOxloodxkO000KKKK00KKKKKKKXK0OkkkkkkkkkkkkkkkkkOOOOOkkkOOOO000000000000000000KKKKKKKKKKKKKKKKKKKXKKK0kolllccccccc:::cc:;,,,,,,,:ccclcccccclcllodxxkOOOO0000KKKKKKKKKKKKKKKKKKKK000OOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOkdoodxkOO00KKKKKKKKKKKXXXK0OkkkkkkkkkkkkkkkkkkkkkkkkkkOOOO0000000000000000000KKKKKKKKKKKKKKKKKKKKKKKOdlccccccccc:::;;,;loxxo:;::ccccc::clodxkkOkkkOO000KKKXXXKKKKKKKKKKKKKKK0000OOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxx
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxoodxxkO00KKKKKKKKKKKKXXXKOkkkkkkkkkkkkkxxkkkkkkkkkkkkOOOO0000000000000000000KKKKKKKKKKKKKKKKKKKKKK00xl:ccccccccc:::ldOKXXK0xlc:cccc:cldxkkkkkkkkOO00KXXXXXXXXXXXKKKKKKKKK00000OOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxxxxxxxxxxxxdd
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkdodkkkO00KKKKKKKKKKKKXXXK0kkkkkkkkkkkkkxxxkkkkkkkkkkkkOOOO0000000000000000000KKKKKKKKKKKKKKKKKKKKKKK0kl::ccccccccclokOKXXXXXOocccccloddxxxddddkO0KKXXXXNNXXXXXXXXXXXXXKKKK0000OOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxxxxxxxxxxxxxxddddddddddooooo
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxodkkkO00KKKKKKKKKKKKKXXXKOkkkkkkkkkkkxddxxxxkxxxxxkkkkOOOOOO00000O000000000000KKKKKKKKK00KKKKKKKKKKK0ko:;:c::clldooxO0KXXXKKkllccloodooooodkOKXXXNXXXNNNNNNXXNXXXXXXXXKKKK000OOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxxxxxxxxxxxxxxxdddddddddddddoooollllllllllooll
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkdoxkkOO000KKKKKXXXKKKKXXX0OkkkkkkkkkkxdddxxxxxxxxxxxkkkOOOOOOOOOOOO000OOO00000KK00KKKKKK00KKKKKKKKKKK0Oo;,;:::ldOxldkO0XXXKKOxolllooolodxOKKKXXXNNNNNNNNNNNNNNNXXXXXXXKKKK0000OOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxxxxxxxxxxxxxxxxxxddddddddddoodoooolllllllllllloollloooooodddddd
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOkdoxkOOO00OO0KKKKKKKKK0KKXX0OkkkkkkkkkdoodddxxxxxxxxxkkkOOOOOOOOOOO00OOOOO0000000000KKKK0000K000KKKKKK00Oo;',;:okKOllxO0KKXXK00kllolloxO0KKKKXXXXXXNNNNNNNNNNNNNNNXXXXXXKKKK000OOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkddddddddddddddddddooooolllllllllllllloooooooooddddddddddddoooooooolo
+xxxxxxxxxxxxxxxxxxkkkkkkkkkkkOOkkkkkkkOOkkkxddkkkOOOOOOOO0000000000KKKOkkkkkkkkkdooodddddddddxxxkkkkOOOOOOOOO0OOOOO000000000000KKK000000000KKKKK000ko,..:x0XKdlodxk0KK0OO0klloxO0KKKKKXXXXXXXNNNNNNNNNNNNNNNXXXXXXXKKKK00OOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxxxxxxxxxxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxkxoooolllllllllloooolooooooooodddddddddddooooooooooooooooooooddddxx
+ddddddddddddddddxdxxxxxxxxxxxxxxxxxxxxxxxxxxxdddxxkkkxxxxkkkOOOOkkOO0K0OOOkkkkOkdlooooddddddddxxxkkkkOOOOOOOOOOOOOO000000000O00000000000K000000K000Oko,'d0KKKKkolloxxxkxOXKxxO000KKKKKXXXXXXXNNNNNNNNNNNNNNNXXXXXXXKKKK00OOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxxxxxxxxxxxxxxxxxxxxxxxxxxxddddddddddxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxkkdoooloooooddddddddddooooooooooooooooooooooodddddxxxkkkkkkkkkkkkkk
+lllllllllllllllloooooooodddddddddddddddddddxxxdoooddddddddddxxkOOOOkO00OkxxxxxxxolloooddddddddxxxxkkkkkkkkOOOOOOOOO0000000O0000000000000000000000000OkooO00KKX0o;::ccccoOXX0000KKKKKKKXXXXXNNNNNNNXXXNNNNNNNNXXXXXXKKKKK00Okkkxxkxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxddddddddddddddddddddddddddoooooolllllllldkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxkkkkkxxdoooooooooooooooooooodddddxxxxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+xxdddddddddoooooooooolooolllllllllllllllllloodoollooooddddodddxxkkOOkO00OxddddddollllooodddddddddxxkkkkkkkkkOOOOOOOOOO000O000000000000000000000000000OkkkkkOO0Odc,'''';dOKK000KKKKKKXXXXXXXNNNNNNXXXXXXNNNNNNXXXXXXKKKKKK0Okxxxxdddddddddddddddddddddddddddddddddoooooooollllllllllllllllllllllllloolloooooddxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxkkkkkxxdooodddddxxxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+oooooooodooodddddddddxxxxxxxxxxxxddddddoooolccccccllooodddddxxxxxxkkkkO0KOxdollllllllooodddddddddxxxxkkkkkkkkkkOOOOOOOOOOOOOOO00000000000000000000000Oxxddodddddo:;,,:lxkOOOO0KKKXXXXXXXXXXXNNNNNXXXXXXXXXXNNXXXXXXXXXKKK00koooooooollllllllllllllllllllllllllllollloooolloooooooooodddddddddddddddddddddxkkxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+xxxxxxxxddddddddddoodddddooooooooooooooooool:::::cccllloddddxxkkkkkkOOOO0KXKK0kxollllooodddddxddxxxxxxkkkkkkkkkkOOOOOOOOOOOOOO0000000000000000000000Oxooolcccclll:;;;clooddddk0KKXXXXXXXXXXXXNNNNXXXXXXXXXXXNXXXXXXXXXXKKK0Odoooooooooooooooddoddddddddddddxxddddddddddddoooooooooooooooooddddddddddddddddxkxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxkkkkkxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkxxxxxxxdddddddddddoc::::::::cclooooodxkkOOO00O00KKKXXK0xollloooddxxxxxxxxxxxkkkxkkkkkkkOOOOOOOOOOOOOO00000000000OOOO00000OOxccllc:ccccc:::::ccccllok0KKKXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXKKK0Oxdddddddddoodoooooooooooddoodddddoooodddoddddddddddddddxxxxxxkkkkkkkkkkkkkkkxkkxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxkkkkkxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkoc::;;;;;:::cllcccodxkkOO00000KKKKKXK0xoloooddxxxxxxxxxxxkkkkkkkkkkkkkkOOOOOOOOOOOO0000000000OOOOOOOOOOOxc,;c:::cccc:::::::ccclokO0KKKKKXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXKKK0kdxdddddddddddddxxdxxxxxxxxxkkkkkkkkkkkkkkkkkOOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxkkkkkxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxc::;;:;;;:::clllcclodxkOOOO000KKKKKKKKOdoooddxxxxxkkkkkkkkkkkkkkkkkkkkkkkkkOOkOOOOO000000000OOOOOOOOOOkxl,',:::::::::::::ccccloxO0KKKKKKXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXKKKK0OOOOOOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxkkkkkxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkl:::;;;;;::::ccloollodxxkkOO000KKKKKKKKKkdoddxxxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOOOOOO00000000OOOkkkOOkkkxo:'.....''',;:::ccc::cdxO0KKKKKKKXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXKKKK0Okkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxkkkkxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkdc::;;;;;;;;:::ccllcclodxxkOO0000000K00KK0kdddxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOOOOOO000000000OOkkkkkkkkxoc;.     ...',,;,;,,:oxkO0000KKKKKKKXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXKKKKKOOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxkkkkxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkdc::;;;;;;;;;;:::ccclllodxxxkOOOOO0000000KK0xdxxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOOOOOO000000000OOOOkkkkkkxoc;'     ...'''',,,:odxkOO0000KKKKKKKKXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXKKXKKKOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkdc::;;;;;;;;;;::::::cllooddxxxkkOOO000OO00KKKOxxxkkxkkkkkkkkkkkkkkkkkkkkkkkkkkOOOOOOO000000000OOOkkkkkxdol:,.   ..'',,,,;;:ldxkkOO000KKKKKKKKKKKKXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXKKK0OkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxkkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkdcc::;;;;;;;;;;:::::::looodddddxkOOO0OO0OO00O0OxxxxxkkkkkkkkkkxxkkkkkkkkkkkkkkkkkOOOOOOOO000000OOkkkkxxdol:,.   ..',,,;;;:lddxxkOO0000KKKKKKKKKKKKXXXKXXXXXXXXXXXXXXXXXXXXXXXXXKKKK0OkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxlc::;;;;;;;;;;;:::::::cloooooodxkOOOO0OkkkkkOOkxxxxkkkkkkkkkkxxxkkkxxxkkkkkkkkkkkOOOOOOOOO000OOOkkkxxddolc;.   ..',,;:::lodxxxkOOO00000000KKKKKKKKKKKKKKKKKKKKKKKXXXXXXXXXXXXXXXXXK0Okkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxoc::;;;;;;;;;;;:::::::::llooolloxxkkOOdloxxkO0OkxxkkkkkkkkkkxxxxxxxxxxxxxxxkkkkkkOOOOOOOOOO00OOOkxxxxddolc:'  ..'',;;::clodxxxkkOOO0000000KKKKKKKKKKKKKKKKKKKKKKKKXXXXXXXXXXXXXXXXKK0OkkkkkkkkkkkOOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkdl:::;;;;;;;;;;;;::::::;:clddddooddxOOdcldxxkO0OkkkkkkkkkkkkxxxxxxxxxxxxxxxxkkkkkOOkkOOOOOOO00OOkxxxdddolc:'   .'',;;:cloddxxxkkOOOO0000000K00KKK00KKKKKKKKKKKKKKKXXXXXXXXXXXXXXXXKKK0OkkkkkkkkkkkkkkkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkoc::;;;;;;;;;;;;;;::cccccloddoooddxkOkolodxkO00OkkkkOkkkkkkxxxxxxxxxxxxxxxxxxkkkkkkkkOOOOOO0OOOkkxddddolc:,. ..',;;:cllodddxxkkkOOOO0000000000000000KKKKKKKKKKKKKXXXXXXXXXXXXXXXXXXKK0OkkkkkkkkkkkkOOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxoc::;;;;;;;;;;;;:c::ccc::::cllodxkOO0kocodxkO00OkkkkkkkkxxxxxxxxxxxxxxxxxxxkkkkkkkkkOOOOOOOOOOOkxxddoolc:,.  .',;;:cllodddxxxkkkOOOO000000000000000KKKKKKKKKKKKXXXXXXXXXXXXXXXXXXXXK0OOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxl:::;;;;;;;;;;;;::;;;;;;;::ldkkkkOKKKOocldxkO00OkkkkkkxxxxxxxxxxxxxxxxxxxxkkkkkkkkOOOOOOOOOOOOkxxddoolc:,.  .',;:ccllloddddxxkkkOOOOO00000000000000KKKKKKKKKKKKKKXXXXXXXXXXXXXXXXXKK0OkkkkkkkOOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOkxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkdc:::;;;;;;;;;;;::::::::::::ldkOOOO000OocdkkO000OkxxxxxxxxxxxxxxxxxxxxxxxxxxxkkkkOOOOOOOOOOOOOkxxddoolc:,.  ..,;:cclllodddxxxxxkOOOOOOO000000000000KKKKKKKKKKKKKKKKXXXXXXXXXXXXXXXKKK0OOOkkkkOOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOkkkkkkkkkkkkkkOko:::;;;;;;;;;;;:cccccc::::::coxxxxkkO0xcokkxxkkkkxxxxxxxxddxxxdxxxxxxxkkxxxxxkkkkOOOOOOOOOOOkkxxddoolc:,.  ..';::cllloodddxxxxkkkOOOOOOOOOO00000000KKKKKKKKKKKKKKKKXXXXXXXXXXXXXXKKK0OOOOkkkOOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkdc::::::;;;;;;;;:lloolc:;::;;:loxxxkkOkccoxxolodxxxdddddddxxxxxxxxxxxxxkkkkkkkkkkkkkOOOOOOOOkkxxdoooll:;.  ..';::clllloodddxxxxkkkkkOOOOOOOOO0000000000KKKKKKKKKKKKKXXXXXXXXXXXXXXKKK0OOkkkkkOOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOkkkdc::::::;;;;;;;;:cccclc;;;;;;;:ldxxkOOkl:loxxxxxxxxdddddddxxxxddddxxxxxxkkkkkkkkkkkkkkkOOkkkkkxxdoollc:;.  ..,;::ccllloooddddxxxxkkkkkkOOOOOOO0000000000KKKKKKKKKKKKKKKXXXXXXXXXXXXKK00OkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOkkkkxxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOkkkkOOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkdc::::::;;;;;;;;;:::::;;;,,,;:coxkOO0Oo;:lodxddxxxddddddddxxdddddxxxxxxxkkkkkkkkkkkkkkkkkkkkxxddoollc:;.  ..';::cccllloodddddxxxxxkkkkkOOOOOO0000000000000000KKKKKKKKKKKKXXXXXXXXXKKK0OOOOkOOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOkkkkxkkkkkkkkkkkkkkkkkkkkkkkkkkOkkkkkkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxdolc::::;;;;;;;;;;;;;;,'..,;:oxOO00KOl;:codxkOOxdxdddddddddddddxxxxxxxkkkkkkkkkkkkkkkkkkkkxxddoollc:;'....',::cccllllooodddddxxxxxkkkkkkkOOOOO0000000000000KKKKKKKKKKKKKKKKXXXXXKKK00OOOkOOkkkkkkkkkkkkkkkkkkkkkkkkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxkkkkkkkOOkkkkkkkkkkkkkkkkOOkkkxkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxoc:::;;;;;;;;;:::;;'..';cldkOO00Kx:;ccoxkOOkxdddddddddddddddxxxxxxxxxkkkkkkkkkkkkkkxxxxxddoolcc::;'...',;:ccclllllooodddddxxxxxxxxxkkkOOOOO0000000000000KKKKKKKKKKKKXXKKXKKKKKKK0OOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOkkkkxxkkkkkkkkkkkkkkkkkkkkkkkOOOkkkkkkkkOkkkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOkxdolc:::;;;:::ccc:,...,:codxOO000l,;:codxxdolodddddddddddddddxxxxxxxxkxxxxxkkkkkkkxxxxxddollcc:coc''',,;::cclllllooooodddddxxxxxxxxkkkkOOO00OOOOO0000000KKKKKKKKKKXXXKKXKKKKKKK00OOOOOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOkkkkkxkkkkkkkkkkkkkkkkkkkkkkkkkkkkOkkkkkOkkkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxl:::;;::::cc:,....;:cldkkO00x;',,;:c:;:clooooooddddddddddxxxxxxxxxxxkkkkkkkkxxxxxxdoollcc:cxkl,,,,;:::ccccllllooooddddddxxxxxxxkkkkOOOOOOOOO00000000KKKKKKKKKXXKKXXXKKKKK000OOOkOOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOkkkkkxkkkkkkkkOOkkkkkkkkkkkkkkkkkkkkxkkkOkkkkOOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxl:::;:::::c:;,'..';:clodkOOOd:;'....';clooooooddddddddddxxxxxxxxxxxkkkkkkkxxxxxxxddoolcc:lkOxl;,;;:::ccccllllllooooddddddxxxxxkkkkOOOOOOO00000000000KKKKKKKKKKKKKKKKKKKKK000OOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxxkkkkkkkkkkkkkkkkkkkkkkkOOOkkkkkkkkOkkkkOOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOxoc::::::::::;,..',;:clldxkkOOOkdl,',:clooooooooodddddddxxxxxxxxxxxxkkkkxxxxxxxxxddoolc::dOkkxc;;;:::cccccllllloooooodddddxxxxxkkkkOOOOOOOOO000000000KKKKKKKKKKKKKKKKKKKK000OOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOkkkkkxkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOkkkkOOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkOkkkkkkkkkkkkkkkkkkkkkkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkdl:::::;:::;,''.,;;:codxkkxkOO00x:,:cllloooooooooooddddxxxxxxxxxxxkkkxxxxxxxxxdddolcc;cxOkkkxc;;::::cccccclllllloooodddddxxxxxkkkkOOOOOOOOO00000000000KKKKKKKKKKKKKKKKKK000OOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOkkkkkxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOOkkkOOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOOkkkkkkkkkkkkkkkkkkkkkkkkkkkkocc::::::;;;,,;:::clooodooodddl;,;:cllloooooooooddddddddddxxxxxxxkkxxxxxxxxxxddooc::okkkkkkxl::::ccccccccccllllooooodddddxxxkkkOOOOOOOOOO0000000000KKKKKKKKKKKKKKKKKKKK000OkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOOkkkkkxkkkkkOkkkkkkkOkkkkkkkkkkOOOkkkkkkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkOOOkkkkkkkkkkkkkkkOOOkkkkkOkkkkkkkkkkkkkkkkkkkOkkxxdl::::;;;,;cc:;;;::::::::;;,,;::cclllooooooooodddddddddxxxxxxxxxxxxxxxxxxxddoc:cxkkkkkkkxl:::ccccccccccclllloooooddddxxxxkkOOOkkkOOOO00000000000KKKKKKKKKKKKKKKKKKKK00OOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOkkkkkkkkkkkkkkOkkkkkxkkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkOkkkkkOkkkkkkkOOkkkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxl:::::;;;:c::;;;;;;;,'.'',;;::ccllllloollooooooooodddddxxxxxxxxxxxxxxxxxxdoc:okkkkkkkkOxl:ccccccccccccllllllloooooddxxxkkOOOkkOOOOOOOO00000000KKKKKKKKKKKKKKKKKKK000OOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOkkkkkxkkkOOkkkkkkkkkkkkkkkkkkkOkkkkkkkkkOOkkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkOkkkkkOOOOkkkkOkkkkkkkkkkOOOkkkkOOOkkkkkkkkkkkkkkkkkkkkkkkkkdl::::::::::;;,,,,,,'...',;;;:ccclllllllllooooooooodddddddxxxxxxxxxxxxkxxdoccdOkkkkkkkkkxlcccccccccccccllllllooooodddxxkkkOOOOOOOOOOOO00000000000KKKKKKKKKKKKKKK0000OOOOkkkkkkkkkkkkkkkkkkkkkkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkOkkkkkxkkkOOkkkkkOkkkkkkkkkkkkkkOOkkkkkkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkOOOOOkkkOOOOkkkkOOOOkkkOOOkkOOkkkkkOOkkkkkkkkOOkkkkOkkkkkkkkkOOOkkkkOkkkxdoc:::::::::;;;;;;,,,,;;;;::ccllllllllllllooooooodddddddddxxxddxxxkkkxxoclkOkkkkkkkkkOkoccccccccccccclllllllloodddxxkkkOOOOOOOO0OO0000000000000KKKKKKKKKKKKKK00000OOOkkkkkkkkkkkkkkkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOkkkkkxkkkkkkkkkkOkkkkkkkkkOOkkkkkkkkkkkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+OkkkkkOOOkkkkOOkkkkkkkOOkkkOOOOOkkkkkkkkOkkkkkkOOOOOOOOOOOOOOkkkOkkOOkkkkkkkkkOkkxdolc:::cllllc::;;;::;;:::cccccllllllllooooooooddddddddxxxxxxxxkkkkxocdkkkkkkkOkkOkkkdcccccc::ccccccllllllooooddxxkkkOOOOOOO0000000000000000KKKKKKKKKKKKKK00000OOOkkOOOOOkkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOkkkkkxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkOOOkkkkkkkkkkkkkkkkkkkOOOOOOOOkkkkkkOOOOOkkkkkkOOOOkkkkkOOOOkkkkOOkkkkkkkkkkkkkkkxxxxkkkkxoc:::::::;:::ccccccllllllllooooooooooddddddddxxxxkkkkkkdlxOkkkkkkkkkOkkkkxlcccccc:ccccccclllllooooddxxkkkkOOOOO00000000000000000KKKKKKKKKKKK0000000OOkOOkkkkkkkOOOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOkkkkkxkkkkkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkOkkkkkkkkkkkkkkkkkkkkOOOOOOkkkOOOOOOOkkkkOOOOkkkkkkkOkkkkkOOOkkkkkOOOkkkkkkkOkkOkkkkdlc::c:::;:::::cccclllllllllllllloooooodddddddxxxkkkkkkdoxOkkkkkkkkkkkkkOkxocccccccccccccclllloooooddxxkkkkkOOO0000000000000000KKK00KKKKKKKKK000000OOOOOkkkOkkkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOkkkkkxkkkkkkkOOkkkkkkkkkkkkkkkkkkkkkkkkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkOOOkkkkkkkkkkkkkkkkkkkkkkOOkkkkkkkkOOOOOOkkkOOOkkkkkkkkkkOkkkOkkkkkkkkkkkkkkkOkkkOkkkkkxlccc:::::::::cccccclllllllllllllllloooooodddddxxkkkkkkxdkkkkkkkkkkkkkOOOkkkdlccccccccccccccllllloooddxxkkkkkOOOO00000000000KKKKK0KKKKKKKKKKK0000000OOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOOkkkkkxkkkkkkkOOkkkkkkkkkkkOOOkkkkkkkkkkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkOkkkkkkkkkkkkkkkkkkkkOOOkkkkkkkkkkkkkkkkkkkkkOOkkkkkkkkkkkkkkkkkkkkkkkkkkdccc:::::::::cccccccclllclllllllllllooooodddddxxxkkkkkxxkkkkkkkkkkkkkkkOkkkkxoccccccccccccccllllloooddxxkkkkOOOOOO00000000K0000K0KKKKKKKK0000000000OOkkkkkkkkkkkkkkkkkkkkkkkkkOOOkkkkkkkkkkkkkkkkkkkkkkkkOkkkkkxkkkkkkkOkkkkOkkkkkkkkkkkkkkkkkkkkkkOkkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOOOkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxocc::::::::::ccccccccccccllllllllllllooooooddxxxkkkkkkkkkkkkkkkkkkkkkkOkkkkkxolclcccccccccccllllloooddxxxkkkkkOOO0000000000KKKKKKKKKKK000000000000OOOkkkkkkkkkkkkkkkkkkkkkkOOOOOkkkkkkkkkkOOkkkkkkkkkkkkkkkkkkxkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOkkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkOkkkkkkkkkkkkkkkkkkkOOOkkkOOkkkkkkkkkkkkkkkkOkkkkkkOOkkkkkkkkkkkkkkkkkkkkkkkdlcc::::::::::cccccccccccccccclllllllllooooddxxxkkkkkxxkkkkkkkkkkkkkkkOkkkkkxkxocccccccccccccllllllooddxxxkkkkkOO000000000KKKKKKKKKK000000000000000OOOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxkkkkkkkOOkkkkkkkkkkkkkkkkkkkkkkkkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kOOkkkOkkkkkkkkkkkkkkkkkkkkkkkkkOkkOOOkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOOOkkkkkkkkkkkkkkkkkkkkkkkoccc:::::::::cc::ccccccccccccccccllllllloooddxxxxxkkxxkkkOkkkkkkkkOkkOkkkkkxkkxdllccccccc:ccclllllloodddxxkkkkOOO00000000KKKKKKKKK0000000000000000OOOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxkkkkkkkkkkkkkkkkkkkkkkOkkkkkkkkkkkkOkkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkkkOOkkkkkOOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOkkOkkkkkkkkkkkkkkkkkkkkkkkkdcccc::::::::ccc:cccccccccccccccccclllllloodddxxxxkkxxxkkkOOkkkOkOOOOOkkkkkxkkkkxolccccccccccccclllloodddxxkkkOOOO000000000KKKKK000000000000000000OOOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOkkkkkxkkkkOkkOOkkkkkkkkkkkkkkkkkkkkkkkkkkOkkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkkkkkkkkOOOOOOOOOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOkkkkkkOkkOkkkkkkkkkkkkkkkkkkkkOkocccc::::::::::::::::::::ccccccccccclllloooddxxxxkkxxxkkkkkkkkkkkkOOOkxkkkxkkxkOkxolcccccccccccclllooodddxxkkkOOOO00000000KKKKKKKK00000000000000OOOOkkkkkkkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxkkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOkkkkOkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkkkOOkkkkkkkOOOOOOOkkkkkkkkkkkkkkkkkOOkkkkkkkkkkkOOOkkkkkkkkOOkkkkkkkkkkkkkkkkkkkkkkkkxlcccc::::::::::::::::::::::::c::ccccllloooddddxxxxxxxkkkkkkkkkkkkkkOkkkkkxkkkkkOOkdlcccccccccccclllooooddxxkkOOOO00000000KKKKKKKK00000000000000OOOkkOkkkkkkkOOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkxkkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOkkkkOOOOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+kkkkkkkkkkkkkOOOkkkkkkkOOOOOOOOOOkkkkkkkkkkkkkkkkkOOOOOkkkkOOOOOkkkOkkkOkkkkkkkkkkkkkkkkkkkkkkkkkOkoccccc::::::::::::::::::::::::::ccccllllooddddxxxxxdxxkkkkkkkkkkkkOOkkkkkxkkkkkOOOOxllcccccccccccllloooddxxkkOOOO0000000000000KKK00000000OOOOOOOOkkkOkkkkkkkOOOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkOOkkkkkkxkkkkkkkkkkOkkkkkOkkkkkkkkkkkkkkkkkkOkkkkOkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk
+*/

proxy/blackhole/blackhole.go

@@ -3,8 +3,10 @@ package blackhole
 import (
 	"io/ioutil"
 
+	"github.com/v2ray/v2ray-core/app"
 	v2net "github.com/v2ray/v2ray-core/common/net"
-	"github.com/v2ray/v2ray-core/proxy/common/connhandler"
+	"github.com/v2ray/v2ray-core/proxy"
+	"github.com/v2ray/v2ray-core/proxy/internal"
 	"github.com/v2ray/v2ray-core/transport/ray"
 )
 
@@ -16,7 +18,7 @@ func NewBlackHole() *BlackHole {
 	return &BlackHole{}
 }
 
-func (bh *BlackHole) Dispatch(firstPacket v2net.Packet, ray ray.OutboundRay) error {
+func (this *BlackHole) Dispatch(firstPacket v2net.Packet, ray ray.OutboundRay) error {
 	if chunk := firstPacket.Chunk(); chunk != nil {
 		chunk.Release()
 	}
@@ -28,13 +30,9 @@ func (bh *BlackHole) Dispatch(firstPacket v2net.Packet, ray ray.OutboundRay) err
 	return nil
 }
 
-type BlackHoleFactory struct {
-}
-
-func (factory BlackHoleFactory) Create(config interface{}) (connhandler.OutboundConnectionHandler, error) {
-	return NewBlackHole(), nil
-}
-
 func init() {
-	connhandler.RegisterOutboundConnectionHandlerFactory("blackhole", BlackHoleFactory{})
+	internal.MustRegisterOutboundConnectionHandlerCreator("blackhole",
+		func(space app.Space, config interface{}) (proxy.OutboundConnectionHandler, error) {
+			return NewBlackHole(), nil
+		})
 }

proxy/blackhole/config.go

@@ -0,0 +1,4 @@
+package blackhole
+
+type Config interface {
+}

proxy/blackhole/config/json/json.go

@@ -1,14 +0,0 @@
-package json
-
-import (
-	"github.com/v2ray/v2ray-core/proxy/common/config/json"
-)
-
-type BlackHoleConfig struct {
-}
-
-func init() {
-	json.RegisterOutboundConnectionConfig("blackhole", func() interface{} {
-		return new(BlackHoleConfig)
-	})
-}

proxy/blackhole/json/json.go

@@ -0,0 +1,15 @@
+package json
+
+import (
+	"github.com/v2ray/v2ray-core/proxy/internal/config"
+	"github.com/v2ray/v2ray-core/proxy/internal/config/json"
+)
+
+type BlackHoleConfig struct {
+}
+
+func init() {
+	config.RegisterOutboundConnectionConfig("blackhole", json.JsonConfigLoader(func() interface{} {
+		return new(BlackHoleConfig)
+	}))
+}

proxy/common/config/errors.go

@@ -1,9 +0,0 @@
-package config
-
-import (
-	"errors"
-)
-
-var (
-	BadConfiguration = errors.New("Bad proxy configuration.")
-)