diff --git a/.gitignore b/.gitignore index d59fd02..e3ffe4b 100644 --- a/.gitignore +++ b/.gitignore @@ -5,7 +5,7 @@ *.exe *.exe~ #*.dll -*.so +#*.so *.dylib # Test binary, built with `go test -c` diff --git a/bookImage.go b/bookImage.go deleted file mode 100644 index a053100..0000000 --- a/bookImage.go +++ /dev/null @@ -1,202 +0,0 @@ -package main - -import ( - "database/sql" - "fmt" - - _ "github.com/go-sql-driver/mysql" -) - -// 全局变量 -var ( - // 数据库连接配置 - DBUsername = "root" // 用户名 - DBPassword = "Long6166@@" // 密码 - DBHost = "nj-cynosdbmysql-grp-1v6vxn5f.sql.tencentcdb.com" // 主机 - DBPort = 26247 // 端口 - DBDataBase = "book_center" // 数据库 - DBCharset = "utf8mb4" // 字符集 - - //连接池配置 - MaxOpenConns = 20 - MaxIdleConns = 10 -) - -// 连接数据库 -func connectDB() (*sql.DB, error) { - // 数据源名称格式 - dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=%s&parseTime=True&loc=Local", - DBUsername, - DBPassword, - DBHost, - DBPort, - DBDataBase, - DBCharset) - // 连接数据库 - db, err := sql.Open("mysql", dsn) - if err != nil { - return nil, fmt.Errorf("打开数据库连接失败: %v", err) - } - // 设置连接池参数 - db.SetMaxOpenConns(MaxOpenConns) // 最大打开连接数 - db.SetMaxIdleConns(MaxIdleConns) // 最大空闲连接数 - // 测试链接 - err = db.Ping() - if err != nil { - return nil, fmt.Errorf("数据库连接测试失败: %v", err) - } - return db, nil -} - -func selectBookIsbn(db *sql.DB, bookId int) error { - //// 执行语句 - //query := `SELECT isbn, MAX(create_time) as max_create_time - //FROM shop_goods_rejection - //WHERE isbn IS NOT NULL - //GROUP BY isbn` - // - //exec, err := db.Exec(query) - //fmt.Println(exec, err) - return nil -} - -//func main() { -//db, err := connectDB() -//if err != nil { -// log.Fatal("数据库连接失败:", err) -//} -// -//books, err := GetAllCategoryBooks() -//if err != nil { -// fmt.Printf("", err) -//} -//if len(books) == 0 { -// fmt.Printf("数组是空！") -//} -//// 查询数据库中不存在的ISBN -//missingISBNs, err := findMissingISBNs(db, books) -//if err != nil { -// log.Fatal("查询失败:", err) -//} -//log.Printf("数据库中不存在的ISBN数量: %d", len(missingISBNs)) -//fmt.Println("数据库中不存在的ISBN数组:") -//for i, isbn := range missingISBNs { -// fmt.Printf("%d. %s\n", i+1, isbn) -//} -// -//missingISBNsString := strings.Join(missingISBNs, "\n") -// -//// 这里您可以将 missingISBNs 数组用于后续处理 -//// 比如保存到文件、插入到另一个表等 -//fmt.Printf("\n新的missingISBNs字符串: %v\n", missingISBNsString) -//} - -// 查询数据库中不存在的ISBN -func findMissingISBNs(db *sql.DB, books []string) ([]string, error) { - if len(books) == 0 { - return []string{}, nil - } - - // 查询数据库中存在的ISBN - existingISBNs, err := queryExistingISBNs(db, books) - if err != nil { - return nil, err - } - - // 创建现有ISBN的映射，用于快速查找 - existingMap := make(map[string]bool) - for _, isbn := range existingISBNs { - existingMap[isbn] = true - } - - // 创建新数组，存储数据库中不存在的ISBN - missingISBNs := make([]string, 0) - for _, isbn := range books { - if !existingMap[isbn] { - missingISBNs = append(missingISBNs, isbn) - } - } - - return missingISBNs, nil -} - -// 查询数据库中存在的ISBN -func queryExistingISBNs(db *sql.DB, isbns []string) ([]string, error) { - if len(isbns) == 0 { - return []string{}, nil - } - - // 分批处理，避免SQL语句过长 - batchSize := 1000 - allExistingISBNs := make([]string, 0) - - for i := 0; i < len(isbns); i += batchSize { - end := i + batchSize - if end > len(isbns) { - end = len(isbns) - } - - batchISBNs := isbns[i:end] - batchExisting, err := queryBatchISBNs(db, batchISBNs) - if err != nil { - return nil, err - } - allExistingISBNs = append(allExistingISBNs, batchExisting...) - } - - return allExistingISBNs, nil -} - -// 批量查询ISBN -func queryBatchISBNs(db *sql.DB, isbns []string) ([]string, error) { - if len(isbns) == 0 { - return []string{}, nil - } - // 构建IN查询的占位符 - placeholders := make([]string, len(isbns)) - args := make([]interface{}, len(isbns)) - for i, isbn := range isbns { - placeholders[i] = "?" - args[i] = isbn - } - query := fmt.Sprintf(` - SELECT isbn - FROM book_center - WHERE isbn IN (%s) - AND del_flag = 0 - `, joinPlaceholders(placeholders, ",")) - - rows, err := db.Query(query, args...) - if err != nil { - return nil, fmt.Errorf("查询数据库失败: %v", err) - } - defer rows.Close() - - var existingISBNs []string - for rows.Next() { - var isbn string - if err := rows.Scan(&isbn); err != nil { - return nil, fmt.Errorf("扫描结果失败: %v", err) - } - existingISBNs = append(existingISBNs, isbn) - } - - if err := rows.Err(); err != nil { - return nil, fmt.Errorf("遍历结果失败: %v", err) - } - - return existingISBNs, nil -} - -// joinPlaceholders 连接占位符 -func joinPlaceholders(placeholders []string, sep string) string { - if len(placeholders) == 0 { - return "" - } - - result := placeholders[0] - for i := 1; i < len(placeholders); i++ { - result += sep + placeholders[i] - } - return result -} diff --git a/bookNameError.go b/bookNameError.go deleted file mode 100644 index 97cd39f..0000000 --- a/bookNameError.go +++ /dev/null @@ -1,299 +0,0 @@ -package main - -import ( - "database/sql" - "fmt" - "regexp" - "strings" - - _ "github.com/go-sql-driver/mysql" -) - -// func main() { -// // 构建数据库连接字符串 -// dsn := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&parseTime=True&loc=Local", -// "root", "Long6166@@", "nj-cynosdbmysql-grp-1v6vxn5f.sql.tencentcdb.com", "26247", "book_center") -// // 连接数据库 -// db, err := sql.Open("mysql", dsn) -// if err != nil { -// log.Fatal("数据库连接失败:", err) -// } -// defer db.Close() -// -// // 测试数据库连接 -// err = db.Ping() -// if err != nil { -// log.Fatal("数据库连接测试失败:", err) -// } -// fmt.Println("数据库连接成功") -// -// // 查询包含"影印版"或"（影印版）"的书名 -// books, err := queryBooksWithCopyVersion(db) -// if err != nil { -// log.Fatal("查询失败:", err) -// } -// -// fmt.Printf("找到 %d 本包含'影印版'或'（影印版）'的书\n", len(books)) -// -// if len(books) == 0 { -// fmt.Println("没有找到需要更新的图书") -// return -// } -// -// // 更新书名，删除"影印版"和"（影印版）" -// updatedCount, err := updateBookNames(db, books) -// if err != nil { -// log.Fatal("更新失败:", err) -// } -// -// fmt.Printf("成功更新 %d 本书的书名\n", updatedCount) -// } -// -// Book 结构体对应 book_center 表 -type Book struct { - ID int64 - BookName string - ISBN string -} - -// queryBooksWithCopyVersion 查询包含"影印版"或"（影印版）"的书名 -func queryBooksWithCopyVersion(db *sql.DB) ([]Book, error) { - query := ` - SELECT id, book_name, isbn - FROM book_center - WHERE book_name LIKE '%影印版%' - AND del_flag = 0 - ` - - rows, err := db.Query(query) - if err != nil { - return nil, err - } - defer rows.Close() - - var books []Book - for rows.Next() { - var book Book - err := rows.Scan(&book.ID, &book.BookName, &book.ISBN) - if err != nil { - return nil, err - } - books = append(books, book) - } - - return books, nil -} - -// cleanBookName 清理书名，删除所有影印版相关文字 -func cleanBookName(bookName string) string { - // 定义需要删除的模式 - patterns := []string{ - "（影印版）", // 全角括号 - "(影印版)", // 半角括号 - "影印版", // 无括号 - "【影印版】", // 方头括号 - "[影印版]", // 方括号 - } - newName := bookName - - // 逐个删除模式 - for _, pattern := range patterns { - newName = strings.ReplaceAll(newName, pattern, "") - } - - // 删除多余的空格 - newName = strings.TrimSpace(newName) - newName = regexp.MustCompile(`\s+`).ReplaceAllString(newName, " ") - - return newName -} - -// updateBookNames 更新书名，删除所有影印版相关文字 -func updateBookNames(db *sql.DB, books []Book) (int, error) { - tx, err := db.Begin() - if err != nil { - return 0, err - } - defer tx.Rollback() - - updateStmt, err := tx.Prepare(` - UPDATE book_center - SET book_name = ?, update_time = UNIX_TIMESTAMP() - WHERE id = ? AND isbn = ? - `) - if err != nil { - return 0, err - } - defer updateStmt.Close() - - updatedCount := 0 - for _, book := range books { - // 清理书名 - newBookName := cleanBookName(book.BookName) - - // 如果书名没有变化，跳过更新 - if newBookName == book.BookName { - fmt.Printf("跳过: 书名无变化 (ID: %d, ISBN: %s)\n", book.ID, book.ISBN) - continue - } - - // 如果书名超过字段长度限制，截断 - if len(newBookName) > 400 { - newBookName = newBookName[:400] - fmt.Printf("警告: 书名超长，已截断 (ID: %d)\n", book.ID) - } - - result, err := updateStmt.Exec(newBookName, book.ID, book.ISBN) - if err != nil { - fmt.Printf("更新失败 (ID: %d): %v\n", book.ID, err) - continue - } - - rowsAffected, err := result.RowsAffected() - if err != nil { - fmt.Printf("获取影响行数失败 (ID: %d): %v\n", book.ID, err) - continue - } - - if rowsAffected > 0 { - updatedCount++ - fmt.Printf("更新成功: ID=%d, ISBN=%s\n", book.ID, book.ISBN) - fmt.Printf(" 原书名: %s\n", book.BookName) - fmt.Printf(" 新书名: %s\n", newBookName) - fmt.Println(" ---") - } - } - - err = tx.Commit() - if err != nil { - return 0, err - } - - return updatedCount, nil -} - -// 没用了 -//// 获取销量榜所有分类中图书的isbn -//func GetAllCategoryBooks() ([]string, error) { -// // 1. 获取分类列表 -// categories, err := GetSalesBookInfo() -// if err != nil { -// return nil, fmt.Errorf("获取分类列表失败: %v", err) -// } -// // 初始化返回的ISBN数组 -// var allISBNs []string -// -// for i, category := range categories { -// fmt.Printf("\n=== 正在处理分类 %d/%d: %s (ID: %d) ===\n", i+1, len(categories), category.Key, category.Value) -// // 根据分类ID获取图书详情 -// bookDetails, err := GetBookDetailsByCategory(category.Value) -// if err != nil { -// fmt.Printf("获取分类 %s 的图书信息失败: %v\n", category.Key, err) -// continue -// } -// // 将当前分类的图书数据添加到结果map中 -// if bookDetails != nil && bookDetails.Result.Data != nil { -// for _, book := range bookDetails.Result.Data { -// if book.Isbn != "" { -// allISBNs = append(allISBNs, book.Isbn) -// fmt.Printf("添加到ISBN列表: %s\n", book.Isbn) -// } -// } -// fmt.Printf("分类 %s 获取到 %d 本图书\n", category.Key, len(bookDetails.Result.Data)) -// } else { -// fmt.Printf("分类 %s 没有获取到图书数据\n", category.Key) -// } -// time.Sleep(500 * time.Microsecond) -// } -// // 去重处理（可选） -// allISBNs = removeDuplicateISBNs(allISBNs) -// // 打印统计信息 -// fmt.Printf("\n=== 总计: %d 个分类, %d 个唯一ISBN ===\n", len(categories), len(allISBNs)) -// return allISBNs, nil -//} -// -//// 获取销量榜的图书信息 -//func GetSalesBookInfo() ([]SalesCategory, error) { -// // 构建请求URL -// url := "https://item.kongfz.com/api/Pc/getSellWellCatList" -// // 创建HTTP客户端 -// client := &http.Client{ -// Timeout: 30 * time.Second, -// } -// // 创建请求 -// req, err := http.NewRequest("GET", url, nil) -// if err != nil { -// return nil, fmt.Errorf("创建请求失败: %v", err) -// } -// // 设置请求头，模拟浏览器请求 -// req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36") -// req.Header.Set("Accept", "application/json, text/plain, */*") -// req.Header.Set("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8") -// req.Header.Set("Referer", "https://item.kongfz.com/") -// // 发送请求 -// resp, err := client.Do(req) -// if err != nil { -// return nil, fmt.Errorf("请求失败: %v", err) -// } -// defer resp.Body.Close() -// // 检查HTTP状态码 -// if resp.StatusCode != http.StatusOK { -// return nil, fmt.Errorf("HTTP错误: %s", resp.Status) -// } -// // 读取响应体 -// body, err := io.ReadAll(resp.Body) -// if err != nil { -// return nil, fmt.Errorf("读取响应失败: %v", err) -// } -// // 解析JSON响应 -// var salesCategoryResponse SalesCategoryResponse -// err = json.Unmarshal(body, &salesCategoryResponse) -// if err != nil { -// return nil, fmt.Errorf("解析JSON失败: %v", err) -// } -// return salesCategoryResponse.Result, nil -//} -// -//// 根据分类ID获取图书详情 -//func GetBookDetailsByCategory(catId int) (*BookDetailResponse, error) { -// // 构建请求URL -// url := fmt.Sprintf("https://item.kongfz.com/api/pc/getSellWellListDetail?page=1&pageSize=100&timeRank=2&catId=%d", catId) -// // 创建HTTP客户端 -// client := &http.Client{ -// Timeout: 30 * time.Second, -// } -// // 创建请求 -// req, err := http.NewRequest("GET", url, nil) -// if err != nil { -// return nil, fmt.Errorf("创建请求失败: %v", err) -// } -// // 设置请求头，模拟浏览器请求 -// req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36") -// req.Header.Set("Accept", "application/json, text/plain, */*") -// req.Header.Set("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8") -// req.Header.Set("Referer", "https://item.kongfz.com/") -// // 发送请求 -// resp, err := client.Do(req) -// if err != nil { -// return nil, fmt.Errorf("请求失败: %v", err) -// } -// defer resp.Body.Close() -// // 检查HTTP状态码 -// if resp.StatusCode != http.StatusOK { -// return nil, fmt.Errorf("HTTP错误: %s", resp.Status) -// } -// // 读取响应体 -// body, err := io.ReadAll(resp.Body) -// if err != nil { -// return nil, fmt.Errorf("读取响应失败: %v", err) -// } -// var bookDetailResponse BookDetailResponse -// err = json.Unmarshal(body, &bookDetailResponse) -// if err != nil { -// return nil, fmt.Errorf("解析JSON失败: %v", err) -// } -// if !bookDetailResponse.Status { -// return nil, fmt.Errorf("API返回错误: %s (代码: %d)", bookDetailResponse.ErrMessage, bookDetailResponse.ErrCode) -// } -// return &bookDetailResponse, nil -//} diff --git a/csv/csv.dll b/csv/csv.dll new file mode 100644 index 0000000..e7b3bd3 Binary files /dev/null and b/csv/csv.dll differ diff --git a/csv/csv.go b/csv/csv.go new file mode 100644 index 0000000..fffb373 --- /dev/null +++ b/csv/csv.go @@ -0,0 +1,1882 @@ +package main + +/* +#include +*/ +import "C" +import ( + "bufio" + "encoding/csv" + "encoding/json" + "fmt" + "io" + "os" + "path/filepath" + "sync" + "sync/atomic" + "time" +) + +// 修改操作类型 +type ModifyType int + +const ( + ModifyRow ModifyType = iota // 修改整行 + ModifyCell // 修改单元格 + InsertRow // 插入行 + DeleteRow // 删除行 +) + +// ModifyRequest 修改请求 +type ModifyRequest struct { + HandleID int64 // 句柄ID + RowNumber int64 // 行号（从1开始） + ModifyType ModifyType // 修改类型 + NewRow []string // 新行数据（整行修改） + NewCellValue string // 新单元格值 + ColumnIndex int // 列索引（单元格修改时使用） + ColumnName string // 列名（可选，单元格修改时使用） +} + +// ModifyResult 修改结果 +type ModifyResult struct { + Success bool // 是否成功 + Message string // 消息 + RowsAffected int64 // 影响的行数 + BackupFile string // 备份文件路径 + OperationID string // 操作ID（用于追踪） +} + +// RowPosition 行位置信息 +type RowPosition struct { + StartOffset int64 // 行开始偏移 + EndOffset int64 // 行结束偏移 + RowLength int // 行长度（字节数） +} + +// CSVHandle CSV文件句柄 +type CSVHandle struct { + ID int64 // 句柄唯一ID + Filename string // 文件名 + Delimiter rune // 分隔符 + HasHeader bool // 是否有表头 + Header []string // 表头（如果有） + File *os.File // 底层文件句柄 + CSVReader *csv.Reader // CSV阅读器 + TotalRows int64 // 总行数（如果已计算） + IsOpen bool // 是否已打开 + OpenTime time.Time // 打开时间 + AccessTime time.Time // 最后访问时间 + AccessCount int64 // 访问计数 + mu sync.RWMutex // 读写锁（保护数据结构） + writeMu sync.Mutex // 写入专用锁（保证写入互斥） + autoCloseTimer *time.Timer // 自动关闭计时器 + + // 修改相关 + rowIndex []RowPosition // 行索引（用于快速定位） + indexBuilt bool // 索引是否已构建 + tempDir string // 临时目录 + backupFiles []string // 备份文件列表 + operationLog []string // 操作日志 +} + +// CSVManager CSV文件管理器 +type CSVManager struct { + handles sync.Map // map[int64]*CSVHandle + nextHandle int64 // 下一个句柄ID + maxOpen int // 最大打开文件数 + semaphore chan struct{} // 信号量控制并发打开 + config ManagerConfig // 管理器配置 + fileLocks *sync.Map // 文件级锁映射 +} + +// ManagerConfig 管理器配置 +type ManagerConfig struct { + MaxOpenFiles int // 最大打开文件数 + AutoCloseTimeout time.Duration // 自动关闭超时 + BufferSize int // 缓冲区大小 + UseMMap bool // 是否使用内存映射（大文件） + MMapThreshold int64 // 使用内存映射的阈值（字节） + CacheRows int // 缓存行数 + MaxWriteRetries int // 最大写入重试次数 + WriteTimeout time.Duration // 写入超时时间 +} + +// DefaultConfig 默认配置 +var DefaultConfig = ManagerConfig{ + MaxOpenFiles: 100, + AutoCloseTimeout: 5 * time.Minute, + BufferSize: 32 * 1024, // 32KB + UseMMap: true, + MMapThreshold: 10 * 1024 * 1024, // 10MB + CacheRows: 1000, + MaxWriteRetries: 3, + WriteTimeout: 30 * time.Second, +} + +// 全局管理器实例 +var ( + globalManager *CSVManager + managerInitOnce sync.Once +) + +// GetManager 获取全局管理器 +func GetManager() *CSVManager { + managerInitOnce.Do(func() { + globalManager = NewCSVManager(DefaultConfig) + }) + return globalManager +} + +// NewCSVManager 创建新的CSV管理器 +func NewCSVManager(config ManagerConfig) *CSVManager { + if config.MaxOpenFiles <= 0 { + config.MaxOpenFiles = DefaultConfig.MaxOpenFiles + } + + return &CSVManager{ + handles: sync.Map{}, + nextHandle: 1, + maxOpen: config.MaxOpenFiles, + semaphore: make(chan struct{}, config.MaxOpenFiles), + config: config, + fileLocks: &sync.Map{}, + } +} + +// getFileLock 获取文件级锁 +func (mgr *CSVManager) getFileLock(filename string) *sync.RWMutex { + lock, _ := mgr.fileLocks.LoadOrStore(filename, &sync.RWMutex{}) + return lock.(*sync.RWMutex) +} + +// ========================== 文件操作 ========================== + +// OpenCSVFile 打开CSV文件并返回句柄 +func (mgr *CSVManager) OpenCSVFile(filename string, delimiter rune, hasHeader bool) (int64, error) { + // 检查文件是否存在 + if _, err := os.Stat(filename); os.IsNotExist(err) { + return -1, fmt.Errorf("文件不存在: %s", filename) + } + + // 限制并发打开文件数 + mgr.semaphore <- struct{}{} + defer func() { <-mgr.semaphore }() + + // 生成唯一句柄ID + handleID := atomic.AddInt64(&mgr.nextHandle, 1) + + // 创建CSV句柄 + csvHandle := &CSVHandle{ + ID: handleID, + Filename: filename, + Delimiter: delimiter, + HasHeader: hasHeader, + OpenTime: time.Now(), + AccessTime: time.Now(), + } + + // 打开文件 + if err := mgr.openFile(csvHandle); err != nil { + return -1, fmt.Errorf("打开文件失败: %w", err) + } + + // 获取总行数 + rows, err := csvHandle.GetTotalRows() + if err != nil { + return -1, err + } + csvHandle.TotalRows = rows + + // 读取表头（如果需要） + if hasHeader { + if err := mgr.readHeader(csvHandle); err != nil { + csvHandle.Close() + return -1, fmt.Errorf("读取表头失败: %w", err) + } + } + + // 注册到管理器 + mgr.handles.Store(handleID, csvHandle) + + // 启动自动关闭计时器 + if mgr.config.AutoCloseTimeout > 0 { + csvHandle.startAutoClose(mgr.config.AutoCloseTimeout, mgr) + } + + return handleID, nil +} + +// openFile 打开文件 +func (mgr *CSVManager) openFile(handle *CSVHandle) error { + handle.mu.Lock() + defer handle.mu.Unlock() + + if handle.IsOpen { + return nil + } + + // 获取文件大小 + fileInfo, err := os.Stat(handle.Filename) + if err != nil { + return err + } + + fileSize := fileInfo.Size() + + // 根据文件大小选择打开策略 + if mgr.config.UseMMap && fileSize > mgr.config.MMapThreshold { + return mgr.openFileWithMMap(handle, fileSize) + } + + return mgr.openFileNormal(handle) +} + +// openFileNormal 正常打开文件 +func (mgr *CSVManager) openFileNormal(handle *CSVHandle) error { + file, err := os.Open(handle.Filename) + if err != nil { + return err + } + + // 创建带缓冲的CSV阅读器 + reader := csv.NewReader(bufio.NewReaderSize(file, mgr.config.BufferSize)) + reader.Comma = handle.Delimiter + reader.LazyQuotes = true + reader.TrimLeadingSpace = true + + handle.File = file + handle.CSVReader = reader + handle.IsOpen = true + handle.AccessTime = time.Now() + return nil +} + +// openFileWithMMap 使用内存映射打开大文件 +func (mgr *CSVManager) openFileWithMMap(handle *CSVHandle, fileSize int64) error { + file, err := os.Open(handle.Filename) + if err != nil { + return err + } + + // 对于大文件，我们可以先只打开，按需读取 + reader := csv.NewReader(file) + reader.Comma = handle.Delimiter + reader.LazyQuotes = true + + handle.File = file + handle.CSVReader = reader + handle.IsOpen = true + handle.AccessTime = time.Now() + + return nil +} + +// readHeader 读取CSV表头 +func (mgr *CSVManager) readHeader(handle *CSVHandle) error { + handle.mu.Lock() + defer handle.mu.Unlock() + + if !handle.IsOpen { + return fmt.Errorf("文件未打开") + } + + // 确保文件指针在开头 + if _, err := handle.File.Seek(0, 0); err != nil { + return err + } + + // 重置CSV阅读器 + handle.CSVReader = csv.NewReader(handle.File) + handle.CSVReader.Comma = handle.Delimiter + + // 读取表头 + header, err := handle.CSVReader.Read() + if err != nil { + return err + } + + handle.Header = header + return nil +} + +// GetHandle 获取句柄对象 +func (mgr *CSVManager) GetHandle(handleID int64) (*CSVHandle, error) { + value, ok := mgr.handles.Load(handleID) + if !ok { + return nil, fmt.Errorf("句柄不存在: %d", handleID) + } + + handle := value.(*CSVHandle) + + // 确保文件已打开 + handle.mu.RLock() + isOpen := handle.IsOpen + handle.mu.RUnlock() + + if !isOpen { + if err := mgr.openFile(handle); err != nil { + return nil, fmt.Errorf("重新打开文件失败: %w", err) + } + } + + // 更新访问时间 + atomic.AddInt64(&handle.AccessCount, 1) + handle.AccessTime = time.Now() + + return handle, nil +} + +// ========================== 读取操作 ========================== + +// ReadRow 读取一行数据 +func (h *CSVHandle) ReadRow() ([]string, error) { + h.mu.RLock() + defer h.mu.RUnlock() + + if !h.IsOpen { + return nil, fmt.Errorf("文件未打开") + } + + if h.CSVReader == nil { + return nil, fmt.Errorf("CSV阅读器未初始化") + } + + return h.CSVReader.Read() +} + +// ReadAllRows 读取所有行 +func (h *CSVHandle) ReadAllRows() ([][]string, error) { + h.mu.Lock() + defer h.mu.Unlock() + + if !h.IsOpen { + return nil, fmt.Errorf("文件未打开") + } + + // 重置文件指针到数据开始位置 + if _, err := h.File.Seek(0, 0); err != nil { + return nil, err + } + + // 重新创建CSV阅读器 + h.CSVReader = csv.NewReader(h.File) + h.CSVReader.Comma = h.Delimiter + + // 跳过表头 + if h.HasHeader { + if _, err := h.CSVReader.Read(); err != nil { + return nil, err + } + } + + // 读取所有行 + return h.CSVReader.ReadAll() +} + +// ReadRows 读取指定数量的行 +func (h *CSVHandle) ReadRows(count int) ([][]string, error) { + h.mu.Lock() + defer h.mu.Unlock() + + if !h.IsOpen { + return nil, fmt.Errorf("文件未打开") + } + + rows := make([][]string, 0, count) + + for i := 0; i < count; i++ { + row, err := h.CSVReader.Read() + if err == io.EOF { + break + } + if err != nil { + return rows, err + } + rows = append(rows, row) + } + + return rows, nil +} + +// GetTotalRows 获取总行数 +func (h *CSVHandle) GetTotalRows() (int64, error) { + h.mu.Lock() + defer h.mu.Unlock() + + if h.TotalRows > 0 { + return h.TotalRows, nil + } + + // 保存当前文件位置 + currentPos, err := h.File.Seek(0, io.SeekCurrent) + if err != nil { + return 0, err + } + defer h.File.Seek(currentPos, io.SeekStart) + + // 重置到文件开始 + if _, err := h.File.Seek(0, 0); err != nil { + return 0, err + } + + // 创建新的CSV阅读器进行计数 + reader := csv.NewReader(h.File) + reader.Comma = h.Delimiter + + var count int64 = 0 + + // 跳过表头 + if h.HasHeader { + if _, err := reader.Read(); err != nil { + return 0, err + } + } + + // 计数行数 + for { + _, err := reader.Read() + if err == io.EOF { + break + } + if err != nil { + return count, err + } + count++ + } + + h.TotalRows = count + return count, nil +} + +// ========================== 修改操作 ========================== + +// ModifyRow 修改指定行 +func (mgr *CSVManager) ModifyRow(handleID int64, rowNumber int64, newRow []string) (*ModifyResult, error) { + req := &ModifyRequest{ + HandleID: handleID, + RowNumber: rowNumber, + ModifyType: ModifyRow, + NewRow: newRow, + } + + return mgr.ModifyCSV(req) +} + +// ModifyCell 修改指定单元格 +func (mgr *CSVManager) ModifyCell(handleID int64, rowNumber int64, columnIndex int, newValue string) (*ModifyResult, error) { + req := &ModifyRequest{ + HandleID: handleID, + RowNumber: rowNumber, + ModifyType: ModifyCell, + ColumnIndex: columnIndex, + NewCellValue: newValue, + } + + return mgr.ModifyCSV(req) +} + +// ModifyCSV 通用的CSV修改函数 +func (mgr *CSVManager) ModifyCSV(req *ModifyRequest) (*ModifyResult, error) { + // 1. 获取句柄 + handle, err := mgr.GetHandle(req.HandleID) + if err != nil { + return &ModifyResult{ + Success: false, + Message: fmt.Sprintf("获取句柄失败: %v", err), + }, err + } + + // 2. 生成操作ID + operationID := fmt.Sprintf("%d_%d_%d", req.HandleID, time.Now().UnixNano(), req.RowNumber) + + // 3. 获取文件级写锁 + fileLock := mgr.getFileLock(handle.Filename) + fileLock.Lock() + defer fileLock.Unlock() + + // 4. 验证基本参数 + if err := mgr.validateModifyRequestBeforeLock(handle, req); err != nil { + return &ModifyResult{ + Success: false, + Message: fmt.Sprintf("参数验证失败: %v", err), + }, err + } + + // 5. 获取句柄写入锁 + handle.writeMu.Lock() + defer handle.writeMu.Unlock() + + // 6. 执行修改操作 + result, err := mgr.executeModifyWithRetry(handle, req, operationID) + if result != nil { + result.OperationID = operationID + } + + return result, err +} + +// validateModifyRequestBeforeLock 验证修改请求（无需句柄锁） +func (mgr *CSVManager) validateModifyRequestBeforeLock(handle *CSVHandle, req *ModifyRequest) error { + if req.RowNumber <= 0 { + return fmt.Errorf("行号必须大于0") + } + + // 验证列数 + handle.mu.RLock() + header := handle.Header + handle.mu.RUnlock() + + if req.ModifyType == ModifyRow { + expectedCols := len(header) + if len(req.NewRow) != expectedCols { + return fmt.Errorf("新行数据列数不匹配，期望: %d，实际: %d", expectedCols, len(req.NewRow)) + } + } + + if req.ModifyType == ModifyCell { + expectedCols := len(header) + if req.ColumnIndex < 0 || req.ColumnIndex >= expectedCols { + return fmt.Errorf("列索引超出范围，有效范围: 0-%d", expectedCols-1) + } + } + + return nil +} + +// executeModifyWithRetry 带重试的修改执行 +func (mgr *CSVManager) executeModifyWithRetry(handle *CSVHandle, req *ModifyRequest, operationID string) (*ModifyResult, error) { + var lastErr error + var result *ModifyResult + + for retry := 0; retry <= mgr.config.MaxWriteRetries; retry++ { + if retry > 0 { + // 重试前等待 + time.Sleep(time.Duration(retry*100) * time.Millisecond) + } + + result, lastErr = mgr.executeModifyOnce(handle, req, operationID) + if lastErr == nil { + // 记录操作日志 + handle.mu.Lock() + handle.operationLog = append(handle.operationLog, + fmt.Sprintf("%s: %s", operationID, result.Message)) + handle.mu.Unlock() + return result, nil + } + } + + return &ModifyResult{ + Success: false, + Message: fmt.Sprintf("修改失败，重试%d次后仍失败: %v", mgr.config.MaxWriteRetries, lastErr), + OperationID: operationID, + }, lastErr +} + +// executeModifyOnce 执行单次修改 +func (mgr *CSVManager) executeModifyOnce(handle *CSVHandle, req *ModifyRequest, operationID string) (*ModifyResult, error) { + // 1. 创建备份 + backupFile, err := mgr.createBackup(handle) + if err != nil { + return &ModifyResult{ + Success: false, + Message: fmt.Sprintf("创建备份失败: %v", err), + }, err + } + + // 2. 获取总行数（使用更高效的方式） + totalRows, err := mgr.getTotalRowsForModification(handle) + if err != nil { + return &ModifyResult{ + Success: false, + Message: fmt.Sprintf("获取总行数失败: %v", err), + }, err + } + + //// 2. 获取总行数用于验证 + //totalRows, err := mgr.calculateTotalRowsWithLock(handle) + //if err != nil { + // return &ModifyResult{ + // Success: false, + // Message: fmt.Sprintf("获取总行数失败: %v", err), + // }, err + //} + + // 3. 验证行号范围 + if err := mgr.validateRowNumber(handle, req, totalRows); err != nil { + return &ModifyResult{ + Success: false, + Message: fmt.Sprintf("行号验证失败: %v", err), + }, err + } + + // 4. 执行修改逻辑 + startTime := time.Now() + var result *ModifyResult + var modifyErr error + + switch req.ModifyType { + case ModifyRow: + result, modifyErr = mgr.modifyRowInternal(handle, req, totalRows) + case ModifyCell: + result, modifyErr = mgr.modifyCellInternal(handle, req, totalRows) + case InsertRow: + result, modifyErr = mgr.insertRowInternal(handle, req, totalRows) + case DeleteRow: + result, modifyErr = mgr.deleteRowInternal(handle, req, totalRows) + default: + modifyErr = fmt.Errorf("不支持的修改类型: %v", req.ModifyType) + result = &ModifyResult{ + Success: false, + Message: fmt.Sprintf("不支持的修改类型: %v", req.ModifyType), + } + } + + // 记录执行时间 + elapsed := time.Since(startTime) + if elapsed > 1*time.Second { + fmt.Printf("警告：修改操作耗时较长: %v\n", elapsed) + } + // 5. 设置备份文件路径 + if result != nil { + result.BackupFile = backupFile + result.OperationID = operationID + } + + // 6. 记录备份文件 + if backupFile != "" { + handle.mu.Lock() + handle.backupFiles = append(handle.backupFiles, backupFile) + handle.mu.Unlock() + } + + return result, modifyErr +} + +// getTotalRowsForModification 为修改操作获取总行数（优化版本） +func (mgr *CSVManager) getTotalRowsForModification(handle *CSVHandle) (int64, error) { + // 先检查是否已有缓存 + if handle.TotalRows > 0 { + return handle.TotalRows, nil + } + + // 如果文件不大，直接快速计算 + fileInfo, err := os.Stat(handle.Filename) + if err != nil { + return 0, err + } + + // 对于小文件，使用快速计算方法 + if fileInfo.Size() < 10*1024*1024 { // 10MB以下 + return mgr.fastCountRows(handle) + } + + // 大文件使用原来的方法 + return mgr.calculateTotalRowsWithLock(handle) +} + +// fastCountRows 快速计算行数（无需复杂锁） +func (mgr *CSVManager) fastCountRows(handle *CSVHandle) (int64, error) { + file, err := os.Open(handle.Filename) + if err != nil { + return 0, err + } + defer file.Close() + + reader := csv.NewReader(file) + reader.Comma = handle.Delimiter + + var count int64 = 0 + for { + _, err := reader.Read() + if err == io.EOF { + break + } + if err != nil { + return count, err + } + count++ + } + + // 减去表头行 + if handle.HasHeader { + count-- + } + + // 缓存结果 + handle.mu.Lock() + handle.TotalRows = count + handle.mu.Unlock() + + return count, nil +} + +// calculateTotalRowsWithLock 计算总行数（带锁） +func (mgr *CSVManager) calculateTotalRowsWithLock(handle *CSVHandle) (int64, error) { + handle.mu.Lock() + defer handle.mu.Unlock() + + if handle.TotalRows > 0 { + return handle.TotalRows, nil + } + + // 保存当前文件位置 + currentPos, err := handle.File.Seek(0, io.SeekCurrent) + if err != nil { + return 0, err + } + defer handle.File.Seek(currentPos, io.SeekStart) + + // 重置到文件开始 + if _, err := handle.File.Seek(0, 0); err != nil { + return 0, err + } + + // 创建新的CSV阅读器进行计数 + reader := csv.NewReader(handle.File) + reader.Comma = handle.Delimiter + + var count int64 = 0 + + // 跳过表头 + if handle.HasHeader { + if _, err := reader.Read(); err != nil { + return 0, err + } + } + + // 计数行数 + for { + _, err := reader.Read() + if err == io.EOF { + break + } + if err != nil { + return count, err + } + count++ + } + + handle.TotalRows = count + return count, nil +} + +// validateRowNumber 验证行号 +func (mgr *CSVManager) validateRowNumber(handle *CSVHandle, req *ModifyRequest, totalRows int64) error { + // 调整行号（考虑表头） + adjustedRowNumber := req.RowNumber + if handle.HasHeader { + adjustedRowNumber = req.RowNumber + 1 // 表头占第1行 + } + + // 验证行号范围 + if req.ModifyType == ModifyRow || req.ModifyType == ModifyCell { + if adjustedRowNumber > totalRows { + return fmt.Errorf("行号超出范围，最大行数为: %d", totalRows-1) + } + } else if req.ModifyType == InsertRow { + // 插入行可以在末尾 + if adjustedRowNumber > totalRows+1 { + return fmt.Errorf("插入行号超出范围，最大行数为: %d", totalRows) + } + } else if req.ModifyType == DeleteRow { + if adjustedRowNumber > totalRows { + return fmt.Errorf("删除行号超出范围，最大行数为: %d", totalRows-1) + } + } + + return nil +} + +// createBackup 创建备份文件 +func (mgr *CSVManager) createBackup(handle *CSVHandle) (string, error) { + handle.mu.RLock() + defer handle.mu.RUnlock() + + // 创建临时目录 + if handle.tempDir == "" { + tempDir, err := os.MkdirTemp("", fmt.Sprintf("csv_backup_%d_", handle.ID)) + if err != nil { + return "", fmt.Errorf("创建临时目录失败: %v", err) + } + handle.tempDir = tempDir + } + + // 生成备份文件名 + backupFile := filepath.Join(handle.tempDir, + fmt.Sprintf("backup_%d_%s.csv", time.Now().UnixNano(), + filepath.Base(handle.Filename))) + + // 复制文件 + src, err := os.Open(handle.Filename) + if err != nil { + return "", err + } + defer src.Close() + + dst, err := os.Create(backupFile) + if err != nil { + return "", err + } + defer dst.Close() + + _, err = io.Copy(dst, src) + if err != nil { + os.Remove(backupFile) // 删除失败的备份文件 + return "", err + } + + return backupFile, nil +} + +// modifyRowInternal 修改整行 +func (mgr *CSVManager) modifyRowInternal(handle *CSVHandle, req *ModifyRequest, totalRows int64) (*ModifyResult, error) { + // 1. 创建临时文件 + tempFile, err := os.CreateTemp(handle.tempDir, "temp_*.csv") + if err != nil { + return nil, fmt.Errorf("创建临时文件失败: %v", err) + } + defer func() { + tempFile.Close() + os.Remove(tempFile.Name()) + }() + + // 2. 复制并修改文件 + modifiedCount, err := mgr.copyAndModifyRow(handle, tempFile, req) + if err != nil { + return nil, fmt.Errorf("复制修改文件失败: %v", err) + } + + // 3. 关闭临时文件以确保数据写入磁盘 + if err := tempFile.Close(); err != nil { + return nil, fmt.Errorf("关闭临时文件失败: %v", err) + } + + // 4. 原子替换原文件 + if err := mgr.atomicReplaceFile(tempFile.Name(), handle.Filename); err != nil { + // 尝试恢复备份 + mgr.restoreFromBackup(handle) + return nil, fmt.Errorf("替换文件失败: %v", err) + } + + // 5. 重新打开文件 + handle.mu.Lock() + if handle.File != nil { + handle.File.Close() + handle.File = nil + handle.IsOpen = false + } + + if err := mgr.openFile(handle); err != nil { + handle.mu.Unlock() + return nil, fmt.Errorf("重新打开文件失败: %v", err) + } + + // 更新总行数 + handle.TotalRows = totalRows + handle.mu.Unlock() + + return &ModifyResult{ + Success: true, + Message: fmt.Sprintf("修改第%d行成功", req.RowNumber), + RowsAffected: modifiedCount, + }, nil +} + +// copyAndModifyRow 复制文件并修改指定行 +func (mgr *CSVManager) copyAndModifyRow(handle *CSVHandle, dst *os.File, req *ModifyRequest) (int64, error) { + // 打开源文件 + src, err := os.Open(handle.Filename) + if err != nil { + return 0, err + } + defer src.Close() + + // 创建CSV读写器 + csvReader := csv.NewReader(src) + csvReader.Comma = handle.Delimiter + csvReader.LazyQuotes = true + + csvWriter := csv.NewWriter(dst) + csvWriter.Comma = handle.Delimiter + + var rowCount int64 = 0 + var modifiedCount int64 = 0 + + for { + row, err := csvReader.Read() + if err == io.EOF { + break + } + if err != nil { + csvWriter.Flush() + return modifiedCount, fmt.Errorf("读取第%d行失败: %v", rowCount+1, err) + } + + rowCount++ + + // 检查是否是目标行（考虑表头） + targetRowNumber := req.RowNumber + if handle.HasHeader { + targetRowNumber = req.RowNumber + 1 + } + + if rowCount == targetRowNumber { + // 修改这一行 + row = req.NewRow + modifiedCount++ + } + + // 写入行 + if err := csvWriter.Write(row); err != nil { + csvWriter.Flush() + return modifiedCount, fmt.Errorf("写入第%d行失败: %v", rowCount, err) + } + } + + // 确保所有数据写入文件 + if err := csvWriter.Error(); err != nil { + return modifiedCount, fmt.Errorf("CSV写入错误: %v", err) + } + + csvWriter.Flush() + return modifiedCount, nil +} + +// modifyCellInternal 修改单元格 +func (mgr *CSVManager) modifyCellInternal(handle *CSVHandle, req *ModifyRequest, totalRows int64) (*ModifyResult, error) { + // 1. 读取目标行 + targetRow, err := mgr.readSpecificRow(handle, req.RowNumber) + if err != nil { + return nil, fmt.Errorf("读取目标行失败: %v", err) + } + + // 2. 修改单元格 + if req.ColumnIndex >= 0 && req.ColumnIndex < len(targetRow) { + targetRow[req.ColumnIndex] = req.NewCellValue + } else { + return nil, fmt.Errorf("列索引超出范围: %d", req.ColumnIndex) + } + + // 3. 构建修改请求（转换为整行修改） + rowReq := &ModifyRequest{ + HandleID: req.HandleID, + RowNumber: req.RowNumber, + ModifyType: ModifyRow, + NewRow: targetRow, + } + + // 4. 调用整行修改 + return mgr.modifyRowInternal(handle, rowReq, totalRows) +} + +// insertRowInternal 插入行 +func (mgr *CSVManager) insertRowInternal(handle *CSVHandle, req *ModifyRequest, totalRows int64) (*ModifyResult, error) { + // 创建临时文件 + tempFile, err := os.CreateTemp(handle.tempDir, "insert_*.csv") + if err != nil { + return nil, fmt.Errorf("创建临时文件失败: %v", err) + } + defer func() { + tempFile.Close() + os.Remove(tempFile.Name()) + }() + + // 打开源文件 + src, err := os.Open(handle.Filename) + if err != nil { + return nil, err + } + defer src.Close() + + // 创建CSV读写器 + csvReader := csv.NewReader(src) + csvReader.Comma = handle.Delimiter + + csvWriter := csv.NewWriter(tempFile) + csvWriter.Comma = handle.Delimiter + + var rowCount int64 = 0 + + for { + row, err := csvReader.Read() + if err == io.EOF { + break + } + if err != nil { + csvWriter.Flush() + return nil, fmt.Errorf("读取第%d行失败: %v", rowCount+1, err) + } + + rowCount++ + + // 写入当前行 + if err := csvWriter.Write(row); err != nil { + csvWriter.Flush() + return nil, fmt.Errorf("写入第%d行失败: %v", rowCount, err) + } + + // 检查是否到达插入位置（考虑表头） + insertPosition := req.RowNumber + if handle.HasHeader { + insertPosition = req.RowNumber + 1 + } + + if rowCount == insertPosition { + // 插入新行 + if err := csvWriter.Write(req.NewRow); err != nil { + csvWriter.Flush() + return nil, fmt.Errorf("插入新行失败: %v", err) + } + } + } + + // 如果是最后一行之后插入 + adjustedTotalRows := totalRows + if handle.HasHeader { + adjustedTotalRows = totalRows - 1 + } + + if req.RowNumber == adjustedTotalRows+1 { + // 在文件末尾插入 + if err := csvWriter.Write(req.NewRow); err != nil { + csvWriter.Flush() + return nil, fmt.Errorf("在末尾插入新行失败: %v", err) + } + } + + // 确保所有数据写入 + csvWriter.Flush() + if err := csvWriter.Error(); err != nil { + return nil, fmt.Errorf("CSV写入错误: %v", err) + } + + // 关闭临时文件 + if err := tempFile.Close(); err != nil { + return nil, fmt.Errorf("关闭临时文件失败: %v", err) + } + + // 原子替换原文件 + handle.mu.Lock() + if handle.File != nil { + handle.File.Close() + handle.File = nil + handle.IsOpen = false + } + + if err := mgr.atomicReplaceFile(tempFile.Name(), handle.Filename); err != nil { + handle.mu.Unlock() + mgr.restoreFromBackup(handle) + return nil, fmt.Errorf("替换文件失败: %v", err) + } + + // 重新打开文件 + if err := mgr.openFile(handle); err != nil { + handle.mu.Unlock() + return nil, fmt.Errorf("重新打开文件失败: %v", err) + } + + // 更新总行数 + handle.TotalRows = totalRows + 1 + handle.mu.Unlock() + + return &ModifyResult{ + Success: true, + Message: fmt.Sprintf("在第%d行后插入成功", req.RowNumber), + RowsAffected: 1, + }, nil +} + +// deleteRowInternal 删除行 +func (mgr *CSVManager) deleteRowInternal(handle *CSVHandle, req *ModifyRequest, totalRows int64) (*ModifyResult, error) { + // 创建临时文件 + tempFile, err := os.CreateTemp(handle.tempDir, "delete_*.csv") + if err != nil { + return nil, fmt.Errorf("创建临时文件失败: %v", err) + } + defer func() { + tempFile.Close() + os.Remove(tempFile.Name()) + }() + + // 打开源文件 + src, err := os.Open(handle.Filename) + if err != nil { + return nil, err + } + defer src.Close() + + // 创建CSV读写器 + csvReader := csv.NewReader(src) + csvReader.Comma = handle.Delimiter + + csvWriter := csv.NewWriter(tempFile) + csvWriter.Comma = handle.Delimiter + + var rowCount int64 = 0 + var deletedCount int64 = 0 + + for { + row, err := csvReader.Read() + if err == io.EOF { + break + } + if err != nil { + csvWriter.Flush() + return nil, fmt.Errorf("读取第%d行失败: %v", rowCount+1, err) + } + + rowCount++ + + // 检查是否是要删除的行（考虑表头） + deleteRowNumber := req.RowNumber + if handle.HasHeader { + deleteRowNumber = req.RowNumber + 1 + } + + if rowCount == deleteRowNumber { + // 跳过这一行（不写入） + deletedCount++ + continue + } + + // 写入行 + if err := csvWriter.Write(row); err != nil { + csvWriter.Flush() + return nil, fmt.Errorf("写入第%d行失败: %v", rowCount, err) + } + } + + // 确保所有数据写入 + csvWriter.Flush() + if err := csvWriter.Error(); err != nil { + return nil, fmt.Errorf("CSV写入错误: %v", err) + } + + // 关闭临时文件 + if err := tempFile.Close(); err != nil { + return nil, fmt.Errorf("关闭临时文件失败: %v", err) + } + + // 原子替换原文件 + handle.mu.Lock() + if handle.File != nil { + handle.File.Close() + handle.File = nil + handle.IsOpen = false + } + + if err := mgr.atomicReplaceFile(tempFile.Name(), handle.Filename); err != nil { + handle.mu.Unlock() + mgr.restoreFromBackup(handle) + return nil, fmt.Errorf("替换文件失败: %v", err) + } + + // 重新打开文件 + if err := mgr.openFile(handle); err != nil { + handle.mu.Unlock() + return nil, fmt.Errorf("重新打开文件失败: %v", err) + } + + // 更新总行数 + handle.TotalRows = totalRows - deletedCount + handle.mu.Unlock() + + return &ModifyResult{ + Success: true, + Message: fmt.Sprintf("删除第%d行成功", req.RowNumber), + RowsAffected: deletedCount, + }, nil +} + +// readSpecificRow 读取指定行 +func (mgr *CSVManager) readSpecificRow(handle *CSVHandle, rowNumber int64) ([]string, error) { + // 保存当前位置 + currentPos, err := handle.File.Seek(0, io.SeekCurrent) + if err != nil { + return nil, err + } + defer handle.File.Seek(currentPos, io.SeekStart) + + // 重置到文件开始 + if _, err := handle.File.Seek(0, 0); err != nil { + return nil, err + } + + // 创建新的CSV阅读器 + reader := csv.NewReader(handle.File) + reader.Comma = handle.Delimiter + + var rowCount int64 = 0 + targetRowNumber := rowNumber + if handle.HasHeader { + targetRowNumber = rowNumber + 1 + } + + for { + row, err := reader.Read() + if err == io.EOF { + break + } + if err != nil { + return nil, err + } + + rowCount++ + if rowCount == targetRowNumber { + return row, nil + } + } + + return nil, fmt.Errorf("行号超出范围: %d", rowNumber) +} + +// ========================== 工具方法 ========================== + +// atomicReplaceFile 原子替换文件 +func (mgr *CSVManager) atomicReplaceFile(src, dst string) error { + // 先尝试原子重命名（Unix/Linux上这是原子的） + if err := os.Rename(src, dst); err == nil { + return nil + } + + // 如果重命名失败（比如Windows或跨分区），使用复制方式 + // 创建临时目标文件 + tmpDst := dst + ".tmp" + if err := mgr.copyFile(src, tmpDst); err != nil { + return err + } + + // 重命名为目标文件 + if err := os.Rename(tmpDst, dst); err != nil { + os.Remove(tmpDst) + return err + } + + return nil +} + +// copyFile 复制文件 +func (mgr *CSVManager) copyFile(src, dst string) error { + source, err := os.Open(src) + if err != nil { + return err + } + defer source.Close() + + destination, err := os.Create(dst) + if err != nil { + return err + } + defer destination.Close() + + _, err = io.Copy(destination, source) + return err +} + +// restoreFromBackup 从备份恢复 +func (mgr *CSVManager) restoreFromBackup(handle *CSVHandle) error { + handle.mu.Lock() + defer handle.mu.Unlock() + + if len(handle.backupFiles) == 0 { + return fmt.Errorf("没有可用的备份文件") + } + + // 使用最新的备份 + latestBackup := handle.backupFiles[len(handle.backupFiles)-1] + + // 关闭当前文件 + if handle.File != nil { + handle.File.Close() + handle.File = nil + handle.IsOpen = false + } + + // 恢复备份 + if err := mgr.atomicReplaceFile(latestBackup, handle.Filename); err != nil { + return fmt.Errorf("恢复备份失败: %v", err) + } + + // 重新打开文件 + return mgr.openFile(handle) +} + +// ========================== 其他操作 ========================== + +// GetRow 获取指定行数据 +func (mgr *CSVManager) GetRow(handleID int64, rowNumber int64) ([]string, error) { + handle, err := mgr.GetHandle(handleID) + if err != nil { + return nil, err + } + + // 获取文件级读锁 + fileLock := mgr.getFileLock(handle.Filename) + fileLock.RLock() + defer fileLock.RUnlock() + + return mgr.readSpecificRow(handle, rowNumber) +} + +// UndoLastModify 撤销最后一次修改 +func (mgr *CSVManager) UndoLastModify(handleID int64) (*ModifyResult, error) { + handle, err := mgr.GetHandle(handleID) + if err != nil { + return nil, err + } + + // 获取文件级写锁 + fileLock := mgr.getFileLock(handle.Filename) + fileLock.Lock() + defer fileLock.Unlock() + + handle.mu.Lock() + defer handle.mu.Unlock() + + if len(handle.backupFiles) == 0 { + return &ModifyResult{ + Success: false, + Message: "没有可撤销的修改", + }, nil + } + + // 关闭当前文件 + if handle.File != nil { + handle.File.Close() + handle.File = nil + handle.IsOpen = false + } + + // 获取最新的备份 + latestBackup := handle.backupFiles[len(handle.backupFiles)-1] + + // 恢复文件 + if err := mgr.atomicReplaceFile(latestBackup, handle.Filename); err != nil { + return &ModifyResult{ + Success: false, + Message: fmt.Sprintf("恢复文件失败: %v", err), + }, err + } + + // 重新打开文件 + if err := mgr.openFile(handle); err != nil { + return &ModifyResult{ + Success: false, + Message: fmt.Sprintf("重新打开文件失败: %v", err), + }, err + } + + // 移除已使用的备份 + handle.backupFiles = handle.backupFiles[:len(handle.backupFiles)-1] + + // 重新计算总行数 + totalRows, _ := mgr.calculateTotalRowsWithLock(handle) + fmt.Printf("总行数: %d\n", totalRows) + + return &ModifyResult{ + Success: true, + Message: "撤销成功", + RowsAffected: 1, + BackupFile: latestBackup, + }, nil +} + +// CleanupBackups 清理备份文件 +func (mgr *CSVManager) CleanupBackups(handleID int64) error { + handle, err := mgr.GetHandle(handleID) + if err != nil { + return err + } + + handle.mu.Lock() + defer handle.mu.Unlock() + + // 清理所有备份文件 + for _, backupFile := range handle.backupFiles { + os.Remove(backupFile) + } + handle.backupFiles = nil + + // 清理临时目录 + if handle.tempDir != "" { + os.RemoveAll(handle.tempDir) + handle.tempDir = "" + } + + return nil +} + +// ========================== 句柄管理 ========================== + +// Close 关闭CSV句柄 +func (h *CSVHandle) Close() error { + h.mu.Lock() + defer h.mu.Unlock() + + h.writeMu.Lock() + defer h.writeMu.Unlock() + + if !h.IsOpen { + return nil + } + + // 停止自动关闭计时器 + if h.autoCloseTimer != nil { + h.autoCloseTimer.Stop() + h.autoCloseTimer = nil + } + + // 关闭文件 + if h.File != nil { + if err := h.File.Close(); err != nil { + return err + } + h.File = nil + } + + h.CSVReader = nil + h.IsOpen = false + + return nil +} + +// startAutoClose 启动自动关闭计时器 +func (h *CSVHandle) startAutoClose(timeout time.Duration, mgr *CSVManager) { + h.autoCloseTimer = time.AfterFunc(timeout, func() { + h.mu.Lock() + defer h.mu.Unlock() + + // 检查是否长时间未访问 + if h.IsOpen && time.Since(h.AccessTime) > timeout { + h.Close() + // 从管理器移除 + mgr.handles.Delete(h.ID) + } + }) +} + +// GetHeader 获取表头 +func (h *CSVHandle) GetHeader() []string { + h.mu.RLock() + defer h.mu.RUnlock() + return h.Header +} + +// GetInfo 获取句柄信息 +func (h *CSVHandle) GetInfo() map[string]interface{} { + h.mu.RLock() + defer h.mu.RUnlock() + + return map[string]interface{}{ + "id": h.ID, + "filename": h.Filename, + "delimiter": string(h.Delimiter), + "has_header": h.HasHeader, + "is_open": h.IsOpen, + "open_time": h.OpenTime, + "access_time": h.AccessTime, + "access_count": h.AccessCount, + "total_rows": h.TotalRows, + "header": h.Header, + } +} + +// CloseHandle 关闭指定句柄 +func (mgr *CSVManager) CloseHandle(handleID int64) error { + value, ok := mgr.handles.Load(handleID) + if !ok { + return fmt.Errorf("句柄不存在: %d", handleID) + } + + handle := value.(*CSVHandle) + if err := handle.Close(); err != nil { + return err + } + + // 清理文件锁 + mgr.fileLocks.Delete(handle.Filename) + + mgr.handles.Delete(handleID) + return nil +} + +// CloseAllHandles 关闭所有句柄 +func (mgr *CSVManager) CloseAllHandles() { + mgr.handles.Range(func(key, value interface{}) bool { + handle := value.(*CSVHandle) + handle.Close() + mgr.fileLocks.Delete(handle.Filename) + mgr.handles.Delete(key) + return true + }) +} + +// ========================== 简便函数 ========================== + +//// OpenCSVFile 打开CSV文件 +//func OpenCSVFile(filename string, delimiter rune, hasHeader bool) (int64, error) { +// return GetManager().OpenCSVFile(filename, delimiter, hasHeader, "utf-8") +//} + +// GetCSVHandle 获取CSV句柄 +func GetCSVHandle(handleID int64) (*CSVHandle, error) { + return GetManager().GetHandle(handleID) +} + +// CloseCSVHandle 关闭CSV句柄 +func CloseCSVHandle(handleID int64) error { + return GetManager().CloseHandle(handleID) +} + +// ModifyCSVRow 修改CSV行 +func ModifyCSVRow(handleID int64, rowNumber int64, newRow []string) (*ModifyResult, error) { + return GetManager().ModifyRow(handleID, rowNumber, newRow) +} + +// ModifyCSVCell 修改CSV单元格 +func ModifyCSVCell(handleID int64, rowNumber int64, columnIndex int, newValue string) (*ModifyResult, error) { + return GetManager().ModifyCell(handleID, rowNumber, columnIndex, newValue) +} + +// GetCSVRow 获取CSV行 +func GetCSVRow(handleID int64, rowNumber int64) ([]string, error) { + return GetManager().GetRow(handleID, rowNumber) +} + +// UndoLastCSVModify 撤销最后修改 +func UndoLastCSVModify(handleID int64) (*ModifyResult, error) { + return GetManager().UndoLastModify(handleID) +} + +// CleanupCSVBackups 清理CSV备份 +func CleanupCSVBackups(handleID int64) error { + return GetManager().CleanupBackups(handleID) +} + +// UpdateCSVRowSafe 修改csv文件行数据 +func (mgr *CSVManager) UpdateCSVRowSafe(handleID int64, rowNum int, newRow []string) error { + getHandle, err := mgr.GetHandle(handleID) + if err != nil { + return fmt.Errorf("获取句柄信息失败: %v", err) + } + + // 1. 创建临时文件 + tempDir := filepath.Dir(getHandle.Filename) + if tempDir == "" { + tempDir = "." + } + + tempFile, err := os.CreateTemp(tempDir, "temp_*.csv") + if err != nil { + return fmt.Errorf("创建临时文件失败: %v", err) + } + tempFileName := tempFile.Name() + + // 确保临时文件被关闭和清理 + defer func() { + tempFile.Close() + // 如果临时文件还存在（替换失败），则清理它 + if _, err := os.Stat(tempFileName); err == nil { + os.Remove(tempFileName) + } + }() + + // 2. 读取原始文件 + sourceFile, err := os.Open(getHandle.Filename) + if err != nil { + return fmt.Errorf("打开源文件失败: %v", err) + } + defer sourceFile.Close() + + // 3. 读取并处理数据 + reader := csv.NewReader(sourceFile) + allRows, err := reader.ReadAll() + if err != nil { + return fmt.Errorf("读取CSV失败: %v", err) + } + + // 4. 验证并更新 + if rowNum < 1 || rowNum > len(allRows) { + return fmt.Errorf("行号 %d 超出范围 (1-%d)", rowNum, len(allRows)) + } + + // 显示修改前后的对比 + oldRow := allRows[rowNum-1] + fmt.Printf("修改前第 %d 行: %v\n", rowNum, oldRow) + fmt.Printf("修改后第 %d 行: %v\n", rowNum, newRow) + + allRows[rowNum-1] = newRow + + // 5. 写入临时文件 + writer := csv.NewWriter(tempFile) + if err := writer.WriteAll(allRows); err != nil { + return fmt.Errorf("写入临时文件失败: %v", err) + } + writer.Flush() + + if err := writer.Error(); err != nil { + return fmt.Errorf("刷新写入失败: %v", err) + } + + // 6. 确保数据写入磁盘 + if err := tempFile.Sync(); err != nil { + return fmt.Errorf("同步文件失败: %v", err) + } + tempFile.Close() + + // 7. 使用复制而不是重命名（解决Windows文件占用问题） + if err := copyFile(tempFileName, getHandle.Filename); err != nil { + return fmt.Errorf("复制文件失败: %v", err) + } + + fmt.Printf("✅ 成功更新第 %d 行，文件已直接更新\n", rowNum) + return nil +} + +// copyFile 复制文件内容 +func copyFile(src, dst string) error { + // 打开源文件 + source, err := os.Open(src) + if err != nil { + return err + } + defer source.Close() + + // 创建目标文件 + destination, err := os.Create(dst) + if err != nil { + return err + } + defer destination.Close() + + // 复制内容 + _, err = io.Copy(destination, source) + if err != nil { + return err + } + + // 确保数据写入磁盘 + err = destination.Sync() + if err != nil { + return err + } + + return nil +} + +// CSV响应结构体 +type CSVResponse struct { + Success bool `json:"success"` + Message string `json:"message,omitempty"` + Data interface{} `json:"data,omitempty"` +} + +// ===================== C 函数导入 ================== +// OpenCSVFile 打开/创建CSV文件 +// +//export OpenCSVFile +func OpenCSVFile(filename *C.char, delimiter C.char, hasHeader C.int) *C.char { + goFilename := C.GoString(filename) + goDelimiter := rune(delimiter) + var hasHeaderBool bool + if hasHeader != 0 { + hasHeaderBool = true + } + hasHeaderBool = false + handle, err := GetManager().OpenCSVFile(goFilename, goDelimiter, hasHeaderBool) + response := struct { + Handle int64 `json:"handle"` + }{ + Handle: handle, + } + var csvResponse CSVResponse + if err != nil { + csvResponse = CSVResponse{ + Success: false, + Message: err.Error(), + } + } else { + csvResponse = CSVResponse{ + Success: true, + Data: response, + } + } + // 转换为JSON字符串 + jsonData, err := json.Marshal(csvResponse) + if err != nil { + // 如果JSON序列化失败，返回错误信息 + csvResponse = CSVResponse{ + Success: false, + Message: fmt.Sprintf("JSON序列化失败: %v", err), + } + errorJson, _ := json.Marshal(csvResponse) + return C.CString(string(errorJson)) + } + return C.CString(string(jsonData)) +} + +// UpdateCSVRowSafe 修改csv文件行数据 +// +//export UpdateCSVRowSafe +func UpdateCSVRowSafe(handleID C.longlong, rowNum C.int, newRow *C.char) *C.char { + goHandle := int64(handleID) + goRowNum := int(rowNum) + goNewRow := C.GoString(newRow) + var row []string + var csvResponse CSVResponse + // 解析JSON + err := json.Unmarshal([]byte(goNewRow), &row) + if err != nil { + csvResponse = CSVResponse{ + Success: false, + Message: fmt.Sprintf("解析JSON失败: %v", err), + } + errorJson, _ := json.Marshal(csvResponse) + return C.CString(string(errorJson)) + } + // 修改csv行数据 + err = GetManager().UpdateCSVRowSafe(goHandle, goRowNum, row) + if err != nil { + csvResponse = CSVResponse{ + Success: false, + Message: fmt.Sprintf(err.Error()), + } + errorJson, _ := json.Marshal(csvResponse) + return C.CString(string(errorJson)) + } else { + csvResponse = CSVResponse{ + Success: true, + } + } + // 转换为JSON字符串 + jsonData, err := json.Marshal(csvResponse) + if err != nil { + // 如果JSON序列化失败，返回错误信息 + csvResponse = CSVResponse{ + Success: false, + Message: fmt.Sprintf("JSON序列化失败: %v", err), + } + errorJson, _ := json.Marshal(csvResponse) + return C.CString(string(errorJson)) + } + return C.CString(string(jsonData)) +} + +// 主函数 +func main() { + //fmt.Println("=== CSV句柄管理器测试 ===") + // + //filename := "csv/taskLog.csv" + //fmt.Printf("1. 创建测试文件: %s\n", filename) + // + //// 2. 打开CSV文件 + //handleID, err := OpenCSVFile(filename, ',', true) + //if err != nil { + // fmt.Printf("打开文件失败: %v\n", err) + // return + //} + //defer CloseCSVHandle(handleID) + // + //fmt.Printf("2. 打开文件成功，句柄ID: %d\n", handleID) + // + ////// 3. 获取句柄信息 + ////handle, err := GetCSVHandle(handleID) + ////if err != nil { + //// fmt.Printf("获取句柄失败: %v\n", err) + //// return + ////} + //// + ////info := handle.GetInfo() + ////fmt.Printf("3. 文件信息:\n") + ////fmt.Printf(" - 文件名: %s\n", info["filename"]) + ////fmt.Printf(" - 总行数: %v\n", info["total_rows"]) + ////fmt.Printf(" - 表头: %v\n", info["header"]) + // + ////// 准备新的行数据 + ////newData := []string{"9787115524539", "20.00", "20", "上传成功", ""} + ////err = UpdateCSVRowSafes(handleID, 6, newData) + ////if err != nil { + //// fmt.Printf("错误: %v\n", err) + ////} else { + //// fmt.Println("CSV文件更新成功！") + ////} + // + //// 4. 读取数据 + //fmt.Println("4. 读取测试:") + //row3, err := GetCSVRow(handleID, 100000) + //if err != nil { + // fmt.Printf(" 读取第100000行失败: %v\n", err) + //} else { + // fmt.Printf(" 第100000行数据: %v\n", row3) + //} + // + ////// 5. 修改测试 + ////fmt.Println("5. 修改测试:") + ////newRow := []string{"9787115524539", "20.00", "1", "上传成功", ""} + ////result, err := ModifyCSVRow(handleID, 3, newRow) + ////if err != nil { + //// fmt.Printf(" 修改失败: %v\n", err) + ////} else { + //// fmt.Printf(" 修改结果: %s (影响行数: %d)\n", result.Message, result.RowsAffected) + //// + //// // 验证修改 + //// modifiedRow, _ := GetCSVRow(handleID, 3) + //// fmt.Printf(" 修改后的第3行: %v\n", modifiedRow) + ////} + // + ////// 6. 单元格修改测试 + ////fmt.Println("6. 单元格修改测试:") + ////cellResult, err := ModifyCSVCell(handleID, 5, 1, "35") + ////if err != nil { + //// fmt.Printf(" 单元格修改失败: %v\n", err) + ////} else { + //// fmt.Printf(" 单元格修改结果: %s\n", cellResult.Message) + //// + //// // 验证修改 + //// cellModifiedRow, _ := GetCSVRow(handleID, 5) + //// fmt.Printf(" 修改后的第5行: %v\n", cellModifiedRow) + ////} + //// + ////// 7. 并发测试 + ////fmt.Println("7. 并发测试:") + ////TestConcurrentOperations(handleID) + //// + ////fmt.Println("=== 测试完成 ===") +} + +// 下面是一个更简单的版本，根据你的具体需求可以选择使用 +func WriteCSVSimple(filename string, data [][]string) error { + if len(data) == 0 { + return fmt.Errorf("写入的数据不能为空") + } + + var file *os.File + var err error + var fileMode int + + // 检查文件是否存在和有内容 + if info, err := os.Stat(filename); err == nil && info.Size() > 0 { + // 文件存在且有内容，追加模式 + fileMode = os.O_APPEND | os.O_WRONLY + } else { + // 文件不存在或为空，创建模式（会清空已有内容） + fileMode = os.O_CREATE | os.O_WRONLY | os.O_TRUNC + } + + // 打开或创建文件 + file, err = os.OpenFile(filename, fileMode, 0755) + if err != nil { + return err + } + defer file.Close() + + // 写入CSV数据 + writer := csv.NewWriter(file) + if err := writer.WriteAll(data); err != nil { + return err + } + writer.Flush() + + return writer.Error() +} diff --git a/dll/proxyConfig.h b/csv/csv.h similarity index 81% rename from dll/proxyConfig.h rename to csv/csv.h index 171e8ae..a397a21 100644 --- a/dll/proxyConfig.h +++ b/csv/csv.h @@ -21,8 +21,9 @@ extern const char *_GoStringPtr(_GoString_ s); /* Start of preamble from import "C" comments. */ -#line 3 "proxyConfig.go" - #include +#line 3 "csv.go" + +#include #line 1 "cgo-generated-wrapper" @@ -87,17 +88,14 @@ extern "C" { #endif -// 导出函数：获取代理健康状态（用于调试） +// ===================== C 函数导入 ================== +// OpenCSVFile 打开/创建CSV文件 // -extern __declspec(dllexport) char* GetProxyHealth(void); +extern __declspec(dllexport) char* OpenCSVFile(char* filename, char delimiter, int hasHeader); -// 导出函数：代理类型管理器 +// UpdateCSVRowSafe 修改csv文件行数据 // -extern __declspec(dllexport) char* ProxyTypeManager(char* proxyType, char* username, char* password, char* machineCode); - -// 导出函数：释放C字符串内存 -// -extern __declspec(dllexport) void FreeCString(char* str); +extern __declspec(dllexport) char* UpdateCSVRowSafe(long long int handleID, int rowNum, char* newRow); #ifdef __cplusplus } diff --git a/csv/csvDllTest.go b/csv/csvDllTest.go new file mode 100644 index 0000000..7c85ea0 --- /dev/null +++ b/csv/csvDllTest.go @@ -0,0 +1,413 @@ +package main + +import "C" +import ( + "bytes" + "encoding/csv" + "encoding/json" + "fmt" + "io" + "net/http" + "os" + "path/filepath" + "syscall" + "unsafe" +) + +// CsvDLL 代理DLL结构 +type csvDLL struct { + dll *syscall.DLL + openCSVFile *syscall.Proc // 打开/创建CSV文件 + readRows *syscall.Proc // 读取多行数据 + writeRows *syscall.Proc // 写入/覆盖行数据 + appendRows *syscall.Proc // 追加行数据 + getRowCount *syscall.Proc // 获取总行数 + findRows *syscall.Proc // 搜索行 + closeCSVFile *syscall.Proc // 关闭CSV文件 + mergeCSVFiles *syscall.Proc // 合并多个CSV文件 + getError *syscall.Proc // 获取错误信息 + updateCSVRowSafe *syscall.Proc + createOpenCSVFile *syscall.Proc + freeCString *syscall.Proc // 释放C字符串 +} + +// 初始化csvDLL +func InitCsvDLL() (*csvDLL, error) { + dllPath := filepath.Join("csv/dll", "csv.dll") + if _, err := os.Stat(dllPath); os.IsNotExist(err) { + return nil, fmt.Errorf("csv DLL 不存在: %s", dllPath) + } + if dll, err := syscall.LoadDLL(dllPath); err != nil { + return nil, fmt.Errorf("加载csv DLL 失败: %s", err) + } else { + return &csvDLL{ + dll: dll, + openCSVFile: dll.MustFindProc("OpenCSVFile"), + updateCSVRowSafe: dll.MustFindProc("UpdateCSVRowSafe"), + readRows: dll.MustFindProc("ReadRows"), + writeRows: dll.MustFindProc("WriteRows"), + appendRows: dll.MustFindProc("AppendRows"), + getRowCount: dll.MustFindProc("GetRowCount"), + findRows: dll.MustFindProc("FindRows"), + closeCSVFile: dll.MustFindProc("CloseCSVFile"), + mergeCSVFiles: dll.MustFindProc("MergeCSVFiles"), + createOpenCSVFile: dll.MustFindProc("CreateOpenCSVFile"), + getError: dll.MustFindProc("GetError"), + freeCString: dll.MustFindProc("FreeCString"), + }, nil + } +} + +// cStr 获取C字符串 +func (m *csvDLL) cStr(p uintptr) string { + if p == 0 { + return "" + } + b := []byte{} + for i := uintptr(0); ; i++ { + c := *(*byte)(unsafe.Pointer(p + i)) + if c == 0 { + break + } + b = append(b, c) + } + s := string(b) + if m.freeCString != nil { + m.freeCString.Call(p) + } + return s +} + +// 打开/创建CSV文件 +func (m *csvDLL) OpenCSVFile(filePath string, delimiter byte, hasHeader bool) (int64, error) { + proc, err := m.dll.FindProc("OpenCSVFile") + if err != nil { + return -1, fmt.Errorf("找不到函数 OpenCSVFile: %v", err) + } + filePathPtr, _ := syscall.BytePtrFromString(filePath) + hasHeaderInt := 0 + if hasHeader { + hasHeaderInt = 1 + } + info, _, _ := proc.Call( + uintptr(unsafe.Pointer(filePathPtr)), + uintptr(delimiter), + uintptr(hasHeaderInt)) + + return int64(info), nil +} + +// CSV响应结构体 +type CSVResponses struct { + Success bool `json:"success"` + Message string `json:"message,omitempty"` + Data CSVData `json:"data,omitempty"` +} + +type CSVData struct { + HandleID int64 `json:"handleID"` +} + +func (m *csvDLL) CreateOpenCSVFile(filePath string, delimiter byte, hasHeader bool) (*CSVResponses, error) { + proc, err := m.dll.FindProc("CreateOpenCSVFile") + if err != nil { + return nil, fmt.Errorf("找不到函数 CreateOpenCSVFile: %v", err) + } + filePathPtr, _ := syscall.BytePtrFromString(filePath) + hasHeaderInt := 0 + if hasHeader { + hasHeaderInt = 1 + } + info, _, _ := proc.Call( + uintptr(unsafe.Pointer(filePathPtr)), + uintptr(delimiter), + uintptr(hasHeaderInt)) + var csvResponse CSVResponses + str := m.cStr(info) + if err := json.Unmarshal([]byte(str), &csvResponse); err != nil { + return nil, err + } + return &csvResponse, nil +} + +func (m *csvDLL) UpdateCSVRowSafe(handleID int64, rowNum int, newRow []string) (*CSVResponses, error) { + proc, err := m.dll.FindProc("UpdateCSVRowSafe") + if err != nil { + return nil, fmt.Errorf("找不到函数 UpdateCSVRowSafe: %v", err) + } + jsonString, _ := json.Marshal(newRow) + newRowPtr, _ := syscall.BytePtrFromString(string(jsonString)) + info, _, _ := proc.Call( + uintptr(handleID), + uintptr(rowNum), + uintptr(unsafe.Pointer(newRowPtr))) + var csvResponse CSVResponses + str := m.cStr(info) + if err := json.Unmarshal([]byte(str), &csvResponse); err != nil { + return nil, err + } + return &csvResponse, nil +} + +//// 读取多行数据 +//func (m *csvDLL) ReadRows(handle int64) ([]string, error) { +// proc, err := m.dll.FindProc("ReadRows") +// if err != nil { +// return nil, fmt.Errorf("找不到函数 ReadRows: %v", err) +// } +// +//} + +// 写入/覆盖行数据 +func (m *csvDLL) WriteRows(handle int64, rowsData [][]string, header int) (int, error) { + proc, err := m.dll.FindProc("WriteRows") + if err != nil { + return -1, fmt.Errorf("找不到函数 WriteRows: %v", err) + } + var buffer bytes.Buffer + writer := csv.NewWriter(&buffer) + // 写入所有行 + if err := writer.WriteAll(rowsData); err != nil { + return -1, fmt.Errorf("序列化 CSV 数据失败: %v", err) + } + writer.Flush() + + // 转换为 C 字符串 + cStr := C.CString(buffer.String()) + + ret, _, _ := proc.Call( + uintptr(handle), + uintptr(unsafe.Pointer(cStr)), + uintptr(header)) + + freeProc, _ := m.dll.FindProc("FreeCString") + if freeProc != nil { + defer freeProc.Call(uintptr(unsafe.Pointer(cStr))) + } + return int(ret), nil +} + +// 定义请求结构体 +type OpenCSVRequest struct { + FilePath string `json:"filePath"` + Delimiter string `json:"delimiter"` // 可以是逗号、分号等字符 + HasHeader bool `json:"hasHeader"` +} + +// 定义响应结构体 +type OpenCSVResponse struct { + Success bool `json:"success"` + Message string `json:"message"` + Handle int64 `json:"handle,omitempty"` + Error string `json:"error,omitempty"` +} + +func handleOpenCSVFile(w http.ResponseWriter, r *http.Request) { + // 设置响应头 + w.Header().Set("Content-Type", "application/json; charset=utf-8") + + // 只允许 POST 请求 + if r.Method != http.MethodPost { + response := OpenCSVResponse{ + Success: false, + Message: "只支持POST请求", + } + w.WriteHeader(http.StatusMethodNotAllowed) + json.NewEncoder(w).Encode(response) + return + } + + // 1.初始化DLL管理器 + dll, err := InitCsvDLL() + if err != nil { + response := OpenCSVResponse{ + Success: false, + Message: "初始化DLL失败", + Error: err.Error(), + } + w.WriteHeader(http.StatusInternalServerError) + json.NewEncoder(w).Encode(response) + return + } + + // 2.读取请求体 + body, err := io.ReadAll(r.Body) + if err != nil { + response := OpenCSVResponse{ + Success: false, + Message: "读取请求体失败", + Error: err.Error(), + } + w.WriteHeader(http.StatusInternalServerError) + json.NewEncoder(w).Encode(response) + return + } + defer r.Body.Close() + + // 3.解析JSON请求 + var req OpenCSVRequest + if err := json.Unmarshal(body, &req); err != nil { + response := OpenCSVResponse{ + Success: false, + Message: "JSON解析失败", + Error: err.Error(), + } + w.WriteHeader(http.StatusInternalServerError) + json.NewEncoder(w).Encode(response) + return + } + + // 4.验证必填参数 + if req.FilePath == "" { + response := OpenCSVResponse{ + Success: false, + Message: "filePath参数不能为空", + } + w.WriteHeader(http.StatusBadRequest) + json.NewEncoder(w).Encode(response) + return + } + + // 5. 处理分隔符参数 + delimiter := ',' + if req.Delimiter != "" { + // 确保分隔符是单个字符 + if len(req.Delimiter) == 1 { + delimiter = rune(req.Delimiter[0]) + } else { + // 尝试解析常见分隔符的字符串表示 + switch req.Delimiter { + case "comma", ",": + delimiter = ',' + case "semicolon", ";": + delimiter = ';' + case "tab", "\t": + delimiter = '\t' + case "pipe", "|": + delimiter = '|' + default: + response := OpenCSVResponse{ + Success: false, + Message: "无效的分隔符，请使用单个字符或预定义的分隔符名称", + } + w.WriteHeader(http.StatusBadRequest) + json.NewEncoder(w).Encode(response) + return + } + } + } + + // 6. 调用DLL函数 + handle, err := dll.OpenCSVFile(req.FilePath, byte(delimiter), req.HasHeader) + if err != nil { + response := OpenCSVResponse{ + Success: false, + Message: "打开CSV文件失败", + Error: err.Error(), + } + w.WriteHeader(http.StatusInternalServerError) + json.NewEncoder(w).Encode(response) + return + } + + // 7. 返回成功响应 + response := OpenCSVResponse{ + Success: true, + Message: "CSV文件打开成功", + Handle: handle, + } + w.WriteHeader(http.StatusOK) + json.NewEncoder(w).Encode(response) +} + +func main() { + dll, err := InitCsvDLL() + if err != nil { + + } + file, err := dll.CreateOpenCSVFile("csv/taskLog.csv", ',', true) + if err != nil { + + } + newRow := []string{"9787115524539", "100.00", "1", "上传成功", ""} + safe, err := dll.UpdateCSVRowSafe(file.Data.HandleID, 9, newRow) + if err != nil { + + } + marshal, _ := json.Marshal(safe) + fmt.Println(string(marshal)) + + //http.HandleFunc("/csv/openCSVFile", handleOpenCSVFile) + //port := "8080" + //server := &http.Server{ + // Addr: ":" + port, + // Handler: nil, + //} + // + //// 4. 优雅关闭设置 + //done := make(chan bool, 1) + //quit := make(chan os.Signal, 1) + //signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM) + // + //// 5. 优雅关闭协程 + //go func() { + // <-quit + // fmt.Println("\n服务器正在关闭...") + // + // ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) + // defer cancel() + // + // if err := server.Shutdown(ctx); err != nil { + // fmt.Printf("强制关闭服务器: %v\n", err) + // } + // close(done) + //}() + // + //// 启动服务器 + //if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed { + // fmt.Printf("服务器启动失败: %s\n", err) + //} + //// 7. 等待关闭完成 + //<-done + //fmt.Println("服务器已关闭") +} + +// 解码从DLL读取的数据 +func decodeRowData(buffer []byte, maxBytes int) [][]string { + var rows [][]string + var currentRow []string + + offset := 0 + for offset < maxBytes { + if offset+4 > maxBytes { + break + } + + // 读取单元格长度 + cellLen := int(uint32(buffer[offset]) | + uint32(buffer[offset+1])<<8 | + uint32(buffer[offset+2])<<16 | + uint32(buffer[offset+3])<<24) + offset += 4 + + if cellLen == 0 { + // 行结束 + if len(currentRow) > 0 { + rows = append(rows, currentRow) + currentRow = nil + } + continue + } + + if offset+cellLen > maxBytes { + break + } + + // 读取单元格数据 + cell := string(buffer[offset : offset+cellLen]) + offset += cellLen + currentRow = append(currentRow, cell) + } + + return rows +} diff --git a/csv/csvTool.go b/csv/csvTool.go new file mode 100644 index 0000000..4bb7e6d --- /dev/null +++ b/csv/csvTool.go @@ -0,0 +1,1050 @@ +package main + +///* +//#include +//*/ +//import "C" +//import ( +// "encoding/csv" +// "encoding/json" +// "fmt" +// "io" +// "os" +// "strings" +// "sync" +// "sync/atomic" +// "time" +// "unsafe" +//) +// +//// CSVManager CSV全局管理器 +//type CSVManager struct { +// files sync.Map // handle -> *CSVFile (并发安全的映射) +// nextHandle int64 // 生成唯一句柄 +// errorMsg string // 全局错误信息 +// mu sync.RWMutex // 管理器级别的锁 +//} +// +//// CSVFile 文件结构 +//type CSVFile struct { +// filename string // 实际文件路径 +// handle int64 // 唯一句柄 +// delimiter rune // 分隔符（如 ','） +// hasHeader bool // 是否有标题行 +// +// // 内存数据缓存 +// data [][]string // 内存中的数据行 +// header []string // 标题行（如果有） +// fileSize int64 // 文件大小 +// modified bool // 标记是否被修改 +// +// // 并发控制 +// mu sync.RWMutex // 文件级锁 +// rowLocks []*sync.RWMutex // 行级锁 +// rowMu sync.Mutex // 行锁数组保护 +// readers int32 // 活跃读取器计数 +// writers int32 // 活跃写入器计数 +// saving int32 // 正在保存的goroutine计数 +// saveErr chan error // 保存错误通道 +// done chan struct{} // 关闭信号 +//} +// +//// CSV响应结构体 +//type CSVResponse struct { +// Success bool `json:"success"` +// Message string `json:"message,omitempty"` +// Data interface{} `json:"data,omitempty"` +//} +// +//// 单例模式的管理器 +//var manager *CSVManager +//var once sync.Once +// +//// newCSVFile 创建新的CSVFile对象 +//func newCSVFile(filename string, delimiter rune, hasHeader bool) *CSVFile { +// return &CSVFile{ +// filename: filename, +// delimiter: delimiter, +// hasHeader: hasHeader, +// data: make([][]string, 0), +// rowLocks: make([]*sync.RWMutex, 0), +// saveErr: make(chan error, 1), +// done: make(chan struct{}), +// } +//} +// +//// getManager 获取全局管理器(单例) +//func getManager() *CSVManager { +// once.Do(func() { +// manager = &CSVManager{ +// nextHandle: 1, +// } +// }) +// return manager +//} +// +//// setError 设置错误信息 +//func setError(err string) { +// mgr := getManager() +// mgr.mu.Lock() +// mgr.errorMsg = err +// mgr.mu.Unlock() +//} +// +//// 初始化管理器 +//func initCSVManager() int64 { +// _ = getManager() +// return 0 // 成功 +//} +// +//// 加载CSV文件到内存 +//func (f *CSVFile) load() error { +// f.mu.Lock() +// defer f.mu.Unlock() +// +// // 打开文件 +// file, err := os.Open(f.filename) +// if err != nil { +// // 文件不存在则创建空文件 +// if os.IsNotExist(err) { +// f.data = make([][]string, 0) // 初始化空数据 +// f.rowLocks = make([]*sync.RWMutex, 0) // 初始化空行锁数组 +// return nil +// } +// return fmt.Errorf("文件不存在: %v", err) +// } +// // 确保函数结束时关闭文件 +// defer file.Close() +// +// // 获取文件大小 +// stat, _ := file.Stat() // 获取文件信息 +// f.fileSize = stat.Size() // 获取文件大小 +// +// // 创建CSV读取器 +// reader := csv.NewReader(file) +// reader.Comma = f.delimiter // 设置分隔符（默认逗号） +// reader.LazyQuotes = true // 允许宽松的引号解析 +// reader.TrimLeadingSpace = true // 去除字段前的空格 +// +// // 关键修改：允许变长记录，不强制检查字段数量 +// reader.FieldsPerRecord = -1 +// firstRecord, err := reader.Read() +// if err != nil { +// if err == io.EOF { +// // 空文件 +// f.data = make([][]string, 0) +// f.rowLocks = make([]*sync.RWMutex, 0) +// return nil +// } +// return err +// } +// maxColumns := len(firstRecord) +// allData := [][]string{firstRecord} +// +// // 读取剩余行 +// for { +// record, err := reader.Read() +// if err == io.EOF { +// break +// } +// if err != nil { +// // 对于有问题的行，可以填充或跳过 +// continue +// } +// +// // 确保所有行都有相同的列数 +// if len(record) < maxColumns { +// // 填充缺失的列为空字符串 +// paddedRecord := make([]string, maxColumns) +// copy(paddedRecord, record) +// for i := len(record); i < maxColumns; i++ { +// paddedRecord[i] = "" +// } +// record = paddedRecord +// } else if len(record) > maxColumns { +// // 如果行有更多列，更新最大列数 +// maxColumns = len(record) +// // 重新处理之前的所有行 +// for i := range allData { +// if len(allData[i]) < maxColumns { +// paddedRecord := make([]string, maxColumns) +// copy(paddedRecord, allData[i]) +// allData[i] = paddedRecord +// } +// } +// } +// +// allData = append(allData, record) +// } +// +// if len(allData) == 0 { +// f.data = make([][]string, 0) +// f.rowLocks = make([]*sync.RWMutex, 0) +// return nil +// } +// +// // 处理表头 +// if f.hasHeader && len(allData) > 0 { +// f.header = allData[0] +// f.data = allData[1:] +// } else { +// f.data = allData +// } +// +// // 初始化行锁 +// f.initRowLocks() +// +// return nil +//} +// +//// initRowLocks 初始化行锁数组 +//func (f *CSVFile) initRowLocks() { +// count := len(f.data) +// f.rowLocks = make([]*sync.RWMutex, count) +// for i := 0; i < count; i++ { +// f.rowLocks[i] = &sync.RWMutex{} +// } +//} +// +//// 创建CSV文件到内存(句柄) +//func openCSVFile(filename string, delimiter rune, hasHeader bool) (int64, error) { +// // 创建CSV全局管理器 +// mgr := getManager() +// +// // 生成句柄 +// handle := atomic.AddInt64(&mgr.nextHandle, 1) +// +// // 创建文件对象 +// file := newCSVFile(filename, delimiter, hasHeader) +// file.handle = handle +// +// // 加载文件数据 +// if err := file.load(); err != nil { +// return -1, err +// } +// +// // 存储到管理器 +// mgr.files.Store(handle, file) +// +// return handle, nil +//} + +//// 写入/覆盖行数据 +//func writeRows(handle int64, rowData [][]string, header int) int64 { +// mgr := getManager() +// +// // 获取文件对象 +// val, ok := mgr.files.Load(handle) +// if !ok { +// setError("文件无效句柄！") +// return -1 +// } +// +// file := val.(*CSVFile) +// +// // 获取写入锁 +// file.mu.Lock() +// defer file.mu.Unlock() +// +// atomic.AddInt32(&file.writers, 1) +// defer atomic.AddInt32(&file.writers, -1) +// +// // 清空现有数据（因为这是覆盖写入） +// file.data = make([][]string, 0, len(rowData)) +// if header == 0 { +// file.header = rowData[0] +// // 添加新数据 +// file.data = rowData[1:] +// } else { +// // 添加新数据 +// for _, row := range rowData { +// file.data = append(file.data, row) +// } +// } +// +// // 扩展行锁数组 +// file.rowMu.Lock() +// file.rowLocks = make([]*sync.RWMutex, len(file.data)) +// for i := range file.rowLocks { +// file.rowLocks[i] = &sync.RWMutex{} +// } +// file.rowMu.Unlock() +// +// file.modified = true +// // 异步保存到文件 +// go file.saveAsync() +// return int64(len(file.data)) +//} +// +//// getRowLock 获取行锁（线程安全） +//func (f *CSVFile) getRowLock(rowIndex int) *sync.RWMutex { +// if rowIndex < 0 { +// return nil +// } +// +// f.rowMu.Lock() +// defer f.rowMu.Unlock() +// +// // 确保行锁存在 +// if rowIndex >= len(f.rowLocks) { +// // 扩展行锁数组 +// newLocks := make([]*sync.RWMutex, rowIndex+1) +// copy(newLocks, f.rowLocks) +// for i := len(f.rowLocks); i <= rowIndex; i++ { +// newLocks[i] = &sync.RWMutex{} +// } +// f.rowLocks = newLocks +// } +// +// return f.rowLocks[rowIndex] +//} +// +//// save 保存到文件 +//func (f *CSVFile) save() error { +// // 标记正在保存 +// if !atomic.CompareAndSwapInt32(&f.saving, 0, 1) { +// // 已经在保存中，直接返回 +// return nil +// } +// defer atomic.StoreInt32(&f.saving, 0) +// +// // 如果没有修改，直接返回 +// f.mu.RLock() +// if !f.modified { +// f.mu.RUnlock() +// return nil +// } +// // 复制数据 +// dataCopy := make([][]string, len(f.data)) +// +// for i := range f.data { +// dataCopy[i] = make([]string, len(f.data[i])) +// copy(dataCopy[i], f.data[i]) +// } +// // 复制表头 +// headerCopy := make([]string, len(f.header)) +// copy(headerCopy, f.header) +// // 复制配置(值类型，直接赋值) +// hasHeader := f.hasHeader +// delimiter := f.delimiter +// filename := f.filename +// f.mu.RUnlock() // 释放读锁 +// +// // 创建临时文件(使用不同的扩展名避免冲突) +// tempFile := filename + ".tmp" +// file, err := os.Create(tempFile) +// if err != nil { +// return err +// } +// +// // 创建CSV写入器 +// writer := csv.NewWriter(file) +// writer.Comma = delimiter +// +// // 写入数据 +// if hasHeader && len(headerCopy) > 0 { +// if err := writer.Write(headerCopy); err != nil { +// file.Close() +// os.Remove(tempFile) +// return err +// } +// } +// +// if err := writer.WriteAll(dataCopy); err != nil { +// file.Close() +// os.Remove(tempFile) +// return err +// } +// +// writer.Flush() +// if err := writer.Error(); err != nil { +// file.Close() +// os.Remove(tempFile) +// return err +// } +// +// // 关闭文件，确保数据写入磁盘 +// if err := file.Close(); err != nil { +// os.Remove(tempFile) +// return err +// } +// +// // 尝试重命名，如果失败可能是文件被占用 +// var renameErr error +// for retry := 0; retry < 3; retry++ { +// renameErr = os.Rename(tempFile, filename) +// if renameErr == nil { +// break +// } +// time.Sleep(100 * time.Millisecond) // 等待重试 +// } +// +// if renameErr != nil { +// os.Remove(tempFile) +// return renameErr +// } +// +// // 标记为已保存 +// f.mu.Lock() +// f.modified = false +// f.mu.Unlock() +// +// return nil +//} +// +//// saveAsync 异步保存，带错误处理 +//func (f *CSVFile) saveAsync() { +// select { +// case f.saveErr <- f.save(): +// // 保存完成 +// default: +// // 通道已满，忽略错误 +// } +//} +// +//// 读取多行数据 +//func readRows(handle int64, startRow, count int64, buffer []byte) int64 { +// mgr := getManager() +// +// // 获取文件对象 +// val, ok := mgr.files.Load(handle) +// if !ok { +// setError("Invalid file handle") +// return -1 +// } +// +// file := val.(*CSVFile) +// atomic.AddInt32(&file.readers, 1) +// defer atomic.AddInt32(&file.readers, -1) +// +// // 获取读取锁 +// file.mu.RLock() +// defer file.mu.RUnlock() +// +// totalRows := int64(len(file.data)) +// if startRow < 0 || startRow >= totalRows { +// return 0 +// } +// +// // 计算实际读取行数 +// endRow := startRow + count +// if endRow > totalRows { +// endRow = totalRows +// } +// +// rowsToRead := endRow - startRow +// +// // 将数据复制到缓冲区 +// bytesWritten := 0 +// +// for i := startRow; i < endRow; i++ { +// row := file.data[i] +// +// // 获取行读锁 +// if rowLock := file.getRowLock(int(i)); rowLock != nil { +// rowLock.RLock() +// } +// +// for _, cell := range row { +// // 写入单元格长度 +// cellLen := len(cell) +// if bytesWritten+4 > len(buffer) { +// break +// } +// +// // 写入4字节长度 +// buffer[bytesWritten] = byte(cellLen & 0xFF) +// buffer[bytesWritten+1] = byte((cellLen >> 8) & 0xFF) +// buffer[bytesWritten+2] = byte((cellLen >> 16) & 0xFF) +// buffer[bytesWritten+3] = byte((cellLen >> 24) & 0xFF) +// bytesWritten += 4 +// +// // 写入单元格数据 +// if bytesWritten+cellLen > len(buffer) { +// // 缓冲区不足，回退长度写入 +// bytesWritten -= 4 +// break +// } +// +// copy(buffer[bytesWritten:bytesWritten+cellLen], cell) +// bytesWritten += cellLen +// } +// +// // 写入行结束标记 +// if bytesWritten+4 <= len(buffer) { +// // 4字节的0表示行结束 +// buffer[bytesWritten] = 0 +// buffer[bytesWritten+1] = 0 +// buffer[bytesWritten+2] = 0 +// buffer[bytesWritten+3] = 0 +// bytesWritten += 4 +// } +// +// // 释放行锁 +// if rowLock := file.getRowLock(int(i)); rowLock != nil { +// rowLock.RUnlock() +// } +// +// if bytesWritten >= len(buffer) { +// break +// } +// } +// +// return rowsToRead +//} +// +//// 追加行数据 +//func appendRows(handle int64, rowsData []byte, rowCount int64) int { +// mgr := getManager() +// +// // 获取文件对象 +// val, ok := mgr.files.Load(handle) +// if !ok { +// setError("Invalid file handle") +// return -1 +// } +// +// file := val.(*CSVFile) +// +// // 获取写入锁 +// file.mu.Lock() +// atomic.AddInt32(&file.writers, 1) +// +// // 解析行数据 +// offset := 0 +// +// for i := int64(0); i < rowCount; i++ { +// var row []string +// +// // 读取行数据 +// for { +// if offset+4 > len(rowsData) { +// break +// } +// +// cellLen := int(uint32(rowsData[offset]) | +// uint32(rowsData[offset+1])<<8 | +// uint32(rowsData[offset+2])<<16 | +// uint32(rowsData[offset+3])<<24) +// offset += 4 +// +// if cellLen == 0 { +// break +// } +// +// if offset+cellLen > len(rowsData) { +// break +// } +// +// cell := string(rowsData[offset : offset+cellLen]) +// offset += cellLen +// row = append(row, cell) +// } +// +// // 追加到数据 +// file.data = append(file.data, row) +// } +// +// file.modified = true +// +// atomic.AddInt32(&file.writers, -1) +// file.mu.Unlock() +// +// // 异步保存 +// go file.saveAsync() +// +// return 0 +//} +// +//// 获取总行数 +//func getRowCount(handle int64) int64 { +// mgr := getManager() +// +// val, ok := mgr.files.Load(handle) +// if !ok { +// setError("Invalid file handle") +// return -1 +// } +// +// file := val.(*CSVFile) +// file.mu.RLock() +// defer file.mu.RUnlock() +// +// return int64(len(file.data)) +//} +// +//// 搜索行 +//func findRows(handle int64, searchText string, columnIndex int64, resultBuffer []byte, maxResults int64) int64 { +// mgr := getManager() +// +// val, ok := mgr.files.Load(handle) +// if !ok { +// setError("Invalid file handle") +// return -1 +// } +// +// file := val.(*CSVFile) +// +// file.mu.RLock() +// defer file.mu.RUnlock() +// +// atomic.AddInt32(&file.readers, 1) +// defer atomic.AddInt32(&file.readers, -1) +// +// var foundRows []int64 +// +// // 搜索行 +// for i, row := range file.data { +// if maxResults > 0 && int64(len(foundRows)) >= maxResults { +// break +// } +// +// // 获取行读锁 +// if rowLock := file.getRowLock(i); rowLock != nil { +// rowLock.RLock() +// } +// +// // 检查列 +// if columnIndex < 0 || columnIndex >= int64(len(row)) { +// // 搜索所有列 +// for _, cell := range row { +// if cell == searchText { +// foundRows = append(foundRows, int64(i)) +// break +// } +// } +// } else if row[columnIndex] == searchText { +// foundRows = append(foundRows, int64(i)) +// } +// +// // 释放行锁 +// if rowLock := file.getRowLock(i); rowLock != nil { +// rowLock.RUnlock() +// } +// } +// +// // 写入结果到缓冲区 +// if resultBuffer != nil && len(foundRows) > 0 { +// bytesWritten := 0 +// +// for _, rowIndex := range foundRows { +// if bytesWritten+8 > len(resultBuffer) { +// break +// } +// +// // 写入行索引（8字节） +// for j := 0; j < 8; j++ { +// resultBuffer[bytesWritten] = byte((rowIndex >> (uint(j) * 8)) & 0xFF) +// bytesWritten++ +// } +// } +// } +// +// return int64(len(foundRows)) +//} +// +//// 合并多个CSV文件（线程安全） +//func mergeCSVFiles(handles []int64, outputFilename string, delimiter rune, hasHeader bool) int64 { +// mgr := getManager() +// +// // 验证所有句柄并获取文件对象 +// files := make([]*CSVFile, 0, len(handles)) +// for _, handle := range handles { +// val, ok := mgr.files.Load(handle) +// if !ok { +// setError("Invalid file handle: " + string(handle)) +// return -1 +// } +// files = append(files, val.(*CSVFile)) +// } +// +// // 创建输出文件对象 +// outputFile := newCSVFile(outputFilename, delimiter, hasHeader) +// outputFile.modified = true // 标记为需要保存 +// +// // 第一步：合并表头 +// mergedHeader := make([]string, 0) +// headerSet := make(map[string]bool) +// +// if hasHeader { +// // 收集所有不重复的表头 +// for _, file := range files { +// file.mu.RLock() +// if file.hasHeader && len(file.header) > 0 { +// for _, h := range file.header { +// if !headerSet[h] { +// headerSet[h] = true +// mergedHeader = append(mergedHeader, h) +// } +// } +// } +// file.mu.RUnlock() +// } +// +// // 如果没有找到表头，创建一个默认的表头 +// if len(mergedHeader) == 0 && len(files) > 0 { +// files[0].mu.RLock() +// maxColumns := len(files[0].data[0]) +// files[0].mu.RUnlock() +// +// for i := 0; i < maxColumns; i++ { +// mergedHeader = append(mergedHeader, fmt.Sprintf("Column%d", i+1)) +// } +// } +// } +// outputFile.header = mergedHeader +// +// // 第二步：合并数据 +// mergedData := make([][]string, 0) +// +// // 为每个输入文件创建读取锁并并发读取 +// var wg sync.WaitGroup +// dataChan := make(chan [][]string, len(files)) +// errorChan := make(chan error, len(files)) +// +// for idx, file := range files { +// wg.Add(1) +// go func(fileIdx int, f *CSVFile) { +// defer wg.Done() +// +// // 获取文件的读取锁 +// f.mu.RLock() +// defer f.mu.RUnlock() +// +// // 增加活跃读取器计数 +// atomic.AddInt32(&f.readers, 1) +// defer atomic.AddInt32(&f.readers, -1) +// +// // 读取数据 +// fileData := make([][]string, len(f.data)) +// for i := 0; i < len(f.data); i++ { +// // 获取行读锁 +// if rowLock := f.getRowLock(i); rowLock != nil { +// rowLock.RLock() +// } +// +// // 复制行数据 +// row := make([]string, len(f.data[i])) +// copy(row, f.data[i]) +// +// // 释放行锁 +// if rowLock := f.getRowLock(i); rowLock != nil { +// rowLock.RUnlock() +// } +// +// fileData[i] = row +// } +// +// // 如果需要处理表头映射 +// if hasHeader && f.hasHeader && len(f.header) > 0 { +// // 创建列映射：源列 -> 目标列 +// columnMapping := make(map[int]int) +// for srcIdx, srcHeader := range f.header { +// for dstIdx, dstHeader := range mergedHeader { +// if srcHeader == dstHeader { +// columnMapping[srcIdx] = dstIdx +// break +// } +// } +// } +// +// // 重新排列数据以匹配合并后的表头 +// for i := 0; i < len(fileData); i++ { +// newRow := make([]string, len(mergedHeader)) +// for srcIdx, dstIdx := range columnMapping { +// if srcIdx < len(fileData[i]) { +// newRow[dstIdx] = fileData[i][srcIdx] +// } +// } +// fileData[i] = newRow +// } +// } else if hasHeader && len(mergedHeader) > 0 { +// // 文件没有表头，但输出需要表头 +// // 简单地将数据填充到对应位置 +// for i := 0; i < len(fileData); i++ { +// newRow := make([]string, len(mergedHeader)) +// for j := 0; j < len(fileData[i]) && j < len(newRow); j++ { +// newRow[j] = fileData[i][j] +// } +// fileData[i] = newRow +// } +// } +// +// // 将处理后的数据发送到通道 +// dataChan <- fileData +// }(idx, file) +// } +// +// // 等待所有goroutine完成 +// go func() { +// wg.Wait() +// close(dataChan) +// close(errorChan) +// }() +// +// // 收集所有数据 +// for data := range dataChan { +// mergedData = append(mergedData, data...) +// } +// +// // 检查是否有错误 +// select { +// case err := <-errorChan: +// if err != nil { +// setError("Error merging files: " + err.Error()) +// return -1 +// } +// default: +// } +// +// // 第三步：设置输出文件的数据 +// outputFile.data = mergedData +// outputFile.initRowLocks() +// +// // 第四步：保存到文件 +// if err := outputFile.save(); err != nil { +// setError("Error saving merged file: " + err.Error()) +// return -1 +// } +// +// // 第五步：将输出文件添加到管理器 +// handle := atomic.AddInt64(&mgr.nextHandle, 1) +// outputFile.handle = handle +// mgr.files.Store(handle, outputFile) +// +// return handle +//} +// +//// 关闭文件 +//func closeCSVFile(handle int64) int64 { +// mgr := getManager() +// +// val, ok := mgr.files.Load(handle) +// if !ok { +// setError("文件句柄无效！") +// return -1 +// } +// +// file := val.(*CSVFile) +// +// // 等待所有读写操作完成 +// for atomic.LoadInt32(&file.readers) > 0 || atomic.LoadInt32(&file.writers) > 0 { +// time.Sleep(time.Millisecond) +// } +// +// // 等待异步保存完成 +// for i := 0; i < 100; i++ { // 最多等待100ms +// if atomic.LoadInt32(&file.saving) == 0 { +// break +// } +// time.Sleep(time.Millisecond) +// } +// +// // 如果有正在进行的保存，等待一小段时间 +// if atomic.LoadInt32(&file.saving) > 0 { +// time.Sleep(50 * time.Millisecond) +// } +// +// // 检查是否需要保存 +// file.mu.RLock() +// needSave := file.modified +// file.mu.RUnlock() +// +// if needSave { +// // 同步保存修改 +// if err := file.save(); err != nil { +// setError(err.Error()) +// return -1 +// } +// } +// +// // 从管理器移除 +// mgr.files.Delete(handle) +// +// // 安全关闭通道（如果存在） +// if file.done != nil { +// close(file.done) +// } +// +// return 0 +//} +// +//// 获取错误信息 +//func getError() string { +// mgr := getManager() +// mgr.mu.RLock() +// defer mgr.mu.RUnlock() +// +// if mgr.errorMsg == "" { +// return "" +// } +// +// err := mgr.errorMsg +// mgr.errorMsg = "" // 清空错误 +// +// return err +//} +// +//// ============ C 导出接口 ============ +// +////export InitCSVManager +//func InitCSVManager() C.longlong { +// return C.longlong(initCSVManager()) +//} +// +//// OpenCSVFile 创建CSV文件到内存 +//// +////export OpenCSVFile +//func OpenCSVFile(filename *C.char, delimiter C.char, hasHeader C.int) *C.char { +// goFilename := C.GoString(filename) +// goDelimiter := rune(delimiter) +// var hasHeaderBool bool +// if hasHeader != 0 { +// hasHeaderBool = true +// } +// hasHeaderBool = false +// handle, err := openCSVFile(goFilename, goDelimiter, hasHeaderBool) +// response := struct { +// Handle int64 `json:"handle"` +// }{ +// Handle: handle, +// } +// var csvResponse CSVResponse +// if err != nil { +// csvResponse = CSVResponse{ +// Success: false, +// Message: err.Error(), +// } +// } else { +// csvResponse = CSVResponse{ +// Success: false, +// Data: response, +// } +// } +// // 转换为JSON字符串 +// jsonData, err := json.Marshal(csvResponse) +// if err != nil { +// // 如果JSON序列化失败，返回错误信息 +// csvResponse = CSVResponse{ +// Success: false, +// Message: fmt.Sprintf("JSON序列化失败: %v", err), +// } +// errorJson, _ := json.Marshal(csvResponse) +// return C.CString(string(errorJson)) +// } +// return C.CString(string(jsonData)) +//} +// +//// ReadRows 读取多行数据 +//// +////export ReadRows +//func ReadRows(handle C.longlong, startRow C.longlong, count C.longlong, buffer *C.char, bufferSize C.int) C.longlong { +// // 将 C 缓冲区转换为 Go 的字节切片 +// goBuffer := unsafe.Slice((*byte)(unsafe.Pointer(buffer)), int(bufferSize)) +// result := readRows(int64(handle), int64(startRow), int64(count), goBuffer) +// return C.longlong(result) +//} +// +//// WriteRows 写入/覆盖行数据 +//// +////export WriteRows +//func WriteRows(handle C.longlong, rowsData *C.char, header C.int) C.int { +// goData := C.GoString(rowsData) +// goHeader := int(header) +// data := parseSimpleTable(goData) +// result := writeRows(int64(handle), data, goHeader) +// return C.int(result) +//} +// +//func parseSimpleTable(goData string) [][]string { +// lines := strings.Split(strings.TrimSpace(goData), "\n") +// result := make([][]string, len(lines)) +// +// for i, line := range lines { +// // 根据你的分隔符分割，这里用逗号举例 +// fields := strings.Split(line, ",") +// // 如果需要去除每个字段的空格 +// for j := range fields { +// fields[j] = strings.TrimSpace(fields[j]) +// } +// result[i] = fields +// } +// +// return result +//} +// +//// AppendRows 追加行数据 +//// +////export AppendRows +//func AppendRows(handle C.longlong, rowsData *C.char, dataSize C.int, rowCount C.longlong) C.int { +// goData := unsafe.Slice((*byte)(unsafe.Pointer(rowsData)), int(dataSize)) +// result := appendRows(int64(handle), goData, int64(rowCount)) +// return C.int(result) +//} +// +//// GetRowCount 获取总行数 +//// +////export GetRowCount +//func GetRowCount(handle C.longlong) C.longlong { +// result := getRowCount(int64(handle)) +// return C.longlong(result) +//} +// +//// FindRows 搜索行 +//// +////export FindRows +//func FindRows(handle C.longlong, searchText *C.char, columnIndex C.longlong, resultBuffer *C.char, bufferSize C.int, maxResults C.longlong) C.longlong { +// goSearchText := C.GoString(searchText) +// goResultBuffer := unsafe.Slice((*byte)(unsafe.Pointer(resultBuffer)), int(bufferSize)) +// result := findRows(int64(handle), goSearchText, int64(columnIndex), goResultBuffer, int64(maxResults)) +// return C.longlong(result) +//} +// +//// MergeCSVFiles 合并多个CSV文件（线程安全） +//// +////export MergeCSVFiles +//func MergeCSVFiles(handlesPtr *C.longlong, handlesCount C.int, outputFilename *C.char, delimiter C.char, hasHeader C.int) C.longlong { +// // 将C数组转换为Go切片 +// goHandles := unsafe.Slice(handlesPtr, int(handlesCount)) +// handles := make([]int64, len(goHandles)) +// for i := 0; i < len(goHandles); i++ { +// handles[i] = int64(goHandles[i]) +// } +// // 调用合并函数 +// result := mergeCSVFiles(handles, C.GoString(outputFilename), rune(delimiter), hasHeader != 0) +// return C.longlong(result) +//} +// +//// CloseCSVFile 关闭文件 +//// +////export CloseCSVFile +//func CloseCSVFile(handle C.longlong) C.int { +// result := closeCSVFile(int64(handle)) +// return C.int(result) +//} +// +//// GetError 获取错误信息 +//// +////export GetError +//func GetError(buffer *C.char, bufferSize C.int) C.int { +// errMsg := getError() +// if errMsg == "" { +// return 0 +// } +// +// // 将错误信息复制到缓冲区 +// goBuffer := unsafe.Slice((*byte)(unsafe.Pointer(buffer)), int(bufferSize)) +// n := copy(goBuffer, errMsg) +// return C.int(n) +//} +// +//// 导出函数：释放C字符串内存 +//// +////export FreeCString +//func FreeCString(str *C.char) { +// C.free(unsafe.Pointer(str)) +//} +// +//// main 函数是必需的，即使为空 +////func main() { +////} diff --git a/csv/dll/csv.dll b/csv/dll/csv.dll new file mode 100644 index 0000000..3eeb663 Binary files /dev/null and b/csv/dll/csv.dll differ diff --git a/csv/dll/csv.h b/csv/dll/csv.h new file mode 100644 index 0000000..94186f5 --- /dev/null +++ b/csv/dll/csv.h @@ -0,0 +1,139 @@ +/* Code generated by cmd/cgo; DO NOT EDIT. */ + +/* package command-line-arguments */ + + +#line 1 "cgo-builtin-export-prolog" + +#include + +#ifndef GO_CGO_EXPORT_PROLOGUE_H +#define GO_CGO_EXPORT_PROLOGUE_H + +#ifndef GO_CGO_GOSTRING_TYPEDEF +typedef struct { const char *p; ptrdiff_t n; } _GoString_; +extern size_t _GoStringLen(_GoString_ s); +extern const char *_GoStringPtr(_GoString_ s); +#endif + +#endif + +/* Start of preamble from import "C" comments. */ + + +#line 3 "newcsv.go" + +#include + +#line 1 "cgo-generated-wrapper" + + +/* End of preamble from import "C" comments. */ + + +/* Start of boilerplate cgo prologue. */ +#line 1 "cgo-gcc-export-header-prolog" + +#ifndef GO_CGO_PROLOGUE_H +#define GO_CGO_PROLOGUE_H + +typedef signed char GoInt8; +typedef unsigned char GoUint8; +typedef short GoInt16; +typedef unsigned short GoUint16; +typedef int GoInt32; +typedef unsigned int GoUint32; +typedef long long GoInt64; +typedef unsigned long long GoUint64; +typedef GoInt64 GoInt; +typedef GoUint64 GoUint; +typedef size_t GoUintptr; +typedef float GoFloat32; +typedef double GoFloat64; +#ifdef _MSC_VER +#if !defined(__cplusplus) || _MSVC_LANG <= 201402L +#include +typedef _Fcomplex GoComplex64; +typedef _Dcomplex GoComplex128; +#else +#include +typedef std::complex GoComplex64; +typedef std::complex GoComplex128; +#endif +#else +typedef float _Complex GoComplex64; +typedef double _Complex GoComplex128; +#endif + +/* + static assertion to make sure the file is being used on architecture + at least with matching size of GoInt. +*/ +typedef char _check_for_64_bit_pointer_matching_GoInt[sizeof(void*)==64/8 ? 1:-1]; + +#ifndef GO_CGO_GOSTRING_TYPEDEF +typedef _GoString_ GoString; +#endif +typedef void *GoMap; +typedef void *GoChan; +typedef struct { void *t; void *v; } GoInterface; +typedef struct { void *data; GoInt len; GoInt cap; } GoSlice; + +#endif + +/* End of boilerplate cgo prologue. */ + +#ifdef __cplusplus +extern "C" { +#endif + +extern __declspec(dllexport) long long int InitCSVManager(void); + +// OpenCSVFile 打开/创建CSV文件 +// +extern __declspec(dllexport) long long int OpenCSVFile(char* filename, char delimiter, int hasHeader); + +// UpdateCSVRowSafe 修改csv文件行数据 +// +extern __declspec(dllexport) char* UpdateCSVRowSafe(long long int handleID, int rowNum, char* newRow); +extern __declspec(dllexport) char* CreateOpenCSVFile(char* filename, char delimiter, int hasHeader); + +// ReadRows 读取多行数据 +// +extern __declspec(dllexport) long long int ReadRows(long long int handle, long long int startRow, long long int count, char* buffer, int bufferSize); + +// WriteRows 写入/覆盖行数据 +// +extern __declspec(dllexport) int WriteRows(long long int handle, char* rowsData, int header); + +// AppendRows 追加行数据 +// +extern __declspec(dllexport) int AppendRows(long long int handle, char* rowsData, int dataSize, long long int rowCount); + +// GetRowCount 获取总行数 +// +extern __declspec(dllexport) long long int GetRowCount(long long int handle); + +// FindRows 搜索行 +// +extern __declspec(dllexport) long long int FindRows(long long int handle, char* searchText, long long int columnIndex, char* resultBuffer, int bufferSize, long long int maxResults); + +// MergeCSVFiles 合并多个CSV文件(线程安全) +// +extern __declspec(dllexport) long long int MergeCSVFiles(long long int* handlesPtr, int handlesCount, char* outputFilename, char delimiter, int hasHeader); + +// CloseCSVFile 关闭文件 +// +extern __declspec(dllexport) int CloseCSVFile(long long int handle); + +// GetError 获取错误信息 +// +extern __declspec(dllexport) int GetError(char* buffer, int bufferSize); + +// 导出函数：释放C字符串内存 +// +extern __declspec(dllexport) void FreeCString(char* str); + +#ifdef __cplusplus +} +#endif diff --git a/csv/newcsv.go b/csv/newcsv.go new file mode 100644 index 0000000..1940d46 --- /dev/null +++ b/csv/newcsv.go @@ -0,0 +1,1225 @@ +package main + +///* +//#include +//*/ +//import "C" +//import ( +// "encoding/csv" +// "encoding/json" +// "fmt" +// "io" +// "os" +// "path/filepath" +// "strings" +// "sync" +// "sync/atomic" +// "time" +// "unsafe" +//) +// +//// CSVManager CSV全局管理器 +//type CSVManager struct { +// files sync.Map // handle -> *CSVFile (并发安全的映射) +// nextHandle int64 // 生成唯一句柄 +// errorMsg string // 全局错误信息 +// mu sync.RWMutex // 管理器级别的锁 +//} +// +//// CSVFile 文件结构 +//type CSVFile struct { +// filename string // 实际文件路径 +// handle int64 // 唯一句柄 +// delimiter rune // 分隔符（如 ','） +// hasHeader bool // 是否有标题行 +// +// // 内存数据缓存 +// data [][]string // 内存中的数据行 +// header []string // 标题行（如果有） +// fileSize int64 // 文件大小 +// modified bool // 标记是否被修改 +// +// // 并发控制 +// mu sync.RWMutex // 文件级锁 +// rowLocks []*sync.RWMutex // 行级锁 +// rowMu sync.Mutex // 行锁数组保护 +// readers int32 // 活跃读取器计数 +// writers int32 // 活跃写入器计数 +// saving int32 // 正在保存的goroutine计数 +// saveErr chan error // 保存错误通道 +// done chan struct{} // 关闭信号 +//} +// +//// 单例模式的管理器 +//var manager *CSVManager +//var once sync.Once +// +//// newCSVFile 创建新的CSVFile对象 +//func newCSVFile(filename string, delimiter rune, hasHeader bool) *CSVFile { +// return &CSVFile{ +// filename: filename, +// delimiter: delimiter, +// hasHeader: hasHeader, +// data: make([][]string, 0), +// rowLocks: make([]*sync.RWMutex, 0), +// saveErr: make(chan error, 1), +// done: make(chan struct{}), +// } +//} +// +//// getManager 获取全局管理器(单例) +//func getManager() *CSVManager { +// once.Do(func() { +// manager = &CSVManager{ +// nextHandle: 1, +// } +// }) +// return manager +//} +// +//// setError 设置错误信息 +//func setError(err string) { +// mgr := getManager() +// mgr.mu.Lock() +// mgr.errorMsg = err +// mgr.mu.Unlock() +//} +// +//// 初始化管理器 +//func initCSVManager() int64 { +// _ = getManager() +// return 0 // 成功 +//} +// +//// 打开/创建CSV文件(句柄) +//func openCSVFile(filename string, delimiter rune, hasHeader bool) int64 { +// // 创建CSV全局管理器 +// mgr := getManager() +// +// // 生成句柄 +// handle := atomic.AddInt64(&mgr.nextHandle, 1) +// +// // 创建文件对象 +// file := newCSVFile(filename, delimiter, hasHeader) +// file.handle = handle +// +// // 加载文件数据 +// if err := file.load(); err != nil { +// setError(err.Error()) +// return -1 +// } +// +// // 存储到管理器 +// mgr.files.Store(handle, file) +// +// return handle +//} +// +//// 读取多行数据 +//func readRows(handle int64, startRow, count int64, buffer []byte) int64 { +// mgr := getManager() +// +// // 获取文件对象 +// val, ok := mgr.files.Load(handle) +// if !ok { +// setError("Invalid file handle") +// return -1 +// } +// +// file := val.(*CSVFile) +// atomic.AddInt32(&file.readers, 1) +// defer atomic.AddInt32(&file.readers, -1) +// +// // 获取读取锁 +// file.mu.RLock() +// defer file.mu.RUnlock() +// +// totalRows := int64(len(file.data)) +// if startRow < 0 || startRow >= totalRows { +// return 0 +// } +// +// // 计算实际读取行数 +// endRow := startRow + count +// if endRow > totalRows { +// endRow = totalRows +// } +// +// rowsToRead := endRow - startRow +// +// // 将数据复制到缓冲区 +// bytesWritten := 0 +// +// for i := startRow; i < endRow; i++ { +// row := file.data[i] +// +// // 获取行读锁 +// if rowLock := file.getRowLock(int(i)); rowLock != nil { +// rowLock.RLock() +// } +// +// for _, cell := range row { +// // 写入单元格长度 +// cellLen := len(cell) +// if bytesWritten+4 > len(buffer) { +// break +// } +// +// // 写入4字节长度 +// buffer[bytesWritten] = byte(cellLen & 0xFF) +// buffer[bytesWritten+1] = byte((cellLen >> 8) & 0xFF) +// buffer[bytesWritten+2] = byte((cellLen >> 16) & 0xFF) +// buffer[bytesWritten+3] = byte((cellLen >> 24) & 0xFF) +// bytesWritten += 4 +// +// // 写入单元格数据 +// if bytesWritten+cellLen > len(buffer) { +// // 缓冲区不足，回退长度写入 +// bytesWritten -= 4 +// break +// } +// +// copy(buffer[bytesWritten:bytesWritten+cellLen], cell) +// bytesWritten += cellLen +// } +// +// // 写入行结束标记 +// if bytesWritten+4 <= len(buffer) { +// // 4字节的0表示行结束 +// buffer[bytesWritten] = 0 +// buffer[bytesWritten+1] = 0 +// buffer[bytesWritten+2] = 0 +// buffer[bytesWritten+3] = 0 +// bytesWritten += 4 +// } +// +// // 释放行锁 +// if rowLock := file.getRowLock(int(i)); rowLock != nil { +// rowLock.RUnlock() +// } +// +// if bytesWritten >= len(buffer) { +// break +// } +// } +// +// return rowsToRead +//} +// +//// 写入/覆盖行数据 +//func writeRows(handle int64, rowData [][]string, header int) int64 { +// mgr := getManager() +// +// // 获取文件对象 +// val, ok := mgr.files.Load(handle) +// if !ok { +// setError("文件无效句柄！") +// return -1 +// } +// +// file := val.(*CSVFile) +// +// // 获取写入锁 +// file.mu.Lock() +// defer file.mu.Unlock() +// +// atomic.AddInt32(&file.writers, 1) +// defer atomic.AddInt32(&file.writers, -1) +// +// // 清空现有数据（因为这是覆盖写入） +// file.data = make([][]string, 0, len(rowData)) +// if header == 0 { +// file.header = rowData[0] +// // 添加新数据 +// file.data = rowData[1:] +// } else { +// // 添加新数据 +// for _, row := range rowData { +// file.data = append(file.data, row) +// } +// } +// +// // 扩展行锁数组 +// file.rowMu.Lock() +// file.rowLocks = make([]*sync.RWMutex, len(file.data)) +// for i := range file.rowLocks { +// file.rowLocks[i] = &sync.RWMutex{} +// } +// file.rowMu.Unlock() +// +// file.modified = true +// // 异步保存到文件 +// go file.saveAsync() +// return int64(len(file.data)) +//} +// +//// 加载CSV文件到内存 +//func (f *CSVFile) load() error { +// f.mu.Lock() +// defer f.mu.Unlock() +// +// // 打开文件 +// file, err := os.Open(f.filename) +// if err != nil { +// // 文件不存在则创建空文件 +// if os.IsNotExist(err) { +// f.data = make([][]string, 0) // 初始化空数据 +// f.rowLocks = make([]*sync.RWMutex, 0) // 初始化空行锁数组 +// return nil +// } +// return fmt.Errorf("文件不存在: %v", err) +// } +// // 确保函数结束时关闭文件 +// defer file.Close() +// +// // 获取文件大小 +// stat, _ := file.Stat() // 获取文件信息 +// f.fileSize = stat.Size() // 获取文件大小 +// +// // 创建CSV读取器 +// reader := csv.NewReader(file) +// reader.Comma = f.delimiter // 设置分隔符（默认逗号） +// reader.LazyQuotes = true // 允许宽松的引号解析 +// reader.TrimLeadingSpace = true // 去除字段前的空格 +// +// // 关键修改：允许变长记录，不强制检查字段数量 +// reader.FieldsPerRecord = -1 +// firstRecord, err := reader.Read() +// if err != nil { +// if err == io.EOF { +// // 空文件 +// f.data = make([][]string, 0) +// f.rowLocks = make([]*sync.RWMutex, 0) +// return nil +// } +// return err +// } +// maxColumns := len(firstRecord) +// allData := [][]string{firstRecord} +// +// // 读取剩余行 +// for { +// record, err := reader.Read() +// if err == io.EOF { +// break +// } +// if err != nil { +// // 对于有问题的行，可以填充或跳过 +// continue +// } +// +// // 确保所有行都有相同的列数 +// if len(record) < maxColumns { +// // 填充缺失的列为空字符串 +// paddedRecord := make([]string, maxColumns) +// copy(paddedRecord, record) +// for i := len(record); i < maxColumns; i++ { +// paddedRecord[i] = "" +// } +// record = paddedRecord +// } else if len(record) > maxColumns { +// // 如果行有更多列，更新最大列数 +// maxColumns = len(record) +// // 重新处理之前的所有行 +// for i := range allData { +// if len(allData[i]) < maxColumns { +// paddedRecord := make([]string, maxColumns) +// copy(paddedRecord, allData[i]) +// allData[i] = paddedRecord +// } +// } +// } +// +// allData = append(allData, record) +// } +// +// if len(allData) == 0 { +// f.data = make([][]string, 0) +// f.rowLocks = make([]*sync.RWMutex, 0) +// return nil +// } +// +// // 处理表头 +// if f.hasHeader && len(allData) > 0 { +// f.header = allData[0] +// f.data = allData[1:] +// } else { +// f.data = allData +// } +// +// // 初始化行锁 +// f.initRowLocks() +// +// return nil +//} +// +//// initRowLocks 初始化行锁数组 +//func (f *CSVFile) initRowLocks() { +// count := len(f.data) +// f.rowLocks = make([]*sync.RWMutex, count) +// for i := 0; i < count; i++ { +// f.rowLocks[i] = &sync.RWMutex{} +// } +//} +// +//// getRowLock 获取行锁（线程安全） +//func (f *CSVFile) getRowLock(rowIndex int) *sync.RWMutex { +// if rowIndex < 0 { +// return nil +// } +// +// f.rowMu.Lock() +// defer f.rowMu.Unlock() +// +// // 确保行锁存在 +// if rowIndex >= len(f.rowLocks) { +// // 扩展行锁数组 +// newLocks := make([]*sync.RWMutex, rowIndex+1) +// copy(newLocks, f.rowLocks) +// for i := len(f.rowLocks); i <= rowIndex; i++ { +// newLocks[i] = &sync.RWMutex{} +// } +// f.rowLocks = newLocks +// } +// +// return f.rowLocks[rowIndex] +//} +// +//// save 保存到文件 +//func (f *CSVFile) save() error { +// // 标记正在保存 +// if !atomic.CompareAndSwapInt32(&f.saving, 0, 1) { +// // 已经在保存中，直接返回 +// return nil +// } +// defer atomic.StoreInt32(&f.saving, 0) +// +// // 如果没有修改，直接返回 +// f.mu.RLock() +// if !f.modified { +// f.mu.RUnlock() +// return nil +// } +// // 复制数据 +// dataCopy := make([][]string, len(f.data)) +// +// for i := range f.data { +// dataCopy[i] = make([]string, len(f.data[i])) +// copy(dataCopy[i], f.data[i]) +// } +// // 复制表头 +// headerCopy := make([]string, len(f.header)) +// copy(headerCopy, f.header) +// // 复制配置(值类型，直接赋值) +// hasHeader := f.hasHeader +// delimiter := f.delimiter +// filename := f.filename +// f.mu.RUnlock() // 释放读锁 +// +// // 创建临时文件(使用不同的扩展名避免冲突) +// tempFile := filename + ".tmp" +// file, err := os.Create(tempFile) +// if err != nil { +// return err +// } +// +// // 创建CSV写入器 +// writer := csv.NewWriter(file) +// writer.Comma = delimiter +// +// // 写入数据 +// if hasHeader && len(headerCopy) > 0 { +// if err := writer.Write(headerCopy); err != nil { +// file.Close() +// os.Remove(tempFile) +// return err +// } +// } +// +// if err := writer.WriteAll(dataCopy); err != nil { +// file.Close() +// os.Remove(tempFile) +// return err +// } +// +// writer.Flush() +// if err := writer.Error(); err != nil { +// file.Close() +// os.Remove(tempFile) +// return err +// } +// +// // 关闭文件，确保数据写入磁盘 +// if err := file.Close(); err != nil { +// os.Remove(tempFile) +// return err +// } +// +// // 尝试重命名，如果失败可能是文件被占用 +// var renameErr error +// for retry := 0; retry < 3; retry++ { +// renameErr = os.Rename(tempFile, filename) +// if renameErr == nil { +// break +// } +// time.Sleep(100 * time.Millisecond) // 等待重试 +// } +// +// if renameErr != nil { +// os.Remove(tempFile) +// return renameErr +// } +// +// // 标记为已保存 +// f.mu.Lock() +// f.modified = false +// f.mu.Unlock() +// +// return nil +//} +// +//// saveAsync 异步保存，带错误处理 +//func (f *CSVFile) saveAsync() { +// select { +// case f.saveErr <- f.save(): +// // 保存完成 +// default: +// // 通道已满，忽略错误 +// } +//} +// +//// 追加行数据 +//func appendRows(handle int64, rowsData []byte, rowCount int64) int { +// mgr := getManager() +// +// // 获取文件对象 +// val, ok := mgr.files.Load(handle) +// if !ok { +// setError("Invalid file handle") +// return -1 +// } +// +// file := val.(*CSVFile) +// +// // 获取写入锁 +// file.mu.Lock() +// atomic.AddInt32(&file.writers, 1) +// +// // 解析行数据 +// offset := 0 +// +// for i := int64(0); i < rowCount; i++ { +// var row []string +// +// // 读取行数据 +// for { +// if offset+4 > len(rowsData) { +// break +// } +// +// cellLen := int(uint32(rowsData[offset]) | +// uint32(rowsData[offset+1])<<8 | +// uint32(rowsData[offset+2])<<16 | +// uint32(rowsData[offset+3])<<24) +// offset += 4 +// +// if cellLen == 0 { +// break +// } +// +// if offset+cellLen > len(rowsData) { +// break +// } +// +// cell := string(rowsData[offset : offset+cellLen]) +// offset += cellLen +// row = append(row, cell) +// } +// +// // 追加到数据 +// file.data = append(file.data, row) +// } +// +// file.modified = true +// +// atomic.AddInt32(&file.writers, -1) +// file.mu.Unlock() +// +// // 异步保存 +// go file.saveAsync() +// +// return 0 +//} +// +//// 打开/创建CSV文件(句柄) +//func createOpenCSVFile(filename string, delimiter rune, hasHeader bool) int64 { +// // 创建CSV全局管理器 +// mgr := getManager() +// +// // 生成句柄 +// handle := atomic.AddInt64(&mgr.nextHandle, 1) +// +// // 创建文件对象 +// file := newCSVFile(filename, delimiter, hasHeader) +// file.handle = handle +// +// //// 加载文件数据 +// //if err := file.load(); err != nil { +// // setError(err.Error()) +// // return -1 +// //} +// +// // 存储到管理器 +// mgr.files.Store(handle, file) +// +// return handle +//} +// +//// updateCSVRowSafe 修改csv文件行数据 +//func updateCSVRowSafe(handleID int64, rowNum int, newRow []string) error { +// mgr := getManager() +// +// // 获取文件对象 +// val, ok := mgr.files.Load(handleID) +// if !ok { +// setError("Invalid file handle") +// return fmt.Errorf("无效句柄: %d", handleID) +// } +// file := val.(*CSVFile) +// +// // 1. 创建临时文件 +// tempDir := filepath.Dir(file.filename) +// if tempDir == "" { +// tempDir = "." +// } +// +// tempFile, err := os.CreateTemp(tempDir, "temp_*.csv") +// if err != nil { +// return fmt.Errorf("创建临时文件失败: %v", err) +// } +// tempFileName := tempFile.Name() +// +// // 确保临时文件被关闭和清理 +// defer func() { +// tempFile.Close() +// // 如果临时文件还存在（替换失败），则清理它 +// if _, err := os.Stat(tempFileName); err == nil { +// os.Remove(tempFileName) +// } +// }() +// +// // 2. 读取原始文件 +// sourceFile, err := os.Open(file.filename) +// if err != nil { +// return fmt.Errorf("打开源文件失败: %v", err) +// } +// defer sourceFile.Close() +// +// // 3. 读取并处理数据 +// reader := csv.NewReader(sourceFile) +// allRows, err := reader.ReadAll() +// if err != nil { +// return fmt.Errorf("读取CSV失败: %v", err) +// } +// +// // 4. 验证并更新 +// if rowNum < 1 || rowNum > len(allRows) { +// return fmt.Errorf("行号 %d 超出范围 (1-%d)", rowNum, len(allRows)) +// } +// +// // 显示修改前后的对比 +// oldRow := allRows[rowNum-1] +// fmt.Printf("修改前第 %d 行: %v\n", rowNum, oldRow) +// fmt.Printf("修改后第 %d 行: %v\n", rowNum, newRow) +// +// allRows[rowNum-1] = newRow +// +// // 5. 写入临时文件 +// writer := csv.NewWriter(tempFile) +// if err := writer.WriteAll(allRows); err != nil { +// return fmt.Errorf("写入临时文件失败: %v", err) +// } +// writer.Flush() +// +// if err := writer.Error(); err != nil { +// return fmt.Errorf("刷新写入失败: %v", err) +// } +// +// // 6. 确保数据写入磁盘 +// if err := tempFile.Sync(); err != nil { +// return fmt.Errorf("同步文件失败: %v", err) +// } +// tempFile.Close() +// +// // 7. 使用复制而不是重命名（解决Windows文件占用问题） +// if err := copyFile(tempFileName, file.filename); err != nil { +// return fmt.Errorf("复制文件失败: %v", err) +// } +// +// fmt.Printf("✅ 成功更新第 %d 行，文件已直接更新\n", rowNum) +// return nil +//} +// +//// copyFile 复制文件内容 +//func copyFile(src, dst string) error { +// // 打开源文件 +// source, err := os.Open(src) +// if err != nil { +// return err +// } +// defer source.Close() +// +// // 创建目标文件 +// destination, err := os.Create(dst) +// if err != nil { +// return err +// } +// defer destination.Close() +// +// // 复制内容 +// _, err = io.Copy(destination, source) +// if err != nil { +// return err +// } +// +// // 确保数据写入磁盘 +// err = destination.Sync() +// if err != nil { +// return err +// } +// +// return nil +//} +// +//// 获取总行数 +//func getRowCount(handle int64) int64 { +// mgr := getManager() +// +// val, ok := mgr.files.Load(handle) +// if !ok { +// setError("Invalid file handle") +// return -1 +// } +// +// file := val.(*CSVFile) +// file.mu.RLock() +// defer file.mu.RUnlock() +// +// return int64(len(file.data)) +//} +// +//// 搜索行 +//func findRows(handle int64, searchText string, columnIndex int64, resultBuffer []byte, maxResults int64) int64 { +// mgr := getManager() +// +// val, ok := mgr.files.Load(handle) +// if !ok { +// setError("Invalid file handle") +// return -1 +// } +// +// file := val.(*CSVFile) +// +// file.mu.RLock() +// defer file.mu.RUnlock() +// +// atomic.AddInt32(&file.readers, 1) +// defer atomic.AddInt32(&file.readers, -1) +// +// var foundRows []int64 +// +// // 搜索行 +// for i, row := range file.data { +// if maxResults > 0 && int64(len(foundRows)) >= maxResults { +// break +// } +// +// // 获取行读锁 +// if rowLock := file.getRowLock(i); rowLock != nil { +// rowLock.RLock() +// } +// +// // 检查列 +// if columnIndex < 0 || columnIndex >= int64(len(row)) { +// // 搜索所有列 +// for _, cell := range row { +// if cell == searchText { +// foundRows = append(foundRows, int64(i)) +// break +// } +// } +// } else if row[columnIndex] == searchText { +// foundRows = append(foundRows, int64(i)) +// } +// +// // 释放行锁 +// if rowLock := file.getRowLock(i); rowLock != nil { +// rowLock.RUnlock() +// } +// } +// +// // 写入结果到缓冲区 +// if resultBuffer != nil && len(foundRows) > 0 { +// bytesWritten := 0 +// +// for _, rowIndex := range foundRows { +// if bytesWritten+8 > len(resultBuffer) { +// break +// } +// +// // 写入行索引（8字节） +// for j := 0; j < 8; j++ { +// resultBuffer[bytesWritten] = byte((rowIndex >> (uint(j) * 8)) & 0xFF) +// bytesWritten++ +// } +// } +// } +// +// return int64(len(foundRows)) +//} +// +//// 合并多个CSV文件（线程安全） +//func mergeCSVFiles(handles []int64, outputFilename string, delimiter rune, hasHeader bool) int64 { +// mgr := getManager() +// +// // 验证所有句柄并获取文件对象 +// files := make([]*CSVFile, 0, len(handles)) +// for _, handle := range handles { +// val, ok := mgr.files.Load(handle) +// if !ok { +// setError("Invalid file handle: " + string(handle)) +// return -1 +// } +// files = append(files, val.(*CSVFile)) +// } +// +// // 创建输出文件对象 +// outputFile := newCSVFile(outputFilename, delimiter, hasHeader) +// outputFile.modified = true // 标记为需要保存 +// +// // 第一步：合并表头 +// mergedHeader := make([]string, 0) +// headerSet := make(map[string]bool) +// +// if hasHeader { +// // 收集所有不重复的表头 +// for _, file := range files { +// file.mu.RLock() +// if file.hasHeader && len(file.header) > 0 { +// for _, h := range file.header { +// if !headerSet[h] { +// headerSet[h] = true +// mergedHeader = append(mergedHeader, h) +// } +// } +// } +// file.mu.RUnlock() +// } +// +// // 如果没有找到表头，创建一个默认的表头 +// if len(mergedHeader) == 0 && len(files) > 0 { +// files[0].mu.RLock() +// maxColumns := len(files[0].data[0]) +// files[0].mu.RUnlock() +// +// for i := 0; i < maxColumns; i++ { +// mergedHeader = append(mergedHeader, fmt.Sprintf("Column%d", i+1)) +// } +// } +// } +// outputFile.header = mergedHeader +// +// // 第二步：合并数据 +// mergedData := make([][]string, 0) +// +// // 为每个输入文件创建读取锁并并发读取 +// var wg sync.WaitGroup +// dataChan := make(chan [][]string, len(files)) +// errorChan := make(chan error, len(files)) +// +// for idx, file := range files { +// wg.Add(1) +// go func(fileIdx int, f *CSVFile) { +// defer wg.Done() +// +// // 获取文件的读取锁 +// f.mu.RLock() +// defer f.mu.RUnlock() +// +// // 增加活跃读取器计数 +// atomic.AddInt32(&f.readers, 1) +// defer atomic.AddInt32(&f.readers, -1) +// +// // 读取数据 +// fileData := make([][]string, len(f.data)) +// for i := 0; i < len(f.data); i++ { +// // 获取行读锁 +// if rowLock := f.getRowLock(i); rowLock != nil { +// rowLock.RLock() +// } +// +// // 复制行数据 +// row := make([]string, len(f.data[i])) +// copy(row, f.data[i]) +// +// // 释放行锁 +// if rowLock := f.getRowLock(i); rowLock != nil { +// rowLock.RUnlock() +// } +// +// fileData[i] = row +// } +// +// // 如果需要处理表头映射 +// if hasHeader && f.hasHeader && len(f.header) > 0 { +// // 创建列映射：源列 -> 目标列 +// columnMapping := make(map[int]int) +// for srcIdx, srcHeader := range f.header { +// for dstIdx, dstHeader := range mergedHeader { +// if srcHeader == dstHeader { +// columnMapping[srcIdx] = dstIdx +// break +// } +// } +// } +// +// // 重新排列数据以匹配合并后的表头 +// for i := 0; i < len(fileData); i++ { +// newRow := make([]string, len(mergedHeader)) +// for srcIdx, dstIdx := range columnMapping { +// if srcIdx < len(fileData[i]) { +// newRow[dstIdx] = fileData[i][srcIdx] +// } +// } +// fileData[i] = newRow +// } +// } else if hasHeader && len(mergedHeader) > 0 { +// // 文件没有表头，但输出需要表头 +// // 简单地将数据填充到对应位置 +// for i := 0; i < len(fileData); i++ { +// newRow := make([]string, len(mergedHeader)) +// for j := 0; j < len(fileData[i]) && j < len(newRow); j++ { +// newRow[j] = fileData[i][j] +// } +// fileData[i] = newRow +// } +// } +// +// // 将处理后的数据发送到通道 +// dataChan <- fileData +// }(idx, file) +// } +// +// // 等待所有goroutine完成 +// go func() { +// wg.Wait() +// close(dataChan) +// close(errorChan) +// }() +// +// // 收集所有数据 +// for data := range dataChan { +// mergedData = append(mergedData, data...) +// } +// +// // 检查是否有错误 +// select { +// case err := <-errorChan: +// if err != nil { +// setError("Error merging files: " + err.Error()) +// return -1 +// } +// default: +// } +// +// // 第三步：设置输出文件的数据 +// outputFile.data = mergedData +// outputFile.initRowLocks() +// +// // 第四步：保存到文件 +// if err := outputFile.save(); err != nil { +// setError("Error saving merged file: " + err.Error()) +// return -1 +// } +// +// // 第五步：将输出文件添加到管理器 +// handle := atomic.AddInt64(&mgr.nextHandle, 1) +// outputFile.handle = handle +// mgr.files.Store(handle, outputFile) +// +// return handle +//} +// +//// 关闭文件 +//func closeCSVFile(handle int64) int64 { +// mgr := getManager() +// +// val, ok := mgr.files.Load(handle) +// if !ok { +// setError("文件句柄无效！") +// return -1 +// } +// +// file := val.(*CSVFile) +// +// // 等待所有读写操作完成 +// for atomic.LoadInt32(&file.readers) > 0 || atomic.LoadInt32(&file.writers) > 0 { +// time.Sleep(time.Millisecond) +// } +// +// // 等待异步保存完成 +// for i := 0; i < 100; i++ { // 最多等待100ms +// if atomic.LoadInt32(&file.saving) == 0 { +// break +// } +// time.Sleep(time.Millisecond) +// } +// +// // 如果有正在进行的保存，等待一小段时间 +// if atomic.LoadInt32(&file.saving) > 0 { +// time.Sleep(50 * time.Millisecond) +// } +// +// // 检查是否需要保存 +// file.mu.RLock() +// needSave := file.modified +// file.mu.RUnlock() +// +// if needSave { +// // 同步保存修改 +// if err := file.save(); err != nil { +// setError(err.Error()) +// return -1 +// } +// } +// +// // 从管理器移除 +// mgr.files.Delete(handle) +// +// // 安全关闭通道（如果存在） +// if file.done != nil { +// close(file.done) +// } +// +// return 0 +//} +// +//// 获取错误信息 +//func getError() string { +// mgr := getManager() +// mgr.mu.RLock() +// defer mgr.mu.RUnlock() +// +// if mgr.errorMsg == "" { +// return "" +// } +// +// err := mgr.errorMsg +// mgr.errorMsg = "" // 清空错误 +// +// return err +//} +// +//func parseSimpleTable(goData string) [][]string { +// lines := strings.Split(strings.TrimSpace(goData), "\n") +// result := make([][]string, len(lines)) +// +// for i, line := range lines { +// // 根据你的分隔符分割，这里用逗号举例 +// fields := strings.Split(line, ",") +// // 如果需要去除每个字段的空格 +// for j := range fields { +// fields[j] = strings.TrimSpace(fields[j]) +// } +// result[i] = fields +// } +// +// return result +//} +// +//// ============ C 导出接口 ============ +// +////export InitCSVManager +//func InitCSVManager() C.longlong { +// return C.longlong(initCSVManager()) +//} +// +//// OpenCSVFile 打开/创建CSV文件 +//// +////export OpenCSVFile +//func OpenCSVFile(filename *C.char, delimiter C.char, hasHeader C.int) C.longlong { +// return C.longlong(openCSVFile(C.GoString(filename), rune(delimiter), hasHeader != 0)) +//} +// +//// CSV响应结构体 +//type CSVResponse struct { +// Success bool `json:"success"` +// Message string `json:"message,omitempty"` +// Data interface{} `json:"data,omitempty"` +//} +// +//// UpdateCSVRowSafe 修改csv文件行数据 +//// +////export UpdateCSVRowSafe +//func UpdateCSVRowSafe(handleID C.longlong, rowNum C.int, newRow *C.char) *C.char { +// goHandle := int64(handleID) +// goRowNum := int(rowNum) +// goNewRow := C.GoString(newRow) +// var row []string +// var csvResponse CSVResponse +// // 解析JSON +// err := json.Unmarshal([]byte(goNewRow), &row) +// if err != nil { +// csvResponse = CSVResponse{ +// Success: false, +// Message: fmt.Sprintf("解析JSON失败: %v", err), +// } +// errorJson, _ := json.Marshal(csvResponse) +// return C.CString(string(errorJson)) +// } +// // 修改csv行数据 +// err = updateCSVRowSafe(goHandle, goRowNum, row) +// if err != nil { +// csvResponse = CSVResponse{ +// Success: false, +// Message: fmt.Sprintf(err.Error()), +// } +// errorJson, _ := json.Marshal(csvResponse) +// return C.CString(string(errorJson)) +// } else { +// csvResponse = CSVResponse{ +// Success: true, +// } +// } +// // 转换为JSON字符串 +// jsonData, err := json.Marshal(csvResponse) +// if err != nil { +// // 如果JSON序列化失败，返回错误信息 +// csvResponse = CSVResponse{ +// Success: false, +// Message: fmt.Sprintf("JSON序列化失败: %v", err), +// } +// errorJson, _ := json.Marshal(csvResponse) +// return C.CString(string(errorJson)) +// } +// return C.CString(string(jsonData)) +//} +// +////export CreateOpenCSVFile +//func CreateOpenCSVFile(filename *C.char, delimiter C.char, hasHeader C.int) *C.char { +// goFilename := C.GoString(filename) +// goDelimiter := rune(delimiter) +// var goHasHeader bool +// if int(hasHeader) == 0 { +// goHasHeader = true +// } +// goHasHeader = false +// handle := createOpenCSVFile(goFilename, goDelimiter, goHasHeader) +// var csvResponse CSVResponse +// response := struct { +// HandleID int64 `json:"handleID"` +// }{ +// HandleID: handle, +// } +// csvResponse.Success = true +// csvResponse.Data = response +// jsonData, _ := json.Marshal(csvResponse) +// return C.CString(string(jsonData)) +//} +// +//// ReadRows 读取多行数据 +//// +////export ReadRows +//func ReadRows(handle C.longlong, startRow C.longlong, count C.longlong, buffer *C.char, bufferSize C.int) C.longlong { +// // 将 C 缓冲区转换为 Go 的字节切片 +// goBuffer := unsafe.Slice((*byte)(unsafe.Pointer(buffer)), int(bufferSize)) +// result := readRows(int64(handle), int64(startRow), int64(count), goBuffer) +// return C.longlong(result) +//} +// +//// WriteRows 写入/覆盖行数据 +//// +////export WriteRows +//func WriteRows(handle C.longlong, rowsData *C.char, header C.int) C.int { +// goData := C.GoString(rowsData) +// goHeader := int(header) +// data := parseSimpleTable(goData) +// result := writeRows(int64(handle), data, goHeader) +// return C.int(result) +//} +// +//// AppendRows 追加行数据 +//// +////export AppendRows +//func AppendRows(handle C.longlong, rowsData *C.char, dataSize C.int, rowCount C.longlong) C.int { +// goData := unsafe.Slice((*byte)(unsafe.Pointer(rowsData)), int(dataSize)) +// result := appendRows(int64(handle), goData, int64(rowCount)) +// return C.int(result) +//} +// +//// GetRowCount 获取总行数 +//// +////export GetRowCount +//func GetRowCount(handle C.longlong) C.longlong { +// result := getRowCount(int64(handle)) +// return C.longlong(result) +//} +// +//// FindRows 搜索行 +//// +////export FindRows +//func FindRows(handle C.longlong, searchText *C.char, columnIndex C.longlong, resultBuffer *C.char, bufferSize C.int, maxResults C.longlong) C.longlong { +// goSearchText := C.GoString(searchText) +// goResultBuffer := unsafe.Slice((*byte)(unsafe.Pointer(resultBuffer)), int(bufferSize)) +// result := findRows(int64(handle), goSearchText, int64(columnIndex), goResultBuffer, int64(maxResults)) +// return C.longlong(result) +//} +// +//// MergeCSVFiles 合并多个CSV文件(线程安全) +//// +////export MergeCSVFiles +//func MergeCSVFiles(handlesPtr *C.longlong, handlesCount C.int, outputFilename *C.char, delimiter C.char, hasHeader C.int) C.longlong { +// // 将C数组转换为Go切片 +// goHandles := unsafe.Slice(handlesPtr, int(handlesCount)) +// handles := make([]int64, len(goHandles)) +// for i := 0; i < len(goHandles); i++ { +// handles[i] = int64(goHandles[i]) +// } +// // 调用合并函数 +// result := mergeCSVFiles(handles, C.GoString(outputFilename), rune(delimiter), hasHeader != 0) +// return C.longlong(result) +//} +// +//// CloseCSVFile 关闭文件 +//// +////export CloseCSVFile +//func CloseCSVFile(handle C.longlong) C.int { +// result := closeCSVFile(int64(handle)) +// return C.int(result) +//} +// +//// GetError 获取错误信息 +//// +////export GetError +//func GetError(buffer *C.char, bufferSize C.int) C.int { +// errMsg := getError() +// if errMsg == "" { +// return 0 +// } +// +// // 将错误信息复制到缓冲区 +// goBuffer := unsafe.Slice((*byte)(unsafe.Pointer(buffer)), int(bufferSize)) +// n := copy(goBuffer, errMsg) +// return C.int(n) +//} +// +//// 导出函数：释放C字符串内存 +//// +////export FreeCString +//func FreeCString(str *C.char) { +// C.free(unsafe.Pointer(str)) +//} +// +////// main 函数是必需的，即使为空 +////func main() { +////} diff --git a/csv/taskLog1.csv b/csv/taskLog1.csv new file mode 100644 index 0000000..b8c3b98 --- /dev/null +++ b/csv/taskLog1.csv @@ -0,0 +1,8 @@ +"isbn","价格","库存","日志","三方平台id" +"9787107267505","30.80","1","上传成功","877133619369" +"9787200066883","23.17","1","上传成功","877132920079" +"9787115524539","8.87","","调用过于频繁，请调整调用频率","" +"9787810791373","32.02","","调用过于频繁，请调整调用频率","" +"9787548745600","151.30","","商品价格不在设置的价格区间","" +"9787111546955","8.47","","商品信息中包含违规内容","" +"9787303284382","62.76","1","上传成功","877133371509" diff --git a/csv/test.csv b/csv/test.csv new file mode 100644 index 0000000..4779d9e --- /dev/null +++ b/csv/test.csv @@ -0,0 +1,11 @@ +测试行tou1,测试值tou1,测试数据tou1,覆盖测试tou +测行2,测值2,测数据2,覆盖测试2 +测行3,测值3,测数据3,覆盖测试3 +测行4,测值4,测数据4,覆盖测试4 +测行5,测值5,测数据5,覆盖测试5 +测行6,测值6,测数据6,覆盖测试6 +测行7,测值7,测数据7,覆盖测试7 +测行8,测值8,测数据8,覆盖测试8 +测行9,测值9,测数据9 +测行10,测值10,测数据10,覆盖测试10,覆盖测试10 + diff --git a/csv/test.go b/csv/test.go new file mode 100644 index 0000000..ce351c7 --- /dev/null +++ b/csv/test.go @@ -0,0 +1,54 @@ +package main + +//func main() { +//filename := filepath.Join("csv", "test1.csv") +//handle := openCSVFile(filename, ',', true) +//fmt.Println("handle:", handle) +// +//// 测试1：基础写入 +//fmt.Println("\n=== 测试1：基础写入 ===") +//// 清空并写入新数据 +//newRow := make([][]string, 0) +//newRow = append(newRow, []string{"基础测试行5", "基础值5", "基础数据5", "基础测试5"}) +// +//for i := 1; i <= 10; i++ { +// row := []string{ +// "基础行" + strconv.Itoa(i), +// "基础值" + strconv.Itoa(i), +// "基础数据" + strconv.Itoa(i), +// fmt.Sprintf("基础测试%d", i), +// } +// newRow = append(newRow, row) +//} +// +//start := time.Now() +//rows := writeRows(handle, newRow, 0) +// +//elapsed := time.Since(start) +//fmt.Printf("基础写入完成，影响行数: %d，耗时: %v\n", rows, elapsed) +// +//buffer := make([]byte, 4096) +//rowss := readRows(handle, 0, rows, buffer) +//fmt.Printf("读取到 %d 行数据\n", rowss) +// +//decodedRows := decodeRowData(buffer, 4096) +//fmt.Println("合并文件前几行数据:") +//for i, row := range decodedRows { +// if i >= int(rowss) { +// break +// } +// fmt.Printf(" 行 %d: %v\n", i, row) +//} + +//// 测试3：读写混合 +//fmt.Println("\n=== 测试3：读写混合 ===") +//testMixedOperations(handle) + +//file, err := closeCSVFile(handle) +//if err != nil { +// fmt.Println(err) +//} +//if file == 0 { +// fmt.Println("\n文件保存成功") +//} +//} diff --git a/dll/csv.dll b/dll/csv.dll new file mode 100644 index 0000000..4deb73b Binary files /dev/null and b/dll/csv.dll differ diff --git a/dll/csv.h b/dll/csv.h new file mode 100644 index 0000000..ec41202 --- /dev/null +++ b/dll/csv.h @@ -0,0 +1,134 @@ +/* Code generated by cmd/cgo; DO NOT EDIT. */ + +/* package command-line-arguments */ + + +#line 1 "cgo-builtin-export-prolog" + +#include + +#ifndef GO_CGO_EXPORT_PROLOGUE_H +#define GO_CGO_EXPORT_PROLOGUE_H + +#ifndef GO_CGO_GOSTRING_TYPEDEF +typedef struct { const char *p; ptrdiff_t n; } _GoString_; +extern size_t _GoStringLen(_GoString_ s); +extern const char *_GoStringPtr(_GoString_ s); +#endif + +#endif + +/* Start of preamble from import "C" comments. */ + + +#line 3 "csv.go" + +#include + +#line 1 "cgo-generated-wrapper" + + +/* End of preamble from import "C" comments. */ + + +/* Start of boilerplate cgo prologue. */ +#line 1 "cgo-gcc-export-header-prolog" + +#ifndef GO_CGO_PROLOGUE_H +#define GO_CGO_PROLOGUE_H + +typedef signed char GoInt8; +typedef unsigned char GoUint8; +typedef short GoInt16; +typedef unsigned short GoUint16; +typedef int GoInt32; +typedef unsigned int GoUint32; +typedef long long GoInt64; +typedef unsigned long long GoUint64; +typedef GoInt64 GoInt; +typedef GoUint64 GoUint; +typedef size_t GoUintptr; +typedef float GoFloat32; +typedef double GoFloat64; +#ifdef _MSC_VER +#if !defined(__cplusplus) || _MSVC_LANG <= 201402L +#include +typedef _Fcomplex GoComplex64; +typedef _Dcomplex GoComplex128; +#else +#include +typedef std::complex GoComplex64; +typedef std::complex GoComplex128; +#endif +#else +typedef float _Complex GoComplex64; +typedef double _Complex GoComplex128; +#endif + +/* + static assertion to make sure the file is being used on architecture + at least with matching size of GoInt. +*/ +typedef char _check_for_64_bit_pointer_matching_GoInt[sizeof(void*)==64/8 ? 1:-1]; + +#ifndef GO_CGO_GOSTRING_TYPEDEF +typedef _GoString_ GoString; +#endif +typedef void *GoMap; +typedef void *GoChan; +typedef struct { void *t; void *v; } GoInterface; +typedef struct { void *data; GoInt len; GoInt cap; } GoSlice; + +#endif + +/* End of boilerplate cgo prologue. */ + +#ifdef __cplusplus +extern "C" { +#endif + +extern __declspec(dllexport) long long int InitCSVManager(void); + +// OpenCSVFile 打开/创建CSV文件 +// +extern __declspec(dllexport) long long int OpenCSVFile(char* filename, char delimiter, int hasHeader); + +// ReadRows 读取多行数据 +// +extern __declspec(dllexport) long long int ReadRows(long long int handle, long long int startRow, long long int count, char* buffer, int bufferSize); + +// WriteRows 写入/覆盖行数据 +// +extern __declspec(dllexport) int WriteRows(long long int handle, char* rowsData, int dataSize, long long int rowCount); + +// AppendRows 追加行数据 +// +extern __declspec(dllexport) int AppendRows(long long int handle, char* rowsData, int dataSize, long long int rowCount); + +// GetRowCount 获取总行数 +// +extern __declspec(dllexport) long long int GetRowCount(long long int handle); + +// FindRows 搜索行 +// +extern __declspec(dllexport) long long int FindRows(long long int handle, char* searchText, long long int columnIndex, char* resultBuffer, int bufferSize, long long int maxResults); + +// MergeCSVFiles 合并多个CSV文件（线程安全） +// +extern __declspec(dllexport) long long int MergeCSVFiles(long long int* handlesPtr, int handlesCount, char* outputFilename, char delimiter, int hasHeader); + +// CloseCSVFile 关闭文件 +// +extern __declspec(dllexport) int CloseCSVFile(long long int handle); + +// GetError 获取错误信息 +// +extern __declspec(dllexport) int GetError(char* buffer, int bufferSize); + +// 导出函数：释放C字符串内存 +// +extern __declspec(dllexport) void FreeCString(char* str); + +#ifdef __cplusplus +} +#endif diff --git a/dll/excel.dll b/dll/excel.dll new file mode 100644 index 0000000..3b7a71d Binary files /dev/null and b/dll/excel.dll differ diff --git a/dll/excel.h b/dll/excel.h new file mode 100644 index 0000000..a5ccca5 --- /dev/null +++ b/dll/excel.h @@ -0,0 +1,141 @@ +/* Code generated by cmd/cgo; DO NOT EDIT. */ + +/* package command-line-arguments */ + + +#line 1 "cgo-builtin-export-prolog" + +#include + +#ifndef GO_CGO_EXPORT_PROLOGUE_H +#define GO_CGO_EXPORT_PROLOGUE_H + +#ifndef GO_CGO_GOSTRING_TYPEDEF +typedef struct { const char *p; ptrdiff_t n; } _GoString_; +extern size_t _GoStringLen(_GoString_ s); +extern const char *_GoStringPtr(_GoString_ s); +#endif + +#endif + +/* Start of preamble from import "C" comments. */ + + +#line 3 "main.go" + +#include + +#line 1 "cgo-generated-wrapper" + + +/* End of preamble from import "C" comments. */ + + +/* Start of boilerplate cgo prologue. */ +#line 1 "cgo-gcc-export-header-prolog" + +#ifndef GO_CGO_PROLOGUE_H +#define GO_CGO_PROLOGUE_H + +typedef signed char GoInt8; +typedef unsigned char GoUint8; +typedef short GoInt16; +typedef unsigned short GoUint16; +typedef int GoInt32; +typedef unsigned int GoUint32; +typedef long long GoInt64; +typedef unsigned long long GoUint64; +typedef GoInt64 GoInt; +typedef GoUint64 GoUint; +typedef size_t GoUintptr; +typedef float GoFloat32; +typedef double GoFloat64; +#ifdef _MSC_VER +#if !defined(__cplusplus) || _MSVC_LANG <= 201402L +#include +typedef _Fcomplex GoComplex64; +typedef _Dcomplex GoComplex128; +#else +#include +typedef std::complex GoComplex64; +typedef std::complex GoComplex128; +#endif +#else +typedef float _Complex GoComplex64; +typedef double _Complex GoComplex128; +#endif + +/* + static assertion to make sure the file is being used on architecture + at least with matching size of GoInt. +*/ +typedef char _check_for_64_bit_pointer_matching_GoInt[sizeof(void*)==64/8 ? 1:-1]; + +#ifndef GO_CGO_GOSTRING_TYPEDEF +typedef _GoString_ GoString; +#endif +typedef void *GoMap; +typedef void *GoChan; +typedef struct { void *t; void *v; } GoInterface; +typedef struct { void *data; GoInt len; GoInt cap; } GoSlice; + +#endif + +/* End of boilerplate cgo prologue. */ + +#ifdef __cplusplus +extern "C" { +#endif + + +// 创建新的Excel管理器并返回指针 +// +extern __declspec(dllexport) uintptr_t NewExcelManagerInstance(void); + +// 释放Excel管理器 +// +extern __declspec(dllexport) void FreeExcelManager(uintptr_t handle); + +// 读取Excel数据 +// +extern __declspec(dllexport) int ReadExcelData(uintptr_t handle, char* filename, char* sheet, char** result); + +// 批量写入数据到Excel文件 +// +extern __declspec(dllexport) int WriteBatchData(uintptr_t handle, char* filename, char* sheet, char* cells, char* values, int count); + +// 追加数据到Excel文件末尾 +// +extern __declspec(dllexport) int AppendDataToExcel(uintptr_t handle, char* filename, char* sheet, char* values, int count); + +// 搜索包含关键字的单元格 +// +extern __declspec(dllexport) int SearchByKeyword(uintptr_t handle, char* filename, char* sheet, char* keyword, char** result); + +// 搜索整行包含关键字的行 +// +extern __declspec(dllexport) int SearchRowsByKeyword(uintptr_t handle, char* filename, char* sheet, char* keyword, char** result); + +// 创建新文件并写入数据 +// +extern __declspec(dllexport) int CreateAndWriteExcel(uintptr_t handle, char* filename, char* sheet, char* rowsData); + +// 增强版合并Excel文件（支持指定文件列表） +// +extern __declspec(dllexport) int MergeExcelFilesEx(uintptr_t handle, char* sourceDir, char* specificFiles, char* outputFile, char* sheetName, int mergeByColumn, int includeHeaders, int skipEmptyRows, char* filePattern, char* sourceSheet, int addSourceColumn, int addIndexColumn); + +// 并行合并Excel文件（增强版） +// +extern __declspec(dllexport) int MergeExcelFilesParallelEx(uintptr_t handle, char* sourceDir, char** specificFiles, int fileCount, char* outputFile, char* sheetName, int includeHeaders, int skipEmptyRows, char* filePattern, char* sourceSheet, int addSourceColumn, int addIndexColumn, int workers); + +// 合并同一文件中的多个sheet +// +extern __declspec(dllexport) int MergeSheetsInFile(uintptr_t handle, char* filename, char* outputFile, char* targetSheetName); + +// 释放C字符串 +// +extern __declspec(dllexport) void FreeCString(char* str); + +#ifdef __cplusplus +} +#endif diff --git a/dll/kongfz.dll b/dll/kongfz.dll index 68fea3d..ae9f169 100644 Binary files a/dll/kongfz.dll and b/dll/kongfz.dll differ diff --git a/dll/kongfz.h b/dll/kongfz.h index 7a6bc6a..2d5deb1 100644 --- a/dll/kongfz.h +++ b/dll/kongfz.h @@ -106,7 +106,7 @@ extern __declspec(dllexport) char* OutGetGoodsTplMsg(char* token, char* itemId, // 获取商品列表-已登的店铺(带有Out的都非官方标准接口) // -extern __declspec(dllexport) char* OutGetGoodsListMsgFromSelfShop(char* token, char* proxy, char* itemSn, char* priceMin, char* priceMax, int startCreateTime, int endCreateTime, char* requestType, int isItemSnEqual, int page, int size); +extern __declspec(dllexport) char* OutGetGoodsListMsgFromSelfShop(char* token, char* proxy, char* itemSn, char* priceMin, char* priceMax, char* startCreateTime, char* endCreateTime, char* requestType, int isItemSnEqual, int page, int size); // 删除商品-已登的店铺(带有Out的都非官方标准接口) // diff --git a/dll/proxy.dll b/dll/proxy.dll index 3afeee7..c8e9413 100644 Binary files a/dll/proxy.dll and b/dll/proxy.dll differ diff --git a/dll/proxy.h b/dll/proxy.h index 171e8ae..dc81637 100644 --- a/dll/proxy.h +++ b/dll/proxy.h @@ -21,7 +21,7 @@ extern const char *_GoStringPtr(_GoString_ s); /* Start of preamble from import "C" comments. */ -#line 3 "proxyConfig.go" +#line 3 "proxy.go" #include #line 1 "cgo-generated-wrapper" @@ -95,6 +95,26 @@ extern __declspec(dllexport) char* GetProxyHealth(void); // extern __declspec(dllexport) char* ProxyTypeManager(char* proxyType, char* username, char* password, char* machineCode); +// 导出函数：查询机器码 +// +extern __declspec(dllexport) char* GetMachineCode(char* tailCardSecret); + +// 导出函数：充值卡密 +// +extern __declspec(dllexport) char* RechargeCard(char* tailCardSecret, char* machineCode); + +// 导出函数：获取代理服务器列表 +// +extern __declspec(dllexport) char* GetProxies(char* machineCode); + +// 导出函数：检查卡密是否过期 +// +extern __declspec(dllexport) char* CheckTailCardSecretExpired(char* tailCardSecret); + +// 导出函数：初始化代理管理器 +// +extern __declspec(dllexport) char* InitProxyManager(char* serversJson, char* username, char* password, char* tailCardSecret, char* proxyType); + // 导出函数：释放C字符串内存 // extern __declspec(dllexport) void FreeCString(char* str); diff --git a/dyso.go b/dyso.go index 902f93f..2dc5f36 100644 --- a/dyso.go +++ b/dyso.go @@ -1,496 +1,503 @@ package main -/* -#cgo linux LDFLAGS: -ldl -#cgo windows LDFLAGS: -lkernel32 - -#include - -#ifdef _WIN32 -#include -static void* dlopen(const char* filename, int flags) { - return (void*)LoadLibraryA(filename); -} -static void dlclose(void* handle) { - FreeLibrary((HMODULE)handle); -} -static void* dlsym(void* handle, const char* name) { - return (void*)GetProcAddress((HMODULE)handle, name); -} -static const char* dlerror() { - static char buf[256]; - FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, - NULL, GetLastError(), 0, buf, sizeof(buf), NULL); - return buf; -} -#define RTLD_LAZY 0 -#else -#include -#endif -*/ -import "C" -import ( - "encoding/json" - "fmt" - "log" - "net/http" - "os" - "path/filepath" - "runtime" - "unsafe" -) - -// 配置结构 -type Configs struct { - App struct { - MaxRetryTimes int `json:"max_retry_times"` - RateLimitDelay int `json:"rate_limit_delay"` - Size int `json:"size"` - DefaultUserAgent string `json:"default_user_agent"` - } `json:"app"` - - API struct { - LoginURL string `json:"login_url"` - BookSearchURL string `json:"book_search_url"` - ProductSearchURL string `json:"product_search_url"` - } `json:"api"` - - Proxy struct { - Servers string `json:"servers"` - Username string `json:"username"` - Password string `json:"password"` - TailMachineCode string `json:"tail_machine_code"` - TailCardKey string `json:"tail_card_key"` - ProxyFilePath string `json:"proxy_file_path"` - } `json:"proxy"` -} - -// API响应结构 -type APIResponseSO struct { - Success bool `json:"success"` - Message string `json:"message,omitempty"` - GoodsNum string `json:"goods_num,omitempty"` - PNum string `json:"pnum,omitempty"` - Data interface{} `json:"data,omitempty"` - Error string `json:"error,omitempty"` -} - -// APIResp 简化的响应结构体 -type APIRespSO struct { - Success bool `json:"success"` - Message string `json:"message"` - Data interface{} `json:"data,omitempty"` -} - -type SOManager struct { - handle unsafe.Pointer -} - -func NewSOManager(soPath string) (*SOManager, error) { - // 根据平台调整库文件扩展名 - if runtime.GOOS == "windows" { - soPath = changeExtensionToDLL(soPath) - } - // 使用 dlopen 加载 .so 文件 - cSoPath := C.CString(soPath) - defer C.free(unsafe.Pointer(cSoPath)) - - handle := C.dlopen(cSoPath, C.RTLD_LAZY) - if handle == nil { - return nil, fmt.Errorf("加载SO文件失败: %s", C.GoString(C.dlerror())) - } - - return &SOManager{handle: handle}, nil -} - -func (m *SOManager) Close() { - if m.handle != nil { - C.dlclose(m.handle) - } -} - -func changeExtensionToDLL(path string) string { - ext := filepath.Ext(path) - if ext == ".so" { - return path[:len(path)-len(ext)] + ".dll" - } - return path -} - -// 获取函数指针 -func (m *SOManager) getFunction(funcName string) (unsafe.Pointer, error) { - cFuncName := C.CString(funcName) - defer C.free(unsafe.Pointer(cFuncName)) - - symbol := C.dlsym(m.handle, cFuncName) - if symbol == nil { - return nil, fmt.Errorf("找不到函数 %s: %s", funcName, C.GoString(C.dlerror())) - } - return symbol, nil -} - -// 初始化 -func (m *SOManager) Initialize(configJSON string) (string, error) { - function, err := m.getFunction("Initialize") - if err != nil { - return "", err - } - funcPtr := (*func(*C.char) *C.char)(unsafe.Pointer(&function)) - configJSONC := C.CString(configJSON) - defer C.free(unsafe.Pointer(configJSONC)) - result := (*funcPtr)(configJSONC) - defer C.free(unsafe.Pointer(result)) - return C.GoString(result), nil -} - -// 登录 -func (m *SOManager) OutLogin(username, password string) (string, error) { - function, err := m.getFunction("OutLogin") - if err != nil { - return "", err - } - funcPtr := (*func(*C.char, *C.char) *C.char)(unsafe.Pointer(&function)) - usernameC := C.CString(username) - passwordC := C.CString(password) - defer C.free(unsafe.Pointer(usernameC)) - defer C.free(unsafe.Pointer(passwordC)) - result := (*funcPtr)(usernameC, passwordC) - defer C.free(unsafe.Pointer(result)) - return C.GoString(result), nil -} - -// 获取用户信息 -func (m *SOManager) OutGetUserMsg(token string) (string, error) { - function, err := m.getFunction("OutGetUserMsg") - if err != nil { - return "", err - } - funcPtr := (*func(*C.char) *C.char)(unsafe.Pointer(&function)) - tokenC := C.CString(token) - defer C.free(unsafe.Pointer(tokenC)) - result := (*funcPtr)(tokenC) - defer C.free(unsafe.Pointer(result)) - return C.GoString(result), nil -} - -// 获取商品模版 -func (m *SOManager) OutGetGoodsTplMsg(token, itemId, proxy string) (string, error) { - function, err := m.getFunction("OutGetGoodsTplMsg") - if err != nil { - return "", err - } - funcPtr := (*func(*C.char, *C.char, *C.char) *C.char)(unsafe.Pointer(&function)) - tokenC := C.CString(token) - itemIdC := C.CString(itemId) - proxyC := C.CString(proxy) - defer C.free(unsafe.Pointer(tokenC)) - defer C.free(unsafe.Pointer(itemIdC)) - defer C.free(unsafe.Pointer(proxyC)) - result := (*funcPtr)(tokenC, itemIdC, proxyC) - defer C.free(unsafe.Pointer(result)) - return C.GoString(result), nil -} - -// 获取商品列表-已登的店铺 -func (m *SOManager) OutGetGoodsListMsgFromSelfShop(token string, proxy string, - itemSn string, priceMin string, priceMax string, startCreateTime int, - endCreateTime int, requestType string, isItemSnEqual int, page int, size int) (string, error) { - function, err := m.getFunction("OutGetGoodsListMsgFromSelfShop") - if err != nil { - return "", err - } - funcPtr := (*func(*C.char, *C.char, *C.char, *C.char, *C.char, C.int, C.int, *C.char, C.int, C.int, C.int) *C.char)(unsafe.Pointer(&function)) - tokenC := C.CString(token) - proxyC := C.CString(proxy) - itemSnC := C.CString(itemSn) - priceMinC := C.CString(priceMin) - priceMaxC := C.CString(priceMax) - startCreateTimeC := C.int(startCreateTime) - endCreateTimeC := C.int(endCreateTime) - requestTypeC := C.CString(requestType) - isItemSnEqualC := C.int(isItemSnEqual) - pageC := C.int(page) - sizeC := C.int(size) - defer C.free(unsafe.Pointer(tokenC)) - defer C.free(unsafe.Pointer(proxyC)) - defer C.free(unsafe.Pointer(itemSnC)) - defer C.free(unsafe.Pointer(priceMinC)) - defer C.free(unsafe.Pointer(priceMaxC)) - defer C.free(unsafe.Pointer(requestTypeC)) - result := (*funcPtr)(tokenC, proxyC, itemSnC, priceMinC, priceMaxC, startCreateTimeC, - endCreateTimeC, requestTypeC, isItemSnEqualC, pageC, sizeC) - defer C.free(unsafe.Pointer(result)) - return C.GoString(result), nil -} - -// 删除商品-已登的店铺 -func (m *SOManager) OutDelGoodsFromSelfShop(token, itemId, proxy string) (string, error) { - function, err := m.getFunction("OutDelGoodsFromSelfShop") - if err != nil { - return "", err - } - funcPtr := (*func(*C.char, *C.char, *C.char) *C.char)(unsafe.Pointer(&function)) - tokenC := C.CString(token) - itemIdC := C.CString(itemId) - proxyC := C.CString(proxy) - defer C.free(unsafe.Pointer(tokenC)) - defer C.free(unsafe.Pointer(itemIdC)) - defer C.free(unsafe.Pointer(proxyC)) - result := (*funcPtr)(tokenC, itemIdC, proxyC) - defer C.free(unsafe.Pointer(result)) - return C.GoString(result), nil -} - -// 新增商品 -func (m *SOManager) OutAddGoods(token, proxy, formData string) (string, error) { - function, err := m.getFunction("OutAddGoods") - if err != nil { - return "", err - } - funcPtr := (*func(*C.char, *C.char, *C.char) *C.char)(unsafe.Pointer(&function)) - tokenC := C.CString(token) - proxyC := C.CString(proxy) - formDataC := C.CString(formData) - defer C.free(unsafe.Pointer(tokenC)) - defer C.free(unsafe.Pointer(proxyC)) - defer C.free(unsafe.Pointer(formDataC)) - result := (*funcPtr)(tokenC, proxyC, formDataC) - defer C.free(unsafe.Pointer(result)) - return C.GoString(result), nil -} - -// 获取图片URL(官图和拍图)带有店铺过滤 -func (m *SOManager) OutGetImageFilterShopId(token string, isbn string, shopId int, proxy string, isLiveImage int, isReturnMsg int) (string, error) { - function, err := m.getFunction("OutGetImageFilterShopId") - if err != nil { - return "", err - } - funcPtr := (*func(*C.char, *C.char, C.int, *C.char, C.int, C.int) *C.char)(unsafe.Pointer(&function)) - tokenC := C.CString(token) - isbnC := C.CString(isbn) - shopIdC := C.int(shopId) - proxyC := C.CString(proxy) - isLiveImageC := C.int(isLiveImage) - isReturnMsgC := C.int(isReturnMsg) - defer C.free(unsafe.Pointer(tokenC)) - defer C.free(unsafe.Pointer(isbnC)) - defer C.free(unsafe.Pointer(proxyC)) - result := (*funcPtr)(tokenC, isbnC, shopIdC, proxyC, isLiveImageC, isReturnMsgC) - defer C.free(unsafe.Pointer(result)) - return C.GoString(result), nil -} - -// 获取商品图片 -func (m *SOManager) OutGetImageByIsbn(token string, isbn string, proxy string, isLiveImage int, isReturnMsg int) (string, error) { - function, err := m.getFunction("OutGetImageByIsbn") - if err != nil { - return "", err - } - funcPtr := (*func(*C.char, *C.char, *C.char, C.int, C.int) *C.char)(unsafe.Pointer(&function)) - tokenC := C.CString(token) - isbnC := C.CString(isbn) - proxyC := C.CString(proxy) - isLiveImageC := C.int(isLiveImage) - isReturnMsgC := C.int(isReturnMsg) - defer C.free(unsafe.Pointer(tokenC)) - defer C.free(unsafe.Pointer(isbnC)) - defer C.free(unsafe.Pointer(proxyC)) - result := (*funcPtr)(tokenC, isbnC, proxyC, isLiveImageC, isReturnMsgC) - defer C.free(unsafe.Pointer(result)) - return C.GoString(result), nil -} - -// 获取商品列表通过店铺ID -func (m *SOManager) OutGetGoodsListMsgByShopId(shopId int, proxy string, retPrice int, isImage int, sortType string, - sort string, priceMin float32, priceMax float32, pageNum, returnNum int) (string, error) { - function, err := m.getFunction("OutGetGoodsListMsgByShopId") - if err != nil { - return "", err - } - funcPtr := (*func(C.int, *C.char, C.int, C.int, *C.char, *C.char, C.double, C.double, C.int, C.int) *C.char)(unsafe.Pointer(&function)) - shopIdC := C.int(shopId) - proxyC := C.CString(proxy) - retPriceC := C.int(retPrice) - isImageC := C.int(isImage) - sortTypeC := C.CString(sortType) - sortC := C.CString(sort) - priceMinC := C.double(priceMin) - priceMaxC := C.double(priceMax) - pageNumC := C.int(pageNum) - returnNumC := C.int(returnNum) - defer C.free(unsafe.Pointer(proxyC)) - defer C.free(unsafe.Pointer(sortTypeC)) - defer C.free(unsafe.Pointer(sortC)) - result := (*funcPtr)(shopIdC, proxyC, retPriceC, isImageC, sortTypeC, sortC, priceMinC, priceMaxC, pageNumC, returnNumC) - defer C.free(unsafe.Pointer(result)) - return C.GoString(result), nil -} - -// 获取商品信息通过商品详情链接 -func (m *SOManager) OutGetGoodsMsgByDetailUrl(detailUrl, proxy string) (string, error) { - function, err := m.getFunction("OutGetGoodsMsgByDetailUrl") - if err != nil { - return "", err - } - funcPtr := (*func(*C.char, *C.char) *C.char)(unsafe.Pointer(&function)) - detailUrlC := C.CString(detailUrl) - proxyC := C.CString(proxy) - defer C.free(unsafe.Pointer(detailUrlC)) - defer C.free(unsafe.Pointer(proxyC)) - result := (*funcPtr)(detailUrlC, proxyC) - defer C.free(unsafe.Pointer(result)) - return C.GoString(result), nil -} - -// 获取销量榜商品列表 -func (m *SOManager) OutGetTopGoodsListMsg(catId int, proxy string) (string, error) { - function, err := m.getFunction("OutGetTopGoodsListMsg") - if err != nil { - return "", err - } - funcPtr := (*func(C.int, *C.char) *C.char)(unsafe.Pointer(&function)) - catIdC := C.int(catId) - proxyC := C.CString(proxy) - defer C.free(unsafe.Pointer(proxyC)) - result := (*funcPtr)(catIdC, proxyC) - defer C.free(unsafe.Pointer(result)) - return C.GoString(result), nil -} - -// 创建默认配置 -func createDefaultConfig() Configs { - var configs Configs - // App配置 - configs.App.MaxRetryTimes = 3 - configs.App.RateLimitDelay = 1000 - configs.App.Size = 10 - configs.App.DefaultUserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36" - // API配置 - configs.API.LoginURL = "https://login.kongfz.com/Pc/Login/account" - configs.API.BookSearchURL = "https://search.kongfz.com/pc-gw/search-web/client/pc/bookLib/keyword/list" - configs.API.ProductSearchURL = "https://search.kongfz.com/pc-gw/search-web/client/pc/product/keyword/list" - // 代理配置 - configs.Proxy.Servers = "http-dynamic.xiaoxiangdaili.com,http-dynamic-S02.xiaoxiangdaili.com,http-dynamic-S03.xiaoxiangdaili.com,http-dynamic-S04.xiaoxiangdaili.com" - configs.Proxy.Username = "1297757178467602432" - configs.Proxy.Password = "QgQBvP7f" - configs.Proxy.TailMachineCode = "b7bf22a237ec692f13fcc2c43ee63252" - configs.Proxy.TailCardKey = "DL_20_YK_1920acb2129844c2aabade3896560a9b" - configs.Proxy.ProxyFilePath = "so/proxyConfig.so" - return configs -} - -// 获取当前可执行文件所在目录 -func getExecutableDir() string { - exePath, err := os.Executable() - if err != nil { - return "." - } - return filepath.Dir(exePath) -} - -func main() { - http.HandleFunc("/api/kfzShopBookInfo", handleGetKFZShopBookInfo) - - port := "8080" - log.Printf("🚀 服务器启动在端口 %s", port) - if err := http.ListenAndServe(":"+port, nil); err != nil { - log.Fatalf("服务器启动失败: %v", err) - } -} - -func handleGetKFZShopBookInfo(w http.ResponseWriter, r *http.Request) { - // 设置响应头 - w.Header().Set("Content-Type", "application/json; charset=utf-8") - - // 只支持GET请求 - if r.Method != http.MethodGet { - sendErrorResponse(w, http.StatusMethodNotAllowed, "只支持GET方法") - return - } - - // 加载SO - manager, err := NewSOManager("so/kongfz.so") - if err != nil { - log.Printf("初始化SO管理器失败: %v", err) - sendErrorResponse(w, http.StatusInternalServerError, "初始化SO管理器失败") - return - } - defer manager.Close() - log.Println("✅ SO加载成功") - // 使用默认配置初始化 - config := createDefaultConfig() - configJSON, err := json.Marshal(config) - if err != nil { - log.Printf("序列化配置失败: %v", err) - sendErrorResponse(w, http.StatusInternalServerError, "序列化配置失败") - return - } - result, err := manager.Initialize(string(configJSON)) - if err != nil { - log.Printf("初始化失败: %v", err) - sendErrorResponse(w, http.StatusInternalServerError, "初始化失败") - return - } - var initResp APIResponseSO - if err := json.Unmarshal([]byte(result), &initResp); err != nil { - log.Printf("解析初始化响应失败: %v", err) - sendErrorResponse(w, http.StatusInternalServerError, "解析初始化响应失败") - return - } - if !initResp.Success { - log.Printf("初始化失败: %s", initResp.Message) - sendErrorResponse(w, http.StatusInternalServerError, "初始化失败: "+initResp.Message) - return - } - log.Println("✅ SO初始化成功") - - // 登录示例 - user, err := manager.OutLogin("18904056801", "Long6166@@") - if err != nil { - log.Printf("登录失败: %v", err) - } else { - log.Printf("登录结果: %s", user) - } - - // 解析token - var data APIResponseSO - if err := json.Unmarshal([]byte(user), &data); err != nil { - log.Printf("解析登录响应失败: %v", err) - } else { - var token string - if dataMap, ok := data.Data.(map[string]interface{}); ok { - if tk, exists := dataMap["token"]; exists { - token = tk.(string) - log.Printf("获取到Token: %s", token) - - // 使用token获取用户信息 - msg, err := manager.OutGetUserMsg(token) - if err != nil { - log.Printf("获取用户信息失败: %v", err) - } else { - log.Printf("用户信息: %s", msg) - } - } else { - log.Println("Token 不存在") - } - } else { - log.Println("Data 格式不正确") - } - } - // 返回成功响应 - response := APIRespSO{ - Success: true, - Message: "SO调用成功", - } - json.NewEncoder(w).Encode(response) -} - -// 发送错误响应 -func sendErrorResponse(w http.ResponseWriter, statusCode int, message string) { - response := APIRespSO{ - Success: false, - Message: message, - } - w.WriteHeader(statusCode) - json.NewEncoder(w).Encode(response) -} +///* +//#cgo linux LDFLAGS: -ldl +//#cgo windows LDFLAGS: -lkernel32 +// +//#include +// +//#ifdef _WIN32 +//#include +//static void* dlopen(const char* filename, int flags) { +// return (void*)LoadLibraryA(filename); +//} +//static void dlclose(void* handle) { +// FreeLibrary((HMODULE)handle); +//} +//static void* dlsym(void* handle, const char* name) { +// return (void*)GetProcAddress((HMODULE)handle, name); +//} +//static const char* dlerror() { +// static char buf[256]; +// FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, +// NULL, GetLastError(), 0, buf, sizeof(buf), NULL); +// return buf; +//} +//#define RTLD_LAZY 0 +//#else +//#include +//#endif +//*/ +//import "C" +//import ( +// "encoding/json" +// "fmt" +// "log" +// "net/http" +// "os" +// "path/filepath" +// "runtime" +// "unsafe" +//) +// +//// 配置结构 +//type Configs struct { +// App struct { +// MaxRetryTimes int `json:"max_retry_times"` +// RateLimitDelay int `json:"rate_limit_delay"` +// Size int `json:"size"` +// DefaultUserAgent string `json:"default_user_agent"` +// } `json:"app"` +// +// API struct { +// LoginURL string `json:"login_url"` +// BookSearchURL string `json:"book_search_url"` +// ProductSearchURL string `json:"product_search_url"` +// } `json:"api"` +// +// Proxy struct { +// Servers string `json:"servers"` +// Username string `json:"username"` +// Password string `json:"password"` +// TailMachineCode string `json:"tail_machine_code"` +// TailCardKey string `json:"tail_card_key"` +// ProxyFilePath string `json:"proxy_file_path"` +// } `json:"proxy"` +//} +// +//// API响应结构 +//type APIResponseSO struct { +// Success bool `json:"success"` +// Message string `json:"message,omitempty"` +// GoodsNum string `json:"goods_num,omitempty"` +// PNum string `json:"pnum,omitempty"` +// Data interface{} `json:"data,omitempty"` +// Error string `json:"error,omitempty"` +//} +// +//// APIResp 简化的响应结构体 +//type APIRespSO struct { +// Success bool `json:"success"` +// Message string `json:"message"` +// Data interface{} `json:"data,omitempty"` +//} +// +//type SOManager struct { +// handle unsafe.Pointer +//} +// +//func NewSOManager(soPath string) (*SOManager, error) { +// // 根据平台调整库文件扩展名 +// if runtime.GOOS == "windows" { +// soPath = changeExtensionToDLL(soPath) +// } +// // 使用 dlopen 加载 .so 文件 +// cSoPath := C.CString(soPath) +// defer C.free(unsafe.Pointer(cSoPath)) +// +// handle := C.dlopen(cSoPath, C.RTLD_LAZY) +// if handle == nil { +// return nil, fmt.Errorf("加载SO文件失败: %s", C.GoString(C.dlerror())) +// } +// +// return &SOManager{handle: handle}, nil +//} +// +//func (m *SOManager) Close() { +// if m.handle != nil { +// C.dlclose(m.handle) +// } +//} +// +//func changeExtensionToDLL(path string) string { +// ext := filepath.Ext(path) +// if ext == ".so" { +// return path[:len(path)-len(ext)] + ".dll" +// } +// return path +//} +// +//// 获取函数指针 +//func (m *SOManager) getFunction(funcName string) (unsafe.Pointer, error) { +// cFuncName := C.CString(funcName) +// defer C.free(unsafe.Pointer(cFuncName)) +// +// symbol := C.dlsym(m.handle, cFuncName) +// if symbol == nil { +// return nil, fmt.Errorf("找不到函数 %s: %s", funcName, C.GoString(C.dlerror())) +// } +// return symbol, nil +//} +// +//// 初始化 +//func (m *SOManager) Initialize(configJSON string) (string, error) { +// function, err := m.getFunction("Initialize") +// if err != nil { +// return "", err +// } +// funcPtr := (*func(*C.char) *C.char)(unsafe.Pointer(&function)) +// configJSONC := C.CString(configJSON) +// defer C.free(unsafe.Pointer(configJSONC)) +// result := (*funcPtr)(configJSONC) +// defer C.free(unsafe.Pointer(result)) +// return C.GoString(result), nil +//} +// +//// 登录 +//func (m *SOManager) OutLogin(username, password string) (string, error) { +// function, err := m.getFunction("OutLogin") +// if err != nil { +// return "", err +// } +// funcPtr := (*func(*C.char, *C.char) *C.char)(unsafe.Pointer(&function)) +// usernameC := C.CString(username) +// passwordC := C.CString(password) +// defer C.free(unsafe.Pointer(usernameC)) +// defer C.free(unsafe.Pointer(passwordC)) +// result := (*funcPtr)(usernameC, passwordC) +// defer C.free(unsafe.Pointer(result)) +// return C.GoString(result), nil +//} +// +//// 获取用户信息 +//func (m *SOManager) OutGetUserMsg(token string) (string, error) { +// function, err := m.getFunction("OutGetUserMsg") +// if err != nil { +// return "", err +// } +// funcPtr := (*func(*C.char) *C.char)(unsafe.Pointer(&function)) +// tokenC := C.CString(token) +// defer C.free(unsafe.Pointer(tokenC)) +// result := (*funcPtr)(tokenC) +// defer C.free(unsafe.Pointer(result)) +// return C.GoString(result), nil +//} +// +//// 获取商品模版 +//func (m *SOManager) OutGetGoodsTplMsg(token, itemId, proxy string) (string, error) { +// function, err := m.getFunction("OutGetGoodsTplMsg") +// if err != nil { +// return "", err +// } +// funcPtr := (*func(*C.char, *C.char, *C.char) *C.char)(unsafe.Pointer(&function)) +// tokenC := C.CString(token) +// itemIdC := C.CString(itemId) +// proxyC := C.CString(proxy) +// defer C.free(unsafe.Pointer(tokenC)) +// defer C.free(unsafe.Pointer(itemIdC)) +// defer C.free(unsafe.Pointer(proxyC)) +// result := (*funcPtr)(tokenC, itemIdC, proxyC) +// defer C.free(unsafe.Pointer(result)) +// return C.GoString(result), nil +//} +// +//// 获取商品列表-已登的店铺 +//func (m *SOManager) OutGetGoodsListMsgFromSelfShop(token string, proxy string, +// itemSn string, priceMin string, priceMax string, startCreateTime int, +// endCreateTime int, requestType string, isItemSnEqual int, page int, size int) (string, error) { +// function, err := m.getFunction("OutGetGoodsListMsgFromSelfShop") +// if err != nil { +// return "", err +// } +// funcPtr := (*func(*C.char, *C.char, *C.char, *C.char, *C.char, C.int, C.int, *C.char, C.int, C.int, C.int) *C.char)(unsafe.Pointer(&function)) +// tokenC := C.CString(token) +// proxyC := C.CString(proxy) +// itemSnC := C.CString(itemSn) +// priceMinC := C.CString(priceMin) +// priceMaxC := C.CString(priceMax) +// startCreateTimeC := C.int(startCreateTime) +// endCreateTimeC := C.int(endCreateTime) +// requestTypeC := C.CString(requestType) +// isItemSnEqualC := C.int(isItemSnEqual) +// pageC := C.int(page) +// sizeC := C.int(size) +// defer C.free(unsafe.Pointer(tokenC)) +// defer C.free(unsafe.Pointer(proxyC)) +// defer C.free(unsafe.Pointer(itemSnC)) +// defer C.free(unsafe.Pointer(priceMinC)) +// defer C.free(unsafe.Pointer(priceMaxC)) +// defer C.free(unsafe.Pointer(requestTypeC)) +// result := (*funcPtr)(tokenC, proxyC, itemSnC, priceMinC, priceMaxC, startCreateTimeC, +// endCreateTimeC, requestTypeC, isItemSnEqualC, pageC, sizeC) +// defer C.free(unsafe.Pointer(result)) +// return C.GoString(result), nil +//} +// +//// 删除商品-已登的店铺 +//func (m *SOManager) OutDelGoodsFromSelfShop(token, itemId, proxy string) (string, error) { +// function, err := m.getFunction("OutDelGoodsFromSelfShop") +// if err != nil { +// return "", err +// } +// funcPtr := (*func(*C.char, *C.char, *C.char) *C.char)(unsafe.Pointer(&function)) +// tokenC := C.CString(token) +// itemIdC := C.CString(itemId) +// proxyC := C.CString(proxy) +// defer C.free(unsafe.Pointer(tokenC)) +// defer C.free(unsafe.Pointer(itemIdC)) +// defer C.free(unsafe.Pointer(proxyC)) +// result := (*funcPtr)(tokenC, itemIdC, proxyC) +// defer C.free(unsafe.Pointer(result)) +// return C.GoString(result), nil +//} +// +//// 新增商品 +//func (m *SOManager) OutAddGoods(token, proxy, formData string) (string, error) { +// function, err := m.getFunction("OutAddGoods") +// if err != nil { +// return "", err +// } +// funcPtr := (*func(*C.char, *C.char, *C.char) *C.char)(unsafe.Pointer(&function)) +// tokenC := C.CString(token) +// proxyC := C.CString(proxy) +// formDataC := C.CString(formData) +// defer C.free(unsafe.Pointer(tokenC)) +// defer C.free(unsafe.Pointer(proxyC)) +// defer C.free(unsafe.Pointer(formDataC)) +// result := (*funcPtr)(tokenC, proxyC, formDataC) +// defer C.free(unsafe.Pointer(result)) +// return C.GoString(result), nil +//} +// +//// 获取图片URL(官图和拍图)带有店铺过滤 +//func (m *SOManager) OutGetImageFilterShopId(token string, isbn string, shopId int, proxy string, isLiveImage int, isReturnMsg int) (string, error) { +// function, err := m.getFunction("OutGetImageFilterShopId") +// if err != nil { +// return "", err +// } +// funcPtr := (*func(*C.char, *C.char, C.int, *C.char, C.int, C.int) *C.char)(unsafe.Pointer(&function)) +// tokenC := C.CString(token) +// isbnC := C.CString(isbn) +// shopIdC := C.int(shopId) +// proxyC := C.CString(proxy) +// isLiveImageC := C.int(isLiveImage) +// isReturnMsgC := C.int(isReturnMsg) +// defer C.free(unsafe.Pointer(tokenC)) +// defer C.free(unsafe.Pointer(isbnC)) +// defer C.free(unsafe.Pointer(proxyC)) +// result := (*funcPtr)(tokenC, isbnC, shopIdC, proxyC, isLiveImageC, isReturnMsgC) +// defer C.free(unsafe.Pointer(result)) +// return C.GoString(result), nil +//} +// +//// 获取商品图片 +//func (m *SOManager) OutGetImageByIsbn(token string, isbn string, proxy string, isLiveImage int, isReturnMsg int) (string, error) { +// function, err := m.getFunction("OutGetImageByIsbn") +// if err != nil { +// return "", err +// } +// funcPtr := (*func(*C.char, *C.char, *C.char, C.int, C.int) *C.char)(unsafe.Pointer(&function)) +// tokenC := C.CString(token) +// isbnC := C.CString(isbn) +// proxyC := C.CString(proxy) +// isLiveImageC := C.int(isLiveImage) +// isReturnMsgC := C.int(isReturnMsg) +// defer C.free(unsafe.Pointer(tokenC)) +// defer C.free(unsafe.Pointer(isbnC)) +// defer C.free(unsafe.Pointer(proxyC)) +// result := (*funcPtr)(tokenC, isbnC, proxyC, isLiveImageC, isReturnMsgC) +// defer C.free(unsafe.Pointer(result)) +// return C.GoString(result), nil +//} +// +//// 获取商品列表通过店铺ID +//func (m *SOManager) OutGetGoodsListMsgByShopId(shopId int, proxy string, retPrice int, isImage int, sortType string, +// sort string, priceMin float32, priceMax float32, pageNum, returnNum int) (string, error) { +// function, err := m.getFunction("OutGetGoodsListMsgByShopId") +// if err != nil { +// return "", err +// } +// funcPtr := (*func(C.int, *C.char, C.int, C.int, *C.char, *C.char, C.double, C.double, C.int, C.int) *C.char)(unsafe.Pointer(&function)) +// shopIdC := C.int(shopId) +// proxyC := C.CString(proxy) +// retPriceC := C.int(retPrice) +// isImageC := C.int(isImage) +// sortTypeC := C.CString(sortType) +// sortC := C.CString(sort) +// priceMinC := C.double(priceMin) +// priceMaxC := C.double(priceMax) +// pageNumC := C.int(pageNum) +// returnNumC := C.int(returnNum) +// defer C.free(unsafe.Pointer(proxyC)) +// defer C.free(unsafe.Pointer(sortTypeC)) +// defer C.free(unsafe.Pointer(sortC)) +// result := (*funcPtr)(shopIdC, proxyC, retPriceC, isImageC, sortTypeC, sortC, priceMinC, priceMaxC, pageNumC, returnNumC) +// defer C.free(unsafe.Pointer(result)) +// return C.GoString(result), nil +//} +// +//// 获取商品信息通过商品详情链接 +//func (m *SOManager) OutGetGoodsMsgByDetailUrl(detailUrl, proxy string) (string, error) { +// function, err := m.getFunction("OutGetGoodsMsgByDetailUrl") +// if err != nil { +// return "", err +// } +// funcPtr := (*func(*C.char, *C.char) *C.char)(unsafe.Pointer(&function)) +// detailUrlC := C.CString(detailUrl) +// proxyC := C.CString(proxy) +// defer C.free(unsafe.Pointer(detailUrlC)) +// defer C.free(unsafe.Pointer(proxyC)) +// result := (*funcPtr)(detailUrlC, proxyC) +// defer C.free(unsafe.Pointer(result)) +// return C.GoString(result), nil +//} +// +//// 获取销量榜商品列表 +//func (m *SOManager) OutGetTopGoodsListMsg(catId int, proxy string) (string, error) { +// function, err := m.getFunction("OutGetTopGoodsListMsg") +// if err != nil { +// return "", err +// } +// funcPtr := (*func(C.int, *C.char) *C.char)(unsafe.Pointer(&function)) +// catIdC := C.int(catId) +// proxyC := C.CString(proxy) +// defer C.free(unsafe.Pointer(proxyC)) +// result := (*funcPtr)(catIdC, proxyC) +// defer C.free(unsafe.Pointer(result)) +// return C.GoString(result), nil +//} +// +//// 创建默认配置 +//func createDefaultConfig() Configs { +// var configs Configs +// // App配置 +// configs.App.MaxRetryTimes = 3 +// configs.App.RateLimitDelay = 1000 +// configs.App.Size = 10 +// configs.App.DefaultUserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36" +// // API配置 +// configs.API.LoginURL = "https://login.kongfz.com/Pc/Login/account" +// configs.API.BookSearchURL = "https://search.kongfz.com/pc-gw/search-web/client/pc/bookLib/keyword/list" +// configs.API.ProductSearchURL = "https://search.kongfz.com/pc-gw/search-web/client/pc/product/keyword/list" +// // 代理配置 +// configs.Proxy.Servers = "http-dynamic.xiaoxiangdaili.com,http-dynamic-S02.xiaoxiangdaili.com,http-dynamic-S03.xiaoxiangdaili.com,http-dynamic-S04.xiaoxiangdaili.com" +// configs.Proxy.Username = "1297757178467602432" +// configs.Proxy.Password = "QgQBvP7f" +// configs.Proxy.TailMachineCode = "b7bf22a237ec692f13fcc2c43ee63252" +// configs.Proxy.TailCardKey = "DL_20_YK_1920acb2129844c2aabade3896560a9b" +// configs.Proxy.ProxyFilePath = "so/proxyConfig.so" +// return configs +//} +// +//// 获取当前可执行文件所在目录 +//func getExecutableDir() string { +// exePath, err := os.Executable() +// if err != nil { +// return "." +// } +// return filepath.Dir(exePath) +//} +// +//func main() { +// fmt.Println("ccc") +// http.HandleFunc("/api/kfzShopBookInfo", handleGetKFZShopBookInfo) +// +// port := "8080" +// log.Printf("🚀 服务器启动在端口 %s", port) +// if err := http.ListenAndServe(":"+port, nil); err != nil { +// log.Fatalf("服务器启动失败: %v", err) +// } +//} +// +//func handleGetKFZShopBookInfo(w http.ResponseWriter, r *http.Request) { +// // 设置响应头 +// w.Header().Set("Content-Type", "application/json; charset=utf-8") +// +// // 只支持GET请求 +// if r.Method != http.MethodGet { +// sendErrorResponse(w, http.StatusMethodNotAllowed, "只支持GET方法") +// return +// } +// soPath := filepath.Join("so", "kongfz.so") +// if _, err := os.Stat(soPath); os.IsNotExist(err) { +// log.Printf("❌ SO文件不存在: %s", soPath) +// sendErrorResponse(w, http.StatusInternalServerError, +// fmt.Sprintf("SO文件不存在: %s", soPath)) +// return +// } +// // 加载SO +// manager, err := NewSOManager(soPath) +// if err != nil { +// log.Printf("初始化SO管理器失败: %v", err) +// sendErrorResponse(w, http.StatusInternalServerError, "初始化SO管理器失败") +// return +// } +// defer manager.Close() +// log.Println("✅ SO加载成功") +// // 使用默认配置初始化 +// config := createDefaultConfig() +// configJSON, err := json.Marshal(config) +// if err != nil { +// log.Printf("序列化配置失败: %v", err) +// sendErrorResponse(w, http.StatusInternalServerError, "序列化配置失败") +// return +// } +// result, err := manager.Initialize(string(configJSON)) +// if err != nil { +// log.Printf("初始化失败: %v", err) +// sendErrorResponse(w, http.StatusInternalServerError, "初始化失败") +// return +// } +// var initResp APIResponseSO +// if err := json.Unmarshal([]byte(result), &initResp); err != nil { +// log.Printf("解析初始化响应失败: %v", err) +// sendErrorResponse(w, http.StatusInternalServerError, "解析初始化响应失败") +// return +// } +// if !initResp.Success { +// log.Printf("初始化失败: %s", initResp.Message) +// sendErrorResponse(w, http.StatusInternalServerError, "初始化失败: "+initResp.Message) +// return +// } +// log.Println("✅ SO初始化成功") +// +// // 登录示例 +// user, err := manager.OutLogin("18904056801", "Long6166@@") +// if err != nil { +// log.Printf("登录失败: %v", err) +// } else { +// log.Printf("登录结果: %s", user) +// } +// +// // 解析token +// var data APIResponseSO +// if err := json.Unmarshal([]byte(user), &data); err != nil { +// log.Printf("解析登录响应失败: %v", err) +// } else { +// var token string +// if dataMap, ok := data.Data.(map[string]interface{}); ok { +// if tk, exists := dataMap["token"]; exists { +// token = tk.(string) +// log.Printf("获取到Token: %s", token) +// +// // 使用token获取用户信息 +// msg, err := manager.OutGetUserMsg(token) +// if err != nil { +// log.Printf("获取用户信息失败: %v", err) +// } else { +// log.Printf("用户信息: %s", msg) +// } +// } else { +// log.Println("Token 不存在") +// } +// } else { +// log.Println("Data 格式不正确") +// } +// } +// // 返回成功响应 +// response := APIRespSO{ +// Success: true, +// Message: "SO调用成功", +// } +// json.NewEncoder(w).Encode(response) +//} +// +//// 发送错误响应 +//func sendErrorResponse(w http.ResponseWriter, statusCode int, message string) { +// response := APIRespSO{ +// Success: false, +// Message: message, +// } +// w.WriteHeader(statusCode) +// json.NewEncoder(w).Encode(response) +//} diff --git a/es/main.go b/es/main.go new file mode 100644 index 0000000..56f12e7 --- /dev/null +++ b/es/main.go @@ -0,0 +1,2088 @@ +package main + +import ( + "context" + "crypto/md5" + "crypto/tls" + "database/sql" + "encoding/hex" + "encoding/json" + "fmt" + "github.com/elastic/go-elasticsearch/v8" + "github.com/elastic/go-elasticsearch/v8/esapi" + "golang.org/x/image/bmp" + "golang.org/x/image/draw" + "golang.org/x/image/tiff" + "golang.org/x/image/webp" + "image" + "image/color" + "image/jpeg" + "image/png" + "io" + "io/ioutil" + "log" + "mime/multipart" + "net/http" + "os" + "path/filepath" + "sort" + "strings" + "sync" + "sync/atomic" + "time" + + _ "github.com/go-sql-driver/mysql" + "github.com/nfnt/resize" +) + +// ES 配置 +const ( + esAddress = "http://103.236.91.138:9200" + esUsername = "elastic" + esPassword = "5mRDIUg52VC0fp14nw-F" + esIndex = "books-from-mysql" + ClientID = "203c5a7ba8bd4b8488d5e26f93052642" // 拼多多开放平台配置 + ClientSecret = "892ffaa86e12b7a3d8d2942b669d9aa520ad8179" + PDDApiURL = "https://gw-upload.pinduoduo.com/api/upload" +) + +// 配置参数 +const ( + maxWorkers = 15 // 最大并发worker数量 + maxRetries = 3 // 最大重试次数 + retryDelay = 2 * time.Second // 重试延迟 + progressInterval = 5 * time.Second // 进度报告间隔 +) + +// ES 客户端封装 +type ESClient struct { + client *elasticsearch.Client +} + +// 数据库记录结构体 +type CrawlerRecord struct { + BookISBN sql.NullString + BookPicture sql.NullString +} + +// 处理结果结构体 +type ProcessResult struct { + Record CrawlerRecord + Success bool + LocalPaths []string + PDDURLs []string + Error error + WorkerID int + ProcessedAt time.Time +} + +// 全局统计 +type Statistics struct { + Total int32 + Success int32 + Failed int32 + Skipped int32 + CurrentIndex int32 + StartTime time.Time +} + +// NewESClient 初始化 ES 客户端 +// 说明：与 main(2).go 保持一致的连接方式（禁用证书校验、设置超时和连接池参数） +func NewESClient(addresses []string, username, password string) (*ESClient, error) { + cfg := elasticsearch.Config{ + Addresses: addresses, + Username: username, + Password: password, + Transport: &http.Transport{ + TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, + MaxIdleConnsPerHost: 100, + ResponseHeaderTimeout: 60 * time.Second, + }, + } + cli, err := elasticsearch.NewClient(cfg) + if err != nil { + return nil, err + } + return &ESClient{client: cli}, nil +} + +// CheckHealth 检查 ES 集群健康 +// 行为：等待状态至少为 yellow，输出基本信息 +func (es *ESClient) CheckHealth() error { + res, err := es.client.Cluster.Health( + es.client.Cluster.Health.WithWaitForStatus("yellow"), + es.client.Cluster.Health.WithTimeout(30*time.Second), + ) + if err != nil { + return err + } + defer res.Body.Close() + if res.IsError() { + return fmt.Errorf("Elasticsearch 健康检查失败: %s", res.String()) + } + var m map[string]interface{} + if err := json.NewDecoder(res.Body).Decode(&m); err == nil { + log.Printf("ES status=%v nodes=%v cluster=%v", m["status"], m["number_of_nodes"], m["cluster_name"]) + } + return nil +} + +// PDDImageProcessor 实现图片处理器 +// pdd上传图片官方接口 +// 上传图片到拼多多 +func uploadToPDD(token, imagePath string) (string, error) { + // 检查token是否有效 + if len(token) == 0 { + return "", fmt.Errorf("获取到的token为空") + } + result, err := ProcessAndUploadImage(imagePath, token) + if err != nil { + return "", fmt.Errorf("拼多多图片上传失败: %v", err) + } + + // 解析JSON响应获取URL + var response struct { + RequestID string `json:"request_id"` + URL string `json:"url"` + } + + err = json.Unmarshal([]byte(result), &response) + if err != nil { + return "", fmt.Errorf("解析上传响应失败: %v", err) + } + + if response.URL == "" { + return "", fmt.Errorf("上传响应中未找到URL") + } + + return response.URL, nil +} +func ProcessAndUploadImage(imagePath, token string) (string, error) { + // 打开图片文件 + file, err := os.Open(imagePath) + if err != nil { + return "", fmt.Errorf("failed to open image file: %v", err) + } + defer file.Close() + + // 准备参数 - 不包含文件路径 + params := map[string]string{ + "access_token": token, + "data_type": "JSON", + "type": "pdd.goods.img.upload", + "client_id": ClientID, + "timestamp": fmt.Sprintf("%d", time.Now().Unix()), + } + + // 生成签名（不包含文件路径） + params["sign"] = generateSign(params) + + // 创建multipart表单 + body := &strings.Builder{} + writer := multipart.NewWriter(body) + + // 写入文本参数 + for key, value := range params { + if err := writer.WriteField(key, value); err != nil { + return "", fmt.Errorf("failed to write field %s: %v", key, err) + } + } + + // 写入文件流 - 使用正确的字段名 "file" + part, err := writer.CreateFormFile("file", filepath.Base(imagePath)) + if err != nil { + return "", fmt.Errorf("failed to create form file: %v", err) + } + + if _, err := io.Copy(part, file); err != nil { + return "", fmt.Errorf("failed to copy file data: %v", err) + } + + // 关闭writer + if err := writer.Close(); err != nil { + return "", fmt.Errorf("failed to close writer: %v", err) + } + + // 创建请求 + req, err := http.NewRequest("POST", PDDApiURL, strings.NewReader(body.String())) + if err != nil { + return "", fmt.Errorf("failed to create request: %v", err) + } + + // 设置请求头 + req.Header.Set("Content-Type", writer.FormDataContentType()) + req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36") + + // 发送请求 + client := &http.Client{Timeout: 30 * time.Second} + resp, err := client.Do(req) + if err != nil { + return "", fmt.Errorf("failed to send request: %v", err) + } + defer resp.Body.Close() + + // 读取响应 + respBody, err := io.ReadAll(resp.Body) + if err != nil { + return "", fmt.Errorf("failed to read response: %v", err) + } + + log.Printf("拼多多API响应状态: %d", resp.StatusCode) + log.Printf("拼多多API响应内容: %s", string(respBody)) + + if resp.StatusCode != http.StatusOK { + return "", fmt.Errorf("API returned error status: %d, body: %s", resp.StatusCode, string(respBody)) + } + + // 解析响应 + var result map[string]interface{} + if err := json.Unmarshal(respBody, &result); err != nil { + return "", fmt.Errorf("failed to parse response: %v", err) + } + + // 检查API返回的错误 + if errorResponse, exists := result["error_response"]; exists { + errorMsg, _ := json.Marshal(errorResponse) + return "", fmt.Errorf("API returned error: %s", string(errorMsg)) + } + + // 查找成功的响应 + for key, value := range result { + if key != "error_response" { + successResponse, _ := json.Marshal(value) + return string(successResponse), nil + } + } + + return string(respBody), nil +} + +// generateSign 生成拼多多API签名 +func generateSign(params map[string]string) string { + // 按参数名排序 + var keys []string + for k := range params { + keys = append(keys, k) + } + sort.Strings(keys) + // 拼接参数字符串 + var signStr string + for _, k := range keys { + signStr += k + params[k] + } + signStr = ClientSecret + signStr + ClientSecret + // 计算MD5并转为大写 + hasher := md5.New() + hasher.Write([]byte(signStr)) + result := strings.ToUpper(hex.EncodeToString(hasher.Sum(nil))) + return result +} + +// GetPddToken 获取PDD token（简化版） +func GetPddToken() (string, error) { + url := "https://api.buzhiyushu.cn/huidiao/pdd/getPddChildrenBooksToken" + + resp, err := http.Get(url) + if err != nil { + return "", err + } + defer resp.Body.Close() + + body, err := ioutil.ReadAll(resp.Body) + if err != nil { + return "", err + } + + // 使用map解析JSON + var result map[string]interface{} + json.Unmarshal(body, &result) + + // 检查业务状态 + if code, ok := result["code"].(float64); !ok || code != 200 { + return "", fmt.Errorf("API错误: %v", result["msg"]) + } + + // 提取token + token := result["data"].(string) + return token, nil +} + +// 并发处理记录的主要函数 +func processRecordsConcurrently(records []CrawlerRecord, imageDir string, es *ESClient, maxWorkers int, token string) []ProcessResult { + var stats Statistics + stats.Total = int32(len(records)) + stats.StartTime = time.Now() + + // 创建通道 + recordChan := make(chan CrawlerRecord, len(records)) + resultChan := make(chan ProcessResult, len(records)) + + // 启动worker + var wg sync.WaitGroup + for i := 0; i < maxWorkers; i++ { + wg.Add(1) + go worker(token, i, &wg, recordChan, resultChan, imageDir, es, &stats) + } + + // 发送任务到通道 + go func() { + for _, record := range records { + recordChan <- record + } + close(recordChan) + }() + + // 启动进度报告 + go progressReporter(&stats) + + // 收集结果 + var results []ProcessResult + go func() { + for result := range resultChan { + results = append(results, result) + } + }() + + // 等待所有worker完成 + wg.Wait() + close(resultChan) + + return results +} + +// worker 处理函数 +func worker(token string, id int, wg *sync.WaitGroup, recordChan <-chan CrawlerRecord, resultChan chan<- ProcessResult, imageDir string, es *ESClient, stats *Statistics) { + defer wg.Done() + + for record := range recordChan { + currentIndex := atomic.AddInt32(&stats.CurrentIndex, 1) + + result := ProcessResult{ + Record: record, + WorkerID: id, + ProcessedAt: time.Now(), + } + + // 检查记录有效性 + if !isRecordValid(record) { + atomic.AddInt32(&stats.Skipped, 1) + result.Success = false + result.Error = fmt.Errorf("无效记录: ISBN或图片URL为空") + resultChan <- result + continue + } + + // 处理记录（带重试机制） + var localPaths, pddURLs []string + var err error + + for attempt := 1; attempt <= maxRetries; attempt++ { + localPaths, pddURLs, err = processSingleRecord(token, record, imageDir, es) + if err == nil { + break + } + + // 如果是ES记录未找到的错误，不需要重试 + if strings.Contains(err.Error(), "ES记录未找到") { + break + } + + if attempt < maxRetries { + log.Printf("Worker %d: 第 %d 次尝试处理 ISBN %s 失败, %d 秒后重试: %v", + id, attempt, record.BookISBN.String, retryDelay/time.Second, err) + time.Sleep(retryDelay) + } + } + + if err != nil { + atomic.AddInt32(&stats.Failed, 1) + result.Success = false + result.Error = err + // 即使失败，也记录已处理的本地路径（如果有） + result.LocalPaths = localPaths + result.PDDURLs = pddURLs + + // 根据错误类型记录不同的日志 + if strings.Contains(err.Error(), "ES记录未找到") { + log.Printf("Worker %d: ES记录未找到 [%d/%d] ISBN: %s", + id, currentIndex, stats.Total, record.BookISBN.String) + } else { + log.Printf("Worker %d: 处理失败 [%d/%d] ISBN: %s, 错误: %v", + id, currentIndex, stats.Total, record.BookISBN.String, err) + } + } else { + atomic.AddInt32(&stats.Success, 1) + result.Success = true + result.LocalPaths = localPaths + result.PDDURLs = pddURLs + + log.Printf("Worker %d: 成功处理 [%d/%d] ISBN: %s, 生成 %d 个文件, 上传 %d 个URL", + id, currentIndex, stats.Total, record.BookISBN.String, len(localPaths), len(pddURLs)) + } + + resultChan <- result + } +} + +// 检查记录有效性 +func isRecordValid(record CrawlerRecord) bool { + if !record.BookISBN.Valid || record.BookISBN.String == "" { + return false + } + if !record.BookPicture.Valid || record.BookPicture.String == "" { + return false + } + return true +} + +// 进度报告器 +func progressReporter(stats *Statistics) { + ticker := time.NewTicker(progressInterval) + defer ticker.Stop() + + for range ticker.C { + processed := atomic.LoadInt32(&stats.CurrentIndex) + success := atomic.LoadInt32(&stats.Success) + failed := atomic.LoadInt32(&stats.Failed) + skipped := atomic.LoadInt32(&stats.Skipped) + + elapsed := time.Since(stats.StartTime) + rate := float64(processed) / elapsed.Seconds() + + // 计算预估剩余时间 + var eta time.Duration + if processed > 0 && rate > 0 { + remaining := float64(stats.Total - processed) + eta = time.Duration(remaining/rate) * time.Second + } + + fmt.Printf("[进度] 已处理: %d/%d (成功: %d, 失败: %d, 跳过: %d) | 速率: %.2f 条/秒 | 运行: %v | ETA: %v\n", + processed, stats.Total, success, failed, skipped, rate, elapsed.Round(time.Second), eta.Round(time.Second)) + + if processed >= stats.Total { + break + } + } +} + +// 打印最终统计 +func printFinalStatistics(results []ProcessResult) { + var success, failed, skipped int + var totalFilesGenerated int + var totalURLsUploaded int + + // 失败原因分类 + failureReasons := make(map[string]int) + + for _, result := range results { + if result.Success { + success++ + totalFilesGenerated += len(result.LocalPaths) + totalURLsUploaded += len(result.PDDURLs) + } else if result.Error != nil && strings.Contains(result.Error.Error(), "无效记录") { + skipped++ + failureReasons["无效记录(ISBN或URL为空)"]++ + } else { + failed++ + // 即使是失败的情况，也可能生成了部分文件 + totalFilesGenerated += len(result.LocalPaths) + totalURLsUploaded += len(result.PDDURLs) + + // 分类失败原因 + errMsg := result.Error.Error() + switch { + case strings.Contains(errMsg, "ES记录未找到"): + failureReasons["ES记录未找到"]++ + case strings.Contains(errMsg, "查询ES中ID失败"): + failureReasons["ES查询失败"]++ + case strings.Contains(errMsg, "下载图片失败"): + failureReasons["图片下载失败"]++ + case strings.Contains(errMsg, "处理图片失败"): + failureReasons["图片处理失败"]++ + case strings.Contains(errMsg, "上传PNG图片失败"): + failureReasons["PNG上传失败"]++ + case strings.Contains(errMsg, "上传JPG图片失败"): + failureReasons["JPG上传失败"]++ + case strings.Contains(errMsg, "更新ES数据失败"): + failureReasons["ES更新失败"]++ + default: + failureReasons["其他错误"]++ + } + } + } + + fmt.Printf("\n=== 处理完成 ===\n") + fmt.Printf("总记录数: %d\n", len(results)) + fmt.Printf("成功: %d\n", success) + fmt.Printf("失败: %d\n", failed) + fmt.Printf("跳过: %d\n", skipped) + fmt.Printf("成功率: %.2f%%\n", float64(success)/float64(len(results))*100) + fmt.Printf("生成文件总数: %d (平均每条记录 %.1f 个文件)\n", totalFilesGenerated, float64(totalFilesGenerated)/float64(len(results))) + fmt.Printf("上传URL总数: %d (平均每条记录 %.1f 个URL)\n", totalURLsUploaded, float64(totalURLsUploaded)/float64(len(results))) + + // 显示失败原因统计 + if len(failureReasons) > 0 { + fmt.Printf("\n=== 失败原因统计 ===\n") + for reason, count := range failureReasons { + fmt.Printf(" %s: %d\n", reason, count) + } + } + + // 显示处理详情示例 + fmt.Printf("\n=== 处理详情示例 ===\n") + successCount := 0 + failedCount := 0 + for _, result := range results { + if result.Success && successCount < 3 { + fmt.Printf("✅ 成功: ISBN %s -> 文件: %d 个, URL: %d 个\n", + result.Record.BookISBN.String, + len(result.LocalPaths), + len(result.PDDURLs)) + successCount++ + } else if !result.Success && failedCount < 3 && !strings.Contains(result.Error.Error(), "无效记录") { + fmt.Printf("❌ 失败: ISBN %s -> 错误: %v\n", + result.Record.BookISBN.String, + result.Error) + failedCount++ + } + if successCount >= 3 && failedCount >= 3 { + break + } + } +} + +// 处理单条记录 +func processSingleRecord(token string, record CrawlerRecord, imageDir string, es *ESClient) ([]string, []string, error) { + // 更新ES + ids, err := es.FindIDsByISBN(esIndex, record.BookISBN.String) + if err != nil { + return nil, nil, fmt.Errorf("查询ES中ID失败: %v", err) + } + var pngImageUrl string + var jpgImageUrl string + var localPaths []string + var pddURLs []string + if ids != "" { + // 下载并处理图片 + pngPath, jpgPath, err := processAndSaveImage(record, imageDir) + if err != nil { + err := saveISBNToFile(record.BookISBN.String, record.BookPicture.String) + if err != nil { + log.Printf("警告: 无法保存未找到的ISBN到文件: %v", err) + } else { + log.Printf("未找到ISBN %s 对应的ES记录，已保存到文件", record.BookISBN.String) + } + return nil, nil, fmt.Errorf("处理图片失败: %v", err) + } + localPaths = []string{pngPath, jpgPath} + // 上传到PDD + pngImageUrl, err = uploadToPDD(token, pngPath) + if err != nil { + err := saveISBNToFile(record.BookISBN.String, record.BookPicture.String) + if err != nil { + log.Printf("警告: 无法保存未找到的ISBN到文件: %v", err) + } else { + log.Printf("未找到ISBN %s 对应的ES记录，已保存到文件", record.BookISBN.String) + } + return nil, nil, fmt.Errorf("上传PNG图片失败: %v", err) + } + // 上传到PDD + jpgImageUrl, err = uploadToPDD(token, jpgPath) + if err != nil { + err := saveISBNToFile(record.BookISBN.String, record.BookPicture.String) + if err != nil { + log.Printf("警告: 无法保存未找到的ISBN到文件: %v", err) + } else { + log.Printf("未找到ISBN %s 对应的ES记录，已保存到文件", record.BookISBN.String) + } + return nil, nil, fmt.Errorf("上传JPG图片失败: %v", err) + } + pddURLs = []string{pngImageUrl, jpgImageUrl} + err = es.UpdateBookPicsByID(esIndex, ids, "", pngImageUrl, jpgImageUrl) + if err != nil { + err := saveISBNToFile(record.BookISBN.String, record.BookPicture.String) + if err != nil { + log.Printf("警告: 无法保存未找到的ISBN到文件: %v", err) + } else { + log.Printf("未找到ISBN %s 对应的ES记录，已保存到文件", record.BookISBN.String) + } + return nil, nil, fmt.Errorf("更新ES数据失败: %v", err) + } + + for _, path := range localPaths { + // ES更新成功后删除本地图片 + if removeErr := os.Remove(path); removeErr == nil { + log.Printf("ES更新成功，已删除本地图片: %s", path) + } else { + log.Printf("警告: 无法删除本地图片 %s: %v", path, removeErr) + } + } + } else { + // ids为空，将ISBN存储到txt文件 + err := saveISBNToFile(record.BookISBN.String, record.BookPicture.String) + if err != nil { + log.Printf("警告: 无法保存未找到的ISBN到文件: %v", err) + } else { + log.Printf("未找到ISBN %s 对应的ES记录，已保存到文件", record.BookISBN.String) + } + return nil, nil, fmt.Errorf("未找到ISBN %s 对应的ES记录", record.BookISBN.String) + } + return localPaths, pddURLs, nil +} + +// 保存未找到的ISBN和图片URL到txt文件（CSV格式，带去重） +func saveISBNToFile(isbn string, imageUrl string) error { + filename := "cmd/update_es_gt/xgy_not_found_isbns.txt" + + // 读取现有内容检查是否已存在 + existingRecords := make(map[string]bool) + if content, err := os.ReadFile(filename); err == nil { + lines := strings.Split(string(content), "\n") + for _, line := range lines { + if line != "" && !strings.HasPrefix(line, "#") { + parts := strings.Split(line, ",") + if len(parts) > 0 { + existingRecords[parts[0]] = true // 以ISBN作为去重依据 + } + } + } + } + + // 如果已存在，则不重复添加 + if existingRecords[isbn] { + return nil + } + // 以追加模式打开文件 + file, err := os.OpenFile(filename, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644) + if err != nil { + return fmt.Errorf("打开文件失败: %v", err) + } + defer file.Close() + // 如果是空文件，先写入CSV表头 + stat, err := file.Stat() + if err == nil && stat.Size() == 0 { + header := "# ISBN,ImageURL\n" + if _, err := file.WriteString(header); err != nil { + return fmt.Errorf("写入表头失败: %v", err) + } + } + + // 写入ISBN和图片URL，用逗号分隔，并添加换行符 + line := fmt.Sprintf("%s,%s\n", isbn, imageUrl) + _, err = file.WriteString(line) + if err != nil { + return fmt.Errorf("写入文件失败: %v", err) + } + + return nil +} + +// 下载并处理图片 +func processAndSaveImage(record CrawlerRecord, saveDir string) (string, string, error) { + // 下载图片 + img, originalFormat, err := downloadImage(record.BookPicture.String) + if err != nil { + return "", "", fmt.Errorf("下载图片失败: %v", err) + } + + fmt.Printf("下载成功，原始格式: %s\n", originalFormat) + + // 调整图片高度为600，等比例缩放 + //resizedImg := resizeImageToHeight(img, 600) + // 使用高质量缩放调整图片高度为600，等比例缩放 + resizedImg := resizeToHeightHighQuality(img, 600) + fmt.Printf("缩放后尺寸: %dx%d\n", resizedImg.Bounds().Dx(), resizedImg.Bounds().Dy()) + + // 创建800x800的透明背景 + finalImg := createCenteredImage(resizedImg, 800, 800, true) + + // 创建800x800的白色背景（用于JPG） + whiteImg := createCenteredImage(resizedImg, 800, 800, false) + + // 生成文件名 + filename := fmt.Sprintf("%s", record.BookISBN.String) + // 清理文件名中的非法字符 + filename = sanitizeFilename(filename) + + // PNG文件路径 + pngPath := filepath.Join(saveDir, filename+".png") + // JPG文件路径 + jpgPath := filepath.Join(saveDir, filename+".jpg") + + // 保存为PNG图片 + err = savePNG(finalImg, pngPath) + if err != nil { + return "", "", fmt.Errorf("保存图片失败: %v", err) + } + + // 保存为JPG图片（白色背景） + err = saveJPG(whiteImg, jpgPath, 95) // 95%质量 + if err != nil { + return "", "", fmt.Errorf("保存JPG图片失败: %v", err) + } + + fmt.Printf("转换成功: %s -> %s, 保存路径: %s\n", originalFormat, "PNG", pngPath) + fmt.Printf("转换成功: %s -> %s, 保存路径: %s\n", originalFormat, "JPG", jpgPath) + return pngPath, jpgPath, nil +} + +// 下载图片 +func downloadImage(url string) (image.Image, string, error) { + // 创建HTTP客户端，设置超时等参数 + client := &http.Client{ + Timeout: 30 * time.Second, + } + + resp, err := client.Get(url) + if err != nil { + return nil, "", err + } + defer resp.Body.Close() + + if resp.StatusCode != http.StatusOK { + return nil, "", fmt.Errorf("HTTP请求失败，状态码: %d", resp.StatusCode) + } + + // 读取响应体前几个字节来判断图片格式 + peekBytes := make([]byte, 512) + n, err := resp.Body.Read(peekBytes) + if err != nil && err != io.EOF { + return nil, "", err + } + + // 创建一个新的Reader，包含已读取的数据和剩余数据 + reader := io.MultiReader(strings.NewReader(string(peekBytes[:n])), resp.Body) + + // 根据文件头识别图片格式 + contentType := http.DetectContentType(peekBytes[:n]) + fmt.Printf("检测到的Content-Type: %s\n", contentType) + + var img image.Image + var format string + + // 根据Content-Type或文件扩展名选择解码器 + switch { + case strings.Contains(contentType, "jpeg") || strings.HasSuffix(strings.ToLower(url), ".jpg") || strings.HasSuffix(strings.ToLower(url), ".jpeg"): + img, err = jpeg.Decode(reader) + format = "JPEG" + case strings.Contains(contentType, "png") || strings.HasSuffix(strings.ToLower(url), ".png"): + img, err = png.Decode(reader) + format = "PNG" + case strings.Contains(contentType, "webp") || strings.HasSuffix(strings.ToLower(url), ".webp"): + img, err = webp.Decode(reader) + format = "WEBP" + case strings.Contains(contentType, "bmp") || strings.HasSuffix(strings.ToLower(url), ".bmp"): + img, err = bmp.Decode(reader) + format = "BMP" + case strings.Contains(contentType, "tiff") || strings.HasSuffix(strings.ToLower(url), ".tiff") || strings.HasSuffix(strings.ToLower(url), ".tif"): + img, err = tiff.Decode(reader) + format = "TIFF" + default: + // 尝试通用解码 + img, format, err = image.Decode(reader) + if err != nil { + return nil, "", fmt.Errorf("不支持的图片格式: %s, 错误: %v", contentType, err) + } + } + + if err != nil { + return nil, "", fmt.Errorf("解码图片失败: %v", err) + } + + return img, format, nil +} + +// 高质量等比例缩放到指定高度 +func resizeToHeightHighQuality(src image.Image, targetHeight int) image.Image { + bounds := src.Bounds() + srcWidth := bounds.Dx() + srcHeight := bounds.Dy() + + // 如果原图高度已经小于等于目标高度，且宽度合适，可以直接返回 + //if srcHeight <= targetHeight { + // return src + //} + + // 计算等比例缩放后的宽度 + targetWidth := uint(float64(srcWidth) * float64(targetHeight) / float64(srcHeight)) + + // 使用 Lanczos3 插值算法进行高质量缩放 + return resize.Resize(targetWidth, uint(targetHeight), src, resize.Lanczos3) +} + +// 创建居中图片（将原图放在指定大小的透明背景中央） +func createCenteredImage(src image.Image, width, height int, transparent bool) *image.RGBA { + // 创建透明背景 + dst := image.NewRGBA(image.Rect(0, 0, width, height)) + + // 设置背景颜色 + var bgColor color.Color + if transparent { + bgColor = color.RGBA{0, 0, 0, 0} // 透明 + } else { + bgColor = color.RGBA{255, 255, 255, 255} // 白色 + } + + // 填充透明背景 + //transparent := color.RGBA{0, 0, 0, 0} + draw.Draw(dst, dst.Bounds(), &image.Uniform{bgColor}, image.Point{}, draw.Src) + + // 计算居中位置 + srcBounds := src.Bounds() + srcWidth := srcBounds.Dx() + srcHeight := srcBounds.Dy() + + x := (width - srcWidth) / 2 + y := (height - srcHeight) / 2 + + // 将原图绘制到中央 + draw.Draw(dst, image.Rect(x, y, x+srcWidth, y+srcHeight), src, image.Point{}, draw.Over) + + return dst +} + +// 保存为PNG图片 +func savePNG(img image.Image, filename string) error { + file, err := os.Create(filename) + if err != nil { + return err + } + defer file.Close() + + return png.Encode(file, img) +} + +// 保存为JPG图片 +func saveJPG(img image.Image, filename string, quality int) error { + file, err := os.Create(filename) + if err != nil { + return err + } + defer file.Close() + + // 设置JPEG编码选项 + options := &jpeg.Options{ + Quality: quality, // 1-100，越高质量越好 + } + + return jpeg.Encode(file, img, options) +} + +// 清理文件名中的非法字符 +func sanitizeFilename(filename string) string { + // 替换Windows文件名中不允许的字符 + invalidChars := []string{"\\", "/", ":", "*", "?", "\"", "<", ">", "|"} + for _, char := range invalidChars { + filename = strings.ReplaceAll(filename, char, "_") + } + // 移除或替换其他可能的问题字符 + filename = strings.TrimSpace(filename) + if filename == "" { + filename = "unknown" + } + return filename +} + +// 从数据库获取记录 +func getRecords(db *sql.DB) ([]CrawlerRecord, error) { + // 查询所有记录，包括 NULL 值 + query := "SELECT book_isbn, book_picture FROM dk_crawler_record_info" + rows, err := db.Query(query) + if err != nil { + return nil, err + } + defer rows.Close() + + var records []CrawlerRecord + for rows.Next() { + var record CrawlerRecord + // 使用 sql.NullString 来接收可能为 NULL 的字段 + err := rows.Scan(&record.BookISBN, &record.BookPicture) + if err != nil { + fmt.Printf("扫描记录失败: %v\n", err) + continue + } + records = append(records, record) + } + + // 检查遍历过程中是否有错误 + if err = rows.Err(); err != nil { + return nil, err + } + + return records, nil +} + +// FindIDsByISBN 根据 ISBN 查询文档 ID 列表 +func (es *ESClient) FindIDsByISBN(index, isbn string) (string, error) { + q := map[string]interface{}{ + "query": map[string]interface{}{ + "term": map[string]interface{}{"isbn": isbn}, + }, + "_source": false, + "size": 1000, + } + b, _ := json.Marshal(q) + res, err := es.client.Search( + es.client.Search.WithIndex(index), + es.client.Search.WithBody(strings.NewReader(string(b))), + es.client.Search.WithContext(context.Background()), + ) + if err != nil { + return "", err + } + defer res.Body.Close() + if res.IsError() { + return "", fmt.Errorf("搜索失败: %s", res.String()) + } + var r map[string]interface{} + if err := json.NewDecoder(res.Body).Decode(&r); err != nil { + return "", err + } + hits, _ := r["hits"].(map[string]interface{}) + arr, _ := hits["hits"].([]interface{}) + var ids string + for _, h := range arr { + m, _ := h.(map[string]interface{}) + id, _ := m["_id"].(string) + if id != "" { + //ids = append(ids, id) + ids = id + } + } + return ids, nil +} + +func (es *ESClient) UpdateBookPicsByID(index, id, localImageS, pngImageUrl, jpgImageUrl string) error { + bookPicJSON, err := json.Marshal(map[string]string{ + "localPath": localImageS, + "pddPath": jpgImageUrl, + }) + if err != nil { + return fmt.Errorf("序列化 book_pic_w 失败: %w", err) + } + + bookPicBJSON, err := json.Marshal(map[string]string{ + "localPath": localImageS, + "pddResponse": pngImageUrl, + }) + if err != nil { + return fmt.Errorf("序列化 book_pic_b 失败: %w", err) + } + // 构建更新文档 + payload := map[string]interface{}{ + "doc": map[string]string{ + "book_pic": string(bookPicJSON), + "book_pic_b": string(bookPicBJSON), + }, + } + // JSON 序列化整个更新请求 + body, err := json.Marshal(payload) + if err != nil { + return fmt.Errorf("序列化更新请求失败: %w", err) + } + req := esapi.UpdateRequest{ + Index: index, + DocumentID: id, + Body: strings.NewReader(string(body)), + } + res, err := req.Do(context.Background(), es.client) + if err != nil { + return err + } + defer res.Body.Close() + if res.IsError() { + data, _ := io.ReadAll(res.Body) + return fmt.Errorf("ES 更新失败: %s", data) + } + return nil +} + +// 从 sql.NullString 获取字符串值 +func getStringValue(nullString sql.NullString) string { + if nullString.Valid { + return nullString.String + } + return "NULL" +} + +func main() { + //// 获取token + //token, err := GetPddToken() + //if err != nil { + // fmt.Errorf("获取拼多多token失败: %v", err) + //} + //fmt.Println("token=", token) + //// 数据源名称格式 + //dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8mb4&parseTime=True&loc=Local", + // "root", + // "123456", + // "localhost", + // 3306, + // "book_image") + //db, err := sql.Open("mysql", dsn) + //if err != nil { + // fmt.Printf("打开数据库连接失败: %v", err) + //} + //// 设置连接池参数 + //db.SetMaxOpenConns(20) // 最大打开连接数 + //db.SetMaxIdleConns(10) + //err = db.Ping() + //if err != nil { + // fmt.Printf("数据库连接测试失败: %v", err) + //} + // + //// 查询数据 + //records, err := getRecords(db) + //if err != nil { + // fmt.Printf("查询失败: %v", err) + //} + //imageDir := "D:\\image" + //err = os.MkdirAll(imageDir, 0755) + //if err != nil { + // fmt.Sprintf("创建目录失败: %v", err) + //} + //fmt.Printf("找到 %d 条记录需要处理\n", len(records)) + // + //es, err := NewESClient([]string{esAddress}, esUsername, esPassword) + //if err != nil { + // log.Fatalf("ES 连接失败: %v", err) + //} + //if err := es.CheckHealth(); err != nil { + // log.Fatalf("ES 健康检查失败: %v", err) + //} + //// 启动并发处理 + //results := processRecordsConcurrently(records, imageDir, es, maxWorkers, token) + // + //// 输出最终统计 + //printFinalStatistics(results) + + //mainQuerySaleISBNs() + //mainFindESOnlyISBNs() + mainQuerySaleISBNsWithEmptyPic() +} + +// 查询并导出有销售记录且book_pic字符串中pddPath为空的ISBN +func queryAndExportSaleISBNs(es *ESClient, outputFile string) error { + log.Printf("开始查询有销售记录且book_pic字符串中pddPath为空的ISBN...") + + // 使用其他字段排序，比如 isbn 字段或者时间字段 + query := map[string]interface{}{ + "query": map[string]interface{}{ + "bool": map[string]interface{}{ + "must": []map[string]interface{}{ + { + "bool": map[string]interface{}{ + "should": []map[string]interface{}{ + {"range": map[string]interface{}{"day_sale_7": map[string]interface{}{"gt": 0}}}, + {"range": map[string]interface{}{"day_sale_15": map[string]interface{}{"gt": 0}}}, + {"range": map[string]interface{}{"day_sale_30": map[string]interface{}{"gt": 0}}}, + {"range": map[string]interface{}{"day_sale_60": map[string]interface{}{"gt": 0}}}, + }, + "minimum_should_match": 1, + }, + }, + { + "bool": map[string]interface{}{ + "should": []map[string]interface{}{ + // 匹配 pddPath:"" 的JSON字符串 + {"regexp": map[string]interface{}{"book_pic": ".*\"pddPath\":\"\".*"}}, + // 匹配 pddPath: "" (带空格的) + {"regexp": map[string]interface{}{"book_pic": ".*\"pddPath\":\\s*\"\".*"}}, + // 匹配整个book_pic字段为空 + {"term": map[string]interface{}{"book_pic": ""}}, + // 匹配book_pic字段不存在 + { + "bool": map[string]interface{}{ + "must_not": map[string]interface{}{ + "exists": map[string]interface{}{"field": "book_pic"}, + }, + }, + }, + }, + }, + }, + }, + }, + }, + "_source": []string{"isbn"}, + "sort": []map[string]interface{}{ + {"isbn": "asc"}, // 使用 isbn 字段排序，或者使用其他可排序字段 + }, + "size": 10000, + } + + // 打印查询条件用于验证 + queryJSON, _ := json.MarshalIndent(query, "", " ") + log.Printf("查询条件:\n%s", string(queryJSON)) + + var allISBNs []string + var searchAfter interface{} + totalCount := 0 + page := 1 + + for { + // 复制基础查询 + currentQuery := make(map[string]interface{}) + for k, v := range query { + currentQuery[k] = v + } + + // 添加游标 + if searchAfter != nil { + currentQuery["search_after"] = searchAfter + } + + body, err := json.Marshal(currentQuery) + if err != nil { + return fmt.Errorf("序列化查询失败: %w", err) + } + + log.Printf("执行第 %d 页查询...", page) + + // 执行搜索 + res, err := es.client.Search( + es.client.Search.WithIndex(esIndex), + es.client.Search.WithBody(strings.NewReader(string(body))), + es.client.Search.WithContext(context.Background()), + ) + if err != nil { + return fmt.Errorf("ES搜索失败: %w", err) + } + defer res.Body.Close() + + if res.IsError() { + bodyBytes, _ := io.ReadAll(res.Body) + return fmt.Errorf("ES搜索返回错误: %s, 响应: %s", res.String(), string(bodyBytes)) + } + + // 读取并解析响应体 + bodyBytes, err := io.ReadAll(res.Body) + if err != nil { + return fmt.Errorf("读取响应体失败: %w", err) + } + + var result map[string]interface{} + if err := json.Unmarshal(bodyBytes, &result); err != nil { + return fmt.Errorf("解析ES响应失败: %w", err) + } + + // 检查是否有错误 + if errMsg, exists := result["error"]; exists { + return fmt.Errorf("ES返回错误: %v", errMsg) + } + + hits, ok := result["hits"].(map[string]interface{}) + if !ok { + return fmt.Errorf("无法解析hits字段") + } + + // 获取总命中数 + if totalHits, exists := hits["total"].(map[string]interface{}); exists { + if totalValue, exists := totalHits["value"]; exists { + log.Printf("ES返回总命中数: %.0f", totalValue) + } + } + + hitList, ok := hits["hits"].([]interface{}) + if !ok || len(hitList) == 0 { + log.Printf("第 %d 页没有数据，查询完成", page) + break // 没有更多数据 + } + + // 处理当前批次的数据 + batchCount := 0 + for _, hit := range hitList { + hitMap, ok := hit.(map[string]interface{}) + if !ok { + log.Printf("警告: 无法解析hit数据") + continue + } + + source, ok := hitMap["_source"].(map[string]interface{}) + if !ok { + log.Printf("警告: 无法解析_source字段") + continue + } + + isbn, ok := source["isbn"].(string) + if ok && isbn != "" { + allISBNs = append(allISBNs, isbn) + batchCount++ + } else { + log.Printf("警告: 跳过空的ISBN字段") + } + + // 更新游标（使用最后一个文档的排序值） + sortValues, ok := hitMap["sort"].([]interface{}) + if ok && len(sortValues) > 0 { + searchAfter = sortValues + } + } + + totalCount += batchCount + log.Printf("第 %d 页: 获取 %d 条ISBN记录，总计: %d", page, batchCount, totalCount) + page++ + + // 如果返回的数量小于请求的数量，说明已经是最后一页 + if len(hitList) < 10000 { + log.Printf("最后一页数据量 %d < 10000，查询完成", len(hitList)) + break + } + + // 添加短暂延迟，避免对ES造成过大压力 + time.Sleep(100 * time.Millisecond) + } + + if len(allISBNs) == 0 { + return fmt.Errorf("没有找到符合条件的ISBN记录") + } + + // 去重 + isbnSet := make(map[string]bool) + uniqueISBNs := make([]string, 0) + for _, isbn := range allISBNs { + if !isbnSet[isbn] { + isbnSet[isbn] = true + uniqueISBNs = append(uniqueISBNs, isbn) + } + } + + log.Printf("去重前: %d 条, 去重后: %d 条", len(allISBNs), len(uniqueISBNs)) + + // 确保输出目录存在 + outputDir := filepath.Dir(outputFile) + if err := os.MkdirAll(outputDir, 0755); err != nil { + return fmt.Errorf("创建输出目录失败: %w", err) + } + + // 写入文件 + file, err := os.Create(outputFile) + if err != nil { + return fmt.Errorf("创建文件失败: %w", err) + } + defer file.Close() + + // 写入文件头信息 + header := fmt.Sprintf(`# 有销售记录且book_pic字符串中pddPath为空的ISBN列表 +# 查询条件: (day_sale_7 > 0 OR day_sale_15 > 0 OR day_sale_30 > 0 OR day_sale_60 > 0) AND (book_pic包含"pddPath":"" 或 book_pic为空 或 book_pic字段不存在) +# 索引: %s +# 统计时间: %s +# 总记录数: %d + +`, esIndex, time.Now().Format("2006-01-02 15:04:05"), len(uniqueISBNs)) + + if _, err := file.WriteString(header); err != nil { + return fmt.Errorf("写入文件头失败: %w", err) + } + + // 按字母顺序排序后写入 + sort.Strings(uniqueISBNs) + successCount := 0 + for _, isbn := range uniqueISBNs { + if _, err := file.WriteString(isbn + "\n"); err != nil { + log.Printf("警告: 写入ISBN失败 %s: %v", isbn, err) + continue + } + successCount++ + } + + log.Printf("成功导出 %d/%d 个有销售记录且book_pic字符串中pddPath为空的ISBN到文件: %s", successCount, len(uniqueISBNs), outputFile) + return nil +} + +// 查询并导出销售ISBN的主函数 +func mainQuerySaleISBNs() { + // 初始化ES客户端 + es, err := NewESClient([]string{esAddress}, esUsername, esPassword) + if err != nil { + log.Fatalf("ES连接失败: %v", err) + } + + // 检查ES健康状态 + if err := es.CheckHealth(); err != nil { + log.Fatalf("ES健康检查失败: %v", err) + } + + // 输出文件路径 + outputFile := "cmd/update_es_gt/all_isbns.txt" + + // 查询并导出ISBN + startTime := time.Now() + if err := exportAllISBNs(es, outputFile); err != nil { + log.Fatalf("导出销售ISBN失败: %v", err) + } + + elapsed := time.Since(startTime) + log.Printf("任务完成！耗时: %v，ISBN已导出到: %s", elapsed.Round(time.Millisecond), outputFile) +} + +// 导出所有ISBN到txt文件 +func exportAllISBNs(es *ESClient, outputFile string) error { + log.Printf("开始导出所有ISBN...") + + // 查询所有包含isbn字段的文档 + query := map[string]interface{}{ + "query": map[string]interface{}{ + "exists": map[string]interface{}{ + "field": "isbn", + }, + }, + "_source": []string{"isbn"}, + "sort": []map[string]interface{}{ + {"isbn": "asc"}, // 按ISBN排序 + }, + "size": 10000, + } + + var allISBNs []string + var searchAfter interface{} + totalCount := 0 + page := 1 + + for { + // 复制基础查询 + currentQuery := make(map[string]interface{}) + for k, v := range query { + currentQuery[k] = v + } + + // 添加游标 + if searchAfter != nil { + currentQuery["search_after"] = searchAfter + } + + body, err := json.Marshal(currentQuery) + if err != nil { + return fmt.Errorf("序列化查询失败: %w", err) + } + + log.Printf("执行第 %d 页查询...", page) + + // 执行搜索 + res, err := es.client.Search( + es.client.Search.WithIndex(esIndex), + es.client.Search.WithBody(strings.NewReader(string(body))), + es.client.Search.WithContext(context.Background()), + ) + if err != nil { + return fmt.Errorf("ES搜索失败: %w", err) + } + defer res.Body.Close() + + if res.IsError() { + bodyBytes, _ := io.ReadAll(res.Body) + return fmt.Errorf("ES搜索返回错误: %s, 响应: %s", res.String(), string(bodyBytes)) + } + + // 读取并解析响应体 + bodyBytes, err := io.ReadAll(res.Body) + if err != nil { + return fmt.Errorf("读取响应体失败: %w", err) + } + + var result map[string]interface{} + if err := json.Unmarshal(bodyBytes, &result); err != nil { + return fmt.Errorf("解析ES响应失败: %w", err) + } + + // 检查是否有错误 + if errMsg, exists := result["error"]; exists { + return fmt.Errorf("ES返回错误: %v", errMsg) + } + + hits, ok := result["hits"].(map[string]interface{}) + if !ok { + return fmt.Errorf("无法解析hits字段") + } + + // 获取总命中数 + if totalHits, exists := hits["total"].(map[string]interface{}); exists { + if totalValue, exists := totalHits["value"]; exists { + if page == 1 { + log.Printf("ES索引中共有 %.0f 条包含ISBN的记录", totalValue) + } + } + } + + hitList, ok := hits["hits"].([]interface{}) + if !ok || len(hitList) == 0 { + log.Printf("第 %d 页没有数据，查询完成", page) + break // 没有更多数据 + } + + // 处理当前批次的数据 + batchCount := 0 + for _, hit := range hitList { + hitMap, ok := hit.(map[string]interface{}) + if !ok { + log.Printf("警告: 无法解析hit数据") + continue + } + + source, ok := hitMap["_source"].(map[string]interface{}) + if !ok { + log.Printf("警告: 无法解析_source字段") + continue + } + + isbn, ok := source["isbn"].(string) + if ok && isbn != "" { + allISBNs = append(allISBNs, isbn) + batchCount++ + } else { + log.Printf("警告: 跳过空的ISBN字段") + } + + // 更新游标（使用最后一个文档的排序值） + sortValues, ok := hitMap["sort"].([]interface{}) + if ok && len(sortValues) > 0 { + searchAfter = sortValues + } + } + + totalCount += batchCount + log.Printf("第 %d 页: 获取 %d 条ISBN记录，总计: %d", page, batchCount, totalCount) + page++ + + // 如果返回的数量小于请求的数量，说明已经是最后一页 + if len(hitList) < 10000 { + log.Printf("最后一页数据量 %d < 10000，查询完成", len(hitList)) + break + } + + // 添加短暂延迟，避免对ES造成过大压力 + time.Sleep(100 * time.Millisecond) + } + + if len(allISBNs) == 0 { + return fmt.Errorf("没有找到包含ISBN字段的记录") + } + + // 去重 + isbnSet := make(map[string]bool) + uniqueISBNs := make([]string, 0) + for _, isbn := range allISBNs { + if !isbnSet[isbn] { + isbnSet[isbn] = true + uniqueISBNs = append(uniqueISBNs, isbn) + } + } + + log.Printf("去重前: %d 条, 去重后: %d 条", len(allISBNs), len(uniqueISBNs)) + + // 确保输出目录存在 + outputDir := filepath.Dir(outputFile) + if err := os.MkdirAll(outputDir, 0755); err != nil { + return fmt.Errorf("创建输出目录失败: %w", err) + } + + // 写入文件 + file, err := os.Create(outputFile) + if err != nil { + return fmt.Errorf("创建文件失败: %w", err) + } + defer file.Close() + + // 写入文件头信息 + header := fmt.Sprintf(`# 所有ISBN列表 +# 索引: %s +# 导出时间: %s +# 总记录数: %d + +`, esIndex, time.Now().Format("2006-01-02 15:04:05"), len(uniqueISBNs)) + + if _, err := file.WriteString(header); err != nil { + return fmt.Errorf("写入文件头失败: %w", err) + } + + // 按字母顺序排序后写入 + sort.Strings(uniqueISBNs) + successCount := 0 + for _, isbn := range uniqueISBNs { + if _, err := file.WriteString(isbn + "\n"); err != nil { + log.Printf("警告: 写入ISBN失败 %s: %v", isbn, err) + continue + } + successCount++ + } + + log.Printf("成功导出 %d/%d 个ISBN到文件: %s", successCount, len(uniqueISBNs), outputFile) + return nil +} + +// 从ES获取所有ISBN +func getAllISBNsFromES(es *ESClient) ([]string, error) { + log.Printf("开始从ES索引 %s 获取所有ISBN...", esIndex) + + var allISBNs []string + var searchAfter interface{} + totalCount := 0 + page := 1 + + for { + query := map[string]interface{}{ + "query": map[string]interface{}{ + "exists": map[string]interface{}{ + "field": "isbn", + }, + }, + "_source": []string{"isbn"}, + "sort": []map[string]interface{}{ + {"isbn": "asc"}, + }, + "size": 10000, + } + + // 添加游标 + if searchAfter != nil { + query["search_after"] = searchAfter + } + + body, err := json.Marshal(query) + if err != nil { + return nil, fmt.Errorf("序列化查询失败: %w", err) + } + + log.Printf("执行第 %d 页ES查询...", page) + + // 执行搜索 + res, err := es.client.Search( + es.client.Search.WithIndex(esIndex), + es.client.Search.WithBody(strings.NewReader(string(body))), + es.client.Search.WithContext(context.Background()), + ) + if err != nil { + return nil, fmt.Errorf("ES搜索失败: %w", err) + } + defer res.Body.Close() + + if res.IsError() { + bodyBytes, _ := io.ReadAll(res.Body) + return nil, fmt.Errorf("ES搜索返回错误: %s, 响应: %s", res.String(), string(bodyBytes)) + } + + // 解析响应 + var result map[string]interface{} + if err := json.NewDecoder(res.Body).Decode(&result); err != nil { + return nil, fmt.Errorf("解析ES响应失败: %w", err) + } + + hits, ok := result["hits"].(map[string]interface{}) + if !ok { + return nil, fmt.Errorf("无法解析hits字段") + } + + hitList, ok := hits["hits"].([]interface{}) + if !ok || len(hitList) == 0 { + log.Printf("第 %d 页没有数据，查询完成", page) + break + } + + // 处理当前批次的数据 + batchCount := 0 + for _, hit := range hitList { + hitMap, ok := hit.(map[string]interface{}) + if !ok { + log.Printf("警告: 无法解析hit数据") + continue + } + + source, ok := hitMap["_source"].(map[string]interface{}) + if !ok { + log.Printf("警告: 无法解析_source字段") + continue + } + + isbn, ok := source["isbn"].(string) + if ok && isbn != "" { + allISBNs = append(allISBNs, isbn) + batchCount++ + } + + // 更新游标 + sortValues, ok := hitMap["sort"].([]interface{}) + if ok && len(sortValues) > 0 { + searchAfter = sortValues + } + } + + totalCount += batchCount + log.Printf("第 %d 页: 获取 %d 条ISBN记录，总计: %d", page, batchCount, totalCount) + page++ + + // 如果返回的数量小于请求的数量，说明已经是最后一页 + if len(hitList) < 10000 { + log.Printf("最后一页数据量 %d < 10000，查询完成", len(hitList)) + break + } + + time.Sleep(100 * time.Millisecond) + } + + if len(allISBNs) == 0 { + return nil, fmt.Errorf("ES中没有找到包含ISBN字段的记录") + } + + log.Printf("从ES中获取到 %d 个ISBN", len(allISBNs)) + return allISBNs, nil +} + +// 批量检查ISBN在数据库中是否存在 +func checkISBNsInDB(db *sql.DB, isbns []string) (map[string]bool, error) { + log.Printf("开始检查 %d 个ISBN在数据库中的存在情况...", len(isbns)) + + existsMap := make(map[string]bool) + + // 分批处理，避免SQL语句过长 + batchSize := 1000 + totalBatches := (len(isbns) + batchSize - 1) / batchSize + + for batch := 0; batch < totalBatches; batch++ { + start := batch * batchSize + end := start + batchSize + if end > len(isbns) { + end = len(isbns) + } + + batchISBNs := isbns[start:end] + log.Printf("处理数据库批次 %d/%d: ISBN范围 %d-%d", batch+1, totalBatches, start+1, end) + + // 构建IN查询的占位符 + placeholders := make([]string, len(batchISBNs)) + args := make([]interface{}, len(batchISBNs)) + for i, isbn := range batchISBNs { + placeholders[i] = "?" + args[i] = isbn + } + + query := fmt.Sprintf( + "SELECT isbn FROM xgy_base_item WHERE isbn IN (%s)", + strings.Join(placeholders, ","), + ) + + rows, err := db.Query(query, args...) + if err != nil { + return nil, fmt.Errorf("数据库查询失败: %w", err) + } + + // 读取存在的ISBN + for rows.Next() { + var isbn string + if err := rows.Scan(&isbn); err != nil { + rows.Close() + return nil, fmt.Errorf("扫描ISBN失败: %w", err) + } + existsMap[isbn] = true + } + rows.Close() + + if err = rows.Err(); err != nil { + return nil, fmt.Errorf("遍历数据库行时出错: %w", err) + } + + // 添加延迟避免对数据库造成压力 + if batch < totalBatches-1 { + time.Sleep(50 * time.Millisecond) + } + } + + log.Printf("数据库中存在 %d 个匹配的ISBN", len(existsMap)) + return existsMap, nil +} + +// 找出数据库中不存在的ISBN（ES中有但数据库中没有） +func findESOnlyISBNs(esISBNs []string, dbExistsMap map[string]bool) []string { + var esOnlyISBNs []string + + for _, isbn := range esISBNs { + if !dbExistsMap[isbn] { + esOnlyISBNs = append(esOnlyISBNs, isbn) + } + } + + log.Printf("ES中有 %d 个ISBN在数据库中不存在", len(esOnlyISBNs)) + return esOnlyISBNs +} + +// 导出ES独有ISBN到txt文件 +func exportESOnlyISBNs(esOnlyISBNs []string, outputFile string) error { + if len(esOnlyISBNs) == 0 { + log.Printf("没有ES独有的ISBN需要导出") + return nil + } + + // 确保输出目录存在 + outputDir := filepath.Dir(outputFile) + if err := os.MkdirAll(outputDir, 0755); err != nil { + return fmt.Errorf("创建输出目录失败: %w", err) + } + + // 写入文件 + file, err := os.Create(outputFile) + if err != nil { + return fmt.Errorf("创建文件失败: %w", err) + } + defer file.Close() + + // 写入文件头信息 + header := fmt.Sprintf(`# ES中有但数据库中没有的ISBN列表 +# 数据库表: xgy_base_item +# ES索引: %s +# 导出时间: %s +# 记录数: %d +# 说明: 这些ISBN在ES索引中存在但在数据库表中不存在 + +`, esIndex, time.Now().Format("2006-01-02 15:04:05"), len(esOnlyISBNs)) + + if _, err := file.WriteString(header); err != nil { + return fmt.Errorf("写入文件头失败: %w", err) + } + + // 按字母顺序排序后写入 + sort.Strings(esOnlyISBNs) + successCount := 0 + for _, isbn := range esOnlyISBNs { + if _, err := file.WriteString(isbn + "\n"); err != nil { + log.Printf("警告: 写入ISBN失败 %s: %v", isbn, err) + continue + } + successCount++ + } + + log.Printf("成功导出 %d/%d 个ES独有ISBN到文件: %s", successCount, len(esOnlyISBNs), outputFile) + return nil +} + +// 主函数：查询ES中有但数据库中没有的ISBN +func mainFindESOnlyISBNs() { + // 初始化数据库连接 + dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8mb4&parseTime=True&loc=Local", + "root", + "123456", + "localhost", + 3306, + "book_image") // 请根据实际情况修改数据库名 + + db, err := sql.Open("mysql", dsn) + if err != nil { + log.Fatalf("打开数据库连接失败: %v", err) + } + defer db.Close() + + // 设置连接池参数 + db.SetMaxOpenConns(20) + db.SetMaxIdleConns(10) + + // 测试数据库连接 + if err := db.Ping(); err != nil { + log.Fatalf("数据库连接测试失败: %v", err) + } + + // 初始化ES客户端 + es, err := NewESClient([]string{esAddress}, esUsername, esPassword) + if err != nil { + log.Fatalf("ES连接失败: %v", err) + } + + // 检查ES健康状态 + if err := es.CheckHealth(); err != nil { + log.Fatalf("ES健康检查失败: %v", err) + } + + startTime := time.Now() + log.Printf("开始处理ES与数据库的ISBN匹配...") + + // 步骤1: 从ES获取所有ISBN + esISBNs, err := getAllISBNsFromES(es) + if err != nil { + log.Fatalf("获取ES ISBN失败: %v", err) + } + + // 步骤2: 检查ISBN在数据库中的存在情况 + dbExistsMap, err := checkISBNsInDB(db, esISBNs) + if err != nil { + log.Fatalf("检查数据库中ISBN存在情况失败: %v", err) + } + + // 步骤3: 找出ES独有ISBN（ES中有但数据库中没有） + esOnlyISBNs := findESOnlyISBNs(esISBNs, dbExistsMap) + + // 步骤4: 导出ES独有ISBN + outputFile := "cmd/update_es_gt/missing_isbns.txt" + if err := exportESOnlyISBNs(esOnlyISBNs, outputFile); err != nil { + log.Fatalf("导出ES独有ISBN失败: %v", err) + } + + elapsed := time.Since(startTime) + + // 输出统计信息 + fmt.Printf("\n=== 处理完成 ===\n") + fmt.Printf("ES中ISBN总数: %d\n", len(esISBNs)) + fmt.Printf("数据库中匹配的ISBN数: %d\n", len(dbExistsMap)) + fmt.Printf("ES独有ISBN数（数据库中没有的）: %d\n", len(esOnlyISBNs)) + fmt.Printf("独有比例: %.2f%%\n", float64(len(esOnlyISBNs))/float64(len(esISBNs))*100) + fmt.Printf("耗时: %v\n", elapsed.Round(time.Millisecond)) + fmt.Printf("输出文件: %s\n", outputFile) + + // 显示部分ES独有ISBN示例 + if len(esOnlyISBNs) > 0 { + fmt.Printf("\nES独有ISBN示例 (前10个):\n") + for i := 0; i < 10 && i < len(esOnlyISBNs); i++ { + fmt.Printf(" %s\n", esOnlyISBNs[i]) + } + if len(esOnlyISBNs) > 10 { + fmt.Printf(" ... 还有 %d 个\n", len(esOnlyISBNs)-10) + } + } +} + +// 查询并导出有销售记录且book_pic为空的ISBN +func queryAndExportSaleISBNsWithEmptyPic(es *ESClient, outputFile string) error { + log.Printf("开始查询有销售记录且book_pic为空的ISBN...") + + // 查询条件: (day_sale_7 > 0 OR day_sale_15 > 0 OR day_sale_30 > 0) AND book_pic为空 + query := map[string]interface{}{ + "query": map[string]interface{}{ + "bool": map[string]interface{}{ + "must": []map[string]interface{}{ + { + "bool": map[string]interface{}{ + "should": []map[string]interface{}{ + {"range": map[string]interface{}{"day_sale_7": map[string]interface{}{"gt": 0}}}, + {"range": map[string]interface{}{"day_sale_15": map[string]interface{}{"gt": 0}}}, + {"range": map[string]interface{}{"day_sale_30": map[string]interface{}{"gt": 0}}}, + }, + "minimum_should_match": 1, + }, + }, + { + "bool": map[string]interface{}{ + "should": []map[string]interface{}{ + // 匹配book_pic字段为空 + {"term": map[string]interface{}{"book_pic": ""}}, + // 匹配book_pic字段不存在 + { + "bool": map[string]interface{}{ + "must_not": map[string]interface{}{ + "exists": map[string]interface{}{"field": "book_pic"}, + }, + }, + }, + }, + }, + }, + }, + }, + }, + "_source": []string{"isbn"}, + "sort": []map[string]interface{}{ + {"isbn": "asc"}, // 按ISBN排序 + }, + "size": 10000, + } + + // 打印查询条件用于验证 + queryJSON, _ := json.MarshalIndent(query, "", " ") + log.Printf("查询条件:\n%s", string(queryJSON)) + + var allISBNs []string + var searchAfter interface{} + totalCount := 0 + page := 1 + + for { + // 复制基础查询 + currentQuery := make(map[string]interface{}) + for k, v := range query { + currentQuery[k] = v + } + + // 添加游标 + if searchAfter != nil { + currentQuery["search_after"] = searchAfter + } + + body, err := json.Marshal(currentQuery) + if err != nil { + return fmt.Errorf("序列化查询失败: %w", err) + } + + log.Printf("执行第 %d 页查询...", page) + + // 执行搜索 + res, err := es.client.Search( + es.client.Search.WithIndex(esIndex), + es.client.Search.WithBody(strings.NewReader(string(body))), + es.client.Search.WithContext(context.Background()), + ) + if err != nil { + return fmt.Errorf("ES搜索失败: %w", err) + } + defer res.Body.Close() + + if res.IsError() { + bodyBytes, _ := io.ReadAll(res.Body) + return fmt.Errorf("ES搜索返回错误: %s, 响应: %s", res.String(), string(bodyBytes)) + } + + // 读取并解析响应体 + bodyBytes, err := io.ReadAll(res.Body) + if err != nil { + return fmt.Errorf("读取响应体失败: %w", err) + } + + var result map[string]interface{} + if err := json.Unmarshal(bodyBytes, &result); err != nil { + return fmt.Errorf("解析ES响应失败: %w", err) + } + + // 检查是否有错误 + if errMsg, exists := result["error"]; exists { + return fmt.Errorf("ES返回错误: %v", errMsg) + } + + hits, ok := result["hits"].(map[string]interface{}) + if !ok { + return fmt.Errorf("无法解析hits字段") + } + + // 获取总命中数 + if totalHits, exists := hits["total"].(map[string]interface{}); exists { + if totalValue, exists := totalHits["value"]; exists { + log.Printf("ES返回总命中数: %.0f", totalValue) + } + } + + hitList, ok := hits["hits"].([]interface{}) + if !ok || len(hitList) == 0 { + log.Printf("第 %d 页没有数据，查询完成", page) + break // 没有更多数据 + } + + // 处理当前批次的数据 + batchCount := 0 + for _, hit := range hitList { + hitMap, ok := hit.(map[string]interface{}) + if !ok { + log.Printf("警告: 无法解析hit数据") + continue + } + + source, ok := hitMap["_source"].(map[string]interface{}) + if !ok { + log.Printf("警告: 无法解析_source字段") + continue + } + + isbn, ok := source["isbn"].(string) + if ok && isbn != "" { + allISBNs = append(allISBNs, isbn) + batchCount++ + } else { + log.Printf("警告: 跳过空的ISBN字段") + } + + // 更新游标（使用最后一个文档的排序值） + sortValues, ok := hitMap["sort"].([]interface{}) + if ok && len(sortValues) > 0 { + searchAfter = sortValues + } + } + + totalCount += batchCount + log.Printf("第 %d 页: 获取 %d 条ISBN记录，总计: %d", page, batchCount, totalCount) + page++ + + // 如果返回的数量小于请求的数量，说明已经是最后一页 + if len(hitList) < 10000 { + log.Printf("最后一页数据量 %d < 10000，查询完成", len(hitList)) + break + } + + // 添加短暂延迟，避免对ES造成过大压力 + time.Sleep(100 * time.Millisecond) + } + + if len(allISBNs) == 0 { + return fmt.Errorf("没有找到符合条件的ISBN记录") + } + + // 去重 + isbnSet := make(map[string]bool) + uniqueISBNs := make([]string, 0) + for _, isbn := range allISBNs { + if !isbnSet[isbn] { + isbnSet[isbn] = true + uniqueISBNs = append(uniqueISBNs, isbn) + } + } + + log.Printf("去重前: %d 条, 去重后: %d 条", len(allISBNs), len(uniqueISBNs)) + + // 确保输出目录存在 + outputDir := filepath.Dir(outputFile) + if err := os.MkdirAll(outputDir, 0755); err != nil { + return fmt.Errorf("创建输出目录失败: %w", err) + } + + // 写入文件 + file, err := os.Create(outputFile) + if err != nil { + return fmt.Errorf("创建文件失败: %w", err) + } + defer file.Close() + + // 写入文件头信息 + header := fmt.Sprintf(`# 有销售记录且book_pic为空的ISBN列表 +# 查询条件: (day_sale_7 > 0 OR day_sale_15 > 0 OR day_sale_30 > 0) AND (book_pic为空 或 book_pic字段不存在) +# 索引: %s +# 查询时间: %s +# 总记录数: %d + +`, esIndex, time.Now().Format("2006-01-02 15:04:05"), len(uniqueISBNs)) + + if _, err := file.WriteString(header); err != nil { + return fmt.Errorf("写入文件头失败: %w", err) + } + + // 按字母顺序排序后写入 + sort.Strings(uniqueISBNs) + successCount := 0 + for _, isbn := range uniqueISBNs { + if _, err := file.WriteString(isbn + "\n"); err != nil { + log.Printf("警告: 写入ISBN失败 %s: %v", isbn, err) + continue + } + successCount++ + } + + log.Printf("成功导出 %d/%d 个符合条件的ISBN到文件: %s", successCount, len(uniqueISBNs), outputFile) + return nil +} + +// 查询并导出有销售记录且book_pic为空的ISBN主函数 +func mainQuerySaleISBNsWithEmptyPic() { + // 初始化ES客户端 + es, err := NewESClient([]string{esAddress}, esUsername, esPassword) + if err != nil { + log.Fatalf("ES连接失败: %v", err) + } + + // 检查ES健康状态 + if err := es.CheckHealth(); err != nil { + log.Fatalf("ES健康检查失败: %v", err) + } + + // 输出文件路径 + outputFile := "es/sale_isbns_empty_pic.txt" + + // 查询并导出ISBN + startTime := time.Now() + if err := queryAndExportSaleISBNsWithEmptyPic(es, outputFile); err != nil { + log.Fatalf("导出有销售记录且book_pic为空的ISBN失败: %v", err) + } + + elapsed := time.Since(startTime) + log.Printf("任务完成！耗时: %v，ISBN已导出到: %s", elapsed.Round(time.Millisecond), outputFile) +} diff --git a/es/sale_isbns_empty_pic.txt b/es/sale_isbns_empty_pic.txt new file mode 100644 index 0000000..45692c5 --- /dev/null +++ b/es/sale_isbns_empty_pic.txt @@ -0,0 +1,150418 @@ +# 有销售记录且book_pic为空的ISBN列表 +# 查询条件: (day_sale_7 > 0 OR day_sale_15 > 0 OR day_sale_30 > 0) AND (book_pic为空 或 book_pic字段不存在) +# 索引: books-from-mysql +# 查询时间: 2025-12-04 10:49:06 +# 总记录数: 150412 + +9770257027006 +9770257656091 +9770583128002 +9770583128248 +9771001189025 +9771001584004 +9771001791006 +9771002279008 +9771002754000 +9771003117163 +9771003178065 +9771003271216 +9771005180219 +9771005180240 +9771005360208 +9771005360239 +9771005384006 +9771005394074 +9771005396016 +9771005715008 +9771005867004 +9771005887002 +9771006358105 +9771007384219 +9771007418044 +9771007700002 +9771007701054 +9771007863004 +9771008332004 +9771008376008 +9771008859006 +9771009633056 +9771009633193 +9771009633209 +9771009633216 +9771009633223 +9771009633230 +9771009633247 +9771009633254 +9771009785199 +9771671064059 +9771671472069 +9771671640017 +9771671688026 +9771671688095 +9771672232020 +9771672666047 +9771672666191 +9771672666207 +9771672666214 +9771672820043 +9771672897083 +9771672897199 +9771672909120 +9771673068062 +9771673082204 +9771673388061 +9771673789004 +9771673789233 +9771673957083 +9771674111224 +9771674168082 +9771674168105 +9771674168136 +9771674168150 +9771674618099 +9771674622096 +9771674678208 +9771674678222 +9771674678239 +9771674678246 +9771674678253 +9771815922009 +9772095127122 +9772095127139 +9772095127146 +9772095127153 +9772095286003 +9772095303120 +9772095400232 +9772095436125 +9772095639151 +9772095985173 +9772096974244 +9780000155160 +9780006176909 +9780006512134 +9780006754022 +9780007119318 +9780007119325 +9780007134014 +9780007134021 +9780007137282 +9780007155668 +9780007158454 +9780007158461 +9780007158478 +9780007158492 +9780007158515 +9780007158522 +9780007158560 +9780007169979 +9780007174164 +9780007175208 +9780007214228 +9780007236244 +9780007241910 +9780007263516 +9780007309283 +9780007313730 +9780007321131 +9780007350773 +9780007350940 +9780007371082 +9780007371464 +9780007423248 +9780007423262 +9780007423279 +9780007431571 +9780007447831 +9780007447848 +9780007447855 +9780007447862 +9780007448036 +9780007453580 +9780007460625 +9780007466061 +9780007466078 +9780007477159 +9780007488346 +9780007527601 +9780007578498 +9780007580422 +9780007580583 +9780007591855 +9780007917884 +9780007917891 +9780007917914 +9780007935185 +9780007935192 +9780007935253 +9780007935277 +9780007935284 +9780008129583 +9780020437505 +9780021195114 +9780021195855 +9780021503124 +9780022880057 +9780029253618 +9780060001506 +9780060084622 +9780060094614 +9780060193140 +9780060234973 +9780060245863 +9780060507022 +9780060507060 +9780060516406 +9780060525507 +9780060530945 +9780060555665 +9780060560454 +9780060572341 +9780060574215 +9780060581800 +9780060586751 +9780060589462 +9780060736262 +9780060741723 +9780060744571 +9780060745189 +9780060752613 +9780060760496 +9780060779726 +9780060797423 +9780060822293 +9780060827670 +9780060827717 +9780060835453 +9780060835538 +9780060837020 +9780060853808 +9780060878979 +9780060891541 +9780060928834 +9780060932138 +9780060935467 +9780061074295 +9780061120084 +9780061124952 +9780061141515 +9780061177491 +9780061233845 +9780061234736 +9780061240171 +9780061241895 +9780061336454 +9780061346057 +9780061433078 +9780061438295 +9780061689093 +9780061720802 +9780061894893 +9780061935060 +9780061964282 +9780061992278 +9780061994425 +9780062022714 +9780062024039 +9780062047410 +9780062060242 +9780062073488 +9780062095268 +9780062110664 +9780062110725 +9780062120991 +9780062244543 +9780062268143 +9780062273208 +9780062288912 +9780062292988 +9780062343963 +9780062366962 +9780062366979 +9780062381859 +9780062381927 +9780062402196 +9780062417107 +9780062422811 +9780062513342 +9780062641540 +9780062730985 +9780062730992 +9780062731005 +9780062731029 +9780062731319 +9780062732743 +9780064400015 +9780064400022 +9780064400039 +9780064400060 +9780064400084 +9780064400558 +9780064400565 +9780064401845 +9780064404891 +9780064405171 +9780064407052 +9780064407687 +9780064408561 +9780064409407 +9780064409421 +9780064409445 +9780064410137 +9780064410151 +9780064410922 +9780064430173 +9780064430180 +9780064430968 +9780064430999 +9780064431453 +9780064431477 +9780064431781 +9780064432108 +9780064436168 +9780064440028 +9780064440042 +9780064440080 +9780064440103 +9780064440202 +9780064440233 +9780064440349 +9780064440387 +9780064440509 +9780064440554 +9780064440578 +9780064440585 +9780064440943 +9780064441049 +9780064441209 +9780064441452 +9780064441551 +9780064441766 +9780064442121 +9780064442374 +9780064442435 +9780064442442 +9780064442640 +9780064442701 +9780064442725 +9780064442886 +9780064443081 +9780064443159 +9780064450263 +9780064450911 +9780064451062 +9780064451192 +9780064451987 +9780064460934 +9780064467032 +9780064471046 +9780064471107 +9780066238500 +9780066620992 +9780070534483 +9780071373586 +9780071392310 +9780071401944 +9780071418584 +9780071469791 +9780071636087 +9780071771320 +9780078458132 +9780091826611 +9780099273974 +9780099276586 +9780099284864 +9780099302780 +9780099408390 +9780099408796 +9780099417958 +9780099419785 +9780099429791 +9780099450252 +9780099456483 +9780099457152 +9780099464464 +9780099470434 +9780099497042 +9780099507383 +9780099511021 +9780099518471 +9780099528128 +9780099546184 +9780099549482 +9780099590088 +9780099596431 +9780099825104 +9780099908401 +9780099908609 +9780099910107 +9780130122179 +9780131933958 +9780140077025 +9780140143508 +9780140157352 +9780140168549 +9780140177398 +9780140189896 +9780140268867 +9780140278798 +9780140283334 +9780140344455 +9780140385724 +9780140432084 +9780140439441 +9780140442939 +9780140444254 +9780140445008 +9780140445688 +9780140446456 +9780140447606 +9780140449303 +9780140449334 +9780140455489 +9780140481389 +9780140501780 +9780140501827 +9780140548754 +9780140563665 +9780140564402 +9780140567281 +9780140569322 +9780140620153 +9780140620429 +9780141014869 +9780141018980 +9780141022727 +9780141033570 +9780141034591 +9780141034898 +9780141041339 +9780141043029 +9780141182483 +9780141182537 +9780141182575 +9780141182636 +9780141182674 +9780141182742 +9780141183336 +9780141184999 +9780141185064 +9780141185071 +9780141185224 +9780141185620 +9780141186672 +9780141186887 +9780141188935 +9780141189208 +9780141199078 +9780141312422 +9780141314570 +9780141321080 +9780141321103 +9780141321264 +9780141322438 +9780141322629 +9780141324906 +9780141324913 +9780141324920 +9780141329680 +9780141331331 +9780141334813 +9780141339665 +9780141340098 +9780141340821 +9780141341880 +9780141345659 +9780141346809 +9780141346816 +9780141346847 +9780141348131 +9780141349985 +9780141354828 +9780141354835 +9780141359786 +9780141365428 +9780141383514 +9780141439471 +9780141439518 +9780141441146 +9780141441726 +9780141500300 +9780141976228 +9780142000281 +9780142001103 +9780142004371 +9780142300701 +9780142401040 +9780142401088 +9780142402498 +9780142402511 +9780142407332 +9780142410318 +9780142410349 +9780142410363 +9780142410387 +9780142414330 +9780142414934 +9780142424179 +9780142426050 +9780142501269 +9780142501856 +9780143034902 +9780143038092 +9780143038139 +9780143038252 +9780143112723 +9780143115267 +9780143118244 +9780143118435 +9780143118756 +9780143127550 +9780143129110 +9780143130154 +9780147515827 +9780152002657 +9780152010669 +9780152019907 +9780152163983 +9780156012195 +9780156027328 +9780156030083 +9780156035880 +9780156078306 +9780192728463 +9780192734136 +9780192739858 +9780192744524 +9780192745712 +9780192775429 +9780192775764 +9780194202466 +9780194505314 +9780194596176 +9780194596275 +9780194740128 +9780194740760 +9780194750455 +9780195179644 +9780195800036 +9780198481515 +9780198612438 +9780198788607 +9780199556557 +9780201483406 +9780205309023 +9780230445161 +9780230747722 +9780241003008 +9780241135907 +9780241137291 +9780241206676 +9780241294055 +9780241377291 +9780241468395 +9780241477779 +9780241950425 +9780241958223 +9780261102354 +9780261102361 +9780261102378 +9780261102736 +9780261103344 +9780261103573 +9780261103580 +9780261103597 +9780262062664 +9780300143324 +9780307119476 +9780307155108 +9780307165480 +9780307261090 +9780307275554 +9780307276476 +9780307277787 +9780307280503 +9780307386458 +9780307388810 +9780307454546 +9780307454898 +9780307455352 +9780307455871 +9780307716989 +9780307739964 +9780307743657 +9780307887894 +9780307945020 +9780307946713 +9780307949899 +9780307975874 +9780307980441 +9780312343750 +9780312367541 +9780312369811 +9780312380038 +9780312384487 +9780312510787 +9780312516895 +9780316003742 +9780316003957 +9780316006682 +9780316010665 +9780316013567 +9780316015844 +9780316017428 +9780316017923 +9780316024969 +9780316032148 +9780316032544 +9780316032551 +9780316034784 +9780316056281 +9780316057905 +9780316058438 +9780316070362 +9780316085298 +9780316160179 +9780316160209 +9780316170727 +9780316228534 +9780316286398 +9780316346627 +9780316358392 +9780316381994 +9780316769174 +9780316769488 +9780321501219 +9780330420051 +9780330433587 +9780340818862 +9780340896983 +9780340932087 +9780340994689 +9780345391803 +9780345404473 +9780345453747 +9780345472328 +9780345514400 +9780349118321 +9780349134284 +9780357123515 +9780357124703 +9780357124710 +9780357124727 +9780357124734 +9780357124741 +9780357372173 +9780374500016 +9780374530716 +9780374531263 +9780375414572 +9780375703768 +9780375706851 +9780375709326 +9780375714832 +9780375725609 +9780375802683 +9780375802720 +9780375806148 +9780375806162 +9780375806216 +9780375810831 +9780375811746 +9780375813566 +9780375813634 +9780375813658 +9780375813672 +9780375822667 +9780375822803 +9780375823770 +9780375824838 +9780375825538 +9780375826696 +9780375827785 +9780375830389 +9780375832192 +9780375832550 +9780375836909 +9780375842207 +9780375849916 +9780375855528 +9780375856495 +9780375858079 +9780375858123 +9780375864919 +9780375865312 +9780375866777 +9780375869020 +9780375873669 +9780375874918 +9780380709120 +9780380709182 +9780380709540 +9780385092395 +9780385349949 +9780385385206 +9780385474542 +9780385490818 +9780385491747 +9780385496490 +9780385504201 +9780385504225 +9780385517256 +9780385528757 +9780385606134 +9780385613675 +9780385738101 +9780385742894 +9780385751537 +9780385751896 +9780385754729 +9780393317558 +9780393324822 +9780393926712 +9780394800011 +9780394800134 +9780394800165 +9780394800295 +9780394800387 +9780394810096 +9780394820378 +9780394823379 +9780394829203 +9780394830780 +9780394831299 +9780394850108 +9780394874715 +9780394880563 +9780394888668 +9780394896953 +9780395137185 +9780395470305 +9780395557013 +9780395599686 +9780395664131 +9780395706725 +9780399144462 +9780399230134 +9780399231667 +9780399236051 +9780399242694 +9780399243875 +9780399245107 +9780399246661 +9780399247477 +9780399247484 +9780399256738 +9780399501487 +9780399533372 +9780399594496 +9780415267632 +9780415278461 +9780415325059 +9780425170342 +9780425176405 +9780425233986 +9780439023498 +9780439023511 +9780439023528 +9780439023535 +9780439023542 +9780439064873 +9780439136365 +9780439139595 +9780439139601 +9780439286060 +9780439358064 +9780439358071 +9780439376129 +9780439405577 +9780439559638 +9780439559645 +9780439559652 +9780439559669 +9780439559676 +9780439559683 +9780439559690 +9780439559706 +9780439559720 +9780439559744 +9780439569897 +9780439598453 +9780439629041 +9780439673631 +9780439681230 +9780439684026 +9780439691390 +9780439691437 +9780439691444 +9780439785969 +9780439798341 +9780439813785 +9780440180296 +9780440221654 +9780440228592 +9780440236672 +9780440237686 +9780440241584 +9780440241898 +9780440242697 +9780440403418 +9780440404385 +9780440406945 +9780440412991 +9780440413028 +9780440414803 +9780440416029 +9780440418214 +9780440418320 +9780440419273 +9780440419518 +9780440420477 +9780440461265 +9780440461913 +9780440462767 +9780440462828 +9780440463009 +9780441172719 +9780441569595 +9780446310789 +9780446357425 +9780446365383 +9780446528382 +9780446567336 +9780446606813 +9780446617680 +9780446695183 +9780446695190 +9780448089010 +9780448409702 +9780448413037 +9780448413044 +9780448418490 +9780448421841 +9780448437651 +9780448478999 +9780448479132 +9780449213940 +9780451167538 +9780451191144 +9780451210852 +9780451419170 +9780451419439 +9780451469885 +9780451471703 +9780451524935 +9780451526342 +9780451526861 +9780451527295 +9780451528308 +9780451528377 +9780451528834 +9780451529411 +9780451529534 +9780451529558 +9780451529701 +9780451529718 +9780451530066 +9780451530295 +9780451530530 +9780451530547 +9780451530578 +9780451530707 +9780451530912 +9780451530936 +9780451531070 +9780451531186 +9780451531346 +9780451531742 +9780451531810 +9780451532077 +9780451532169 +9780451532244 +9780452289963 +9780470616307 +9780470646137 +9780470821923 +9780470858769 +9780470876411 +9780471320579 +9780471678762 +9780471743675 +9780486281544 +9780486282114 +9780486298573 +9780486428819 +9780486435206 +9780486678702 +9780517884539 +9780521146944 +9780521156097 +9780521159487 +9780521179072 +9780521530118 +9780521540513 +9780521653978 +9780521672733 +9780521698894 +9780521719063 +9780525426004 +9780525478607 +9780538453424 +9780544336261 +9780544340688 +9780544456860 +9780544602250 +9780545010221 +9780545016421 +9780545016469 +9780545072700 +9780545137690 +9780545139700 +9780545162074 +9780545208857 +9780545222747 +9780545227728 +9780545341080 +9780545392150 +9780545393515 +9780545477116 +9780545499088 +9780545536011 +9780545540605 +9780545540629 +9780545556231 +9780545556248 +9780545556255 +9780545581608 +9780545582933 +9780545582957 +9780545582995 +9780545583008 +9780545596275 +9780545599320 +9780545623926 +9780545646239 +9780545647717 +9780545658485 +9780545694704 +9780545744638 +9780545746182 +9780545790352 +9780545835367 +9780545935173 +9780545935180 +9780545935203 +9780545935210 +9780545980258 +9780547076805 +9780547237602 +9780547238739 +9780547328614 +9780547577098 +9780547595290 +9780547885476 +9780547904146 +9780552149518 +9780552150736 +9780552151696 +9780552151740 +9780552151764 +9780552545105 +9780552553698 +9780552560061 +9780552560207 +9780552560214 +9780552565974 +9780552577540 +9780552779043 +9780553176988 +9780553208849 +9780553210095 +9780553210163 +9780553210798 +9780553211023 +9780553211160 +9780553211283 +9780553211757 +9780553211764 +9780553211955 +9780553212143 +9780553212181 +9780553212334 +9780553212464 +9780553212495 +9780553212525 +9780553212624 +9780553212730 +9780553212754 +9780553212921 +9780553213102 +9780553213119 +9780553213331 +9780553213409 +9780553213423 +9780553213508 +9780553213560 +9780553213737 +9780553213805 +9780553213874 +9780553214024 +9780553214628 +9780553214642 +9780553263220 +9780553272949 +9780553277456 +9780553281095 +9780553285789 +9780553296983 +9780553380163 +9780553381689 +9780553382563 +9780553406634 +9780553418286 +9780553509977 +9780553524253 +9780553573404 +9780553573428 +9780553577129 +9780553579901 +9780553582024 +9780553585971 +9780553589085 +9780553815221 +9780553840070 +9780571200733 +9780571226122 +9780571333134 +9780571334650 +9780590371254 +9780590372220 +9780590414272 +9780590472807 +9780590480871 +9780590930024 +9780593054277 +9780593090053 +9780593189641 +9780603570537 +9780609610572 +9780609808702 +9780618538225 +9780618663736 +9780618706419 +9780618997138 +9780670479580 +9780670878550 +9780670919536 +9780670922857 +9780671201586 +9780671212094 +9780671449025 +9780671562717 +9780671612979 +9780671631987 +9780671708634 +9780671724009 +9780671739164 +9780671880316 +9780674537514 +9780679444657 +9780679720195 +9780679720201 +9780679721888 +9780679723165 +9780679734772 +9780679745204 +9780679762881 +9780679764021 +9780679778318 +9780679802181 +9780679809012 +9780679812074 +9780679824114 +9780679824121 +9780679824244 +9780679824251 +9780679826422 +9780679863717 +9780679863724 +9780679863748 +9780679880844 +9780679881681 +9780679882800 +9780679882817 +9780679883388 +9780679883395 +9780679883401 +9780679883418 +9780679886501 +9780679887386 +9780679890362 +9780679890478 +9780679890508 +9780679890553 +9780679890614 +9780679890621 +9780679890638 +9780679890645 +9780679890652 +9780679890669 +9780679890676 +9780679890683 +9780679890690 +9780679890706 +9780679890799 +9780679891161 +9780679894575 +9780679894582 +9780679894599 +9780679894605 +9780684801223 +9780684803357 +9780684811635 +9780684830681 +9780684846651 +9780684850337 +9780684852867 +9780688082949 +9780688104795 +9780688128975 +9780688132859 +9780688135737 +9780688147327 +9780688164249 +9780688173647 +9780689711428 +9780689711817 +9780689714412 +9780689716119 +9780689810053 +9780689814747 +9780689815812 +9780689817311 +9780689829598 +9780689835605 +9780689835681 +9780689844317 +9780689847127 +9780689847431 +9780689853494 +9780689856402 +9780689856587 +9780689859373 +9780689863523 +9780689866852 +9780689874727 +9780689877568 +9780690043969 +9780694003617 +9780694004928 +9780694007097 +9780694010677 +9780694011674 +9780694013012 +9780694014569 +9780694015153 +9780698115637 +9780698116498 +9780698117822 +9780698118300 +9780698118959 +9780712625982 +9780714150055 +9780714150659 +9780714151236 +9780714838144 +9780714843377 +9780714861142 +9780714864815 +9780723247708 +9780723263661 +9780723267386 +9780723296782 +9780735204379 +9780738606767 +9780739377451 +9780743200400 +9780743216302 +9780743244589 +9780743260886 +9780743262026 +9780743264747 +9780743269513 +9780743272933 +9780743276375 +9780743453257 +9780743475761 +9780743477109 +9780743487580 +9780743487597 +9780743487689 +9780744523232 +9780744536607 +9780744560275 +9780746071588 +9780746074602 +9780746077269 +9780746097755 +9780746098479 +9780747532743 +9780747538486 +9780747546290 +9780747550990 +9780747551003 +9780747557555 +9780747581086 +9780747584681 +9780747591061 +9780747591917 +9780747596493 +9780747599906 +9780751364361 +9780751503845 +9780751527377 +9780751536140 +9780751537536 +9780751565355 +9780751565362 +9780753522752 +9780753553572 +9780753555200 +9780753827666 +9780761147633 +9780761149125 +9780761149149 +9780761149613 +9780761160915 +9780761160960 +9780761163800 +9780761166559 +9780761185697 +9780761450689 +9780762452385 +9780762458684 +9780763619503 +9780763619619 +9780763632441 +9780763642648 +9780763643676 +9780763644499 +9780763645045 +9780763649524 +9780763650940 +9780763660659 +9780763672539 +9780763680886 +9780763680909 +9780767908184 +9780767922715 +9780786836024 +9780786838653 +9780786865666 +9780786887217 +9780787902698 +9780787948030 +9780794515195 +9780794529468 +9780794532321 +9780802135162 +9780804168915 +9780805047905 +9780805087970 +9780805093452 +9780807508527 +9780807509760 +9780807551417 +9780807592076 +9780810987586 +9780810987999 +9780810988217 +9780811849098 +9780812971156 +9780812981605 +9780842329125 +9780847846177 +9780859539449 +9780860685418 +9780874477184 +9780874775723 +9780875846514 +9780875847160 +9780875848631 +9780877791324 +9780877791515 +9780877796268 +9780877796367 +9780877798071 +9780877798095 +9780877798507 +9780877798552 +9780877799061 +9780877799108 +9780877799313 +9780884271789 +9780884271956 +9780887080265 +9780887306679 +9780960695409 +9780974589237 +9780984688777 +9781007730138 +9781007730312 +9781101872703 +9781101873854 +9781101905555 +9781107480537 +9781107527904 +9781107539303 +9781107539334 +9781107614581 +9781107626133 +9781107664654 +9781108407144 +9781108409728 +9781108413749 +9781108430036 +9781108437189 +9781108586627 +9781108592529 +9781108592543 +9781108610766 +9781108635073 +9781108647533 +9781108647809 +9781108648295 +9781108648554 +9781108671507 +9781108694858 +9781108694865 +9781108888073 +9781118319222 +9781119687924 +9781250010230 +9781250061539 +9781250183866 +9781285165875 +9781305254503 +9781305254527 +9781316612309 +9781316630068 +9781338099133 +9781338109061 +9781338230642 +9781338236576 +9781338299144 +9781338323214 +9781394200214 +9781400031863 +9781400032716 +9781400077915 +9781400078776 +9781400079179 +9781400096046 +9781400096893 +9781401243791 +9781401323257 +9781401398033 +9781402712579 +9781402713187 +9781402725005 +9781402725333 +9781402726644 +9781402736919 +9781402754241 +9781402773341 +9781404827509 +9781404833166 +9781405025263 +9781405255486 +9781405329163 +9781405811262 +9781405903752 +9781406300406 +9781406308129 +9781406313574 +9781406315509 +9781406327847 +9781406331851 +9781406334715 +9781406338430 +9781406338485 +9781406338515 +9781406341638 +9781406348248 +9781406348255 +9781406348262 +9781406353433 +9781406357622 +9781406358780 +9781407108155 +9781407109084 +9781407532059 +9781408215333 +9781408305058 +9781408703748 +9781408810545 +9781408822074 +9781408841754 +9781408845646 +9781408850756 +9781408855652 +9781408855669 +9781408855676 +9781408855683 +9781408855690 +9781408855706 +9781408855713 +9781408855911 +9781408856772 +9781409301493 +9781409305996 +9781409313212 +9781409314943 +9781409337027 +9781409355717 +9781409507376 +9781409509233 +9781409523383 +9781409535256 +9781409538875 +9781409549963 +9781409550181 +9781409550242 +9781409551645 +9781409551652 +9781409551843 +9781409563945 +9781409570202 +9781409581253 +9781409582069 +9781409591528 +9781411449589 +9781416500322 +9781416502494 +9781416502661 +9781416548942 +9781416549000 +9781416936473 +9781416947370 +9781416960799 +9781416978008 +9781416985846 +9781416990529 +9781419702235 +9781419709197 +9781419712173 +9781419713484 +9781422157992 +9781422188613 +9781423100720 +9781423103349 +9781423113461 +9781423113485 +9781423119913 +9781423121909 +9781423133087 +9781423140597 +9781423143437 +9781423154044 +9781423167228 +9781423174912 +9781423177869 +9781423179580 +9781423183051 +9781423190875 +9781426306129 +9781426307041 +9781426307935 +9781426310140 +9781439199190 +9781442419810 +9781442433700 +9781442450707 +9781442452046 +9781442466388 +9781442496354 +9781442500235 +9781444759549 +9781444778137 +9781447264538 +9781447900627 +9781447954200 +9781449474256 +9781451635621 +9781451639612 +9781451648539 +9781451651683 +9781451663884 +9781451673319 +9781451690316 +9781451696196 +9781452107813 +9781452122236 +9781455582877 +9781457304309 +9781465424464 +9781474915083 +9781476764665 +9781481460019 +9781484716304 +9781484737804 +9781491962299 +9781501124020 +9781501150111 +9781511211239 +9781511216708 +9781511217897 +9781511220224 +9781511220736 +9781511223683 +9781511226417 +9781511226455 +9781511228879 +9781511231480 +9781511232548 +9781511234320 +9781511237543 +9781524767297 +9781524772185 +9781529013245 +9781529029765 +9781529112085 +9781551232379 +9781557042460 +9781564026200 +9781568581903 +9781576872673 +9781576875773 +9781577314806 +9781579903626 +9781580242295 +9781582701707 +9781583335086 +9781584855781 +9781585424337 +9781586638481 +9781586638535 +9781591202622 +9781591391104 +9781591391340 +9781591391852 +9781591392842 +9781591396192 +9781591396390 +9781591846444 +9781593080563 +9781594480003 +9781594483011 +9781594483073 +9781594483592 +9781594484803 +9781594631931 +9781594632204 +9781594633102 +9781594746161 +9781595620156 +9781596730380 +9781596730458 +9781596730533 +9781612680194 +9781616204518 +9781629381510 +9781639953998 +9781705160275 +9781782953975 +9781783443857 +9781783938223 +9781784700089 +9781784701178 +9781784703936 +9781784709044 +9781840220551 +9781840221176 +9781840224016 +9781841215655 +9781841483917 +9781844084470 +9781844285136 +9781846434037 +9781846866203 +9781846866555 +9781846868283 +9781848549562 +9781848667921 +9781848779631 +9781853260001 +9781853260087 +9781853260094 +9781853260124 +9781853260155 +9781853260162 +9781853260209 +9781853260230 +9781853260247 +9781853260254 +9781853260285 +9781853260339 +9781853260360 +9781853260391 +9781853260414 +9781853260506 +9781853260629 +9781853260681 +9781853260698 +9781853260704 +9781853260902 +9781853260933 +9781853261008 +9781853261015 +9781853261077 +9781853261145 +9781853261169 +9781853261183 +9781853261206 +9781853261398 +9781853261404 +9781853261411 +9781853261589 +9781853261602 +9781853261763 +9781853261824 +9781853261947 +9781853262104 +9781853262388 +9781853262418 +9781853262715 +9781853262883 +9781853264047 +9781853264085 +9781853264542 +9781853264658 +9781853264849 +9781853264993 +9781853267338 +9781853267482 +9781853268960 +9781857992915 +9781862305274 +9781878424426 +9781888173918 +9781904233657 +9781904233909 +9781904233916 +9781904550051 +9781905026494 +9781905654291 +9781909531192 +9781926776040 +9781933578279 +9781935096566 +9781941234075 +9781984854858 +9782011552457 +9782023083000 +9782024000006 +9782024060901 +9782401102002 +9782401588004 +9782402491006 +9782711848294 +9782723458788 +9782854951455 +9782854955446 +9783038440888 +9783038442776 +9783836538725 +9783939249115 +9784048542869 +9784087474398 +9784087520019 +9784101001548 +9784398111142 +9784544005561 +9784883191024 +9786070601262 +9786263107496 +9786826193676 +9786971028250 +9787000100206 +9787000300040 +9787010000183 +9787010000275 +9787010000299 +9787010000312 +9787010000367 +9787010000510 +9787010000695 +9787010000701 +9787010000794 +9787010000817 +9787010000824 +9787010001012 +9787010001043 +9787010001128 +9787010001166 +9787010001333 +9787010001494 +9787010001715 +9787010001876 +9787010001906 +9787010001937 +9787010001968 +9787010002002 +9787010002279 +9787010002347 +9787010002637 +9787010002668 +9787010002705 +9787010002729 +9787010002743 +9787010003085 +9787010003276 +9787010003375 +9787010003740 +9787010003801 +9787010003818 +9787010003986 +9787010004129 +9787010004136 +9787010004150 +9787010004389 +9787010004624 +9787010004679 +9787010004686 +9787010004754 +9787010004860 +9787010005072 +9787010005317 +9787010005393 +9787010005409 +9787010005744 +9787010006017 +9787010006147 +9787010006253 +9787010006307 +9787010006314 +9787010006321 +9787010006338 +9787010006444 +9787010006512 +9787010006536 +9787010006826 +9787010006857 +9787010007007 +9787010007250 +9787010007281 +9787010007342 +9787010007359 +9787010007762 +9787010008257 +9787010008271 +9787010008301 +9787010008622 +9787010008646 +9787010008691 +9787010009018 +9787010009193 +9787010009384 +9787010009391 +9787010009858 +9787010010021 +9787010010311 +9787010010489 +9787010010571 +9787010010700 +9787010010830 +9787010011417 +9787010011776 +9787010011806 +9787010011820 +9787010011844 +9787010011998 +9787010012063 +9787010012100 +9787010012155 +9787010012162 +9787010012575 +9787010012667 +9787010013107 +9787010013350 +9787010013374 +9787010013404 +9787010013695 +9787010013954 +9787010015125 +9787010015149 +9787010015354 +9787010015507 +9787010015552 +9787010016429 +9787010016474 +9787010017563 +9787010017921 +9787010018027 +9787010018188 +9787010018256 +9787010018966 +9787010019291 +9787010019734 +9787010019826 +9787010019925 +9787010020044 +9787010020051 +9787010020358 +9787010020525 +9787010020556 +9787010020587 +9787010020600 +9787010020624 +9787010020792 +9787010020891 +9787010021119 +9787010021140 +9787010021782 +9787010022598 +9787010022680 +9787010022819 +9787010022857 +9787010022901 +9787010023045 +9787010023601 +9787010023892 +9787010023960 +9787010024240 +9787010024257 +9787010024349 +9787010025087 +9787010025339 +9787010025377 +9787010025940 +9787010025995 +9787010026244 +9787010026671 +9787010026794 +9787010027111 +9787010027128 +9787010027340 +9787010027401 +9787010027609 +9787010027739 +9787010027807 +9787010027852 +9787010027869 +9787010028071 +9787010028118 +9787010028996 +9787010029054 +9787010029320 +9787010029795 +9787010029917 +9787010029986 +9787010030272 +9787010030364 +9787010030579 +9787010030708 +9787010030845 +9787010030906 +9787010031026 +9787010031262 +9787010031347 +9787010031477 +9787010032238 +9787010033198 +9787010033440 +9787010033532 +9787010033624 +9787010033662 +9787010034089 +9787010034102 +9787010034126 +9787010034393 +9787010035314 +9787010035444 +9787010035628 +9787010036045 +9787010036076 +9787010036700 +9787010036854 +9787010036878 +9787010036946 +9787010037011 +9787010037837 +9787010037929 +9787010038100 +9787010038117 +9787010038667 +9787010038919 +9787010039114 +9787010039701 +9787010040363 +9787010040387 +9787010040813 +9787010041551 +9787010043210 +9787010043517 +9787010043777 +9787010044170 +9787010044200 +9787010044712 +9787010045085 +9787010045672 +9787010045924 +9787010046938 +9787010047201 +9787010048932 +9787010049113 +9787010049120 +9787010049236 +9787010050553 +9787010051758 +9787010052236 +9787010054827 +9787010055534 +9787010055619 +9787010056661 +9787010057125 +9787010058337 +9787010058443 +9787010058924 +9787010059105 +9787010059914 +9787010060286 +9787010061016 +9787010061085 +9787010061351 +9787010062259 +9787010062389 +9787010062426 +9787010062846 +9787010065120 +9787010065182 +9787010065205 +9787010065304 +9787010066004 +9787010066264 +9787010067322 +9787010067568 +9787010068695 +9787010069937 +9787010070889 +9787010072357 +9787010072807 +9787010072937 +9787010073231 +9787010073552 +9787010073583 +9787010074771 +9787010074849 +9787010075600 +9787010075785 +9787010075846 +9787010075921 +9787010076263 +9787010077475 +9787010077901 +9787010079172 +9787010079400 +9787010079592 +9787010080543 +9787010080666 +9787010080710 +9787010081366 +9787010081663 +9787010081830 +9787010081922 +9787010083193 +9787010083674 +9787010083681 +9787010084060 +9787010084077 +9787010084374 +9787010085203 +9787010085593 +9787010086453 +9787010087269 +9787010087528 +9787010089089 +9787010089751 +9787010091471 +9787010094083 +9787010097862 +9787010099026 +9787010100982 +9787010102108 +9787010102238 +9787010103358 +9787010104232 +9787010104416 +9787010105833 +9787010106779 +9787010107073 +9787010107349 +9787010107554 +9787010108254 +9787010108506 +9787010109251 +9787010109374 +9787010109664 +9787010109886 +9787010110578 +9787010110639 +9787010110837 +9787010114545 +9787010114859 +9787010116600 +9787010119038 +9787010119137 +9787010119182 +9787010119564 +9787010119939 +9787010120188 +9787010121178 +9787010122687 +9787010124261 +9787010125169 +9787010125749 +9787010125824 +9787010125954 +9787010126326 +9787010127132 +9787010129440 +9787010130309 +9787010130750 +9787010131894 +9787010133065 +9787010133133 +9787010133478 +9787010134277 +9787010134574 +9787010135335 +9787010135427 +9787010136561 +9787010136899 +9787010136967 +9787010138640 +9787010139074 +9787010139128 +9787010139777 +9787010141374 +9787010141954 +9787010143309 +9787010143675 +9787010146065 +9787010146836 +9787010147994 +9787010148823 +9787010150598 +9787010150604 +9787010150697 +9787010151519 +9787010151908 +9787010152448 +9787010152516 +9787010152905 +9787010153636 +9787010154220 +9787010154411 +9787010154473 +9787010154992 +9787010155128 +9787010155500 +9787010157061 +9787010158785 +9787010159010 +9787010159478 +9787010159546 +9787010159591 +9787010161549 +9787010161709 +9787010162676 +9787010162997 +9787010163093 +9787010163345 +9787010163840 +9787010163871 +9787010164069 +9787010165844 +9787010166681 +9787010167268 +9787010167404 +9787010168302 +9787010168654 +9787010168852 +9787010168906 +9787010169040 +9787010169460 +9787010169729 +9787010169859 +9787010170053 +9787010170152 +9787010170237 +9787010170404 +9787010170459 +9787010170534 +9787010170657 +9787010171456 +9787010171593 +9787010171609 +9787010172170 +9787010173207 +9787010173917 +9787010174129 +9787010174211 +9787010174556 +9787010175973 +9787010176178 +9787010176352 +9787010176406 +9787010177038 +9787010177892 +9787010177984 +9787010179377 +9787010179506 +9787010179513 +9787010179568 +9787010180861 +9787010181240 +9787010181769 +9787010182322 +9787010182797 +9787010182919 +9787010183008 +9787010183060 +9787010184029 +9787010184180 +9787010184692 +9787010184944 +9787010184999 +9787010185910 +9787010186801 +9787010187242 +9787010187891 +9787010188294 +9787010188898 +9787010189505 +9787010190921 +9787010190938 +9787010191706 +9787010193076 +9787010193526 +9787010193656 +9787010193977 +9787010194035 +9787010195537 +9787010197029 +9787010197517 +9787010197609 +9787010197999 +9787010198897 +9787010200491 +9787010200811 +9787010200866 +9787010200897 +9787010200903 +9787010200927 +9787010200958 +9787010201061 +9787010201207 +9787010201252 +9787010202723 +9787010204147 +9787010205205 +9787010205854 +9787010205861 +9787010205878 +9787010205946 +9787010206141 +9787010206264 +9787010206295 +9787010206356 +9787010206639 +9787010206653 +9787010207155 +9787010207186 +9787010207735 +9787010208633 +9787010209050 +9787010209845 +9787010210254 +9787010210711 +9787010211572 +9787010211633 +9787010212067 +9787010212142 +9787010212708 +9787010213132 +9787010213545 +9787010214696 +9787010214733 +9787010214863 +9787010215181 +9787010216584 +9787010217406 +9787010218007 +9787010218434 +9787010219233 +9787010219875 +9787010221205 +9787010221335 +9787010221366 +9787010221410 +9787010221526 +9787010221595 +9787010221618 +9787010222417 +9787010222424 +9787010222578 +9787010222660 +9787010222677 +9787010222738 +9787010223049 +9787010224459 +9787010224794 +9787010226347 +9787010227863 +9787010229850 +9787010230085 +9787010230351 +9787010232041 +9787010232539 +9787010232744 +9787010232829 +9787010232904 +9787010233161 +9787010233529 +9787010233987 +9787010234403 +9787010235325 +9787010235615 +9787010235707 +9787010235790 +9787010235950 +9787010236087 +9787010236322 +9787010236506 +9787010236636 +9787010236681 +9787010237633 +9787010237732 +9787010238364 +9787010238869 +9787010239330 +9787010240312 +9787010242569 +9787010243306 +9787010244358 +9787010245553 +9787010245645 +9787010245843 +9787010246246 +9787010246338 +9787010246499 +9787010246604 +9787010247113 +9787010247434 +9787010247526 +9787010247786 +9787010248028 +9787010248127 +9787010248134 +9787010248349 +9787010248417 +9787010249391 +9787010249766 +9787010249865 +9787010250205 +9787010250274 +9787010250663 +9787010250854 +9787010251127 +9787010251493 +9787010251516 +9787010251530 +9787010251561 +9787010251592 +9787010251622 +9787010251837 +9787010253275 +9787010254531 +9787010255101 +9787010255224 +9787010255460 +9787010256337 +9787010256757 +9787010256771 +9787010256993 +9787010257204 +9787010257327 +9787010257464 +9787010257747 +9787010257945 +9787010257969 +9787010258065 +9787010258072 +9787010258300 +9787010258386 +9787010258485 +9787010258607 +9787010258621 +9787010258744 +9787010258836 +9787010259024 +9787010259475 +9787010259642 +9787010259697 +9787010260143 +9787010260495 +9787010260884 +9787010260914 +9787010261454 +9787010262147 +9787010262345 +9787010262802 +9787010262833 +9787010263205 +9787010263243 +9787010263441 +9787010263687 +9787010263878 +9787010263984 +9787010264028 +9787010264035 +9787010264042 +9787010264189 +9787010264585 +9787010265087 +9787010265452 +9787010265537 +9787010265797 +9787010265988 +9787010266015 +9787010266206 +9787010266343 +9787010266602 +9787010267135 +9787010267302 +9787010267470 +9787010267487 +9787010267494 +9787010267500 +9787010267876 +9787010267975 +9787010268583 +9787010268613 +9787010268620 +9787010268668 +9787010268736 +9787010268767 +9787010268781 +9787010268804 +9787010268880 +9787010268927 +9787010268965 +9787010269559 +9787010269832 +9787010269849 +9787010270340 +9787010270395 +9787010270517 +9787010270562 +9787010270784 +9787010270791 +9787010270838 +9787010270913 +9787010270999 +9787010271026 +9787010271088 +9787010271316 +9787010271682 +9787010271705 +9787010272368 +9787010272863 +9787010273075 +9787010273396 +9787020000005 +9787020000012 +9787020000326 +9787020000333 +9787020000340 +9787020000357 +9787020000371 +9787020000500 +9787020000548 +9787020000555 +9787020000616 +9787020000630 +9787020000715 +9787020000869 +9787020000906 +9787020000951 +9787020001033 +9787020001071 +9787020001095 +9787020001149 +9787020001170 +9787020001187 +9787020001194 +9787020001392 +9787020001460 +9787020001750 +9787020001804 +9787020001835 +9787020001866 +9787020002023 +9787020002054 +9787020002108 +9787020002122 +9787020002177 +9787020002238 +9787020002320 +9787020002399 +9787020002429 +9787020002443 +9787020002467 +9787020002559 +9787020002580 +9787020002856 +9787020002863 +9787020002870 +9787020003020 +9787020003433 +9787020003457 +9787020003556 +9787020003662 +9787020003747 +9787020003822 +9787020004034 +9787020004140 +9787020004607 +9787020004614 +9787020004676 +9787020004737 +9787020004744 +9787020004751 +9787020004775 +9787020004799 +9787020004935 +9787020004997 +9787020005093 +9787020005215 +9787020005222 +9787020005246 +9787020005253 +9787020005352 +9787020005420 +9787020005857 +9787020005994 +9787020006038 +9787020006045 +9787020006281 +9787020006380 +9787020006403 +9787020006441 +9787020006458 +9787020006472 +9787020006526 +9787020006588 +9787020006601 +9787020006670 +9787020006779 +9787020007035 +9787020007202 +9787020007325 +9787020007387 +9787020007417 +9787020007431 +9787020007547 +9787020007622 +9787020007684 +9787020007738 +9787020007745 +9787020007783 +9787020007806 +9787020007844 +9787020007943 +9787020008087 +9787020008124 +9787020008414 +9787020008421 +9787020008827 +9787020008841 +9787020008858 +9787020008865 +9787020008988 +9787020009008 +9787020009138 +9787020009213 +9787020009275 +9787020009404 +9787020009442 +9787020009503 +9787020009510 +9787020009565 +9787020009640 +9787020009657 +9787020009787 +9787020009824 +9787020010059 +9787020010073 +9787020010080 +9787020010103 +9787020010127 +9787020010134 +9787020010196 +9787020010295 +9787020010400 +9787020010486 +9787020010554 +9787020010738 +9787020010844 +9787020010875 +9787020010967 +9787020011148 +9787020011216 +9787020011254 +9787020011353 +9787020011360 +9787020011391 +9787020011421 +9787020011582 +9787020011636 +9787020011681 +9787020011728 +9787020011735 +9787020011759 +9787020011773 +9787020011780 +9787020011926 +9787020012343 +9787020012428 +9787020012794 +9787020013012 +9787020013036 +9787020013050 +9787020013128 +9787020013241 +9787020013357 +9787020013425 +9787020013456 +9787020013555 +9787020013609 +9787020013678 +9787020013821 +9787020013852 +9787020013883 +9787020013920 +9787020013944 +9787020014002 +9787020014064 +9787020014156 +9787020014286 +9787020014408 +9787020014620 +9787020014644 +9787020014699 +9787020014712 +9787020014873 +9787020014972 +9787020015108 +9787020015245 +9787020015504 +9787020015511 +9787020015603 +9787020015849 +9787020015900 +9787020016372 +9787020016402 +9787020016471 +9787020016716 +9787020016839 +9787020016969 +9787020017027 +9787020017102 +9787020017164 +9787020017188 +9787020017218 +9787020017379 +9787020017737 +9787020017782 +9787020017935 +9787020017973 +9787020018024 +9787020018093 +9787020018222 +9787020018277 +9787020018376 +9787020018406 +9787020018505 +9787020018512 +9787020018611 +9787020018635 +9787020018642 +9787020019380 +9787020019397 +9787020019410 +9787020019441 +9787020019472 +9787020019571 +9787020019588 +9787020019601 +9787020019649 +9787020019656 +9787020019670 +9787020019762 +9787020019779 +9787020019830 +9787020020096 +9787020020188 +9787020020300 +9787020020379 +9787020020508 +9787020020539 +9787020020645 +9787020020720 +9787020020737 +9787020020744 +9787020020843 +9787020021123 +9787020021338 +9787020021390 +9787020021598 +9787020021604 +9787020021611 +9787020021697 +9787020021840 +9787020021864 +9787020021932 +9787020021987 +9787020022168 +9787020022274 +9787020022359 +9787020022380 +9787020022403 +9787020022519 +9787020022687 +9787020022700 +9787020022717 +9787020022830 +9787020022922 +9787020023004 +9787020023097 +9787020023417 +9787020023455 +9787020023509 +9787020023745 +9787020024049 +9787020024087 +9787020024094 +9787020024186 +9787020024230 +9787020024261 +9787020024360 +9787020024384 +9787020024391 +9787020024438 +9787020024919 +9787020025145 +9787020025589 +9787020025596 +9787020025602 +9787020025701 +9787020025763 +9787020025800 +9787020025923 +9787020026005 +9787020026173 +9787020026241 +9787020026258 +9787020026296 +9787020026371 +9787020026395 +9787020026517 +9787020026692 +9787020026913 +9787020026975 +9787020027019 +9787020027057 +9787020027156 +9787020027422 +9787020027736 +9787020027743 +9787020027774 +9787020028160 +9787020028283 +9787020028429 +9787020028443 +9787020028481 +9787020028511 +9787020028535 +9787020028542 +9787020028948 +9787020029235 +9787020030033 +9787020030200 +9787020030354 +9787020030729 +9787020030750 +9787020030774 +9787020031313 +9787020031368 +9787020031597 +9787020031740 +9787020031849 +9787020032020 +9787020032112 +9787020032204 +9787020032402 +9787020032648 +9787020032686 +9787020032822 +9787020032846 +9787020032938 +9787020032976 +9787020033478 +9787020033621 +9787020033645 +9787020033737 +9787020033805 +9787020033829 +9787020033836 +9787020033881 +9787020033904 +9787020033942 +9787020034185 +9787020034338 +9787020034444 +9787020034611 +9787020034642 +9787020034895 +9787020035113 +9787020036103 +9787020036295 +9787020036530 +9787020036721 +9787020037070 +9787020037230 +9787020037247 +9787020037353 +9787020037810 +9787020038244 +9787020038442 +9787020038480 +9787020039586 +9787020040049 +9787020040070 +9787020040087 +9787020040414 +9787020040780 +9787020041206 +9787020041237 +9787020041657 +9787020042081 +9787020042517 +9787020043262 +9787020043507 +9787020043606 +9787020044047 +9787020044139 +9787020044344 +9787020044634 +9787020045150 +9787020045396 +9787020045976 +9787020046058 +9787020046096 +9787020046218 +9787020046416 +9787020047147 +9787020047246 +9787020047536 +9787020047710 +9787020048083 +9787020048120 +9787020048137 +9787020048182 +9787020048199 +9787020048380 +9787020048557 +9787020049134 +9787020049509 +9787020049974 +9787020049981 +9787020050208 +9787020050369 +9787020050840 +9787020051342 +9787020051397 +9787020051946 +9787020051960 +9787020052219 +9787020052332 +9787020052561 +9787020052912 +9787020053025 +9787020053407 +9787020055029 +9787020055302 +9787020055517 +9787020055890 +9787020056606 +9787020056873 +9787020058037 +9787020058167 +9787020061839 +9787020062089 +9787020062201 +9787020062300 +9787020062782 +9787020064038 +9787020064144 +9787020064175 +9787020064717 +9787020064939 +9787020066544 +9787020068944 +9787020070152 +9787020072767 +9787020073481 +9787020074396 +9787020076154 +9787020076178 +9787020076215 +9787020076321 +9787020078561 +9787020080410 +9787020080984 +9787020081073 +9787020095346 +9787020096305 +9787020096374 +9787020097388 +9787020105038 +9787020106059 +9787020106196 +9787020107438 +9787020107483 +9787020109326 +9787020115426 +9787020116348 +9787020121243 +9787020122660 +9787020122752 +9787020123704 +9787020133543 +9787020136674 +9787020139156 +9787020140862 +9787020143566 +9787020145829 +9787020151028 +9787020153381 +9787020154364 +9787020154579 +9787020154647 +9787020154715 +9787020154920 +9787020155156 +9787020155200 +9787020155552 +9787020156078 +9787020156269 +9787020161409 +9787020162949 +9787020163700 +9787020163939 +9787020165193 +9787020165636 +9787020165841 +9787020169573 +9787020169979 +9787020170975 +9787020172023 +9787020172030 +9787020173501 +9787020174744 +9787020175307 +9787020175581 +9787020175642 +9787020177608 +9787020178506 +9787020178735 +9787020178988 +9787020180639 +9787020181001 +9787020182466 +9787020182541 +9787020182626 +9787020182930 +9787020183548 +9787020183623 +9787020183708 +9787020183951 +9787020183975 +9787020184323 +9787020184385 +9787020184521 +9787020184606 +9787020184644 +9787020184729 +9787020184828 +9787020184910 +9787020184934 +9787020185009 +9787020185191 +9787020185429 +9787020185481 +9787020185511 +9787020185566 +9787020185634 +9787020186068 +9787020186136 +9787020186150 +9787020186266 +9787020186556 +9787020186570 +9787020186662 +9787020186679 +9787020186976 +9787020187140 +9787020187379 +9787020187409 +9787020187805 +9787020188123 +9787020188208 +9787020188345 +9787020188369 +9787020188444 +9787020188468 +9787020188796 +9787020188925 +9787020188994 +9787020189007 +9787020189205 +9787020189250 +9787020189274 +9787020189281 +9787020189298 +9787020189359 +9787020189373 +9787020189410 +9787020189427 +9787020189434 +9787020189618 +9787020189625 +9787020189649 +9787020189670 +9787020189687 +9787020189748 +9787020189793 +9787020189823 +9787020189830 +9787020189847 +9787020189854 +9787020189892 +9787020189908 +9787020190058 +9787020190072 +9787020190126 +9787020190133 +9787020190171 +9787020190188 +9787020190249 +9787020190256 +9787020190294 +9787020190317 +9787020190324 +9787020190379 +9787020190386 +9787020190430 +9787020190447 +9787020190546 +9787020190553 +9787020190614 +9787020190683 +9787020190713 +9787020190744 +9787020190751 +9787020190836 +9787020190973 +9787020191024 +9787020191147 +9787020191291 +9787020191345 +9787020191352 +9787020191390 +9787020191413 +9787020191468 +9787020191499 +9787020191505 +9787020191512 +9787020191567 +9787020191598 +9787020191635 +9787020191697 +9787020191918 +9787020192113 +9787020192304 +9787020192359 +9787020192694 +9787020192700 +9787020192755 +9787020193318 +9787020194162 +9787020194391 +9787020195336 +9787029461142 +9787030000149 +9787030000194 +9787030000590 +9787030000903 +9787030001290 +9787030001733 +9787030002532 +9787030003034 +9787030003256 +9787030003379 +9787030003485 +9787030004000 +9787030004253 +9787030004604 +9787030004925 +9787030006035 +9787030006219 +9787030006394 +9787030006509 +9787030008626 +9787030008695 +9787030009302 +9787030010483 +9787030011084 +9787030012227 +9787030012234 +9787030012470 +9787030013019 +9787030014009 +9787030014245 +9787030014320 +9787030015099 +9787030015273 +9787030015310 +9787030015402 +9787030015426 +9787030015808 +9787030016775 +9787030017239 +9787030017383 +9787030017420 +9787030017635 +9787030017703 +9787030018137 +9787030018281 +9787030018380 +9787030018854 +9787030019790 +9787030020246 +9787030020307 +9787030020529 +9787030020628 +9787030020710 +9787030020741 +9787030020796 +9787030021182 +9787030023179 +9787030023414 +9787030023674 +9787030024220 +9787030024664 +9787030025227 +9787030025432 +9787030026026 +9787030026132 +9787030026873 +9787030029225 +9787030029232 +9787030029416 +9787030029478 +9787030029492 +9787030029614 +9787030030559 +9787030030764 +9787030031020 +9787030031211 +9787030031334 +9787030031389 +9787030032003 +9787030032379 +9787030033178 +9787030033260 +9787030033963 +9787030034533 +9787030035929 +9787030036568 +9787030036605 +9787030037374 +9787030037671 +9787030037688 +9787030037831 +9787030038210 +9787030038234 +9787030038388 +9787030039118 +9787030039262 +9787030039279 +9787030039606 +9787030039798 +9787030041012 +9787030041036 +9787030041296 +9787030041340 +9787030041418 +9787030041524 +9787030041876 +9787030042125 +9787030042248 +9787030042293 +9787030042354 +9787030042378 +9787030042699 +9787030042903 +9787030043856 +9787030044211 +9787030045003 +9787030045539 +9787030046260 +9787030046697 +9787030047335 +9787030047748 +9787030048264 +9787030048349 +9787030048943 +9787030048950 +9787030049490 +9787030049599 +9787030050137 +9787030050342 +9787030051257 +9787030051493 +9787030052919 +9787030053053 +9787030053312 +9787030053398 +9787030053466 +9787030054197 +9787030054326 +9787030054395 +9787030054845 +9787030054890 +9787030054920 +9787030055958 +9787030056146 +9787030056405 +9787030057594 +9787030058508 +9787030059963 +9787030060075 +9787030060112 +9787030060327 +9787030060389 +9787030060532 +9787030060587 +9787030061379 +9787030061546 +9787030061751 +9787030061898 +9787030062611 +9787030062628 +9787030062635 +9787030062741 +9787030063151 +9787030063168 +9787030063854 +9787030063861 +9787030063878 +9787030063953 +9787030063991 +9787030064011 +9787030064042 +9787030064745 +9787030064851 +9787030064943 +9787030065353 +9787030065735 +9787030066008 +9787030066824 +9787030067395 +9787030067470 +9787030067500 +9787030068026 +9787030068101 +9787030068200 +9787030068279 +9787030068743 +9787030069115 +9787030069191 +9787030069498 +9787030069535 +9787030069788 +9787030069795 +9787030070098 +9787030070425 +9787030070463 +9787030070487 +9787030070968 +9787030071040 +9787030071200 +9787030071583 +9787030071965 +9787030072177 +9787030072443 +9787030072757 +9787030072870 +9787030073396 +9787030073532 +9787030074249 +9787030074522 +9787030074706 +9787030074737 +9787030074898 +9787030075154 +9787030075413 +9787030075987 +9787030076175 +9787030076311 +9787030076854 +9787030076885 +9787030077271 +9787030077363 +9787030078001 +9787030078094 +9787030078216 +9787030078766 +9787030079145 +9787030079169 +9787030079985 +9787030080073 +9787030080509 +9787030080790 +9787030080851 +9787030080943 +9787030080974 +9787030081001 +9787030081193 +9787030081346 +9787030081360 +9787030081704 +9787030081711 +9787030081735 +9787030081964 +9787030082473 +9787030082572 +9787030082985 +9787030083685 +9787030085306 +9787030086150 +9787030086334 +9787030087546 +9787030087898 +9787030088451 +9787030088802 +9787030089557 +9787030089960 +9787030089991 +9787030090546 +9787030091055 +9787030091437 +9787030091550 +9787030092267 +9787030092441 +9787030092861 +9787030093905 +9787030093929 +9787030094223 +9787030095343 +9787030095763 +9787030096142 +9787030096203 +9787030096593 +9787030097613 +9787030097712 +9787030097729 +9787030097842 +9787030099099 +9787030099280 +9787030099297 +9787030099761 +9787030101198 +9787030101204 +9787030101792 +9787030102829 +9787030103147 +9787030103185 +9787030103352 +9787030103406 +9787030103659 +9787030104908 +9787030105578 +9787030106421 +9787030106834 +9787030107589 +9787030107916 +9787030108050 +9787030108661 +9787030108937 +9787030109774 +9787030110053 +9787030110114 +9787030111135 +9787030111319 +9787030112132 +9787030112378 +9787030113122 +9787030115911 +9787030117090 +9787030117199 +9787030117892 +9787030118578 +9787030119698 +9787030120649 +9787030121646 +9787030122179 +9787030124241 +9787030124265 +9787030124340 +9787030124388 +9787030127624 +9787030127891 +9787030128010 +9787030128737 +9787030129390 +9787030130846 +9787030133038 +9787030133601 +9787030134660 +9787030135223 +9787030135483 +9787030137180 +9787030138767 +9787030139634 +9787030142269 +9787030143716 +9787030143761 +9787030145567 +9787030147233 +9787030150257 +9787030150301 +9787030153333 +9787030153609 +9787030153838 +9787030154361 +9787030156419 +9787030156778 +9787030157775 +9787030159441 +9787030162250 +9787030162694 +9787030163486 +9787030164278 +9787030164629 +9787030168146 +9787030169037 +9787030169273 +9787030170620 +9787030175717 +9787030181701 +9787030181756 +9787030182357 +9787030182395 +9787030182623 +9787030182685 +9787030182906 +9787030182920 +9787030183248 +9787030188533 +9787030188731 +9787030191984 +9787030197108 +9787030197696 +9787030197740 +9787030198044 +9787030199621 +9787030202215 +9787030204356 +9787030205247 +9787030206213 +9787030214133 +9787030215833 +9787030217936 +9787030221483 +9787030228055 +9787030230485 +9787030232625 +9787030233929 +9787030234940 +9787030241542 +9787030241849 +9787030242044 +9787030242075 +9787030250926 +9787030255365 +9787030257550 +9787030263353 +9787030276810 +9787030289780 +9787030293770 +9787030308924 +9787030310330 +9787030311832 +9787030315199 +9787030322630 +9787030325556 +9787030335302 +9787030337238 +9787030344380 +9787030348920 +9787030383075 +9787030384928 +9787030387820 +9787030390134 +9787030397065 +9787030398369 +9787030405067 +9787030415189 +9787030417114 +9787030433350 +9787030465085 +9787030471024 +9787030494764 +9787030496997 +9787030511256 +9787030514486 +9787030520173 +9787030534064 +9787030536372 +9787030541734 +9787030546197 +9787030547057 +9787030548696 +9787030550774 +9787030559333 +9787030564405 +9787030569066 +9787030597816 +9787030606594 +9787030607133 +9787030608512 +9787030611802 +9787030619976 +9787030625335 +9787030634191 +9787030634207 +9787030634269 +9787030635020 +9787030647979 +9787030650696 +9787030655462 +9787030661371 +9787030665829 +9787030675408 +9787030676238 +9787030693129 +9787030694164 +9787030696069 +9787030696410 +9787030707666 +9787030709912 +9787030712875 +9787030720351 +9787030721402 +9787030724885 +9787030728180 +9787030729767 +9787030729873 +9787030736000 +9787030748577 +9787030754448 +9787030758149 +9787030758484 +9787030764713 +9787030768230 +9787030769091 +9787030773173 +9787030773524 +9787030774095 +9787030777904 +9787030787989 +9787030789310 +9787030789976 +9787030792693 +9787030794000 +9787030794307 +9787030794413 +9787030795458 +9787030795854 +9787030795977 +9787030795984 +9787030796301 +9787030796479 +9787030796493 +9787030796936 +9787030799067 +9787030799456 +9787030800596 +9787030800640 +9787030801128 +9787030801210 +9787030801333 +9787030801487 +9787030801555 +9787030801883 +9787030803016 +9787030803825 +9787030804259 +9787030809537 +9787030810151 +9787030810199 +9787030810502 +9787030811646 +9787030815958 +9787030816610 +9787030817495 +9787030818195 +9787030818669 +9787030820020 +9787030821911 +9787030824561 +9787030826329 +9787030828323 +9787040000436 +9787040000528 +9787040000603 +9787040002126 +9787040002300 +9787040002447 +9787040006452 +9787040008166 +9787040008210 +9787040008685 +9787040008821 +9787040008937 +9787040008951 +9787040009156 +9787040009545 +9787040011999 +9787040012200 +9787040012385 +9787040012682 +9787040013269 +9787040014860 +9787040016093 +9787040016253 +9787040016352 +9787040017113 +9787040018080 +9787040018585 +9787040019148 +9787040020137 +9787040020199 +9787040020328 +9787040020342 +9787040020663 +9787040020687 +9787040020779 +9787040020816 +9787040021226 +9787040021363 +9787040021448 +9787040021578 +9787040021981 +9787040022582 +9787040023084 +9787040023237 +9787040024517 +9787040025002 +9787040025224 +9787040025309 +9787040025354 +9787040025675 +9787040025712 +9787040026580 +9787040027051 +9787040027464 +9787040028140 +9787040028928 +9787040029666 +9787040030143 +9787040030341 +9787040030358 +9787040030648 +9787040031485 +9787040031621 +9787040031645 +9787040033212 +9787040033281 +9787040033342 +9787040034349 +9787040034554 +9787040034608 +9787040035025 +9787040035360 +9787040036503 +9787040036824 +9787040037548 +9787040037753 +9787040037760 +9787040039177 +9787040039467 +9787040039511 +9787040039757 +9787040040104 +9787040040777 +9787040041088 +9787040041521 +9787040041538 +9787040041569 +9787040041613 +9787040041835 +9787040041842 +9787040042054 +9787040042214 +9787040042696 +9787040042771 +9787040043655 +9787040043969 +9787040044218 +9787040044256 +9787040045475 +9787040045512 +9787040045550 +9787040045666 +9787040046076 +9787040047127 +9787040047400 +9787040047493 +9787040047547 +9787040047561 +9787040047578 +9787040047684 +9787040048339 +9787040048889 +9787040049008 +9787040049343 +9787040049763 +9787040050240 +9787040051018 +9787040051506 +9787040051735 +9787040051926 +9787040052923 +9787040052978 +9787040053531 +9787040053944 +9787040053975 +9787040054279 +9787040054521 +9787040054644 +9787040055092 +9787040055474 +9787040056570 +9787040056983 +9787040057768 +9787040058413 +9787040059113 +9787040059335 +9787040059618 +9787040059786 +9787040059809 +9787040059854 +9787040059960 +9787040060669 +9787040060973 +9787040063226 +9787040063233 +9787040063257 +9787040063691 +9787040063967 +9787040064575 +9787040065473 +9787040066180 +9787040066227 +9787040066418 +9787040066500 +9787040066579 +9787040068849 +9787040069273 +9787040069303 +9787040069594 +9787040069662 +9787040069914 +9787040070941 +9787040071092 +9787040071146 +9787040071290 +9787040072617 +9787040072990 +9787040073966 +9787040074000 +9787040074048 +9787040074222 +9787040074345 +9787040074697 +9787040074932 +9787040076004 +9787040076028 +9787040076646 +9787040076837 +9787040077087 +9787040077599 +9787040077971 +9787040078015 +9787040079005 +9787040079579 +9787040079753 +9787040079777 +9787040082760 +9787040083569 +9787040084474 +9787040085105 +9787040086195 +9787040087000 +9787040088151 +9787040088342 +9787040088526 +9787040088632 +9787040089608 +9787040091045 +9787040091236 +9787040093322 +9787040093964 +9787040094510 +9787040094725 +9787040095548 +9787040095616 +9787040099027 +9787040100419 +9787040101355 +9787040101560 +9787040102987 +9787040105483 +9787040106190 +9787040106862 +9787040107159 +9787040109436 +9787040111910 +9787040112047 +9787040112306 +9787040112474 +9787040113068 +9787040114676 +9787040115345 +9787040117608 +9787040118582 +9787040118599 +9787040120943 +9787040123371 +9787040123531 +9787040123722 +9787040123838 +9787040127331 +9787040127973 +9787040128567 +9787040131024 +9787040133189 +9787040137248 +9787040137507 +9787040140101 +9787040141207 +9787040141214 +9787040141658 +9787040143140 +9787040144581 +9787040145137 +9787040145311 +9787040145694 +9787040145854 +9787040145922 +9787040148114 +9787040150490 +9787040152692 +9787040152869 +9787040153071 +9787040153972 +9787040156386 +9787040159240 +9787040161694 +9787040167740 +9787040169614 +9787040172164 +9787040173611 +9787040173703 +9787040177619 +9787040180466 +9787040182637 +9787040183009 +9787040183795 +9787040186703 +9787040197747 +9787040198782 +9787040202236 +9787040202809 +9787040202892 +9787040205428 +9787040207491 +9787040214536 +9787040215762 +9787040216103 +9787040218886 +9787040220483 +9787040220872 +9787040223804 +9787040226058 +9787040228243 +9787040232776 +9787040240474 +9787040240986 +9787040242072 +9787040245592 +9787040247527 +9787040248029 +9787040255027 +9787040256505 +9787040256925 +9787040258219 +9787040262148 +9787040263473 +9787040264432 +9787040265941 +9787040267693 +9787040267723 +9787040269994 +9787040275216 +9787040277692 +9787040280555 +9787040283013 +9787040284447 +9787040284713 +9787040289305 +9787040292886 +9787040298536 +9787040300642 +9787040307283 +9787040314045 +9787040323894 +9787040324327 +9787040324518 +9787040327519 +9787040328004 +9787040328097 +9787040329964 +9787040340716 +9787040344394 +9787040349740 +9787040351330 +9787040361933 +9787040363326 +9787040364026 +9787040364293 +9787040364590 +9787040366662 +9787040367164 +9787040369298 +9787040371062 +9787040373110 +9787040377477 +9787040379013 +9787040381559 +9787040384406 +9787040387308 +9787040390872 +9787040391435 +9787040401486 +9787040403169 +9787040404562 +9787040404647 +9787040404913 +9787040405538 +9787040405569 +9787040406368 +9787040407433 +9787040414905 +9787040416091 +9787040417227 +9787040417661 +9787040435276 +9787040443820 +9787040443837 +9787040443844 +9787040443899 +9787040443905 +9787040448979 +9787040454246 +9787040455540 +9787040456585 +9787040458497 +9787040463774 +9787040469585 +9787040471823 +9787040476385 +9787040483598 +9787040484007 +9787040485936 +9787040489514 +9787040490572 +9787040492422 +9787040493078 +9787040497878 +9787040509748 +9787040510058 +9787040510201 +9787040512267 +9787040516562 +9787040517545 +9787040517736 +9787040520361 +9787040520606 +9787040524574 +9787040524611 +9787040524741 +9787040524758 +9787040524765 +9787040525670 +9787040526233 +9787040527759 +9787040530094 +9787040530636 +9787040531046 +9787040531282 +9787040531442 +9787040532005 +9787040532128 +9787040532791 +9787040535891 +9787040539851 +9787040545616 +9787040546293 +9787040548679 +9787040548877 +9787040549614 +9787040551198 +9787040553772 +9787040553857 +9787040555431 +9787040555691 +9787040555981 +9787040557480 +9787040558517 +9787040558777 +9787040559293 +9787040559606 +9787040561920 +9787040562590 +9787040562729 +9787040563443 +9787040563801 +9787040563849 +9787040564044 +9787040564129 +9787040564150 +9787040564181 +9787040564280 +9787040564853 +9787040565133 +9787040566246 +9787040566284 +9787040566734 +9787040567700 +9787040567991 +9787040568073 +9787040568523 +9787040568738 +9787040568912 +9787040569179 +9787040569193 +9787040569223 +9787040569285 +9787040569322 +9787040569377 +9787040569704 +9787040569759 +9787040570090 +9787040571233 +9787040571332 +9787040571516 +9787040572179 +9787040572292 +9787040572834 +9787040573589 +9787040573596 +9787040573794 +9787040573916 +9787040573930 +9787040574173 +9787040574227 +9787040574579 +9787040574944 +9787040574975 +9787040574999 +9787040575040 +9787040575095 +9787040575651 +9787040575736 +9787040577105 +9787040577983 +9787040578218 +9787040578652 +9787040578720 +9787040578898 +9787040579024 +9787040579260 +9787040580518 +9787040580709 +9787040580884 +9787040580907 +9787040581263 +9787040581539 +9787040582703 +9787040582734 +9787040582819 +9787040582895 +9787040583519 +9787040583687 +9787040583762 +9787040583946 +9787040583977 +9787040584691 +9787040584783 +9787040584806 +9787040584813 +9787040585902 +9787040586817 +9787040586923 +9787040586930 +9787040587562 +9787040588194 +9787040589047 +9787040590524 +9787040590579 +9787040591293 +9787040591569 +9787040591965 +9787040592580 +9787040592948 +9787040593631 +9787040593976 +9787040594430 +9787040594676 +9787040595116 +9787040595635 +9787040595796 +9787040597165 +9787040597608 +9787040597813 +9787040598650 +9787040599046 +9787040599510 +9787040599961 +9787040600209 +9787040601060 +9787040601114 +9787040602371 +9787040603088 +9787040603217 +9787040603323 +9787040603545 +9787040603903 +9787040603934 +9787040604269 +9787040604382 +9787040604528 +9787040604696 +9787040604719 +9787040604801 +9787040604993 +9787040605020 +9787040605105 +9787040605426 +9787040605464 +9787040605549 +9787040605570 +9787040605808 +9787040605969 +9787040605990 +9787040606034 +9787040606652 +9787040606935 +9787040607079 +9787040607208 +9787040607215 +9787040607239 +9787040607253 +9787040607321 +9787040607437 +9787040607628 +9787040607925 +9787040608090 +9787040608298 +9787040608588 +9787040608854 +9787040608991 +9787040609011 +9787040609080 +9787040609097 +9787040609127 +9787040609141 +9787040609158 +9787040609257 +9787040609332 +9787040609370 +9787040609523 +9787040609684 +9787040609738 +9787040610024 +9787040610307 +9787040610314 +9787040610413 +9787040610420 +9787040610529 +9787040610543 +9787040610741 +9787040610826 +9787040610956 +9787040611465 +9787040611489 +9787040611502 +9787040611588 +9787040612059 +9787040612165 +9787040612202 +9787040612752 +9787040613063 +9787040613094 +9787040613148 +9787040613223 +9787040613582 +9787040613797 +9787040613902 +9787040613919 +9787040613957 +9787040614350 +9787040614374 +9787040614480 +9787040614589 +9787040614701 +9787040614718 +9787040614732 +9787040614794 +9787040614817 +9787040614893 +9787040615081 +9787040615104 +9787040615241 +9787040615623 +9787040615654 +9787040615869 +9787040615883 +9787040615999 +9787040616200 +9787040616217 +9787040616224 +9787040616255 +9787040616309 +9787040616415 +9787040616439 +9787040616460 +9787040616569 +9787040616590 +9787040616781 +9787040616811 +9787040616842 +9787040616859 +9787040616903 +9787040616941 +9787040617191 +9787040617436 +9787040617610 +9787040617634 +9787040617641 +9787040617764 +9787040617993 +9787040618020 +9787040618051 +9787040618082 +9787040618228 +9787040618303 +9787040618372 +9787040618426 +9787040618457 +9787040618631 +9787040618990 +9787040619010 +9787040619096 +9787040619157 +9787040619317 +9787040619409 +9787040619768 +9787040619782 +9787040619911 +9787040620115 +9787040620146 +9787040620238 +9787040620245 +9787040620252 +9787040620269 +9787040620290 +9787040620412 +9787040620429 +9787040620450 +9787040620580 +9787040620603 +9787040620740 +9787040620757 +9787040620788 +9787040620795 +9787040620801 +9787040620818 +9787040620887 +9787040620931 +9787040620962 +9787040621006 +9787040621051 +9787040621297 +9787040621303 +9787040621327 +9787040621389 +9787040621631 +9787040621693 +9787040621891 +9787040621907 +9787040621983 +9787040621990 +9787040622027 +9787040622331 +9787040622386 +9787040622676 +9787040622683 +9787040622706 +9787040622713 +9787040622744 +9787040622935 +9787040622942 +9787040622997 +9787040623000 +9787040623253 +9787040623291 +9787040623444 +9787040623598 +9787040623635 +9787040623697 +9787040623727 +9787040623796 +9787040624137 +9787040624229 +9787040624496 +9787040624557 +9787040624700 +9787040624724 +9787040624731 +9787040624854 +9787040625080 +9787040625240 +9787040625486 +9787040625530 +9787040625547 +9787040625615 +9787040625691 +9787040625745 +9787040625820 +9787040626063 +9787040626247 +9787040626292 +9787040626360 +9787040626827 +9787040626834 +9787040626919 +9787040627114 +9787040627213 +9787040627381 +9787040627411 +9787040627817 +9787040627862 +9787040628456 +9787040628579 +9787040628692 +9787040628739 +9787040628753 +9787040628968 +9787040629170 +9787040629224 +9787040629248 +9787040629484 +9787040629538 +9787040629644 +9787040630350 +9787040630473 +9787040630664 +9787040631869 +9787040631890 +9787040632279 +9787040632859 +9787040632989 +9787040633504 +9787040633511 +9787040633658 +9787040633771 +9787040634327 +9787040635881 +9787040636109 +9787040636123 +9787040636840 +9787040637830 +9787040637946 +9787040638509 +9787040640199 +9787040641097 +9787040642681 +9787040642933 +9787040643671 +9787040643770 +9787040644739 +9787040651751 +9787040651768 +9787052934675 +9787061105202 +9787100000246 +9787100000420 +9787100000796 +9787100000802 +9787100001151 +9787100001557 +9787100001595 +9787100001601 +9787100001786 +9787100001960 +9787100002486 +9787100002561 +9787100002707 +9787100002752 +9787100002851 +9787100002875 +9787100003018 +9787100003094 +9787100003131 +9787100003254 +9787100003308 +9787100003483 +9787100003575 +9787100003704 +9787100003766 +9787100003889 +9787100004046 +9787100004091 +9787100004466 +9787100004497 +9787100004503 +9787100004534 +9787100004589 +9787100004596 +9787100004633 +9787100004718 +9787100004763 +9787100004800 +9787100005135 +9787100005418 +9787100005647 +9787100005807 +9787100005890 +9787100006040 +9787100006088 +9787100006095 +9787100006101 +9787100006460 +9787100006866 +9787100006934 +9787100006996 +9787100007092 +9787100007184 +9787100007511 +9787100007610 +9787100007764 +9787100007849 +9787100007900 +9787100007917 +9787100008082 +9787100008228 +9787100008600 +9787100008822 +9787100009010 +9787100009126 +9787100009133 +9787100009461 +9787100009539 +9787100009614 +9787100009720 +9787100010191 +9787100010207 +9787100010498 +9787100010726 +9787100010870 +9787100010894 +9787100011259 +9787100011273 +9787100011297 +9787100012478 +9787100012515 +9787100012539 +9787100012652 +9787100012737 +9787100012867 +9787100013000 +9787100013093 +9787100013215 +9787100013383 +9787100014069 +9787100014090 +9787100014298 +9787100014434 +9787100014526 +9787100014533 +9787100014656 +9787100014724 +9787100015608 +9787100015806 +9787100015875 +9787100015981 +9787100016278 +9787100016308 +9787100016322 +9787100016520 +9787100016544 +9787100016612 +9787100016728 +9787100017015 +9787100017107 +9787100017350 +9787100017374 +9787100017497 +9787100017701 +9787100017893 +9787100018029 +9787100018777 +9787100018906 +9787100019019 +9787100019095 +9787100019231 +9787100019309 +9787100019347 +9787100019460 +9787100019873 +9787100020060 +9787100020152 +9787100020466 +9787100020756 +9787100021845 +9787100021920 +9787100022545 +9787100022699 +9787100023115 +9787100023658 +9787100024358 +9787100025454 +9787100026093 +9787100026987 +9787100028134 +9787100028288 +9787100028752 +9787100029063 +9787100030328 +9787100031097 +9787100031639 +9787100032056 +9787100032582 +9787100032933 +9787100032964 +9787100033350 +9787100034746 +9787100034944 +9787100035149 +9787100035255 +9787100035439 +9787100036283 +9787100037389 +9787100039550 +9787100040655 +9787100040662 +9787100041898 +9787100041911 +9787100042291 +9787100044431 +9787100044592 +9787100044684 +9787100048354 +9787100051354 +9787100055253 +9787100057233 +9787100057998 +9787100058766 +9787100060110 +9787100060219 +9787100060363 +9787100060394 +9787100060424 +9787100060554 +9787100061063 +9787100061131 +9787100061735 +9787100061841 +9787100061858 +9787100062831 +9787100062954 +9787100063449 +9787100063517 +9787100063531 +9787100063562 +9787100063715 +9787100063975 +9787100063982 +9787100064101 +9787100064118 +9787100064620 +9787100065672 +9787100065771 +9787100065863 +9787100066556 +9787100066624 +9787100067713 +9787100068451 +9787100069328 +9787100071215 +9787100071505 +9787100072809 +9787100072823 +9787100077682 +9787100078405 +9787100078610 +9787100079280 +9787100079419 +9787100079488 +9787100079822 +9787100080170 +9787100080866 +9787100080903 +9787100081214 +9787100081306 +9787100081313 +9787100081429 +9787100081610 +9787100081634 +9787100081641 +9787100082617 +9787100089883 +9787100092302 +9787100094146 +9787100094306 +9787100096263 +9787100099271 +9787100101820 +9787100104982 +9787100106719 +9787100108386 +9787100108522 +9787100108591 +9787100109420 +9787100111331 +9787100112161 +9787100114967 +9787100120388 +9787100124515 +9787100124676 +9787100125475 +9787100127929 +9787100128438 +9787100129589 +9787100129596 +9787100129602 +9787100129619 +9787100136761 +9787100140201 +9787100140218 +9787100140836 +9787100140843 +9787100140935 +9787100141932 +9787100142588 +9787100142748 +9787100143028 +9787100143455 +9787100143714 +9787100143769 +9787100144087 +9787100144094 +9787100144773 +9787100144896 +9787100145176 +9787100145282 +9787100145305 +9787100145374 +9787100145381 +9787100145404 +9787100145411 +9787100145435 +9787100145589 +9787100145633 +9787100145671 +9787100145718 +9787100145749 +9787100145831 +9787100145947 +9787100146036 +9787100146142 +9787100146388 +9787100147033 +9787100147095 +9787100147194 +9787100147293 +9787100147477 +9787100147712 +9787100147750 +9787100147781 +9787100147859 +9787100148412 +9787100148504 +9787100148672 +9787100148917 +9787100148979 +9787100149020 +9787100150118 +9787100152389 +9787100154062 +9787100154086 +9787100156370 +9787100164108 +9787100174664 +9787100174671 +9787100175128 +9787100177009 +9787100177306 +9787100181433 +9787100182836 +9787100183697 +9787100184984 +9787100187657 +9787100195942 +9787100196475 +9787100198035 +9787100200066 +9787100200578 +9787100201889 +9787100204064 +9787100207850 +9787100209748 +9787100211376 +9787100215510 +9787100215534 +9787100215565 +9787100215633 +9787100216197 +9787100217507 +9787100219587 +9787100220521 +9787100221672 +9787100221931 +9787100221948 +9787100222143 +9787100222419 +9787100222525 +9787100222976 +9787100224512 +9787100224949 +9787100224994 +9787100225250 +9787100225281 +9787100225601 +9787100226134 +9787100226400 +9787100226882 +9787100226905 +9787100227018 +9787100227155 +9787100227650 +9787100227728 +9787100227865 +9787100228107 +9787100228169 +9787100228503 +9787100228633 +9787100228824 +9787100228985 +9787100229098 +9787100229111 +9787100229142 +9787100229197 +9787100229265 +9787100229548 +9787100229692 +9787100229807 +9787100229876 +9787100230131 +9787100230766 +9787100230926 +9787100231008 +9787100231367 +9787100231374 +9787100231909 +9787100232388 +9787100232838 +9787100233774 +9787100233989 +9787100234108 +9787100234214 +9787100234580 +9787100234627 +9787100234917 +9787100235129 +9787100235624 +9787100235839 +9787100236003 +9787100238793 +9787100238861 +9787100239257 +9787100239318 +9787100239325 +9787100239493 +9787100239707 +9787100239851 +9787100240093 +9787100240147 +9787100240307 +9787100240543 +9787100241717 +9787100242011 +9787100242448 +9787100242509 +9787100242929 +9787100243254 +9787100243735 +9787100244060 +9787100244077 +9787100244336 +9787100244381 +9787100244534 +9787100244701 +9787100244886 +9787100245203 +9787100245500 +9787100245548 +9787100245807 +9787100245814 +9787100245968 +9787100246019 +9787100246217 +9787100246248 +9787100246279 +9787100246392 +9787100246668 +9787100246903 +9787100247139 +9787100247153 +9787100247337 +9787100247535 +9787100248846 +9787100248877 +9787100249034 +9787100249065 +9787100249270 +9787100249294 +9787100249508 +9787100249638 +9787100249645 +9787100250054 +9787100250146 +9787100250597 +9787100250603 +9787100250962 +9787100251167 +9787100251525 +9787100251549 +9787100251556 +9787100251570 +9787100252263 +9787100252287 +9787100256650 +9787100740906 +9787101000207 +9787101000443 +9787101000450 +9787101000504 +9787101000542 +9787101000559 +9787101000580 +9787101000627 +9787101000696 +9787101000870 +9787101001617 +9787101001860 +9787101001938 +9787101002119 +9787101002287 +9787101002324 +9787101002348 +9787101002362 +9787101002669 +9787101002683 +9787101002805 +9787101002836 +9787101003284 +9787101003505 +9787101003543 +9787101003871 +9787101004038 +9787101004090 +9787101004120 +9787101004144 +9787101004199 +9787101004229 +9787101004458 +9787101004588 +9787101004618 +9787101004885 +9787101004960 +9787101005004 +9787101005127 +9787101005295 +9787101005479 +9787101005707 +9787101005721 +9787101005813 +9787101006506 +9787101006643 +9787101006858 +9787101006902 +9787101007404 +9787101007947 +9787101007961 +9787101008005 +9787101008135 +9787101008227 +9787101008395 +9787101008654 +9787101008821 +9787101009019 +9787101009101 +9787101009170 +9787101010053 +9787101010312 +9787101010459 +9787101010466 +9787101010770 +9787101010954 +9787101011005 +9787101011074 +9787101011166 +9787101011425 +9787101011562 +9787101011678 +9787101011760 +9787101011791 +9787101011814 +9787101012088 +9787101012415 +9787101012569 +9787101012644 +9787101012804 +9787101012811 +9787101012880 +9787101012903 +9787101012910 +9787101013290 +9787101013481 +9787101013498 +9787101013627 +9787101013795 +9787101013986 +9787101014235 +9787101014419 +9787101014525 +9787101014600 +9787101014723 +9787101014884 +9787101014976 +9787101015119 +9787101015430 +9787101015553 +9787101015744 +9787101015935 +9787101016291 +9787101016369 +9787101016710 +9787101016727 +9787101016901 +9787101016925 +9787101017335 +9787101017397 +9787101017403 +9787101017410 +9787101017892 +9787101018516 +9787101018523 +9787101018783 +9787101019360 +9787101019612 +9787101019704 +9787101019827 +9787101020113 +9787101020182 +9787101020618 +9787101022353 +9787101022421 +9787101022438 +9787101022520 +9787101022797 +9787101022858 +9787101023442 +9787101024395 +9787101024500 +9787101025187 +9787101025330 +9787101026047 +9787101026320 +9787101026757 +9787101026948 +9787101026979 +9787101027334 +9787101027525 +9787101027891 +9787101029925 +9787101030136 +9787101030679 +9787101031003 +9787101031096 +9787101031430 +9787101031928 +9787101032017 +9787101032918 +9787101033076 +9787101033137 +9787101033366 +9787101033786 +9787101033830 +9787101034332 +9787101035308 +9787101036541 +9787101036633 +9787101036879 +9787101036930 +9787101037258 +9787101037999 +9787101038026 +9787101040135 +9787101040166 +9787101041293 +9787101041651 +9787101041859 +9787101041927 +9787101042795 +9787101042825 +9787101042856 +9787101043273 +9787101044034 +9787101044485 +9787101044515 +9787101044959 +9787101045048 +9787101045321 +9787101045796 +9787101046281 +9787101047578 +9787101047585 +9787101047615 +9787101048179 +9787101048841 +9787101049060 +9787101049206 +9787101050165 +9787101050585 +9787101050615 +9787101050660 +9787101051674 +9787101052411 +9787101053326 +9787101053593 +9787101053791 +9787101055115 +9787101055733 +9787101055740 +9787101056730 +9787101057393 +9787101057775 +9787101058192 +9787101059106 +9787101060331 +9787101060607 +9787101062861 +9787101063363 +9787101064681 +9787101065183 +9787101065237 +9787101066807 +9787101067408 +9787101067996 +9787101068450 +9787101071450 +9787101072488 +9787101074253 +9787101074925 +9787101075380 +9787101075489 +9787101077001 +9787101077971 +9787101080155 +9787101082234 +9787101083040 +9787101083842 +9787101083866 +9787101083972 +9787101084474 +9787101084610 +9787101085006 +9787101085037 +9787101086911 +9787101089288 +9787101089653 +9787101090758 +9787101091106 +9787101091489 +9787101093292 +9787101095470 +9787101096675 +9787101099034 +9787101099041 +9787101099553 +9787101102291 +9787101102789 +9787101103168 +9787101104028 +9787101104233 +9787101104370 +9787101108453 +9787101111293 +9787101119503 +9787101122886 +9787101122893 +9787101125191 +9787101126105 +9787101126761 +9787101130256 +9787101131611 +9787101131994 +9787101133165 +9787101135466 +9787101136241 +9787101136937 +9787101138665 +9787101138771 +9787101138849 +9787101141641 +9787101142181 +9787101142747 +9787101143386 +9787101144932 +9787101148299 +9787101148565 +9787101152203 +9787101153064 +9787101154566 +9787101156164 +9787101156294 +9787101156713 +9787101156751 +9787101156775 +9787101158106 +9787101158120 +9787101158649 +9787101158694 +9787101159691 +9787101160499 +9787101160857 +9787101160918 +9787101161915 +9787101162264 +9787101162646 +9787101163476 +9787101163643 +9787101163650 +9787101163919 +9787101164114 +9787101164329 +9787101164343 +9787101164855 +9787101165234 +9787101165241 +9787101165265 +9787101165319 +9787101165326 +9787101165531 +9787101165678 +9787101165753 +9787101165784 +9787101165876 +9787101165999 +9787101166057 +9787101166101 +9787101166156 +9787101166309 +9787101166316 +9787101166330 +9787101166361 +9787101166378 +9787101166484 +9787101166514 +9787101166545 +9787101166576 +9787101166675 +9787101166743 +9787101166767 +9787101166781 +9787101166798 +9787101166804 +9787101166989 +9787101167092 +9787101167184 +9787101167207 +9787101167214 +9787101167405 +9787101167467 +9787101167801 +9787101167955 +9787101168006 +9787101168167 +9787101168266 +9787101168372 +9787101168464 +9787101168532 +9787101168747 +9787101168778 +9787101168792 +9787101168921 +9787101168969 +9787101169034 +9787101169201 +9787101169348 +9787101169416 +9787101169430 +9787101169447 +9787101169454 +9787101169485 +9787101169577 +9787101169645 +9787101169751 +9787101169782 +9787101169836 +9787101169850 +9787101169867 +9787101169874 +9787101169904 +9787101169973 +9787101170146 +9787101170429 +9787101170436 +9787101170511 +9787101170535 +9787101170702 +9787101170764 +9787101170801 +9787101170955 +9787101171129 +9787101171150 +9787101171228 +9787101171259 +9787101171440 +9787101171563 +9787101171570 +9787101171594 +9787101171716 +9787101171815 +9787101172140 +9787101172812 +9787101172829 +9787101172850 +9787101172935 +9787101410501 +9787101862744 +9787101953985 +9787102000039 +9787102000084 +9787102000107 +9787102000114 +9787102000145 +9787102000152 +9787102000183 +9787102000190 +9787102000220 +9787102000305 +9787102000466 +9787102000473 +9787102000497 +9787102000541 +9787102000657 +9787102000701 +9787102000978 +9787102000985 +9787102001258 +9787102001821 +9787102001838 +9787102001845 +9787102002019 +9787102002262 +9787102002408 +9787102002521 +9787102002675 +9787102002750 +9787102002798 +9787102003054 +9787102003207 +9787102003252 +9787102003726 +9787102003788 +9787102003795 +9787102004112 +9787102004167 +9787102004327 +9787102004631 +9787102005089 +9787102005164 +9787102005249 +9787102005324 +9787102005492 +9787102005768 +9787102005966 +9787102006116 +9787102006215 +9787102006222 +9787102006291 +9787102006857 +9787102007120 +9787102007168 +9787102007502 +9787102007519 +9787102007878 +9787102007908 +9787102008134 +9787102008202 +9787102008363 +9787102008493 +9787102008592 +9787102008752 +9787102008929 +9787102009049 +9787102009162 +9787102009292 +9787102009360 +9787102009391 +9787102009407 +9787102009544 +9787102009629 +9787102009643 +9787102009902 +9787102009919 +9787102009957 +9787102009995 +9787102010045 +9787102010069 +9787102010090 +9787102010120 +9787102010151 +9787102010168 +9787102010182 +9787102010199 +9787102010250 +9787102010274 +9787102010304 +9787102010359 +9787102010373 +9787102010403 +9787102010540 +9787102010557 +9787102010618 +9787102010649 +9787102010816 +9787102010830 +9787102010878 +9787102010991 +9787102011318 +9787102011424 +9787102011455 +9787102011486 +9787102011592 +9787102011677 +9787102011691 +9787102011707 +9787102011776 +9787102011806 +9787102011882 +9787102012070 +9787102012155 +9787102012742 +9787102012827 +9787102012834 +9787102012858 +9787102012896 +9787102012940 +9787102013152 +9787102013169 +9787102013381 +9787102013602 +9787102013640 +9787102013800 +9787102013817 +9787102014081 +9787102014517 +9787102014531 +9787102014593 +9787102014654 +9787102014678 +9787102014807 +9787102014890 +9787102014920 +9787102015002 +9787102015040 +9787102015538 +9787102016108 +9787102016597 +9787102016818 +9787102017273 +9787102017327 +9787102017419 +9787102017433 +9787102017488 +9787102017716 +9787102017723 +9787102017730 +9787102017747 +9787102017785 +9787102017945 +9787102018157 +9787102018195 +9787102018256 +9787102018423 +9787102018621 +9787102018812 +9787102018850 +9787102018942 +9787102018973 +9787102019222 +9787102019932 +9787102020266 +9787102020730 +9787102020891 +9787102021027 +9787102021140 +9787102021164 +9787102021737 +9787102021775 +9787102021812 +9787102022093 +9787102022185 +9787102022710 +9787102023137 +9787102023182 +9787102023342 +9787102023403 +9787102023588 +9787102023601 +9787102023618 +9787102024028 +9787102024431 +9787102024769 +9787102025162 +9787102026725 +9787102026909 +9787102027159 +9787102027197 +9787102027326 +9787102028309 +9787102028828 +9787102029337 +9787102029467 +9787102029603 +9787102030340 +9787102031019 +9787102031040 +9787102031279 +9787102031347 +9787102031941 +9787102032023 +9787102032443 +9787102032573 +9787102032627 +9787102033020 +9787102033044 +9787102033167 +9787102033327 +9787102033365 +9787102034867 +9787102035062 +9787102035857 +9787102036847 +9787102037394 +9787102037974 +9787102038056 +9787102038186 +9787102040035 +9787102040264 +9787102040325 +9787102040363 +9787102041636 +9787102042022 +9787102042084 +9787102042213 +9787102042466 +9787102042800 +9787102043616 +9787102043852 +9787102044071 +9787102045900 +9787102045917 +9787102046723 +9787102047379 +9787102047867 +9787102047898 +9787102047911 +9787102049014 +9787102049021 +9787102049434 +9787102050249 +9787102050553 +9787102051260 +9787102051338 +9787102051710 +9787102051727 +9787102052519 +9787102053295 +9787102054049 +9787102054810 +9787102054889 +9787102055053 +9787102055169 +9787102055299 +9787102055305 +9787102055381 +9787102055633 +9787102056135 +9787102057460 +9787102057880 +9787102058191 +9787102058214 +9787102058689 +9787102059075 +9787102059242 +9787102059747 +9787102059907 +9787102060965 +9787102061092 +9787102061108 +9787102061306 +9787102061825 +9787102062914 +9787102064246 +9787102064260 +9787102064277 +9787102064284 +9787102064291 +9787102064307 +9787102064314 +9787102064321 +9787102064345 +9787102064352 +9787102064369 +9787102065359 +9787102065694 +9787102065717 +9787102067100 +9787102067117 +9787102068367 +9787102069111 +9787102069142 +9787102069760 +9787102069838 +9787102070667 +9787102070674 +9787102070926 +9787102071329 +9787102071336 +9787102073002 +9787102073040 +9787102073484 +9787102076003 +9787102076669 +9787102077567 +9787102077796 +9787102077949 +9787102080017 +9787102080925 +9787102081205 +9787102083490 +9787102083537 +9787102084831 +9787102085791 +9787102086194 +9787102086378 +9787102087030 +9787102087122 +9787102087160 +9787102087207 +9787102087955 +9787102088013 +9787102088204 +9787102088532 +9787102090627 +9787102092652 +9787102092737 +9787102094175 +9787102094335 +9787102095028 +9787102095844 +9787102095875 +9787102095998 +9787103000434 +9787103000663 +9787103001103 +9787103001417 +9787103001820 +9787103002162 +9787103002216 +9787103002841 +9787103003244 +9787103003411 +9787103003442 +9787103003558 +9787103003916 +9787103004012 +9787103004029 +9787103004340 +9787103004395 +9787103004401 +9787103004500 +9787103004616 +9787103004753 +9787103004784 +9787103004869 +9787103005224 +9787103005668 +9787103006016 +9787103006474 +9787103006672 +9787103006696 +9787103006948 +9787103006979 +9787103007075 +9787103007396 +9787103007419 +9787103007525 +9787103007907 +9787103008041 +9787103008089 +9787103008409 +9787103008423 +9787103008508 +9787103008591 +9787103009314 +9787103009444 +9787103010051 +9787103010167 +9787103010266 +9787103010310 +9787103010389 +9787103010419 +9787103010532 +9787103010556 +9787103011034 +9787103011287 +9787103012093 +9787103012161 +9787103012192 +9787103012253 +9787103012468 +9787103012505 +9787103013045 +9787103013274 +9787103013625 +9787103013915 +9787103014134 +9787103014226 +9787103014264 +9787103014509 +9787103014608 +9787103015032 +9787103016930 +9787103017340 +9787103019382 +9787103022610 +9787103023365 +9787103023389 +9787103023433 +9787103023808 +9787103023815 +9787103023884 +9787103023891 +9787103023952 +9787103024539 +9787103024843 +9787103028995 +9787103029275 +9787103029909 +9787103030349 +9787103032183 +9787103034323 +9787103036037 +9787103037959 +9787103038918 +9787103039007 +9787103039854 +9787103041598 +9787103042519 +9787103042823 +9787103043387 +9787103043752 +9787103044346 +9787103044742 +9787103045190 +9787103045268 +9787103045534 +9787103047286 +9787103047408 +9787103048962 +9787103052150 +9787103052174 +9787103054918 +9787103059043 +9787103059159 +9787103059609 +9787103060193 +9787103060711 +9787103060735 +9787103062418 +9787103062876 +9787103064184 +9787103065235 +9787103065242 +9787103065594 +9787103065969 +9787103066447 +9787103067086 +9787103067475 +9787103067741 +9787103068793 +9787103069141 +9787103069226 +9787104000136 +9787104000143 +9787104000303 +9787104000419 +9787104000501 +9787104000662 +9787104000723 +9787104000884 +9787104001102 +9787104001126 +9787104001270 +9787104001300 +9787104001461 +9787104001614 +9787104001720 +9787104001898 +9787104001980 +9787104002116 +9787104002437 +9787104002550 +9787104002604 +9787104002611 +9787104002659 +9787104002826 +9787104002840 +9787104003359 +9787104003397 +9787104003526 +9787104003588 +9787104003755 +9787104003779 +9787104003786 +9787104004097 +9787104004233 +9787104004486 +9787104004806 +9787104005018 +9787104005254 +9787104005353 +9787104005360 +9787104005407 +9787104005414 +9787104005421 +9787104005605 +9787104005803 +9787104005940 +9787104006176 +9787104006299 +9787104006503 +9787104006510 +9787104006565 +9787104006756 +9787104006985 +9787104007111 +9787104007210 +9787104007241 +9787104007371 +9787104007531 +9787104007562 +9787104007586 +9787104007623 +9787104007630 +9787104007715 +9787104008057 +9787104008064 +9787104008170 +9787104008293 +9787104008316 +9787104008415 +9787104008446 +9787104008521 +9787104008620 +9787104008637 +9787104008798 +9787104008866 +9787104008910 +9787104009009 +9787104009092 +9787104009443 +9787104009634 +9787104009696 +9787104009726 +9787104009801 +9787104009986 +9787104010104 +9787104010203 +9787104010586 +9787104010647 +9787104010661 +9787104010760 +9787104010968 +9787104010975 +9787104010982 +9787104011286 +9787104011316 +9787104011330 +9787104011392 +9787104011446 +9787104011460 +9787104011538 +9787104011590 +9787104011651 +9787104011774 +9787104011811 +9787104011880 +9787104011897 +9787104012054 +9787104012153 +9787104012290 +9787104012368 +9787104012382 +9787104012672 +9787104012726 +9787104012788 +9787104012849 +9787104012856 +9787104012870 +9787104012894 +9787104012979 +9787104013082 +9787104013181 +9787104013198 +9787104013204 +9787104013242 +9787104013365 +9787104013419 +9787104013471 +9787104013501 +9787104013525 +9787104013679 +9787104013709 +9787104013716 +9787104014034 +9787104014072 +9787104014270 +9787104014638 +9787104014645 +9787104014768 +9787104015079 +9787104015093 +9787104015130 +9787104015321 +9787104015338 +9787104015369 +9787104015437 +9787104015567 +9787104015581 +9787104015598 +9787104015611 +9787104015710 +9787104015765 +9787104015833 +9787104015857 +9787104015864 +9787104015932 +9787104016038 +9787104016281 +9787104016564 +9787104016755 +9787104016922 +9787104016939 +9787104017066 +9787104017103 +9787104017189 +9787104017226 +9787104017264 +9787104017349 +9787104017363 +9787104017417 +9787104017653 +9787104017660 +9787104017691 +9787104017912 +9787104017936 +9787104017950 +9787104018322 +9787104018407 +9787104018445 +9787104018988 +9787104019121 +9787104019169 +9787104019176 +9787104019183 +9787104019329 +9787104019442 +9787104019688 +9787104019695 +9787104019718 +9787104019824 +9787104019831 +9787104020318 +9787104020363 +9787104020431 +9787104020479 +9787104020615 +9787104021247 +9787104021490 +9787104021612 +9787104021667 +9787104021766 +9787104022336 +9787104022527 +9787104022558 +9787104022695 +9787104022770 +9787104023005 +9787104023012 +9787104023111 +9787104023159 +9787104023166 +9787104023449 +9787104023562 +9787104023791 +9787104023814 +9787104023838 +9787104023906 +9787104024026 +9787104024453 +9787104024682 +9787104024828 +9787104024996 +9787104025207 +9787104025405 +9787104025573 +9787104025672 +9787104025788 +9787104025818 +9787104025832 +9787104025863 +9787104025986 +9787104026136 +9787104026273 +9787104026280 +9787104026327 +9787104026402 +9787104026419 +9787104026471 +9787104026488 +9787104026587 +9787104026952 +9787104026990 +9787104027041 +9787104027072 +9787104027362 +9787104027393 +9787104027508 +9787104028390 +9787104028420 +9787104029038 +9787104029083 +9787104029137 +9787104029366 +9787104029397 +9787104029403 +9787104029779 +9787104029786 +9787104030454 +9787104030591 +9787104030638 +9787104031130 +9787104031475 +9787104031680 +9787104031765 +9787104032144 +9787104032212 +9787104032526 +9787104032649 +9787104033004 +9787104033417 +9787104033493 +9787104033967 +9787104034131 +9787104034902 +9787104035480 +9787104035602 +9787104036425 +9787104036555 +9787104036623 +9787104036630 +9787104036883 +9787104036975 +9787104036982 +9787104037149 +9787104037507 +9787104037682 +9787104037705 +9787104037804 +9787104038467 +9787104038993 +9787104039198 +9787104039310 +9787104039617 +9787104040507 +9787104040583 +9787104040927 +9787104041900 +9787104042266 +9787104042907 +9787104043829 +9787104044307 +9787104044338 +9787104044802 +9787104044895 +9787104045229 +9787104045236 +9787104047865 +9787104048060 +9787104049265 +9787104049364 +9787104049951 +9787104050063 +9787104050070 +9787104050391 +9787104050483 +9787104050513 +9787104050858 +9787104051022 +9787104051183 +9787104051244 +9787104052104 +9787104052210 +9787104052555 +9787104053231 +9787104053361 +9787104053996 +9787104054184 +9787104055044 +9787104055457 +9787104055556 +9787104056409 +9787105001170 +9787105002702 +9787105005192 +9787105005659 +9787105006274 +9787105006458 +9787105006557 +9787105006724 +9787105008117 +9787105009213 +9787105010783 +9787105016020 +9787105016419 +9787105017126 +9787105017874 +9787105017881 +9787105018727 +9787105019434 +9787105019458 +9787105019724 +9787105020621 +9787105021291 +9787105022304 +9787105022533 +9787105024155 +9787105024926 +9787105025336 +9787105025701 +9787105025763 +9787105026203 +9787105026753 +9787105027460 +9787105028450 +9787105029471 +9787105029563 +9787105029761 +9787105029792 +9787105029921 +9787105030071 +9787105030453 +9787105030941 +9787105030989 +9787105031269 +9787105031276 +9787105031429 +9787105031733 +9787105031962 +9787105032747 +9787105032792 +9787105032914 +9787105033508 +9787105033539 +9787105033690 +9787105033775 +9787105033782 +9787105033980 +9787105034000 +9787105034154 +9787105034420 +9787105034611 +9787105034710 +9787105035151 +9787105035229 +9787105035847 +9787105036127 +9787105036257 +9787105036479 +9787105036493 +9787105036721 +9787105036806 +9787105036837 +9787105036875 +9787105037322 +9787105037582 +9787105037797 +9787105037919 +9787105037971 +9787105038077 +9787105038770 +9787105038886 +9787105039098 +9787105040490 +9787105041909 +9787105042791 +9787105042883 +9787105043705 +9787105044269 +9787105044344 +9787105044368 +9787105044917 +9787105044924 +9787105046492 +9787105046935 +9787105047079 +9787105047161 +9787105047727 +9787105047895 +9787105049752 +9787105050116 +9787105050260 +9787105050550 +9787105052073 +9787105052141 +9787105052554 +9787105052868 +9787105055456 +9787105057238 +9787105058082 +9787105058099 +9787105058426 +9787105059447 +9787105059720 +9787105059799 +9787105060030 +9787105060580 +9787105061020 +9787105061211 +9787105062720 +9787105064229 +9787105064687 +9787105066285 +9787105066889 +9787105067060 +9787105067329 +9787105067787 +9787105067800 +9787105068395 +9787105069866 +9787105070466 +9787105070824 +9787105071821 +9787105071876 +9787105072170 +9787105072569 +9787105073382 +9787105074211 +9787105076796 +9787105076925 +9787105078301 +9787105078905 +9787105079735 +9787105083459 +9787105083992 +9787105084333 +9787105086641 +9787105091485 +9787105091669 +9787105091690 +9787105092161 +9787105093540 +9787105096688 +9787105100576 +9787105101269 +9787105101931 +9787105102655 +9787105104598 +9787105108336 +9787105108343 +9787105110025 +9787105110193 +9787105111541 +9787105111633 +9787105112159 +9787105114559 +9787105115037 +9787105115396 +9787105115709 +9787105115761 +9787105119707 +9787105119837 +9787105120000 +9787105120031 +9787105122783 +9787105123100 +9787105123568 +9787105123704 +9787105124428 +9787105126927 +9787105128167 +9787105129003 +9787105129232 +9787105132959 +9787105133390 +9787105134397 +9787105135738 +9787105139682 +9787105142064 +9787105143016 +9787105144723 +9787105148486 +9787105149452 +9787105152353 +9787105155811 +9787105156382 +9787105158089 +9787105158850 +9787105160785 +9787105162246 +9787105162345 +9787105163526 +9787105163540 +9787105163557 +9787105164660 +9787105164776 +9787105166497 +9787105167333 +9787105168231 +9787105170227 +9787105170364 +9787105170982 +9787105172191 +9787105172320 +9787105173044 +9787105173105 +9787105173839 +9787105174034 +9787105255238 +9787106000004 +9787106000257 +9787106000301 +9787106000455 +9787106000738 +9787106000912 +9787106001155 +9787106001285 +9787106002299 +9787106002480 +9787106002619 +9787106002657 +9787106002701 +9787106002800 +9787106002923 +9787106003258 +9787106003548 +9787106003685 +9787106003807 +9787106004781 +9787106004804 +9787106005115 +9787106005832 +9787106006037 +9787106006488 +9787106006853 +9787106007232 +9787106007980 +9787106008574 +9787106008703 +9787106008888 +9787106009496 +9787106009687 +9787106009885 +9787106010027 +9787106010058 +9787106010102 +9787106010362 +9787106010379 +9787106010416 +9787106010867 +9787106011048 +9787106011123 +9787106011369 +9787106011420 +9787106011796 +9787106011901 +9787106012250 +9787106012519 +9787106012526 +9787106012618 +9787106012700 +9787106012731 +9787106013011 +9787106013080 +9787106013127 +9787106013233 +9787106013646 +9787106013684 +9787106014049 +9787106014131 +9787106014148 +9787106014629 +9787106014742 +9787106015169 +9787106015435 +9787106015596 +9787106015985 +9787106016012 +9787106016135 +9787106016159 +9787106016234 +9787106016913 +9787106017033 +9787106017071 +9787106017200 +9787106017385 +9787106017408 +9787106017545 +9787106018405 +9787106018443 +9787106018450 +9787106018573 +9787106018689 +9787106018801 +9787106018832 +9787106018894 +9787106018962 +9787106019006 +9787106019037 +9787106019044 +9787106019228 +9787106019242 +9787106019556 +9787106019723 +9787106019884 +9787106019921 +9787106019990 +9787106020019 +9787106020118 +9787106020637 +9787106020811 +9787106020828 +9787106021252 +9787106021337 +9787106021863 +9787106021900 +9787106021979 +9787106022013 +9787106022112 +9787106022129 +9787106022136 +9787106022259 +9787106022839 +9787106022846 +9787106022860 +9787106023607 +9787106023720 +9787106024239 +9787106026363 +9787106026370 +9787106026431 +9787106027759 +9787106028053 +9787106029180 +9787106032036 +9787106033767 +9787106033835 +9787106034276 +9787106034627 +9787106035358 +9787106036065 +9787106036362 +9787106036621 +9787106038106 +9787106038595 +9787106039578 +9787106039677 +9787106039691 +9787106040246 +9787106040413 +9787106040420 +9787106040444 +9787106040451 +9787106041298 +9787106042134 +9787106042554 +9787106042776 +9787106043285 +9787106043308 +9787106046255 +9787106046293 +9787106046453 +9787106047344 +9787106048792 +9787106049058 +9787106050238 +9787106051068 +9787106051082 +9787106051174 +9787106051440 +9787106051815 +9787106052171 +9787106052393 +9787106052560 +9787106052621 +9787106052690 +9787106052843 +9787106052911 +9787106053024 +9787106053062 +9787106053130 +9787106053147 +9787106053161 +9787106053185 +9787106053260 +9787106053277 +9787106053284 +9787106053321 +9787106053345 +9787106053376 +9787106054564 +9787106055516 +9787106055691 +9787106056711 +9787107000003 +9787107000348 +9787107000386 +9787107000393 +9787107000416 +9787107000423 +9787107000447 +9787107000454 +9787107000461 +9787107000478 +9787107000485 +9787107000744 +9787107000782 +9787107000911 +9787107000973 +9787107000980 +9787107001031 +9787107001178 +9787107001208 +9787107001505 +9787107001567 +9787107001611 +9787107001918 +9787107001925 +9787107002052 +9787107002236 +9787107002441 +9787107002625 +9787107003028 +9787107003127 +9787107003134 +9787107003189 +9787107003202 +9787107003226 +9787107003240 +9787107003257 +9787107003264 +9787107003271 +9787107003325 +9787107003394 +9787107003400 +9787107003455 +9787107003479 +9787107003776 +9787107003790 +9787107003929 +9787107003943 +9787107003950 +9787107003967 +9787107003998 +9787107004070 +9787107004216 +9787107004223 +9787107004285 +9787107004308 +9787107004384 +9787107005022 +9787107005046 +9787107005077 +9787107005084 +9787107005091 +9787107005107 +9787107005220 +9787107005275 +9787107005299 +9787107005497 +9787107005626 +9787107005749 +9787107005756 +9787107005794 +9787107005800 +9787107005923 +9787107005954 +9787107005978 +9787107006234 +9787107006241 +9787107006869 +9787107009532 +9787107009549 +9787107009648 +9787107009662 +9787107009679 +9787107009723 +9787107009730 +9787107009839 +9787107009907 +9787107009914 +9787107010118 +9787107010217 +9787107010231 +9787107010552 +9787107010613 +9787107010774 +9787107011313 +9787107011344 +9787107011368 +9787107011573 +9787107011580 +9787107011627 +9787107012013 +9787107012075 +9787107012211 +9787107012259 +9787107012266 +9787107012396 +9787107012495 +9787107013126 +9787107013140 +9787107013218 +9787107013317 +9787107013836 +9787107013935 +9787107014420 +9787107014581 +9787107014772 +9787107014796 +9787107014932 +9787107015007 +9787107015205 +9787107015212 +9787107015489 +9787107015502 +9787107015588 +9787107015595 +9787107015823 +9787107015847 +9787107015885 +9787107015984 +9787107016028 +9787107016059 +9787107016158 +9787107016554 +9787107016578 +9787107017025 +9787107017032 +9787107017049 +9787107017278 +9787107017292 +9787107017377 +9787107017605 +9787107017612 +9787107017643 +9787107017650 +9787107017674 +9787107017681 +9787107017797 +9787107017834 +9787107018084 +9787107018312 +9787107018411 +9787107018671 +9787107018794 +9787107019241 +9787107019258 +9787107019265 +9787107019418 +9787107019425 +9787107019432 +9787107019449 +9787107019616 +9787107019913 +9787107019999 +9787107020001 +9787107020124 +9787107020179 +9787107020261 +9787107020872 +9787107020933 +9787107021381 +9787107021404 +9787107021442 +9787107021657 +9787107021701 +9787107021763 +9787107021916 +9787107021923 +9787107021978 +9787107022449 +9787107022463 +9787107022500 +9787107022524 +9787107022807 +9787107022814 +9787107022845 +9787107022876 +9787107022890 +9787107022913 +9787107022982 +9787107023064 +9787107023095 +9787107023316 +9787107023361 +9787107023378 +9787107023453 +9787107023712 +9787107070143 +9787107070174 +9787107070211 +9787107070235 +9787107070440 +9787107070723 +9787107070921 +9787107080012 +9787107080975 +9787107081293 +9787107081316 +9787107081774 +9787107090288 +9787107090301 +9787107090400 +9787107090424 +9787107090585 +9787107090622 +9787107091179 +9787107100031 +9787107100260 +9787107100314 +9787107100437 +9787107100475 +9787107100741 +9787107100765 +9787107100789 +9787107100819 +9787107100833 +9787107100895 +9787107101267 +9787107101373 +9787107101380 +9787107101397 +9787107101472 +9787107101496 +9787107101601 +9787107101755 +9787107101786 +9787107102011 +9787107102059 +9787107102561 +9787107103865 +9787107104114 +9787107104183 +9787107105166 +9787107105173 +9787107105180 +9787107105227 +9787107105234 +9787107105258 +9787107105548 +9787107105722 +9787107107030 +9787107107412 +9787107108518 +9787107108600 +9787107108709 +9787107109447 +9787107109591 +9787107109607 +9787107110733 +9787107110870 +9787107111532 +9787107111693 +9787107111839 +9787107111853 +9787107111877 +9787107112072 +9787107112102 +9787107112348 +9787107112607 +9787107113024 +9787107113611 +9787107113635 +9787107113765 +9787107113772 +9787107114427 +9787107115103 +9787107115653 +9787107115660 +9787107115707 +9787107116001 +9787107117404 +9787107117664 +9787107118005 +9787107118012 +9787107118364 +9787107118449 +9787107119002 +9787107119064 +9787107119163 +9787107119576 +9787107119675 +9787107120152 +9787107120671 +9787107121067 +9787107121081 +9787107121159 +9787107121838 +9787107122040 +9787107122293 +9787107122798 +9787107122996 +9787107123009 +9787107123023 +9787107125034 +9787107125331 +9787107125492 +9787107125669 +9787107125683 +9787107126932 +9787107126949 +9787107127700 +9787107128370 +9787107130274 +9787107130397 +9787107131172 +9787107132254 +9787107132841 +9787107134821 +9787107134982 +9787107135460 +9787107135491 +9787107135620 +9787107136511 +9787107136658 +9787107137143 +9787107137150 +9787107137389 +9787107138157 +9787107138850 +9787107139048 +9787107139062 +9787107139109 +9787107139246 +9787107139475 +9787107139598 +9787107139857 +9787107140907 +9787107141218 +9787107141485 +9787107141577 +9787107142666 +9787107143052 +9787107143083 +9787107143625 +9787107143700 +9787107144370 +9787107144516 +9787107144639 +9787107145384 +9787107146206 +9787107146220 +9787107146244 +9787107146299 +9787107146305 +9787107146312 +9787107146329 +9787107146350 +9787107146473 +9787107146817 +9787107147135 +9787107147661 +9787107147678 +9787107147685 +9787107147715 +9787107147722 +9787107147784 +9787107148286 +9787107148378 +9787107148453 +9787107148675 +9787107148798 +9787107149252 +9787107149320 +9787107149535 +9787107150326 +9787107150395 +9787107150623 +9787107150876 +9787107150982 +9787107151194 +9787107151422 +9787107151675 +9787107151934 +9787107152009 +9787107152023 +9787107152696 +9787107152856 +9787107152870 +9787107152917 +9787107153013 +9787107153631 +9787107154614 +9787107155093 +9787107155345 +9787107155536 +9787107156960 +9787107159312 +9787107160196 +9787107161476 +9787107162039 +9787107163869 +9787107164880 +9787107164996 +9787107165009 +9787107165054 +9787107165122 +9787107165238 +9787107165283 +9787107165290 +9787107165467 +9787107165726 +9787107165931 +9787107166006 +9787107166501 +9787107167393 +9787107167423 +9787107167751 +9787107168338 +9787107168666 +9787107168697 +9787107169335 +9787107169403 +9787107170737 +9787107171062 +9787107171154 +9787107171369 +9787107171451 +9787107171840 +9787107172151 +9787107172229 +9787107174131 +9787107174148 +9787107174445 +9787107174483 +9787107174506 +9787107175893 +9787107175947 +9787107176166 +9787107178054 +9787107178153 +9787107178313 +9787107178597 +9787107178672 +9787107180941 +9787107180989 +9787107181009 +9787107181337 +9787107181375 +9787107181696 +9787107182020 +9787107182457 +9787107182716 +9787107184949 +9787107185748 +9787107186172 +9787107186431 +9787107187087 +9787107187100 +9787107187254 +9787107188657 +9787107189395 +9787107189470 +9787107190759 +9787107190797 +9787107190933 +9787107191060 +9787107191305 +9787107191541 +9787107191657 +9787107191695 +9787107191701 +9787107192104 +9787107192692 +9787107194375 +9787107195181 +9787107196065 +9787107196072 +9787107196119 +9787107196126 +9787107196140 +9787107196157 +9787107196218 +9787107196294 +9787107196300 +9787107196454 +9787107196485 +9787107196492 +9787107198670 +9787107198892 +9787107199349 +9787107199455 +9787107199745 +9787107199936 +9787107200151 +9787107200281 +9787107200434 +9787107200953 +9787107201349 +9787107201431 +9787107201448 +9787107201493 +9787107202087 +9787107202117 +9787107202605 +9787107202759 +9787107208768 +9787107212468 +9787107215216 +9787107216831 +9787107217548 +9787107218606 +9787107222962 +9787107226045 +9787107226571 +9787107231575 +9787107231582 +9787107242953 +9787107243097 +9787107243301 +9787107243851 +9787107244506 +9787107244643 +9787107244889 +9787107244964 +9787107244995 +9787107245091 +9787107245350 +9787107245541 +9787107246050 +9787107246647 +9787107248658 +9787107249198 +9787107249297 +9787107250637 +9787107252204 +9787107252440 +9787107252570 +9787107252686 +9787107252853 +9787107253287 +9787107253331 +9787107254871 +9787107254963 +9787107255816 +9787107255830 +9787107255878 +9787107261503 +9787107262388 +9787107263576 +9787107263620 +9787107263743 +9787107264160 +9787107266706 +9787107267291 +9787107267307 +9787107269226 +9787107269264 +9787107273964 +9787107274169 +9787107274336 +9787107274558 +9787107274947 +9787107276194 +9787107279959 +9787107279997 +9787107280115 +9787107280122 +9787107280566 +9787107280597 +9787107280795 +9787107281808 +9787107282508 +9787107283802 +9787107284335 +9787107285011 +9787107285226 +9787107285233 +9787107285264 +9787107285417 +9787107285707 +9787107286056 +9787107290442 +9787107290664 +9787107290725 +9787107290855 +9787107291043 +9787107292491 +9787107292521 +9787107294570 +9787107296789 +9787107298493 +9787107309946 +9787107310966 +9787107312441 +9787107313080 +9787107313455 +9787107313462 +9787107313479 +9787107313547 +9787107314100 +9787107314889 +9787107315831 +9787107317859 +9787107318719 +9787107319310 +9787107319334 +9787107319600 +9787107320040 +9787107320194 +9787107321221 +9787107321573 +9787107322112 +9787107323478 +9787107324956 +9787107325601 +9787107326240 +9787107327827 +9787107327841 +9787107328046 +9787107328862 +9787107331688 +9787107333507 +9787107333620 +9787107335129 +9787107335174 +9787107335501 +9787107335532 +9787107335549 +9787107335686 +9787107335716 +9787107335730 +9787107335952 +9787107336133 +9787107336164 +9787107336522 +9787107336690 +9787107337475 +9787107337871 +9787107337888 +9787107338045 +9787107338113 +9787107338410 +9787107338434 +9787107340116 +9787107340611 +9787107341274 +9787107341403 +9787107341533 +9787107341632 +9787107342240 +9787107342417 +9787107343681 +9787107344190 +9787107344398 +9787107344688 +9787107344886 +9787107344893 +9787107345180 +9787107345289 +9787107346118 +9787107346217 +9787107346255 +9787107346323 +9787107346507 +9787107346965 +9787107347528 +9787107347900 +9787107348044 +9787107348099 +9787107348150 +9787107348204 +9787107348228 +9787107349041 +9787107349102 +9787107349553 +9787107349560 +9787107349577 +9787107349737 +9787107350528 +9787107350719 +9787107350757 +9787107350788 +9787107355219 +9787107355479 +9787107355790 +9787107357046 +9787107357183 +9787107357824 +9787107357848 +9787107358272 +9787107358357 +9787107359026 +9787107359323 +9787107359330 +9787107359361 +9787107359439 +9787107359507 +9787107359514 +9787107359705 +9787107359743 +9787107359750 +9787107359934 +9787107360411 +9787107361463 +9787107362637 +9787107362644 +9787107364648 +9787107365003 +9787107365904 +9787107366628 +9787107366642 +9787107366932 +9787107367397 +9787107367441 +9787107367465 +9787107368226 +9787107369247 +9787107369261 +9787107370014 +9787107370045 +9787107370069 +9787107370168 +9787107370243 +9787107371295 +9787107371417 +9787107371721 +9787107371738 +9787107371745 +9787107373442 +9787107374753 +9787107376047 +9787107377693 +9787107377709 +9787107382369 +9787107382383 +9787107382390 +9787107382413 +9787107382420 +9787107382437 +9787107382444 +9787107382451 +9787107382468 +9787107382475 +9787107382505 +9787107382543 +9787107382550 +9787107382574 +9787107382581 +9787107382598 +9787107382604 +9787107382611 +9787107382635 +9787107382666 +9787107382840 +9787107382857 +9787107382956 +9787107383007 +9787107383373 +9787107383649 +9787107383717 +9787107383731 +9787107383755 +9787107383793 +9787107384165 +9787107384226 +9787107384318 +9787107384561 +9787107385179 +9787107385766 +9787107388187 +9787107390128 +9787107390722 +9787107390982 +9787107391200 +9787107392337 +9787107392795 +9787108000026 +9787108000040 +9787108000125 +9787108000170 +9787108000279 +9787108000323 +9787108000538 +9787108000552 +9787108000569 +9787108000774 +9787108000804 +9787108001214 +9787108001269 +9787108001283 +9787108001344 +9787108001436 +9787108001450 +9787108001726 +9787108001818 +9787108001863 +9787108001917 +9787108001931 +9787108001955 +9787108002129 +9787108002389 +9787108002488 +9787108002495 +9787108002754 +9787108002815 +9787108002822 +9787108002976 +9787108003126 +9787108003218 +9787108003232 +9787108003324 +9787108003331 +9787108003348 +9787108003362 +9787108003607 +9787108003706 +9787108003744 +9787108003829 +9787108004031 +9787108004055 +9787108004109 +9787108004376 +9787108004406 +9787108004529 +9787108004680 +9787108004840 +9787108005021 +9787108005182 +9787108005236 +9787108005250 +9787108005267 +9787108005441 +9787108005540 +9787108005564 +9787108005656 +9787108005731 +9787108005793 +9787108005861 +9787108006509 +9787108006530 +9787108006554 +9787108006752 +9787108006776 +9787108006844 +9787108006882 +9787108006998 +9787108007049 +9787108007186 +9787108007209 +9787108007278 +9787108007285 +9787108007292 +9787108007728 +9787108007926 +9787108007940 +9787108008022 +9787108008237 +9787108008329 +9787108008343 +9787108008350 +9787108008374 +9787108008466 +9787108008480 +9787108008626 +9787108008657 +9787108008749 +9787108008916 +9787108008930 +9787108009005 +9787108009135 +9787108009142 +9787108009173 +9787108009227 +9787108009289 +9787108009302 +9787108009500 +9787108009609 +9787108009692 +9787108009739 +9787108010094 +9787108010162 +9787108010223 +9787108010254 +9787108010438 +9787108010599 +9787108010650 +9787108010681 +9787108010728 +9787108010827 +9787108010902 +9787108010919 +9787108010957 +9787108010971 +9787108011169 +9787108011350 +9787108011398 +9787108011909 +9787108012081 +9787108012241 +9787108012395 +9787108012500 +9787108012517 +9787108012661 +9787108012753 +9787108012944 +9787108012982 +9787108012999 +9787108013002 +9787108013095 +9787108013156 +9787108013392 +9787108013514 +9787108013521 +9787108013552 +9787108013712 +9787108014016 +9787108014382 +9787108014511 +9787108014535 +9787108014894 +9787108015129 +9787108015143 +9787108015358 +9787108015501 +9787108015570 +9787108015617 +9787108015730 +9787108015808 +9787108015891 +9787108016249 +9787108016294 +9787108016423 +9787108016430 +9787108016478 +9787108016591 +9787108016683 +9787108017147 +9787108017437 +9787108017550 +9787108017567 +9787108017703 +9787108018373 +9787108018809 +9787108020185 +9787108020987 +9787108020994 +9787108021939 +9787108022226 +9787108022240 +9787108022332 +9787108022721 +9787108022738 +9787108022776 +9787108023056 +9787108023841 +9787108024237 +9787108024244 +9787108024695 +9787108024701 +9787108026675 +9787108026835 +9787108026927 +9787108029133 +9787108030337 +9787108031877 +9787108032706 +9787108033451 +9787108034144 +9787108035011 +9787108037138 +9787108038159 +9787108038487 +9787108038524 +9787108038555 +9787108038562 +9787108038586 +9787108038630 +9787108038661 +9787108038678 +9787108038685 +9787108038692 +9787108038753 +9787108038777 +9787108038845 +9787108038876 +9787108038913 +9787108038951 +9787108038975 +9787108038999 +9787108039095 +9787108039286 +9787108039385 +9787108039491 +9787108039545 +9787108039620 +9787108042743 +9787108044198 +9787108044549 +9787108044563 +9787108045928 +9787108046024 +9787108046710 +9787108046727 +9787108046758 +9787108047557 +9787108047564 +9787108047632 +9787108048981 +9787108049070 +9787108049599 +9787108050168 +9787108051103 +9787108051325 +9787108054630 +9787108055088 +9787108055156 +9787108055453 +9787108062963 +9787108063045 +9787108063755 +9787108064646 +9787108065148 +9787108065964 +9787108066725 +9787108068354 +9787108073884 +9787108073891 +9787108073976 +9787108073983 +9787108074171 +9787108074300 +9787108074324 +9787108074492 +9787108075925 +9787108076052 +9787108076069 +9787108076311 +9787108076328 +9787108076335 +9787108076670 +9787108076748 +9787108077059 +9787108077103 +9787108077349 +9787108077417 +9787108077493 +9787108077677 +9787108077707 +9787108077721 +9787108077783 +9787108077790 +9787108077806 +9787108077844 +9787108077950 +9787108077974 +9787108078018 +9787108078025 +9787108078100 +9787108078162 +9787108078186 +9787108078346 +9787108078360 +9787108078391 +9787108078452 +9787108078506 +9787108078544 +9787108078605 +9787108078643 +9787108078698 +9787108078728 +9787108078735 +9787108078797 +9787108078926 +9787108078933 +9787108079060 +9787108079114 +9787108079190 +9787108079206 +9787108079213 +9787108079220 +9787108079237 +9787108079244 +9787108079282 +9787108079305 +9787108079312 +9787108079350 +9787108079442 +9787108079459 +9787108079466 +9787108079473 +9787108079503 +9787108079541 +9787108079596 +9787108079619 +9787108079626 +9787108079664 +9787108079701 +9787108079718 +9787108079787 +9787108079794 +9787108079800 +9787108079817 +9787108079824 +9787108079848 +9787108079855 +9787108079879 +9787108079886 +9787108079923 +9787108079930 +9787108080042 +9787108080141 +9787108080158 +9787108080172 +9787108080202 +9787108080417 +9787108080424 +9787108080493 +9787108080653 +9787108080714 +9787108080721 +9787108080769 +9787108080820 +9787108080882 +9787108081445 +9787109000520 +9787109000971 +9787109001190 +9787109001589 +9787109001664 +9787109002555 +9787109002623 +9787109003132 +9787109003729 +9787109004092 +9787109005778 +9787109006515 +9787109006645 +9787109007031 +9787109007413 +9787109010338 +9787109012493 +9787109014572 +9787109014633 +9787109017719 +9787109019836 +9787109020009 +9787109020276 +9787109020474 +9787109020641 +9787109021266 +9787109021396 +9787109021815 +9787109023529 +9787109024861 +9787109025158 +9787109026827 +9787109027022 +9787109028319 +9787109028722 +9787109031210 +9787109033443 +9787109034150 +9787109034266 +9787109034563 +9787109034648 +9787109037014 +9787109037588 +9787109038844 +9787109039308 +9787109042704 +9787109043404 +9787109045026 +9787109045682 +9787109046009 +9787109047396 +9787109047495 +9787109048461 +9787109050501 +9787109050754 +9787109051331 +9787109051713 +9787109054295 +9787109055124 +9787109055131 +9787109056176 +9787109056411 +9787109057258 +9787109057319 +9787109057579 +9787109057722 +9787109057906 +9787109058071 +9787109060104 +9787109062382 +9787109063082 +9787109063822 +9787109063907 +9787109066083 +9787109066526 +9787109068841 +9787109069237 +9787109070516 +9787109077249 +9787109079823 +9787109080768 +9787109081536 +9787109082366 +9787109084322 +9787109085824 +9787109087866 +9787109088283 +9787109092501 +9787109094291 +9787109094321 +9787109094772 +9787109095144 +9787109095700 +9787109096301 +9787109097674 +9787109100374 +9787109100756 +9787109103498 +9787109105232 +9787109107168 +9787109107458 +9787109111936 +9787109114289 +9787109115330 +9787109118249 +9787109122543 +9787109125544 +9787109129719 +9787109137127 +9787109137622 +9787109145962 +9787109146242 +9787109148031 +9787109148062 +9787109148451 +9787109148765 +9787109149281 +9787109149342 +9787109149847 +9787109150836 +9787109150874 +9787109152687 +9787109154353 +9787109154421 +9787109158054 +9787109159662 +9787109162549 +9787109162570 +9787109163348 +9787109170209 +9787109174115 +9787109178199 +9787109180956 +9787109188501 +9787109196599 +9787109197725 +9787109200241 +9787109201194 +9787109210578 +9787109213111 +9787109215658 +9787109220546 +9787109221673 +9787109221840 +9787109226883 +9787109229808 +9787109232051 +9787109235748 +9787109240421 +9787109242531 +9787109244870 +9787109245969 +9787109260580 +9787109261129 +9787109261754 +9787109262096 +9787109265097 +9787109268982 +9787109270107 +9787109270619 +9787109271418 +9787109273467 +9787109278240 +9787109279797 +9787109281035 +9787109282001 +9787109282964 +9787109283114 +9787109283794 +9787109284142 +9787109284586 +9787109285514 +9787109287921 +9787109289420 +9787109289468 +9787109289772 +9787109289796 +9787109290853 +9787109296015 +9787109297852 +9787109297869 +9787109298088 +9787109299764 +9787109299801 +9787109300255 +9787109300316 +9787109302389 +9787109302396 +9787109304093 +9787109304109 +9787109304123 +9787109304130 +9787109304147 +9787109304802 +9787109305601 +9787109306257 +9787109306875 +9787109307728 +9787109309685 +9787109309807 +9787109309821 +9787109310766 +9787109310889 +9787109311428 +9787109311787 +9787109312449 +9787109312654 +9787109312883 +9787109315174 +9787109316935 +9787109317185 +9787109317291 +9787109317833 +9787109318076 +9787109318083 +9787109318090 +9787109318328 +9787109318441 +9787109318540 +9787109319103 +9787109319684 +9787109320062 +9787109320109 +9787109320420 +9787109320550 +9787109321571 +9787109322295 +9787109322363 +9787109322912 +9787109322998 +9787109323070 +9787109323773 +9787109323988 +9787109324022 +9787109324893 +9787109325333 +9787109325579 +9787109326422 +9787109326613 +9787109327122 +9787109327399 +9787109327771 +9787109327795 +9787109327993 +9787109329720 +9787109330689 +9787109331266 +9787109332638 +9787109332898 +9787109914933 +9787110001127 +9787110001271 +9787110001295 +9787110001318 +9787110001325 +9787110001349 +9787110001790 +9787110001875 +9787110002032 +9787110002810 +9787110003114 +9787110003121 +9787110003664 +9787110004203 +9787110004661 +9787110004678 +9787110004685 +9787110005118 +9787110005125 +9787110005132 +9787110005422 +9787110005453 +9787110005460 +9787110005477 +9787110005484 +9787110005491 +9787110005767 +9787110005965 +9787110006221 +9787110006245 +9787110006290 +9787110006450 +9787110006856 +9787110006863 +9787110008492 +9787110010198 +9787110010488 +9787110010891 +9787110011102 +9787110011126 +9787110011355 +9787110011676 +9787110011836 +9787110012710 +9787110012857 +9787110014776 +9787110015728 +9787110016695 +9787110017692 +9787110017739 +9787110017807 +9787110017814 +9787110018125 +9787110018217 +9787110018385 +9787110018439 +9787110018477 +9787110018897 +9787110019726 +9787110019795 +9787110020180 +9787110020579 +9787110020999 +9787110021675 +9787110021972 +9787110022405 +9787110022887 +9787110023044 +9787110023259 +9787110024157 +9787110026557 +9787110028353 +9787110031285 +9787110031933 +9787110031988 +9787110033036 +9787110033067 +9787110033180 +9787110033234 +9787110034644 +9787110034682 +9787110037058 +9787110038543 +9787110039342 +9787110039458 +9787110039809 +9787110040225 +9787110040263 +9787110040331 +9787110040522 +9787110040591 +9787110040775 +9787110041079 +9787110041116 +9787110041475 +9787110043233 +9787110043394 +9787110043479 +9787110043493 +9787110044926 +9787110047293 +9787110047941 +9787110049075 +9787110050538 +9787110052075 +9787110056219 +9787110056837 +9787110058121 +9787110058442 +9787110059739 +9787110059753 +9787110062982 +9787110066409 +9787110067499 +9787110070642 +9787110071489 +9787110071502 +9787110072172 +9787110072271 +9787110072592 +9787110076583 +9787110076637 +9787110079416 +9787110079867 +9787110080337 +9787110080382 +9787110080900 +9787110081747 +9787110081754 +9787110081785 +9787110081792 +9787110081808 +9787110081891 +9787110082119 +9787110082201 +9787110082454 +9787110082539 +9787110082867 +9787110083222 +9787110083338 +9787110083628 +9787110083697 +9787110083758 +9787110083802 +9787110085349 +9787110085707 +9787110085714 +9787110085738 +9787110086308 +9787110087091 +9787110087749 +9787110088555 +9787110089187 +9787110090138 +9787110090220 +9787110092255 +9787110094068 +9787110094181 +9787110095799 +9787110097267 +9787110098301 +9787110098356 +9787110098509 +9787110099407 +9787110100448 +9787110100455 +9787110100462 +9787110100479 +9787110100585 +9787110100899 +9787110101124 +9787110101476 +9787110102190 +9787110103951 +9787110104873 +9787110104880 +9787110104934 +9787110105153 +9787110105740 +9787110105764 +9787110105955 +9787110106143 +9787110106150 +9787110106280 +9787110106976 +9787110107027 +9787110107072 +9787110107331 +9787110108505 +9787110108529 +9787110108642 +9787110108819 +9787110108864 +9787110109014 +9787110109021 +9787111001447 +9787111001485 +9787111004196 +9787111004929 +9787111005933 +9787111006343 +9787111007050 +9787111007630 +9787111010234 +9787111010340 +9787111013501 +9787111014935 +9787111016038 +9787111016274 +9787111017110 +9787111017400 +9787111019954 +9787111020769 +9787111022831 +9787111024507 +9787111025474 +9787111026488 +9787111027164 +9787111027171 +9787111027638 +9787111027706 +9787111030737 +9787111031024 +9787111033561 +9787111033592 +9787111034391 +9787111035091 +9787111035916 +9787111035992 +9787111036142 +9787111036555 +9787111036685 +9787111038061 +9787111038078 +9787111039143 +9787111039501 +9787111039976 +9787111040118 +9787111041337 +9787111043942 +9787111044567 +9787111046462 +9787111046653 +9787111051190 +9787111051565 +9787111052241 +9787111052616 +9787111053835 +9787111054283 +9787111054436 +9787111055402 +9787111055679 +9787111055990 +9787111056270 +9787111058250 +9787111058526 +9787111058861 +9787111059172 +9787111059592 +9787111059653 +9787111059950 +9787111060246 +9787111060284 +9787111060581 +9787111061182 +9787111062028 +9787111062769 +9787111064343 +9787111064633 +9787111065210 +9787111065944 +9787111066682 +9787111066699 +9787111066750 +9787111067665 +9787111069348 +9787111069461 +9787111069614 +9787111069645 +9787111070351 +9787111071563 +9787111071761 +9787111071976 +9787111072393 +9787111073109 +9787111073161 +9787111073802 +9787111074397 +9787111074625 +9787111075462 +9787111075691 +9787111076469 +9787111076605 +9787111076643 +9787111076735 +9787111077237 +9787111078166 +9787111078876 +9787111079002 +9787111079033 +9787111079408 +9787111079767 +9787111080145 +9787111080169 +9787111080183 +9787111080770 +9787111081333 +9787111081968 +9787111082712 +9787111085850 +9787111086055 +9787111086550 +9787111086659 +9787111086703 +9787111087700 +9787111087809 +9787111087823 +9787111088417 +9787111088813 +9787111089100 +9787111089445 +9787111089780 +9787111089902 +9787111090014 +9787111090816 +9787111090922 +9787111091950 +9787111092209 +9787111092414 +9787111092643 +9787111093121 +9787111093145 +9787111093442 +9787111093725 +9787111094371 +9787111094500 +9787111095941 +9787111098256 +9787111098782 +9787111098966 +9787111100379 +9787111101017 +9787111101260 +9787111101772 +9787111102588 +9787111103844 +9787111105725 +9787111106746 +9787111106906 +9787111107958 +9787111108474 +9787111113065 +9787111113607 +9787111115632 +9787111116905 +9787111119128 +9787111119692 +9787111120018 +9787111123965 +9787111124160 +9787111124375 +9787111124825 +9787111124832 +9787111125495 +9787111125754 +9787111126157 +9787111126669 +9787111126775 +9787111129158 +9787111130116 +9787111130550 +9787111130581 +9787111130949 +9787111132042 +9787111132134 +9787111136538 +9787111137917 +9787111138082 +9787111139089 +9787111139133 +9787111144519 +9787111145240 +9787111146896 +9787111148173 +9787111149958 +9787111151081 +9787111151173 +9787111151876 +9787111151951 +9787111153023 +9787111153177 +9787111156970 +9787111157502 +9787111158929 +9787111159056 +9787111159391 +9787111160892 +9787111164777 +9787111165903 +9787111165989 +9787111167891 +9787111168126 +9787111170488 +9787111171683 +9787111174592 +9787111175902 +9787111175988 +9787111178538 +9787111178897 +9787111181941 +9787111182030 +9787111183051 +9787111183525 +9787111185079 +9787111185567 +9787111185901 +9787111188957 +9787111189145 +9787111189268 +9787111199045 +9787111199083 +9787111199823 +9787111203698 +9787111205234 +9787111205418 +9787111207542 +9787111209706 +9787111211273 +9787111214731 +9787111214991 +9787111215516 +9787111216759 +9787111226130 +9787111228042 +9787111229735 +9787111230731 +9787111235552 +9787111240068 +9787111241133 +9787111249320 +9787111250241 +9787111255987 +9787111263050 +9787111263302 +9787111265443 +9787111268703 +9787111271086 +9787111272526 +9787111280002 +9787111280774 +9787111282259 +9787111283744 +9787111287605 +9787111298359 +9787111304425 +9787111304968 +9787111312413 +9787111314080 +9787111320333 +9787111322863 +9787111334293 +9787111342526 +9787111344025 +9787111359067 +9787111363408 +9787111364191 +9787111367895 +9787111370123 +9787111370635 +9787111374701 +9787111378327 +9787111379003 +9787111384069 +9787111385868 +9787111390282 +9787111393344 +9787111403326 +9787111404132 +9787111405627 +9787111406624 +9787111408154 +9787111408659 +9787111412397 +9787111416678 +9787111416982 +9787111419259 +9787111423195 +9787111424666 +9787111426974 +9787111430605 +9787111441663 +9787111441960 +9787111443865 +9787111444015 +9787111450986 +9787111451877 +9787111454618 +9787111455400 +9787111459026 +9787111461982 +9787111462330 +9787111462552 +9787111463146 +9787111468462 +9787111472063 +9787111476498 +9787111476719 +9787111483779 +9787111485094 +9787111490449 +9787111493778 +9787111497509 +9787111499503 +9787111501121 +9787111504979 +9787111505143 +9787111511786 +9787111527404 +9787111528371 +9787111546481 +9787111555810 +9787111567622 +9787111586791 +9787111590651 +9787111596455 +9787111602088 +9787111602880 +9787111608851 +9787111618249 +9787111618799 +9787111619307 +9787111622253 +9787111624806 +9787111633181 +9787111648888 +9787111651864 +9787111657668 +9787111661498 +9787111665823 +9787111685388 +9787111706595 +9787111710745 +9787111713135 +9787111713159 +9787111713371 +9787111713418 +9787111715627 +9787111720201 +9787111721109 +9787111726814 +9787111732426 +9787111734642 +9787111736769 +9787111737414 +9787111737445 +9787111738817 +9787111738824 +9787111740018 +9787111740179 +9787111741886 +9787111744733 +9787111746621 +9787111746645 +9787111746676 +9787111746997 +9787111747284 +9787111748410 +9787111748755 +9787111748991 +9787111749875 +9787111749936 +9787111749974 +9787111750192 +9787111750987 +9787111751182 +9787111752257 +9787111753179 +9787111753261 +9787111753742 +9787111754121 +9787111754374 +9787111755708 +9787111757207 +9787111757269 +9787111757313 +9787111758167 +9787111760818 +9787111762393 +9787111763055 +9787111763093 +9787111763116 +9787111763215 +9787111763222 +9787111763376 +9787111763727 +9787111763765 +9787111764304 +9787111764328 +9787111764472 +9787111764670 +9787111764786 +9787111764793 +9787111765134 +9787111765226 +9787111765271 +9787111765325 +9787111765363 +9787111765370 +9787111765424 +9787111765752 +9787111765783 +9787111765950 +9787111765974 +9787111766063 +9787111766414 +9787111766452 +9787111766483 +9787111766544 +9787111766681 +9787111766919 +9787111767008 +9787111767060 +9787111767145 +9787111767183 +9787111767206 +9787111767497 +9787111767527 +9787111767602 +9787111767701 +9787111767930 +9787111767947 +9787111768166 +9787111768210 +9787111768296 +9787111768470 +9787111768531 +9787111768647 +9787111768661 +9787111768760 +9787111768937 +9787111768951 +9787111769088 +9787111769590 +9787111769620 +9787111770176 +9787111770251 +9787111770596 +9787111771074 +9787111771586 +9787111774334 +9787111774426 +9787111775317 +9787111775515 +9787111775706 +9787111776215 +9787111776352 +9787111776390 +9787111776451 +9787111777182 +9787111777656 +9787111777687 +9787111778097 +9787111778738 +9787111778769 +9787111779278 +9787111779872 +9787111780175 +9787111780830 +9787111780946 +9787111780991 +9787111781172 +9787111781912 +9787111784272 +9787111785750 +9787111786382 +9787111787099 +9787111787174 +9787111787372 +9787111789390 +9787112000081 +9787112000753 +9787112001057 +9787112002290 +9787112003518 +9787112003600 +9787112004447 +9787112004454 +9787112004607 +9787112005345 +9787112006076 +9787112006137 +9787112006205 +9787112006212 +9787112007073 +9787112008049 +9787112010844 +9787112011193 +9787112011438 +9787112013715 +9787112013852 +9787112015627 +9787112015818 +9787112016167 +9787112016174 +9787112017010 +9787112017553 +9787112017690 +9787112018208 +9787112018727 +9787112019984 +9787112020140 +9787112021857 +9787112021895 +9787112022250 +9787112022359 +9787112022366 +9787112022861 +9787112022939 +9787112023226 +9787112024803 +9787112025589 +9787112026135 +9787112026463 +9787112027149 +9787112027156 +9787112027217 +9787112027514 +9787112027682 +9787112028221 +9787112028429 +9787112029334 +9787112029792 +9787112031221 +9787112032464 +9787112032716 +9787112032846 +9787112033379 +9787112033683 +9787112034543 +9787112034611 +9787112034741 +9787112034765 +9787112035328 +9787112035649 +9787112035984 +9787112036165 +9787112036219 +9787112036646 +9787112037773 +9787112038398 +9787112038602 +9787112039029 +9787112039623 +9787112039722 +9787112039814 +9787112040865 +9787112040995 +9787112041435 +9787112041633 +9787112041695 +9787112041770 +9787112042142 +9787112042470 +9787112042517 +9787112043330 +9787112044054 +9787112046058 +9787112046089 +9787112047215 +9787112047277 +9787112047291 +9787112047727 +9787112049615 +9787112049899 +9787112050215 +9787112051793 +9787112051977 +9787112053803 +9787112053834 +9787112056811 +9787112058716 +9787112060788 +9787112062317 +9787112063444 +9787112063611 +9787112064076 +9787112064526 +9787112067978 +9787112072729 +9787112074037 +9787112075133 +9787112078936 +9787112079605 +9787112081141 +9787112083169 +9787112091270 +9787112105755 +9787112108756 +9787112115150 +9787112118298 +9787112129928 +9787112131884 +9787112133130 +9787112135608 +9787112135707 +9787112135981 +9787112138364 +9787112138425 +9787112139248 +9787112142415 +9787112144051 +9787112146567 +9787112151158 +9787112153756 +9787112154180 +9787112158553 +9787112160396 +9787112164806 +9787112167586 +9787112169139 +9787112177691 +9787112180936 +9787112183166 +9787112183340 +9787112210305 +9787112213306 +9787112218516 +9787112221974 +9787112232321 +9787112232918 +9787112234158 +9787112235056 +9787112239719 +9787112244010 +9787112244232 +9787112248346 +9787112249107 +9787112251513 +9787112255962 +9787112256266 +9787112258970 +9787112260744 +9787112260997 +9787112264520 +9787112267132 +9787112275076 +9787112280070 +9787112285853 +9787112286935 +9787112288311 +9787112288335 +9787112289257 +9787112290376 +9787112292318 +9787112292387 +9787112294190 +9787112297245 +9787112297672 +9787112298044 +9787112299645 +9787112300365 +9787112300532 +9787112301447 +9787112302178 +9787112302949 +9787112304400 +9787112305636 +9787112305964 +9787112306152 +9787112306374 +9787112306428 +9787112306824 +9787112306978 +9787112307340 +9787112311576 +9787113000370 +9787113000844 +9787113001803 +9787113003319 +9787113005139 +9787113005818 +9787113008529 +9787113009939 +9787113010324 +9787113010591 +9787113010614 +9787113013387 +9787113013455 +9787113013950 +9787113015022 +9787113015824 +9787113016135 +9787113016678 +9787113017477 +9787113017712 +9787113018368 +9787113018771 +9787113019693 +9787113020002 +9787113020200 +9787113021160 +9787113021856 +9787113022419 +9787113022655 +9787113023386 +9787113023461 +9787113023591 +9787113023683 +9787113025304 +9787113025809 +9787113027148 +9787113027278 +9787113027759 +9787113028107 +9787113028374 +9787113028893 +9787113031381 +9787113031602 +9787113031794 +9787113032180 +9787113032326 +9787113032876 +9787113033675 +9787113034580 +9787113034696 +9787113035211 +9787113036430 +9787113037154 +9787113038779 +9787113038946 +9787113038953 +9787113040062 +9787113040451 +9787113040864 +9787113041311 +9787113042479 +9787113044008 +9787113045951 +9787113046132 +9787113047870 +9787113048600 +9787113048860 +9787113049331 +9787113050221 +9787113050283 +9787113050566 +9787113051099 +9787113061760 +9787113061883 +9787113062163 +9787113062965 +9787113063146 +9787113064808 +9787113065829 +9787113066949 +9787113068790 +9787113069438 +9787113069643 +9787113071158 +9787113079864 +9787113080426 +9787113081935 +9787113081942 +9787113091507 +9787113091682 +9787113092948 +9787113101275 +9787113105976 +9787113107901 +9787113114084 +9787113114879 +9787113116873 +9787113117436 +9787113117504 +9787113119072 +9787113141110 +9787113143794 +9787113146443 +9787113151324 +9787113151621 +9787113157517 +9787113157968 +9787113165239 +9787113167271 +9787113174859 +9787113175177 +9787113175184 +9787113178680 +9787113188115 +9787113191191 +9787113191245 +9787113192969 +9787113193430 +9787113194017 +9787113194048 +9787113195281 +9787113195465 +9787113210885 +9787113215095 +9787113217785 +9787113220495 +9787113237622 +9787113239589 +9787113240035 +9787113247485 +9787113255497 +9787113257057 +9787113261597 +9787113262150 +9787113263515 +9787113266417 +9787113268671 +9787113269159 +9787113270254 +9787113270896 +9787113271978 +9787113277109 +9787113278540 +9787113280239 +9787113281335 +9787113282554 +9787113282622 +9787113282646 +9787113282714 +9787113282981 +9787113283124 +9787113283704 +9787113283735 +9787113287146 +9787113291648 +9787113292119 +9787113292867 +9787113294694 +9787113294809 +9787113295806 +9787113299781 +9787113303020 +9787113303617 +9787113305116 +9787113305369 +9787113305383 +9787113306441 +9787113306649 +9787113306861 +9787113311780 +9787113311896 +9787113311957 +9787113312015 +9787113312978 +9787113313678 +9787113313975 +9787113314316 +9787113314958 +9787113315368 +9787113315405 +9787113316754 +9787113316761 +9787113316778 +9787113316792 +9787113316815 +9787113316846 +9787113319007 +9787113319984 +9787114000836 +9787114000997 +9787114001888 +9787114002328 +9787114004124 +9787114007026 +9787114007156 +9787114009440 +9787114009594 +9787114011078 +9787114011467 +9787114011498 +9787114012266 +9787114013058 +9787114015939 +9787114016691 +9787114018534 +9787114019296 +9787114019487 +9787114020582 +9787114020643 +9787114022166 +9787114022524 +9787114022753 +9787114023033 +9787114023781 +9787114024412 +9787114026782 +9787114028021 +9787114028700 +9787114029912 +9787114030451 +9787114031052 +9787114032646 +9787114032745 +9787114032967 +9787114033407 +9787114034824 +9787114036606 +9787114036736 +9787114039287 +9787114040351 +9787114043109 +9787114044700 +9787114045653 +9787114046476 +9787114047121 +9787114052644 +9787114052705 +9787114054969 +9787114059278 +9787114065194 +9787114068423 +9787114069093 +9787114076244 +9787114076633 +9787114091100 +9787114093647 +9787114099069 +9787114101182 +9787114101601 +9787114103834 +9787114108471 +9787114108884 +9787114112676 +9787114113277 +9787114115134 +9787114115912 +9787114117268 +9787114117817 +9787114118548 +9787114119217 +9787114124013 +9787114124785 +9787114125270 +9787114134777 +9787114140723 +9787114148194 +9787114148309 +9787114148859 +9787114151422 +9787114152849 +9787114152924 +9787114155000 +9787114156083 +9787114169625 +9787114170454 +9787114173059 +9787114173547 +9787114177286 +9787114180507 +9787114180934 +9787114182167 +9787114183331 +9787114187247 +9787114187889 +9787114188299 +9787114192142 +9787114194689 +9787114194726 +9787114196966 +9787114197222 +9787114199288 +9787114199400 +9787114200861 +9787114200878 +9787114200915 +9787114201479 +9787115004697 +9787115009876 +9787115010285 +9787115011688 +9787115012012 +9787115035738 +9787115037527 +9787115038586 +9787115039811 +9787115040541 +9787115041951 +9787115042361 +9787115042637 +9787115043740 +9787115043832 +9787115043863 +9787115044105 +9787115045003 +9787115045010 +9787115045041 +9787115045119 +9787115045126 +9787115045553 +9787115046253 +9787115046840 +9787115047182 +9787115047458 +9787115047656 +9787115047816 +9787115047922 +9787115048226 +9787115048301 +9787115048622 +9787115048714 +9787115048721 +9787115048738 +9787115048745 +9787115049230 +9787115049360 +9787115049971 +9787115050359 +9787115050496 +9787115050991 +9787115051547 +9787115051639 +9787115051721 +9787115052032 +9787115052216 +9787115052292 +9787115052315 +9787115052759 +9787115052865 +9787115053411 +9787115054104 +9787115054234 +9787115054869 +9787115055170 +9787115055972 +9787115055989 +9787115056047 +9787115056078 +9787115057181 +9787115057358 +9787115058027 +9787115058188 +9787115058829 +9787115058942 +9787115059482 +9787115059703 +9787115061089 +9787115061560 +9787115061676 +9787115062352 +9787115062512 +9787115062581 +9787115063021 +9787115063663 +9787115063724 +9787115064035 +9787115064080 +9787115064097 +9787115064332 +9787115064479 +9787115065223 +9787115065483 +9787115065865 +9787115066084 +9787115067166 +9787115067180 +9787115067371 +9787115068378 +9787115068835 +9787115069016 +9787115069375 +9787115069757 +9787115069795 +9787115070234 +9787115070432 +9787115071163 +9787115072320 +9787115074485 +9787115074942 +9787115075802 +9787115076670 +9787115077738 +9787115077806 +9787115077899 +9787115078445 +9787115079831 +9787115079848 +9787115082725 +9787115082886 +9787115082893 +9787115083289 +9787115084514 +9787115084828 +9787115086266 +9787115086327 +9787115087140 +9787115087317 +9787115087553 +9787115088932 +9787115088963 +9787115088994 +9787115091697 +9787115094520 +9787115094759 +9787115096210 +9787115096357 +9787115097743 +9787115098399 +9787115100634 +9787115101136 +9787115101273 +9787115102324 +9787115102362 +9787115102492 +9787115103079 +9787115103475 +9787115106117 +9787115106575 +9787115110039 +9787115110992 +9787115114099 +9787115114266 +9787115115751 +9787115117809 +9787115118783 +9787115119803 +9787115119810 +9787115120502 +9787115122704 +9787115122957 +9787115124937 +9787115126405 +9787115129925 +9787115130174 +9787115130266 +9787115131393 +9787115133809 +9787115134431 +9787115135841 +9787115135926 +9787115135964 +9787115135971 +9787115136244 +9787115138804 +9787115139078 +9787115139214 +9787115139702 +9787115140005 +9787115140203 +9787115143051 +9787115143679 +9787115144003 +9787115144416 +9787115145574 +9787115146458 +9787115146717 +9787115149732 +9787115161901 +9787115161918 +9787115162854 +9787115163004 +9787115163264 +9787115166074 +9787115174666 +9787115175700 +9787115176165 +9787115177391 +9787115182050 +9787115183071 +9787115188755 +9787115188939 +9787115188977 +9787115190987 +9787115192158 +9787115192370 +9787115192394 +9787115195777 +9787115196125 +9787115200532 +9787115201010 +9787115201256 +9787115201805 +9787115205902 +9787115206893 +9787115208118 +9787115208378 +9787115209085 +9787115209146 +9787115209153 +9787115212122 +9787115214898 +9787115215833 +9787115217707 +9787115217882 +9787115217950 +9787115221414 +9787115222329 +9787115222725 +9787115222756 +9787115227232 +9787115228451 +9787115228567 +9787115228574 +9787115228826 +9787115228864 +9787115228871 +9787115229847 +9787115230683 +9787115231888 +9787115234292 +9787115235527 +9787115235800 +9787115241061 +9787115242242 +9787115242877 +9787115243522 +9787115243676 +9787115243782 +9787115243799 +9787115244307 +9787115246752 +9787115246950 +9787115247674 +9787115247704 +9787115247728 +9787115247766 +9787115248770 +9787115249777 +9787115249791 +9787115250698 +9787115251411 +9787115251671 +9787115252029 +9787115256874 +9787115258946 +9787115260215 +9787115261786 +9787115264732 +9787115265173 +9787115266460 +9787115268082 +9787115269331 +9787115269515 +9787115274434 +9787115274748 +9787115277329 +9787115280312 +9787115281166 +9787115281364 +9787115282118 +9787115283306 +9787115283467 +9787115283801 +9787115284457 +9787115284471 +9787115284525 +9787115285447 +9787115287083 +9787115290076 +9787115292568 +9787115292599 +9787115293688 +9787115299758 +9787115300058 +9787115300874 +9787115301604 +9787115303899 +9787115313850 +9787115313973 +9787115314581 +9787115314659 +9787115314895 +9787115315229 +9787115316196 +9787115322029 +9787115322326 +9787115324504 +9787115326140 +9787115329592 +9787115331069 +9787115331076 +9787115331083 +9787115331311 +9787115334220 +9787115334244 +9787115335104 +9787115335555 +9787115340443 +9787115344632 +9787115349743 +9787115354358 +9787115355522 +9787115355539 +9787115355560 +9787115357038 +9787115357519 +9787115359506 +9787115359605 +9787115360571 +9787115363589 +9787115365590 +9787115365668 +9787115366481 +9787115369307 +9787115369413 +9787115372734 +9787115381224 +9787115382917 +9787115383549 +9787115383556 +9787115384089 +9787115384454 +9787115385321 +9787115385963 +9787115389015 +9787115389671 +9787115390509 +9787115391025 +9787115391216 +9787115392008 +9787115392411 +9787115393678 +9787115393807 +9787115396518 +9787115403612 +9787115405739 +9787115405937 +9787115407061 +9787115407214 +9787115411952 +9787115413826 +9787115414076 +9787115420855 +9787115424501 +9787115425577 +9787115425997 +9787115426369 +9787115426413 +9787115426420 +9787115428332 +9787115429261 +9787115429278 +9787115430557 +9787115430618 +9787115431363 +9787115435811 +9787115436870 +9787115444974 +9787115453242 +9787115454799 +9787115454805 +9787115458889 +9787115461353 +9787115463272 +9787115463470 +9787115464736 +9787115474551 +9787115476746 +9787115481856 +9787115481863 +9787115489029 +9787115490476 +9787115493569 +9787115493576 +9787115493583 +9787115493590 +9787115496652 +9787115496676 +9787115496751 +9787115499370 +9787115499424 +9787115500236 +9787115500243 +9787115505620 +9787115507099 +9787115509642 +9787115511935 +9787115517876 +9787115518330 +9787115519405 +9787115520913 +9787115520951 +9787115521170 +9787115523785 +9787115529480 +9787115530516 +9787115531087 +9787115534705 +9787115538147 +9787115538819 +9787115540553 +9787115544582 +9787115544599 +9787115544605 +9787115544612 +9787115547002 +9787115547019 +9787115547033 +9787115552105 +9787115552129 +9787115552136 +9787115553096 +9787115556905 +9787115560445 +9787115561633 +9787115564580 +9787115565471 +9787115567871 +9787115568427 +9787115568434 +9787115569356 +9787115569370 +9787115571175 +9787115571489 +9787115573834 +9787115574015 +9787115574633 +9787115574664 +9787115583444 +9787115586124 +9787115589743 +9787115592187 +9787115592804 +9787115593047 +9787115593122 +9787115593481 +9787115593788 +9787115594334 +9787115596123 +9787115596147 +9787115597021 +9787115597083 +9787115597144 +9787115597540 +9787115597571 +9787115597908 +9787115598950 +9787115599766 +9787115600042 +9787115600219 +9787115601049 +9787115601858 +9787115603357 +9787115603371 +9787115603593 +9787115604552 +9787115605757 +9787115606846 +9787115609823 +9787115610430 +9787115610522 +9787115610751 +9787115611666 +9787115613356 +9787115613547 +9787115613813 +9787115614087 +9787115614766 +9787115615251 +9787115616012 +9787115616104 +9787115616661 +9787115616739 +9787115617910 +9787115618030 +9787115618221 +9787115618580 +9787115620682 +9787115621108 +9787115621337 +9787115621382 +9787115622075 +9787115624130 +9787115624239 +9787115624789 +9787115625250 +9787115625731 +9787115626141 +9787115626158 +9787115626202 +9787115626547 +9787115626806 +9787115627162 +9787115627353 +9787115627520 +9787115627728 +9787115627810 +9787115629098 +9787115629531 +9787115629555 +9787115630179 +9787115630247 +9787115630810 +9787115630858 +9787115630889 +9787115631572 +9787115631589 +9787115631961 +9787115632906 +9787115633224 +9787115633316 +9787115633507 +9787115633668 +9787115633675 +9787115633798 +9787115633835 +9787115634016 +9787115636133 +9787115636829 +9787115636898 +9787115637079 +9787115637543 +9787115638427 +9787115638656 +9787115638748 +9787115638885 +9787115639387 +9787115639912 +9787115640710 +9787115641311 +9787115641366 +9787115641564 +9787115642097 +9787115643100 +9787115643322 +9787115643421 +9787115643988 +9787115644213 +9787115644220 +9787115644558 +9787115644565 +9787115644916 +9787115645104 +9787115645586 +9787115646446 +9787115646637 +9787115646828 +9787115646842 +9787115646873 +9787115647320 +9787115647498 +9787115647900 +9787115648488 +9787115648518 +9787115648785 +9787115648921 +9787115648945 +9787115648969 +9787115648990 +9787115649072 +9787115649423 +9787115649768 +9787115649775 +9787115649829 +9787115650184 +9787115650412 +9787115650467 +9787115650573 +9787115650818 +9787115650955 +9787115651174 +9787115651372 +9787115651419 +9787115651471 +9787115651549 +9787115651761 +9787115651778 +9787115651921 +9787115652034 +9787115652201 +9787115652225 +9787115652294 +9787115652362 +9787115652461 +9787115652720 +9787115653468 +9787115653543 +9787115653604 +9787115653772 +9787115653864 +9787115654496 +9787115655622 +9787115655639 +9787115655745 +9787115656407 +9787115656797 +9787115657510 +9787115657541 +9787115657664 +9787115657862 +9787115657961 +9787115658029 +9787115658586 +9787115658715 +9787115658906 +9787115659194 +9787115659217 +9787115659415 +9787115659743 +9787115659835 +9787115660022 +9787115660039 +9787115660114 +9787115660879 +9787115662453 +9787115662880 +9787115663702 +9787115663733 +9787115663887 +9787115664259 +9787115664686 +9787115664785 +9787115665683 +9787115665812 +9787115666451 +9787115666635 +9787115666840 +9787115667076 +9787115667212 +9787115667250 +9787115667748 +9787115667908 +9787115667915 +9787115669162 +9787115669711 +9787115669902 +9787115670014 +9787115670144 +9787115670205 +9787115670311 +9787115670601 +9787115670830 +9787115670915 +9787115671424 +9787115672681 +9787115673497 +9787115674289 +9787115674364 +9787115676245 +9787115676412 +9787116002852 +9787116002920 +9787116003156 +9787116003361 +9787116003538 +9787116004443 +9787116005174 +9787116005181 +9787116006232 +9787116006669 +9787116007208 +9787116008304 +9787116009189 +9787116009684 +9787116011311 +9787116012158 +9787116012806 +9787116014770 +9787116015463 +9787116016323 +9787116016491 +9787116016866 +9787116017313 +9787116017320 +9787116017856 +9787116019782 +9787116020009 +9787116020030 +9787116020962 +9787116020979 +9787116023123 +9787116023376 +9787116023741 +9787116024267 +9787116025004 +9787116025486 +9787116026254 +9787116027466 +9787116027718 +9787116027756 +9787116028258 +9787116029026 +9787116029422 +9787116029484 +9787116030244 +9787116030404 +9787116031166 +9787116032866 +9787116033511 +9787116033689 +9787116034723 +9787116034891 +9787116036512 +9787116036567 +9787116038721 +9787116039643 +9787116041981 +9787116043220 +9787116045736 +9787116046658 +9787116048980 +9787116048997 +9787116050006 +9787116051171 +9787116053397 +9787116054424 +9787116055339 +9787116055346 +9787116057104 +9787116057210 +9787116057722 +9787116060371 +9787116060487 +9787116060975 +9787116062030 +9787116062085 +9787116062092 +9787116062146 +9787116062221 +9787116063891 +9787116064829 +9787116066038 +9787116066397 +9787116066618 +9787116068438 +9787116069442 +9787116070431 +9787116070516 +9787116071575 +9787116071612 +9787116071711 +9787116072084 +9787116072657 +9787116073388 +9787116073760 +9787116074255 +9787116074484 +9787116075351 +9787116075627 +9787116077263 +9787116077751 +9787116077867 +9787116078659 +9787116078970 +9787116079052 +9787116079427 +9787116080508 +9787116080621 +9787116082168 +9787116083134 +9787116085350 +9787116086272 +9787116086364 +9787116086418 +9787116087316 +9787116089617 +9787116090156 +9787116091696 +9787116098909 +9787116100213 +9787116100824 +9787116103818 +9787116103825 +9787116103856 +9787116103894 +9787116109742 +9787116111608 +9787116112025 +9787116114210 +9787116115385 +9787116115637 +9787116116030 +9787116116573 +9787116119192 +9787116120129 +9787116120280 +9787116120518 +9787116121034 +9787116122666 +9787116124684 +9787116125261 +9787116126367 +9787116127371 +9787116127579 +9787116127661 +9787116127678 +9787116128323 +9787116128514 +9787116130036 +9787116130296 +9787116131255 +9787116133402 +9787116133853 +9787116134478 +9787116135314 +9787116136236 +9787116137554 +9787116139152 +9787116140134 +9787116141933 +9787116144422 +9787116144842 +9787116146051 +9787117000048 +9787117000352 +9787117000703 +9787117000819 +9787117000918 +9787117001052 +9787117001076 +9787117001397 +9787117001427 +9787117001434 +9787117001526 +9787117001724 +9787117001731 +9787117001847 +9787117001854 +9787117001984 +9787117002028 +9787117002042 +9787117002059 +9787117002073 +9787117002080 +9787117002356 +9787117002363 +9787117002387 +9787117002585 +9787117002677 +9787117002691 +9787117002776 +9787117002783 +9787117002905 +9787117002974 +9787117002981 +9787117003018 +9787117003087 +9787117003100 +9787117003223 +9787117003230 +9787117003247 +9787117003254 +9787117003261 +9787117003377 +9787117003469 +9787117003513 +9787117003520 +9787117003537 +9787117003551 +9787117003575 +9787117003681 +9787117003698 +9787117003834 +9787117003858 +9787117004305 +9787117004732 +9787117004862 +9787117005128 +9787117005272 +9787117005364 +9787117005432 +9787117006279 +9787117006354 +9787117006378 +9787117006545 +9787117006590 +9787117006606 +9787117006613 +9787117006637 +9787117006712 +9787117006828 +9787117006859 +9787117006873 +9787117006996 +9787117007122 +9787117007153 +9787117007177 +9787117007238 +9787117007269 +9787117007368 +9787117007412 +9787117007528 +9787117007535 +9787117007566 +9787117007573 +9787117007597 +9787117007641 +9787117007658 +9787117007788 +9787117007849 +9787117007894 +9787117007900 +9787117007993 +9787117008143 +9787117008174 +9787117008181 +9787117008198 +9787117008259 +9787117008303 +9787117008310 +9787117008501 +9787117008518 +9787117008549 +9787117008556 +9787117008594 +9787117008624 +9787117008761 +9787117008778 +9787117009201 +9787117009287 +9787117009317 +9787117009324 +9787117009362 +9787117009553 +9787117009614 +9787117009621 +9787117009836 +9787117009911 +9787117009959 +9787117010139 +9787117010528 +9787117010795 +9787117011006 +9787117011013 +9787117011129 +9787117011150 +9787117011259 +9787117011280 +9787117011372 +9787117011389 +9787117011549 +9787117011617 +9787117011648 +9787117011730 +9787117011792 +9787117011846 +9787117011952 +9787117012072 +9787117012096 +9787117012355 +9787117012423 +9787117012614 +9787117012683 +9787117012812 +9787117013093 +9787117013253 +9787117013352 +9787117013765 +9787117013888 +9787117014106 +9787117014175 +9787117014304 +9787117014427 +9787117014700 +9787117014793 +9787117014861 +9787117014878 +9787117014915 +9787117014939 +9787117015202 +9787117015370 +9787117015462 +9787117015585 +9787117015653 +9787117015738 +9787117015745 +9787117015790 +9787117016216 +9787117016438 +9787117016452 +9787117016537 +9787117016568 +9787117016605 +9787117016780 +9787117016896 +9787117016902 +9787117016957 +9787117017145 +9787117017176 +9787117017268 +9787117017329 +9787117017336 +9787117017558 +9787117017602 +9787117017831 +9787117017855 +9787117017916 +9787117018340 +9787117018432 +9787117018487 +9787117018531 +9787117018579 +9787117018609 +9787117018968 +9787117019033 +9787117019156 +9787117019576 +9787117019972 +9787117020039 +9787117020220 +9787117020244 +9787117020305 +9787117020428 +9787117020442 +9787117020602 +9787117020619 +9787117020671 +9787117020688 +9787117020732 +9787117020787 +9787117020817 +9787117020923 +9787117020947 +9787117021043 +9787117021104 +9787117021111 +9787117021227 +9787117021234 +9787117021241 +9787117021326 +9787117021340 +9787117021487 +9787117021661 +9787117021753 +9787117021814 +9787117021890 +9787117021968 +9787117022040 +9787117022323 +9787117022330 +9787117022408 +9787117022460 +9787117022521 +9787117022538 +9787117022675 +9787117022705 +9787117023160 +9787117023184 +9787117023238 +9787117023368 +9787117023450 +9787117023702 +9787117023764 +9787117023795 +9787117023801 +9787117023856 +9787117023870 +9787117023894 +9787117023900 +9787117024280 +9787117024426 +9787117024532 +9787117024556 +9787117024624 +9787117024853 +9787117025126 +9787117025164 +9787117025225 +9787117025232 +9787117025300 +9787117025744 +9787117025843 +9787117026000 +9787117026178 +9787117026222 +9787117026369 +9787117026512 +9787117026611 +9787117026666 +9787117026703 +9787117026888 +9787117026949 +9787117027052 +9787117027106 +9787117027182 +9787117027205 +9787117027236 +9787117027434 +9787117027441 +9787117027465 +9787117027489 +9787117027618 +9787117027762 +9787117027878 +9787117027960 +9787117028462 +9787117028479 +9787117028639 +9787117028660 +9787117028677 +9787117028813 +9787117029070 +9787117029162 +9787117029278 +9787117029285 +9787117029568 +9787117029704 +9787117029759 +9787117029827 +9787117029889 +9787117030014 +9787117030410 +9787117030519 +9787117030687 +9787117030755 +9787117031141 +9787117031646 +9787117031691 +9787117031721 +9787117031943 +9787117031998 +9787117032056 +9787117032131 +9787117032209 +9787117032230 +9787117032247 +9787117032278 +9787117032285 +9787117032292 +9787117032308 +9787117032339 +9787117032346 +9787117032353 +9787117032360 +9787117032377 +9787117032391 +9787117032506 +9787117032513 +9787117032568 +9787117033329 +9787117033671 +9787117034159 +9787117034456 +9787117034487 +9787117034494 +9787117034548 +9787117034845 +9787117034852 +9787117035101 +9787117035613 +9787117035682 +9787117035705 +9787117035736 +9787117035811 +9787117035859 +9787117036009 +9787117036085 +9787117036535 +9787117036542 +9787117036627 +9787117036665 +9787117037105 +9787117037709 +9787117037976 +9787117038249 +9787117038256 +9787117038270 +9787117038287 +9787117038300 +9787117038317 +9787117038331 +9787117038362 +9787117038386 +9787117038850 +9787117039413 +9787117040167 +9787117040884 +9787117040969 +9787117041201 +9787117041447 +9787117041911 +9787117042017 +9787117042284 +9787117042550 +9787117042680 +9787117042789 +9787117042819 +9787117043083 +9787117043090 +9787117043137 +9787117043151 +9787117044493 +9787117045025 +9787117045148 +9787117045209 +9787117045551 +9787117045650 +9787117046015 +9787117046022 +9787117046039 +9787117046046 +9787117046060 +9787117046077 +9787117046084 +9787117046091 +9787117046107 +9787117046190 +9787117046480 +9787117046572 +9787117046961 +9787117047364 +9787117047883 +9787117047975 +9787117048170 +9787117048286 +9787117048293 +9787117048743 +9787117049054 +9787117049696 +9787117049900 +9787117050098 +9787117050340 +9787117050524 +9787117051576 +9787117052580 +9787117052887 +9787117053082 +9787117053426 +9787117054560 +9787117054997 +9787117057035 +9787117060387 +9787117060677 +9787117065160 +9787117069397 +9787117069427 +9787117069465 +9787117069670 +9787117071147 +9787117071901 +9787117072489 +9787117074025 +9787117075701 +9787117079310 +9787117079518 +9787117079716 +9787117080316 +9787117080835 +9787117081009 +9787117081795 +9787117082310 +9787117082655 +9787117086097 +9787117086127 +9787117086349 +9787117088121 +9787117089340 +9787117089685 +9787117092104 +9787117102483 +9787117104432 +9787117104609 +9787117108621 +9787117109055 +9787117112161 +9787117112932 +9787117114622 +9787117116343 +9787117119221 +9787117121200 +9787117126045 +9787117126083 +9787117127264 +9787117133890 +9787117133982 +9787117134156 +9787117134163 +9787117136396 +9787117138703 +9787117141147 +9787117142274 +9787117147705 +9787117150217 +9787117154130 +9787117154239 +9787117156035 +9787117161145 +9787117176026 +9787117193733 +9787117197922 +9787117198219 +9787117198554 +9787117201919 +9787117206723 +9787117207546 +9787117207607 +9787117209809 +9787117220361 +9787117226745 +9787117230094 +9787117237390 +9787117237857 +9787117243124 +9787117243582 +9787117246897 +9787117248907 +9787117259415 +9787117261937 +9787117263733 +9787117266154 +9787117280785 +9787117281225 +9787117285896 +9787117288231 +9787117289597 +9787117292085 +9787117293303 +9787117296250 +9787117296649 +9787117299381 +9787117302579 +9787117303477 +9787117304153 +9787117304191 +9787117305495 +9787117306447 +9787117307680 +9787117309370 +9787117311519 +9787117312738 +9787117312745 +9787117317689 +9787117317696 +9787117318600 +9787117320924 +9787117322720 +9787117323604 +9787117327565 +9787117327770 +9787117330275 +9787117332477 +9787117335188 +9787117339742 +9787117341264 +9787117342483 +9787117348171 +9787117349451 +9787117350532 +9787117351102 +9787117352451 +9787117356374 +9787117356701 +9787117358460 +9787117359573 +9787117361217 +9787117362931 +9787117363181 +9787117363631 +9787117364256 +9787117364423 +9787117364683 +9787117364720 +9787117365765 +9787117365932 +9787117366113 +9787117366564 +9787117367035 +9787117367349 +9787117367356 +9787117368131 +9787117368179 +9787117368872 +9787117369190 +9787117369220 +9787117370035 +9787117370073 +9787117370912 +9787117371506 +9787117373609 +9787117374088 +9787117374330 +9787117374538 +9787117374781 +9787117375085 +9787117375894 +9787117375900 +9787117376006 +9787117376365 +9787117377119 +9787117377553 +9787117378130 +9787117378147 +9787117378895 +9787117379182 +9787117379496 +9787117379922 +9787117381765 +9787118000290 +9787118000368 +9787118001754 +9787118002270 +9787118002492 +9787118002652 +9787118003284 +9787118004441 +9787118004830 +9787118005547 +9787118006056 +9787118008265 +9787118009699 +9787118009897 +9787118010022 +9787118010091 +9787118010404 +9787118010541 +9787118010909 +9787118010954 +9787118011203 +9787118011531 +9787118011685 +9787118011968 +9787118012392 +9787118013221 +9787118013689 +9787118014242 +9787118014723 +9787118015119 +9787118015171 +9787118015232 +9787118015324 +9787118015706 +9787118015973 +9787118016093 +9787118016871 +9787118017106 +9787118017205 +9787118017601 +9787118017717 +9787118017809 +9787118018042 +9787118018332 +9787118018387 +9787118018714 +9787118018790 +9787118018806 +9787118019476 +9787118019537 +9787118019940 +9787118019988 +9787118020571 +9787118020823 +9787118020885 +9787118021066 +9787118021097 +9787118021172 +9787118021585 +9787118021592 +9787118022599 +9787118022674 +9787118022957 +9787118023305 +9787118023855 +9787118025415 +9787118025460 +9787118025538 +9787118025903 +9787118026641 +9787118028058 +9787118028188 +9787118028232 +9787118028515 +9787118028898 +9787118028980 +9787118032185 +9787118033557 +9787118035636 +9787118038927 +9787118039214 +9787118043815 +9787118054217 +9787118054422 +9787118055917 +9787118057461 +9787118059908 +9787118061345 +9787118073300 +9787118078220 +9787118080940 +9787118082319 +9787118083590 +9787118084085 +9787118084344 +9787118084696 +9787118085693 +9787118085969 +9787118088892 +9787118096378 +9787118100754 +9787118109603 +9787118112078 +9787118113068 +9787118113945 +9787118116267 +9787118117271 +9787118118230 +9787118118407 +9787118118780 +9787118119336 +9787118119596 +9787118119688 +9787118120004 +9787118120349 +9787118121087 +9787118123661 +9787118126617 +9787118127317 +9787118127324 +9787118127348 +9787118128116 +9787118128147 +9787118128925 +9787118129304 +9787118129434 +9787118129731 +9787118130294 +9787118130478 +9787118130706 +9787118131376 +9787118131918 +9787118132458 +9787118132847 +9787118132854 +9787118132960 +9787118133554 +9787118133622 +9787118134650 +9787118134667 +9787118134773 +9787118134827 +9787118135046 +9787118136043 +9787118136203 +9787118138924 +9787119001043 +9787119007236 +9787119007526 +9787119008783 +9787119008790 +9787119008806 +9787119008851 +9787119010939 +9787119013800 +9787119013992 +9787119014210 +9787119014654 +9787119015323 +9787119015378 +9787119015392 +9787119015422 +9787119015712 +9787119015910 +9787119015934 +9787119016153 +9787119016467 +9787119016535 +9787119016726 +9787119016764 +9787119016894 +9787119017327 +9787119017365 +9787119017396 +9787119018089 +9787119018355 +9787119018430 +9787119018584 +9787119019093 +9787119019147 +9787119019857 +9787119019864 +9787119020020 +9787119020044 +9787119020068 +9787119020105 +9787119020167 +9787119021072 +9787119021317 +9787119021416 +9787119021584 +9787119021898 +9787119022079 +9787119022284 +9787119022307 +9787119022369 +9787119022567 +9787119022581 +9787119022673 +9787119022918 +9787119023045 +9787119023069 +9787119023106 +9787119023120 +9787119023342 +9787119023373 +9787119023496 +9787119023564 +9787119023588 +9787119023601 +9787119023625 +9787119023663 +9787119023793 +9787119023816 +9787119023823 +9787119024134 +9787119024479 +9787119024561 +9787119024660 +9787119025049 +9787119025384 +9787119025407 +9787119025476 +9787119025506 +9787119025698 +9787119026350 +9787119026749 +9787119026756 +9787119027135 +9787119027609 +9787119028200 +9787119028231 +9787119028798 +9787119028873 +9787119029122 +9787119029146 +9787119029320 +9787119029450 +9787119029849 +9787119032702 +9787119033501 +9787119034560 +9787119034638 +9787119035086 +9787119035352 +9787119035376 +9787119035390 +9787119035406 +9787119035468 +9787119035475 +9787119035482 +9787119035765 +9787119035925 +9787119035994 +9787119036182 +9787119037936 +9787119038872 +9787119040318 +9787119040325 +9787119041056 +9787119041063 +9787119041148 +9787119048673 +9787119048871 +9787119049021 +9787119049113 +9787119049816 +9787119051475 +9787119052120 +9787119054735 +9787119055121 +9787119055831 +9787119057668 +9787119058306 +9787119058870 +9787119058887 +9787119059198 +9787119061801 +9787119062877 +9787119063867 +9787119064161 +9787119064673 +9787119064970 +9787119065052 +9787119065595 +9787119065632 +9787119066356 +9787119069371 +9787119070537 +9787119070698 +9787119070704 +9787119070711 +9787119070773 +9787119072203 +9787119073613 +9787119076324 +9787119076584 +9787119076621 +9787119077925 +9787119077932 +9787119077949 +9787119077956 +9787119077970 +9787119079059 +9787119079134 +9787119079783 +9787119080130 +9787119080147 +9787119080178 +9787119080314 +9787119081946 +9787119081953 +9787119083629 +9787119084770 +9787119086095 +9787119086101 +9787119086118 +9787119086125 +9787119086132 +9787119086149 +9787119086156 +9787119086163 +9787119086330 +9787119086972 +9787119090597 +9787119092560 +9787119093536 +9787119094861 +9787119094922 +9787119095653 +9787119095936 +9787119096667 +9787119108704 +9787119110608 +9787119111667 +9787119115597 +9787119115849 +9787119115870 +9787119117621 +9787119123349 +9787119124995 +9787119127019 +9787119128306 +9787119130934 +9787119132020 +9787119134925 +9787119136899 +9787119139678 +9787119139715 +9787119140049 +9787119143347 +9787120001155 +9787120003616 +9787120003906 +9787120005757 +9787120007768 +9787120009373 +9787120009557 +9787120012779 +9787120016913 +9787120017248 +9787120017286 +9787120018177 +9787120023331 +9787120024017 +9787121002878 +9787121008559 +9787121012532 +9787121014499 +9787121016660 +9787121017988 +9787121019098 +9787121019326 +9787121022395 +9787121022401 +9787121022807 +9787121025686 +9787121027772 +9787121030345 +9787121033391 +9787121038594 +9787121039508 +9787121045202 +9787121049859 +9787121052767 +9787121052842 +9787121059018 +9787121060632 +9787121067921 +9787121068959 +9787121072376 +9787121075650 +9787121078590 +9787121078774 +9787121083952 +9787121087660 +9787121095009 +9787121104619 +9787121106668 +9787121107306 +9787121112744 +9787121120510 +9787121126253 +9787121129278 +9787121131448 +9787121134784 +9787121137501 +9787121143229 +9787121147210 +9787121147319 +9787121149399 +9787121155352 +9787121155505 +9787121165337 +9787121167218 +9787121167249 +9787121168772 +9787121179242 +9787121181351 +9787121181450 +9787121185120 +9787121187193 +9787121196584 +9787121204258 +9787121204456 +9787121213274 +9787121215803 +9787121221170 +9787121221552 +9787121222108 +9787121222382 +9787121223068 +9787121230233 +9787121231827 +9787121236686 +9787121236846 +9787121237836 +9787121239441 +9787121242977 +9787121244544 +9787121246852 +9787121248795 +9787121254222 +9787121259678 +9787121267475 +9787121269646 +9787121282621 +9787121284991 +9787121290503 +9787121291876 +9787121295607 +9787121301100 +9787121302817 +9787121303159 +9787121319259 +9787121328824 +9787121331770 +9787121334788 +9787121336867 +9787121345883 +9787121351518 +9787121353697 +9787121353932 +9787121357947 +9787121358074 +9787121359132 +9787121359378 +9787121359866 +9787121360749 +9787121369322 +9787121374616 +9787121382529 +9787121383526 +9787121385148 +9787121385193 +9787121385209 +9787121385629 +9787121387623 +9787121388385 +9787121390401 +9787121391576 +9787121391606 +9787121392818 +9787121393778 +9787121394195 +9787121394492 +9787121396410 +9787121397417 +9787121397974 +9787121400308 +9787121400599 +9787121401053 +9787121401749 +9787121405785 +9787121406164 +9787121406188 +9787121406232 +9787121406867 +9787121407475 +9787121410505 +9787121411441 +9787121411465 +9787121411625 +9787121414961 +9787121415234 +9787121419379 +9787121425943 +9787121425981 +9787121426728 +9787121427114 +9787121427671 +9787121427848 +9787121428104 +9787121428494 +9787121430022 +9787121430060 +9787121431197 +9787121431913 +9787121432378 +9787121432903 +9787121432910 +9787121434723 +9787121435614 +9787121435706 +9787121436390 +9787121436444 +9787121437465 +9787121437571 +9787121437687 +9787121439032 +9787121439759 +9787121440137 +9787121442070 +9787121443282 +9787121443442 +9787121443596 +9787121445552 +9787121447204 +9787121448690 +9787121450914 +9787121454875 +9787121456176 +9787121456527 +9787121456626 +9787121456749 +9787121458231 +9787121458767 +9787121460791 +9787121461644 +9787121462887 +9787121463006 +9787121463259 +9787121463303 +9787121463891 +9787121464188 +9787121465284 +9787121465369 +9787121465628 +9787121466458 +9787121466588 +9787121469800 +9787121470073 +9787121470387 +9787121470967 +9787121472480 +9787121473159 +9787121473227 +9787121473999 +9787121475436 +9787121475504 +9787121475658 +9787121476600 +9787121477218 +9787121477409 +9787121477485 +9787121478451 +9787121479090 +9787121479434 +9787121481055 +9787121481116 +9787121482373 +9787121482663 +9787121483103 +9787121483165 +9787121483257 +9787121483288 +9787121483295 +9787121484049 +9787121484728 +9787121486838 +9787121487361 +9787121488139 +9787121488795 +9787121488894 +9787121489112 +9787121489174 +9787121490019 +9787121490170 +9787121490552 +9787121490842 +9787121491313 +9787121491320 +9787121491368 +9787121491801 +9787121491887 +9787121492105 +9787121492242 +9787121492419 +9787121492518 +9787121493492 +9787121493508 +9787121493652 +9787121493669 +9787121494871 +9787121494888 +9787121494932 +9787121495540 +9787121496516 +9787121497155 +9787121497209 +9787121497520 +9787121497704 +9787121498169 +9787121498176 +9787121498282 +9787121498510 +9787121498596 +9787121498695 +9787121498954 +9787121499265 +9787121499272 +9787121499555 +9787121500114 +9787121500329 +9787121500336 +9787121500510 +9787121501111 +9787121501364 +9787121501807 +9787121504211 +9787121504518 +9787121505041 +9787121506147 +9787121507960 +9787122000552 +9787122003737 +9787122013446 +9787122018588 +9787122020505 +9787122025807 +9787122026989 +9787122044914 +9787122048837 +9787122048912 +9787122053756 +9787122057846 +9787122062086 +9787122063090 +9787122067692 +9787122071484 +9787122074034 +9787122079329 +9787122087362 +9787122087690 +9787122087768 +9787122092175 +9787122094988 +9787122098474 +9787122101815 +9787122109958 +9787122110640 +9787122112798 +9787122118684 +9787122121813 +9787122125712 +9787122126016 +9787122126221 +9787122128614 +9787122129284 +9787122133816 +9787122134950 +9787122135704 +9787122153326 +9787122157577 +9787122159069 +9787122159847 +9787122169976 +9787122170620 +9787122170668 +9787122176905 +9787122179821 +9787122180711 +9787122181138 +9787122183262 +9787122184306 +9787122184344 +9787122184801 +9787122187659 +9787122189059 +9787122201911 +9787122205681 +9787122205810 +9787122206053 +9787122208224 +9787122215697 +9787122221018 +9787122223739 +9787122223760 +9787122226723 +9787122228499 +9787122229281 +9787122230126 +9787122231062 +9787122232298 +9787122233509 +9787122239198 +9787122244376 +9787122244789 +9787122248534 +9787122266941 +9787122270603 +9787122270986 +9787122277824 +9787122279934 +9787122283269 +9787122292605 +9787122293589 +9787122302595 +9787122309426 +9787122310811 +9787122314987 +9787122315007 +9787122318954 +9787122322425 +9787122333858 +9787122341143 +9787122347039 +9787122347428 +9787122348470 +9787122350565 +9787122362292 +9787122365460 +9787122381941 +9787122387998 +9787122392534 +9787122396303 +9787122402561 +9787122402646 +9787122405470 +9787122409423 +9787122410238 +9787122414038 +9787122416810 +9787122418036 +9787122419392 +9787122422255 +9787122423917 +9787122429582 +9787122432261 +9787122433053 +9787122434029 +9787122436351 +9787122438621 +9787122438645 +9787122438935 +9787122440020 +9787122440303 +9787122440433 +9787122440471 +9787122441294 +9787122441652 +9787122443137 +9787122444561 +9787122445766 +9787122448194 +9787122450760 +9787122451668 +9787122452245 +9787122452511 +9787122452528 +9787122452665 +9787122452696 +9787122452740 +9787122452863 +9787122453419 +9787122455291 +9787122455529 +9787122455987 +9787122456298 +9787122456991 +9787122457080 +9787122457240 +9787122458186 +9787122459183 +9787122459299 +9787122459923 +9787122461421 +9787122461636 +9787122462817 +9787122462961 +9787122463012 +9787122463661 +9787122463722 +9787122463777 +9787122464514 +9787122465498 +9787122465580 +9787122465757 +9787122467294 +9787122467430 +9787122467843 +9787122468840 +9787122469236 +9787122469472 +9787122469670 +9787122469755 +9787122470195 +9787122470263 +9787122471161 +9787122472373 +9787122473479 +9787122473554 +9787122475046 +9787122475305 +9787122476029 +9787122476234 +9787122476296 +9787122476555 +9787122477965 +9787122478023 +9787122478337 +9787122479341 +9787122479495 +9787122479945 +9787122481627 +9787122482167 +9787125196092 +9787130062597 +9787135036081 +9787148682541 +9787170600308 +9787200000177 +9787200000184 +9787200000191 +9787200000207 +9787200000269 +9787200000283 +9787200000481 +9787200000559 +9787200000580 +9787200000627 +9787200000634 +9787200000719 +9787200000726 +9787200000733 +9787200000795 +9787200000962 +9787200001006 +9787200001020 +9787200001181 +9787200001211 +9787200001235 +9787200001259 +9787200001389 +9787200001471 +9787200001495 +9787200001587 +9787200001655 +9787200001723 +9787200001808 +9787200001952 +9787200002249 +9787200002256 +9787200002461 +9787200002614 +9787200002812 +9787200002850 +9787200002966 +9787200003000 +9787200003031 +9787200003048 +9787200003055 +9787200003116 +9787200003338 +9787200003345 +9787200003437 +9787200003444 +9787200003796 +9787200003864 +9787200003888 +9787200004038 +9787200004076 +9787200004335 +9787200004366 +9787200004410 +9787200004649 +9787200004724 +9787200005097 +9787200005165 +9787200005202 +9787200005219 +9787200005226 +9787200005264 +9787200005554 +9787200005561 +9787200005677 +9787200005684 +9787200005776 +9787200005981 +9787200006056 +9787200006360 +9787200006476 +9787200006513 +9787200006568 +9787200006643 +9787200006841 +9787200006896 +9787200006919 +9787200007008 +9787200007107 +9787200007176 +9787200007206 +9787200007374 +9787200007411 +9787200007473 +9787200007626 +9787200007640 +9787200007855 +9787200008166 +9787200008203 +9787200008241 +9787200008517 +9787200008647 +9787200008715 +9787200008890 +9787200008906 +9787200009583 +9787200009637 +9787200010114 +9787200010527 +9787200010572 +9787200011043 +9787200011050 +9787200011159 +9787200011173 +9787200011289 +9787200011500 +9787200011548 +9787200011715 +9787200011937 +9787200011944 +9787200012019 +9787200012033 +9787200012118 +9787200012200 +9787200012217 +9787200012415 +9787200012422 +9787200012682 +9787200012835 +9787200012880 +9787200012934 +9787200012989 +9787200013313 +9787200013412 +9787200013436 +9787200013474 +9787200013511 +9787200013610 +9787200013627 +9787200013658 +9787200013665 +9787200013733 +9787200013764 +9787200013894 +9787200014112 +9787200014167 +9787200014280 +9787200014525 +9787200014617 +9787200014624 +9787200014723 +9787200014754 +9787200014884 +9787200014907 +9787200015508 +9787200015553 +9787200015591 +9787200015621 +9787200015836 +9787200015935 +9787200016178 +9787200016369 +9787200016468 +9787200016505 +9787200016550 +9787200016581 +9787200016796 +9787200016840 +9787200016871 +9787200017199 +9787200017250 +9787200017274 +9787200017298 +9787200017366 +9787200017540 +9787200017557 +9787200017687 +9787200017717 +9787200017878 +9787200017915 +9787200017946 +9787200018011 +9787200018035 +9787200018189 +9787200018196 +9787200018219 +9787200018226 +9787200018431 +9787200018547 +9787200018691 +9787200018783 +9787200018806 +9787200019223 +9787200019377 +9787200019391 +9787200019414 +9787200019438 +9787200019599 +9787200019711 +9787200019896 +9787200019988 +9787200020212 +9787200020267 +9787200020373 +9787200020595 +9787200021233 +9787200021622 +9787200022070 +9787200022179 +9787200022285 +9787200022346 +9787200022377 +9787200023046 +9787200023213 +9787200023220 +9787200023435 +9787200023442 +9787200023459 +9787200023817 +9787200023824 +9787200023879 +9787200024166 +9787200024586 +9787200024845 +9787200025040 +9787200025590 +9787200026276 +9787200026283 +9787200026306 +9787200026429 +9787200026559 +9787200026658 +9787200026689 +9787200026825 +9787200026948 +9787200026955 +9787200027280 +9787200027297 +9787200027372 +9787200027662 +9787200027754 +9787200027792 +9787200027952 +9787200027969 +9787200028010 +9787200028195 +9787200028249 +9787200028263 +9787200028317 +9787200028324 +9787200028744 +9787200028768 +9787200028843 +9787200029024 +9787200029376 +9787200029536 +9787200029628 +9787200029895 +9787200029918 +9787200029994 +9787200030150 +9787200030167 +9787200030198 +9787200030228 +9787200030273 +9787200030334 +9787200030372 +9787200030396 +9787200030419 +9787200030440 +9787200030549 +9787200030587 +9787200030600 +9787200030631 +9787200030648 +9787200030716 +9787200030846 +9787200030860 +9787200030952 +9787200031027 +9787200031164 +9787200031249 +9787200031485 +9787200031577 +9787200031898 +9787200031911 +9787200031966 +9787200031980 +9787200031997 +9787200032017 +9787200032062 +9787200032154 +9787200032161 +9787200032178 +9787200032314 +9787200032598 +9787200032635 +9787200032703 +9787200032734 +9787200032758 +9787200032895 +9787200033014 +9787200033021 +9787200033120 +9787200033168 +9787200033175 +9787200033380 +9787200033496 +9787200033502 +9787200033601 +9787200033717 +9787200033724 +9787200033748 +9787200034066 +9787200034257 +9787200034295 +9787200034325 +9787200034349 +9787200034387 +9787200034684 +9787200034783 +9787200034806 +9787200034943 +9787200035308 +9787200035391 +9787200035704 +9787200035742 +9787200035766 +9787200036206 +9787200036268 +9787200036275 +9787200036299 +9787200036336 +9787200036442 +9787200036459 +9787200036473 +9787200036824 +9787200037111 +9787200037234 +9787200037395 +9787200037500 +9787200037517 +9787200037708 +9787200037715 +9787200037722 +9787200037852 +9787200037944 +9787200037968 +9787200038057 +9787200038132 +9787200038163 +9787200038217 +9787200038231 +9787200038309 +9787200039382 +9787200039450 +9787200039566 +9787200039870 +9787200039917 +9787200039924 +9787200039962 +9787200039979 +9787200040067 +9787200040081 +9787200040104 +9787200040210 +9787200040234 +9787200040395 +9787200040449 +9787200040463 +9787200040647 +9787200040685 +9787200040982 +9787200040999 +9787200041057 +9787200041569 +9787200041705 +9787200041804 +9787200041842 +9787200041903 +9787200042078 +9787200042139 +9787200042320 +9787200042665 +9787200043266 +9787200043396 +9787200043709 +9787200044072 +9787200044089 +9787200044416 +9787200044867 +9787200045086 +9787200045949 +9787200046281 +9787200047240 +9787200047288 +9787200048445 +9787200048964 +9787200049404 +9787200049930 +9787200049992 +9787200050028 +9787200050332 +9787200050677 +9787200050707 +9787200050868 +9787200051193 +9787200051308 +9787200051483 +9787200051568 +9787200051827 +9787200053104 +9787200053128 +9787200053135 +9787200053159 +9787200053173 +9787200053180 +9787200053197 +9787200053203 +9787200053227 +9787200053258 +9787200053265 +9787200053685 +9787200054767 +9787200054897 +9787200055030 +9787200055863 +9787200056624 +9787200056693 +9787200056723 +9787200056785 +9787200056808 +9787200056884 +9787200057256 +9787200057287 +9787200057317 +9787200057386 +9787200059779 +9787200060416 +9787200060805 +9787200060874 +9787200061093 +9787200061475 +9787200061598 +9787200061857 +9787200062052 +9787200062274 +9787200062717 +9787200062809 +9787200062946 +9787200062991 +9787200063134 +9787200063189 +9787200063424 +9787200063479 +9787200063721 +9787200064032 +9787200064391 +9787200064490 +9787200064698 +9787200065152 +9787200065343 +9787200065367 +9787200065718 +9787200066135 +9787200066562 +9787200066746 +9787200067040 +9787200067286 +9787200067477 +9787200067590 +9787200068054 +9787200068795 +9787200068986 +9787200069532 +9787200070194 +9787200070781 +9787200070804 +9787200071245 +9787200071528 +9787200072280 +9787200072785 +9787200073515 +9787200074017 +9787200074604 +9787200074949 +9787200075076 +9787200076165 +9787200076202 +9787200076622 +9787200076998 +9787200078268 +9787200078749 +9787200079517 +9787200079531 +9787200079685 +9787200079999 +9787200080568 +9787200081046 +9787200081411 +9787200082319 +9787200082753 +9787200083149 +9787200083316 +9787200083408 +9787200083446 +9787200083897 +9787200083934 +9787200084061 +9787200084900 +9787200085143 +9787200085327 +9787200085402 +9787200085884 +9787200086010 +9787200086980 +9787200087161 +9787200087178 +9787200087536 +9787200087543 +9787200087826 +9787200087833 +9787200087864 +9787200088830 +9787200089189 +9787200089349 +9787200089462 +9787200090406 +9787200090451 +9787200091083 +9787200091809 +9787200091816 +9787200092660 +9787200092813 +9787200092974 +9787200092981 +9787200093230 +9787200093247 +9787200093667 +9787200093902 +9787200094787 +9787200094930 +9787200095364 +9787200095548 +9787200095753 +9787200095814 +9787200095937 +9787200096477 +9787200097023 +9787200097290 +9787200097443 +9787200097900 +9787200098099 +9787200098204 +9787200098211 +9787200100150 +9787200100662 +9787200100679 +9787200101768 +9787200101799 +9787200101836 +9787200103274 +9787200103489 +9787200104547 +9787200104691 +9787200105346 +9787200105940 +9787200106336 +9787200106954 +9787200107951 +9787200108125 +9787200109184 +9787200109467 +9787200110036 +9787200110081 +9787200110159 +9787200110302 +9787200110340 +9787200110388 +9787200111019 +9787200111316 +9787200111422 +9787200112061 +9787200114683 +9787200115185 +9787200115734 +9787200116373 +9787200116472 +9787200117073 +9787200117752 +9787200118537 +9787200119381 +9787200122756 +9787200126273 +9787200129007 +9787200129984 +9787200130232 +9787200131819 +9787200131895 +9787200132090 +9787200133165 +9787200133172 +9787200136142 +9787200137514 +9787200137606 +9787200137620 +9787200137637 +9787200137989 +9787200140811 +9787200142945 +9787200143102 +9787200143263 +9787200145021 +9787200145304 +9787200148022 +9787200150360 +9787200151039 +9787200151343 +9787200151800 +9787200153644 +9787200155242 +9787200156102 +9787200156751 +9787200156829 +9787200156898 +9787200156966 +9787200156973 +9787200156980 +9787200157062 +9787200157109 +9787200157116 +9787200157123 +9787200157208 +9787200158281 +9787200158328 +9787200158335 +9787200158342 +9787200158465 +9787200158915 +9787200159035 +9787200159073 +9787200159189 +9787200159226 +9787200159233 +9787200159301 +9787200159349 +9787200160048 +9787200160062 +9787200160123 +9787200160161 +9787200160741 +9787200161069 +9787200161144 +9787200162738 +9787200162912 +9787200162981 +9787200163049 +9787200163193 +9787200163339 +9787200164183 +9787200164299 +9787200164572 +9787200164664 +9787200164879 +9787200164947 +9787200164985 +9787200166491 +9787200166514 +9787200166781 +9787200167184 +9787200167580 +9787200167672 +9787200168693 +9787200169959 +9787200169980 +9787200170023 +9787200170030 +9787200170047 +9787200170054 +9787200170061 +9787200170078 +9787200170108 +9787200170115 +9787200170122 +9787200170672 +9787200170689 +9787200171587 +9787200172010 +9787200172089 +9787200172188 +9787200172591 +9787200174526 +9787200175288 +9787200178173 +9787200178609 +9787200178715 +9787200178746 +9787200179163 +9787200179200 +9787200179705 +9787200180510 +9787200180558 +9787200180589 +9787200181289 +9787200181388 +9787200181746 +9787200181753 +9787200181807 +9787200182156 +9787200182224 +9787200182385 +9787200183375 +9787200183849 +9787200184051 +9787200184327 +9787200184457 +9787200185218 +9787200185225 +9787200185782 +9787200185874 +9787200185980 +9787200185997 +9787200186628 +9787200187274 +9787200187946 +9787200188080 +9787200188554 +9787200189728 +9787200189810 +9787200189872 +9787200192582 +9787200208085 +9787200208108 +9787201000121 +9787201000480 +9787201000718 +9787201000763 +9787201001210 +9787201002101 +9787201002484 +9787201002545 +9787201004259 +9787201005003 +9787201005140 +9787201005157 +9787201005430 +9787201005454 +9787201005683 +9787201006062 +9787201006314 +9787201007441 +9787201008325 +9787201008417 +9787201008431 +9787201008448 +9787201008455 +9787201010557 +9787201010861 +9787201010991 +9787201011127 +9787201012070 +9787201012124 +9787201012841 +9787201013367 +9787201013473 +9787201014166 +9787201014173 +9787201014210 +9787201014746 +9787201015613 +9787201015675 +9787201015705 +9787201015774 +9787201016603 +9787201016870 +9787201016887 +9787201016993 +9787201017273 +9787201017785 +9787201018461 +9787201019277 +9787201019871 +9787201020174 +9787201020860 +9787201021652 +9787201021959 +9787201022215 +9787201022420 +9787201022703 +9787201023021 +9787201023328 +9787201023427 +9787201023878 +9787201024288 +9787201024554 +9787201025070 +9787201025353 +9787201025612 +9787201025681 +9787201026244 +9787201026251 +9787201026350 +9787201026411 +9787201027326 +9787201027678 +9787201028675 +9787201028699 +9787201028880 +9787201029009 +9787201029290 +9787201029368 +9787201029542 +9787201029573 +9787201029702 +9787201030302 +9787201030319 +9787201030326 +9787201030586 +9787201030760 +9787201030777 +9787201031170 +9787201031330 +9787201031637 +9787201031644 +9787201031651 +9787201031668 +9787201031675 +9787201031682 +9787201031699 +9787201031705 +9787201032047 +9787201032054 +9787201032061 +9787201032078 +9787201032085 +9787201032092 +9787201032108 +9787201032115 +9787201032122 +9787201032139 +9787201032146 +9787201032269 +9787201032504 +9787201032665 +9787201032696 +9787201032719 +9787201032849 +9787201033150 +9787201033259 +9787201034140 +9787201035345 +9787201035697 +9787201035703 +9787201035932 +9787201036311 +9787201036861 +9787201037097 +9787201037424 +9787201038001 +9787201039398 +9787201039442 +9787201041155 +9787201041643 +9787201041650 +9787201042305 +9787201044026 +9787201044057 +9787201045238 +9787201046068 +9787201046297 +9787201046730 +9787201046747 +9787201047713 +9787201048499 +9787201048574 +9787201048680 +9787201049540 +9787201052366 +9787201053561 +9787201053721 +9787201054049 +9787201054223 +9787201054490 +9787201055497 +9787201059990 +9787201062785 +9787201062860 +9787201064741 +9787201065151 +9787201065175 +9787201065182 +9787201065205 +9787201065212 +9787201065267 +9787201069524 +9787201070872 +9787201071336 +9787201072012 +9787201073811 +9787201075853 +9787201077642 +9787201078229 +9787201078762 +9787201079141 +9787201081458 +9787201087719 +9787201090382 +9787201091006 +9787201091204 +9787201091310 +9787201091648 +9787201093178 +9787201094908 +9787201095905 +9787201097893 +9787201101736 +9787201102597 +9787201102634 +9787201108926 +9787201111162 +9787201114040 +9787201114095 +9787201114477 +9787201114514 +9787201114606 +9787201114675 +9787201119274 +9787201121024 +9787201124049 +9787201126678 +9787201128009 +9787201130217 +9787201130705 +9787201130989 +9787201131047 +9787201131702 +9787201133218 +9787201134864 +9787201138404 +9787201138411 +9787201139579 +9787201139876 +9787201140087 +9787201150826 +9787201152158 +9787201153339 +9787201154022 +9787201155128 +9787201155838 +9787201155906 +9787201156095 +9787201156637 +9787201156811 +9787201158846 +9787201159683 +9787201160597 +9787201161181 +9787201161204 +9787201164540 +9787201165042 +9787201165370 +9787201166353 +9787201168593 +9787201171029 +9787201171050 +9787201171265 +9787201171449 +9787201173726 +9787201173948 +9787201174815 +9787201175607 +9787201176925 +9787201177588 +9787201178486 +9787201179605 +9787201179858 +9787201180434 +9787201180588 +9787201180625 +9787201180885 +9787201181349 +9787201182377 +9787201182575 +9787201185361 +9787201185644 +9787201186177 +9787201186993 +9787201187211 +9787201189482 +9787201190235 +9787201191331 +9787201192505 +9787201194080 +9787201194783 +9787201195179 +9787201195186 +9787201195384 +9787201195544 +9787201195674 +9787201195797 +9787201195964 +9787201196961 +9787201197838 +9787201199184 +9787201199535 +9787201199542 +9787201199696 +9787201199702 +9787201199726 +9787201200408 +9787201201696 +9787201202037 +9787201202051 +9787201202211 +9787201202259 +9787201202839 +9787201203010 +9787201203584 +9787201203737 +9787201204024 +9787201204871 +9787201205045 +9787201205083 +9787201205618 +9787201206585 +9787201206912 +9787201207285 +9787201207292 +9787201207469 +9787201207827 +9787201208190 +9787201208497 +9787201208510 +9787201208930 +9787201209333 +9787201209975 +9787201210315 +9787201210803 +9787201211619 +9787201212326 +9787201213453 +9787202000021 +9787202000083 +9787202000090 +9787202000120 +9787202000151 +9787202000366 +9787202000373 +9787202000540 +9787202000663 +9787202000694 +9787202000922 +9787202001080 +9787202001141 +9787202001165 +9787202001196 +9787202001288 +9787202001295 +9787202001318 +9787202001462 +9787202001479 +9787202001493 +9787202001523 +9787202001547 +9787202001578 +9787202001639 +9787202001691 +9787202001752 +9787202001790 +9787202001851 +9787202001981 +9787202002056 +9787202002421 +9787202002780 +9787202002803 +9787202003510 +9787202003572 +9787202003602 +9787202003626 +9787202003916 +9787202003947 +9787202004012 +9787202004111 +9787202004432 +9787202004524 +9787202004623 +9787202004678 +9787202004852 +9787202005248 +9787202005729 +9787202006061 +9787202006221 +9787202006238 +9787202007075 +9787202007105 +9787202007204 +9787202007334 +9787202007860 +9787202007945 +9787202008485 +9787202008805 +9787202008874 +9787202008898 +9787202008904 +9787202009215 +9787202009246 +9787202009437 +9787202009482 +9787202009499 +9787202010082 +9787202010297 +9787202010600 +9787202011003 +9787202011249 +9787202011348 +9787202011409 +9787202011454 +9787202011775 +9787202011904 +9787202011959 +9787202012109 +9787202012116 +9787202012260 +9787202012505 +9787202012680 +9787202012703 +9787202013595 +9787202013601 +9787202013670 +9787202013694 +9787202013908 +9787202013960 +9787202014844 +9787202014875 +9787202014943 +9787202015254 +9787202015469 +9787202015537 +9787202015704 +9787202015711 +9787202015759 +9787202015872 +9787202015964 +9787202015971 +9787202016107 +9787202016237 +9787202016282 +9787202016312 +9787202016466 +9787202016572 +9787202017067 +9787202017470 +9787202018026 +9787202018200 +9787202018255 +9787202018309 +9787202018507 +9787202018798 +9787202018804 +9787202018835 +9787202019016 +9787202019085 +9787202019214 +9787202019429 +9787202019689 +9787202019818 +9787202019832 +9787202019962 +9787202020036 +9787202020203 +9787202020418 +9787202020494 +9787202020524 +9787202020548 +9787202020760 +9787202020807 +9787202020845 +9787202020982 +9787202021040 +9787202022023 +9787202022122 +9787202022139 +9787202022245 +9787202022283 +9787202022368 +9787202022559 +9787202022917 +9787202023082 +9787202023150 +9787202023167 +9787202023297 +9787202023617 +9787202023921 +9787202024171 +9787202024188 +9787202024423 +9787202024553 +9787202025291 +9787202025468 +9787202025710 +9787202025819 +9787202026212 +9787202027103 +9787202027530 +9787202027707 +9787202027912 +9787202028438 +9787202028537 +9787202029381 +9787202029794 +9787202029862 +9787202030899 +9787202031230 +9787202032121 +9787202032206 +9787202032404 +9787202033371 +9787202033890 +9787202040706 +9787202040898 +9787202042984 +9787202045350 +9787202045657 +9787202045732 +9787202048467 +9787202050354 +9787202050361 +9787202050460 +9787202053492 +9787202054918 +9787202055274 +9787202055458 +9787202055731 +9787202056127 +9787202056868 +9787202057308 +9787202058794 +9787202059142 +9787202059159 +9787202059258 +9787202059371 +9787202059692 +9787202060513 +9787202063934 +9787202068229 +9787202069301 +9787202069790 +9787202069936 +9787202082072 +9787202082317 +9787202098394 +9787202100943 +9787202108536 +9787202109014 +9787202111147 +9787202114094 +9787202120255 +9787202121344 +9787202121481 +9787202122327 +9787202126141 +9787202133118 +9787202133514 +9787202133859 +9787202137666 +9787202138069 +9787202139196 +9787202140659 +9787202145746 +9787202146545 +9787202147771 +9787202151365 +9787202154526 +9787202154946 +9787202156551 +9787202157299 +9787202162415 +9787202163566 +9787202173633 +9787203000075 +9787203001584 +9787203002185 +9787203002819 +9787203004097 +9787203008071 +9787203008194 +9787203008712 +9787203008743 +9787203008804 +9787203010074 +9787203010111 +9787203010272 +9787203010500 +9787203011729 +9787203011835 +9787203012177 +9787203013488 +9787203014201 +9787203014652 +9787203015307 +9787203015796 +9787203016281 +9787203016847 +9787203016878 +9787203017370 +9787203017493 +9787203017868 +9787203018018 +9787203018209 +9787203018421 +9787203018445 +9787203018780 +9787203018858 +9787203018919 +9787203018926 +9787203019275 +9787203019572 +9787203019671 +9787203019800 +9787203020080 +9787203020196 +9787203020400 +9787203020547 +9787203020592 +9787203021162 +9787203021308 +9787203021643 +9787203021810 +9787203021841 +9787203021964 +9787203022152 +9787203022916 +9787203023364 +9787203023470 +9787203023920 +9787203023975 +9787203024507 +9787203024675 +9787203025146 +9787203025207 +9787203025337 +9787203025368 +9787203025375 +9787203025474 +9787203027157 +9787203027195 +9787203027232 +9787203027539 +9787203028147 +9787203028895 +9787203029076 +9787203029267 +9787203029984 +9787203030027 +9787203030652 +9787203030942 +9787203031079 +9787203031574 +9787203032250 +9787203032823 +9787203032830 +9787203033028 +9787203033554 +9787203034247 +9787203034599 +9787203034636 +9787203034766 +9787203034827 +9787203035923 +9787203036036 +9787203036043 +9787203036098 +9787203036272 +9787203036548 +9787203036852 +9787203037019 +9787203038252 +9787203038429 +9787203038665 +9787203038726 +9787203038733 +9787203038818 +9787203039075 +9787203039181 +9787203039297 +9787203039341 +9787203039709 +9787203039723 +9787203039839 +9787203040538 +9787203040828 +9787203040859 +9787203041610 +9787203041894 +9787203041986 +9787203042600 +9787203042778 +9787203044123 +9787203044536 +9787203044734 +9787203045342 +9787203045724 +9787203045885 +9787203046066 +9787203046127 +9787203046622 +9787203046820 +9787203047056 +9787203047094 +9787203047292 +9787203047377 +9787203047513 +9787203047698 +9787203048541 +9787203048794 +9787203049616 +9787203049654 +9787203049685 +9787203049722 +9787203050025 +9787203050292 +9787203050537 +9787203050582 +9787203050766 +9787203050919 +9787203051190 +9787203051527 +9787203051572 +9787203051961 +9787203052296 +9787203052739 +9787203052746 +9787203053118 +9787203053248 +9787203053279 +9787203053309 +9787203053491 +9787203053514 +9787203053569 +9787203053583 +9787203053835 +9787203054832 +9787203054993 +9787203055082 +9787203055303 +9787203055648 +9787203055877 +9787203056263 +9787203056973 +9787203057154 +9787203057161 +9787203057277 +9787203057406 +9787203058137 +9787203058601 +9787203059257 +9787203059271 +9787203061243 +9787203061809 +9787203062011 +9787203064961 +9787203065159 +9787203065760 +9787203066354 +9787203067405 +9787203068563 +9787203069928 +9787203070368 +9787203070535 +9787203070832 +9787203071044 +9787203071105 +9787203073680 +9787203073802 +9787203074045 +9787203074120 +9787203074465 +9787203074564 +9787203074625 +9787203075479 +9787203075943 +9787203076018 +9787203077862 +9787203079712 +9787203079958 +9787203081043 +9787203081913 +9787203081920 +9787203082095 +9787203083092 +9787203083245 +9787203083498 +9787203083979 +9787203084945 +9787203085775 +9787203085980 +9787203086987 +9787203087229 +9787203087472 +9787203087618 +9787203087915 +9787203088134 +9787203088219 +9787203088905 +9787203089957 +9787203092322 +9787203092452 +9787203094319 +9787203100577 +9787203100973 +9787203102847 +9787203104513 +9787203108580 +9787203109297 +9787203110002 +9787203110156 +9787203112730 +9787203113829 +9787203114000 +9787203114239 +9787203115199 +9787203115625 +9787203116264 +9787203116882 +9787203117599 +9787203117605 +9787203119159 +9787203119319 +9787203119395 +9787203123149 +9787203123804 +9787203124450 +9787203124757 +9787203124771 +9787203125204 +9787203125693 +9787203126058 +9787203126157 +9787203126218 +9787203126874 +9787203127451 +9787203127666 +9787203128045 +9787203128366 +9787203128816 +9787203130161 +9787203130826 +9787203133117 +9787203133186 +9787203133315 +9787203133353 +9787203133377 +9787203133476 +9787203134343 +9787203134404 +9787203134565 +9787203134671 +9787203134756 +9787203134855 +9787203134930 +9787203135388 +9787203135685 +9787203135746 +9787203135791 +9787203136033 +9787203136149 +9787203136163 +9787203136187 +9787203136705 +9787203136743 +9787203136866 +9787203137009 +9787203137269 +9787203137719 +9787203138235 +9787203138419 +9787203138501 +9787203139171 +9787203815167 +9787204000005 +9787204000036 +9787204001293 +9787204001774 +9787204002108 +9787204002399 +9787204002665 +9787204003372 +9787204003549 +9787204003716 +9787204003921 +9787204005024 +9787204005048 +9787204005215 +9787204005246 +9787204005642 +9787204006038 +9787204008391 +9787204008971 +9787204008988 +9787204009183 +9787204009558 +9787204009602 +9787204009688 +9787204009886 +9787204009947 +9787204010387 +9787204010400 +9787204012312 +9787204012565 +9787204012718 +9787204012893 +9787204012985 +9787204013326 +9787204014170 +9787204014415 +9787204014422 +9787204014439 +9787204014583 +9787204015535 +9787204015658 +9787204016952 +9787204017379 +9787204017546 +9787204017591 +9787204018413 +9787204019144 +9787204019519 +9787204019540 +9787204019595 +9787204019656 +9787204019670 +9787204019700 +9787204020232 +9787204020539 +9787204020607 +9787204020676 +9787204020782 +9787204021147 +9787204021215 +9787204021291 +9787204022359 +9787204023103 +9787204023257 +9787204023288 +9787204023356 +9787204023646 +9787204023660 +9787204024629 +9787204024766 +9787204024865 +9787204025305 +9787204025497 +9787204025817 +9787204025831 +9787204027118 +9787204027545 +9787204027866 +9787204028153 +9787204028467 +9787204028917 +9787204029952 +9787204029969 +9787204030002 +9787204030521 +9787204031153 +9787204031221 +9787204031337 +9787204031344 +9787204031504 +9787204031733 +9787204031795 +9787204031818 +9787204031894 +9787204031931 +9787204031962 +9787204031979 +9787204032006 +9787204032044 +9787204032075 +9787204032112 +9787204032129 +9787204032389 +9787204032419 +9787204032433 +9787204032495 +9787204032501 +9787204032525 +9787204032532 +9787204032631 +9787204032792 +9787204032839 +9787204033294 +9787204033300 +9787204033607 +9787204033638 +9787204033690 +9787204033706 +9787204033744 +9787204033751 +9787204033775 +9787204033782 +9787204033805 +9787204033898 +9787204034178 +9787204034185 +9787204034475 +9787204034604 +9787204034956 +9787204034987 +9787204035175 +9787204035748 +9787204035786 +9787204035861 +9787204036318 +9787204036899 +9787204036936 +9787204036943 +9787204036998 +9787204037087 +9787204037230 +9787204037278 +9787204037605 +9787204038091 +9787204038107 +9787204038503 +9787204038558 +9787204038572 +9787204038664 +9787204038718 +9787204038787 +9787204038794 +9787204038893 +9787204038930 +9787204039135 +9787204039234 +9787204039289 +9787204039340 +9787204039364 +9787204039401 +9787204039418 +9787204039449 +9787204039470 +9787204039487 +9787204039500 +9787204039579 +9787204039630 +9787204039906 +9787204039951 +9787204040032 +9787204040254 +9787204040407 +9787204040445 +9787204040452 +9787204040469 +9787204040636 +9787204040674 +9787204040797 +9787204040827 +9787204040940 +9787204040957 +9787204041053 +9787204041077 +9787204041107 +9787204041152 +9787204041190 +9787204041206 +9787204041275 +9787204041374 +9787204041534 +9787204041633 +9787204041824 +9787204041985 +9787204042456 +9787204042630 +9787204042807 +9787204042975 +9787204043170 +9787204043217 +9787204043248 +9787204043484 +9787204043569 +9787204043620 +9787204043682 +9787204043910 +9787204044191 +9787204044238 +9787204044450 +9787204044559 +9787204044580 +9787204044597 +9787204044665 +9787204044689 +9787204044733 +9787204044917 +9787204044962 +9787204044979 +9787204045266 +9787204045273 +9787204045341 +9787204045648 +9787204045686 +9787204045822 +9787204045846 +9787204046348 +9787204046379 +9787204046386 +9787204046928 +9787204047109 +9787204047185 +9787204047208 +9787204047475 +9787204047666 +9787204048021 +9787204048274 +9787204048298 +9787204048632 +9787204048687 +9787204048731 +9787204048885 +9787204048946 +9787204048953 +9787204049011 +9787204049653 +9787204049868 +9787204049912 +9787204049950 +9787204050116 +9787204050178 +9787204050246 +9787204050253 +9787204050642 +9787204050925 +9787204051342 +9787204051380 +9787204051441 +9787204051489 +9787204051496 +9787204051618 +9787204051786 +9787204051816 +9787204051847 +9787204052011 +9787204052059 +9787204052257 +9787204052387 +9787204052394 +9787204052523 +9787204052790 +9787204052981 +9787204053025 +9787204053292 +9787204053445 +9787204053872 +9787204054022 +9787204054077 +9787204054671 +9787204054824 +9787204054978 +9787204055050 +9787204055203 +9787204055272 +9787204055333 +9787204055753 +9787204055791 +9787204056163 +9787204056620 +9787204056989 +9787204057443 +9787204057795 +9787204057801 +9787204058150 +9787204058204 +9787204058693 +9787204059232 +9787204059294 +9787204060337 +9787204061129 +9787204061280 +9787204061839 +9787204061914 +9787204062577 +9787204062645 +9787204062829 +9787204062874 +9787204062881 +9787204063192 +9787204063246 +9787204063260 +9787204063277 +9787204063512 +9787204063574 +9787204063581 +9787204063819 +9787204064120 +9787204064632 +9787204064663 +9787204065257 +9787204065271 +9787204065448 +9787204065455 +9787204065752 +9787204066070 +9787204066384 +9787204066407 +9787204066421 +9787204066438 +9787204067275 +9787204067398 +9787204067831 +9787204067855 +9787204068036 +9787204068142 +9787204068388 +9787204068401 +9787204068623 +9787204068647 +9787204068654 +9787204068838 +9787204069330 +9787204069422 +9787204069446 +9787204069507 +9787204069613 +9787204069644 +9787204069651 +9787204069668 +9787204070138 +9787204070428 +9787204070466 +9787204070572 +9787204070619 +9787204070848 +9787204070954 +9787204070978 +9787204071791 +9787204072149 +9787204072156 +9787204072378 +9787204072408 +9787204072569 +9787204073375 +9787204073528 +9787204073931 +9787204074167 +9787204074716 +9787204074860 +9787204075041 +9787204075324 +9787204075393 +9787204075409 +9787204075508 +9787204075645 +9787204075867 +9787204076383 +9787204076468 +9787204076963 +9787204077199 +9787204077496 +9787204077649 +9787204078127 +9787204078226 +9787204078325 +9787204078332 +9787204078363 +9787204078424 +9787204078486 +9787204078523 +9787204078615 +9787204078868 +9787204079179 +9787204079193 +9787204079285 +9787204079346 +9787204079469 +9787204079513 +9787204079971 +9787204080298 +9787204080465 +9787204080502 +9787204080526 +9787204080717 +9787204080946 +9787204081172 +9787204081578 +9787204081585 +9787204081592 +9787204081660 +9787204082049 +9787204082438 +9787204082445 +9787204082629 +9787204082643 +9787204082667 +9787204082780 +9787204082902 +9787204082988 +9787204083039 +9787204083046 +9787204083206 +9787204083220 +9787204083244 +9787204083350 +9787204083466 +9787204083558 +9787204083565 +9787204083589 +9787204083596 +9787204084074 +9787204084470 +9787204085002 +9787204085071 +9787204085088 +9787204086177 +9787204086566 +9787204086856 +9787204087525 +9787204087600 +9787204087686 +9787204087693 +9787204087860 +9787204088119 +9787204088263 +9787204088591 +9787204088942 +9787204089178 +9787204089390 +9787204089505 +9787204089642 +9787204089666 +9787204089949 +9787204089956 +9787204089970 +9787204090044 +9787204090105 +9787204090198 +9787204090310 +9787204090372 +9787204090808 +9787204090860 +9787204092116 +9787204092192 +9787204092239 +9787204092406 +9787204092567 +9787204092611 +9787204092871 +9787204093052 +9787204093410 +9787204093519 +9787204093526 +9787204093809 +9787204094141 +9787204094172 +9787204094349 +9787204094394 +9787204094677 +9787204094707 +9787204094851 +9787204095308 +9787204095353 +9787204095384 +9787204095421 +9787204095537 +9787204096008 +9787204096428 +9787204096459 +9787204096466 +9787204096855 +9787204096992 +9787204097319 +9787204097333 +9787204097388 +9787204097685 +9787204097708 +9787204098255 +9787204098491 +9787204099603 +9787204099771 +9787204100286 +9787204100507 +9787204100842 +9787204101009 +9787204101214 +9787204101245 +9787204101290 +9787204101542 +9787204101559 +9787204101665 +9787204101825 +9787204101832 +9787204101931 +9787204102020 +9787204102150 +9787204102198 +9787204102235 +9787204102884 +9787204102921 +9787204103119 +9787204103447 +9787204103492 +9787204103560 +9787204103881 +9787204103898 +9787204104222 +9787204104277 +9787204104284 +9787204104918 +9787204105120 +9787204105779 +9787204105816 +9787204105823 +9787204106844 +9787204107308 +9787204107636 +9787204107940 +9787204108039 +9787204108374 +9787204108589 +9787204108640 +9787204109180 +9787204109296 +9787204109319 +9787204109890 +9787204110599 +9787204110957 +9787204111206 +9787204111282 +9787204111480 +9787204111503 +9787204111510 +9787204112098 +9787204112678 +9787204113026 +9787204113453 +9787204114535 +9787204114696 +9787204114986 +9787204116508 +9787204116553 +9787204118977 +9787204119165 +9787204119486 +9787204119882 +9787204119981 +9787204119998 +9787204120000 +9787204121854 +9787204121885 +9787204121915 +9787204122035 +9787204122196 +9787204122288 +9787204122615 +9787204123186 +9787204123698 +9787204123834 +9787204124190 +9787204124329 +9787204124992 +9787204125432 +9787204125852 +9787204125890 +9787204125975 +9787204126071 +9787204126507 +9787204126781 +9787204129171 +9787204130511 +9787204130771 +9787204131396 +9787204133123 +9787204133529 +9787204136513 +9787204137015 +9787204141364 +9787204142927 +9787204142972 +9787204143085 +9787204143108 +9787204148387 +9787204148905 +9787204150816 +9787204151837 +9787204152155 +9787204152186 +9787204152216 +9787204153152 +9787204155569 +9787204158041 +9787204159574 +9787204160006 +9787204160877 +9787204161188 +9787204163168 +9787204163281 +9787204164561 +9787204165018 +9787204165544 +9787204165704 +9787204167395 +9787204167791 +9787204168156 +9787204169092 +9787204170760 +9787204171088 +9787204173525 +9787204174997 +9787204175215 +9787204179909 +9787204181285 +9787204182404 +9787204337170 +9787204378340 +9787204378418 +9787204732067 +9787204742028 +9787204742066 +9787204742080 +9787204832187 +9787205000400 +9787205000554 +9787205000578 +9787205000936 +9787205000974 +9787205001247 +9787205001452 +9787205001520 +9787205001674 +9787205001827 +9787205001841 +9787205002992 +9787205003029 +9787205003135 +9787205003210 +9787205003401 +9787205004163 +9787205004170 +9787205004224 +9787205004859 +9787205005207 +9787205005351 +9787205005429 +9787205006136 +9787205006747 +9787205006815 +9787205006891 +9787205008505 +9787205008703 +9787205008727 +9787205009441 +9787205009533 +9787205009854 +9787205009939 +9787205010003 +9787205010157 +9787205010171 +9787205010447 +9787205011352 +9787205011994 +9787205012069 +9787205012939 +9787205012977 +9787205013271 +9787205014445 +9787205014971 +9787205015947 +9787205016135 +9787205016647 +9787205016791 +9787205017101 +9787205017149 +9787205017309 +9787205017583 +9787205017675 +9787205018184 +9787205018634 +9787205020095 +9787205020132 +9787205020750 +9787205020880 +9787205021009 +9787205021306 +9787205021436 +9787205022068 +9787205022853 +9787205023294 +9787205023386 +9787205023393 +9787205023447 +9787205023744 +9787205024574 +9787205025526 +9787205026615 +9787205026707 +9787205027117 +9787205027643 +9787205027797 +9787205028015 +9787205028367 +9787205028398 +9787205029395 +9787205029401 +9787205029852 +9787205030698 +9787205030919 +9787205032036 +9787205032722 +9787205033446 +9787205033781 +9787205033804 +9787205034207 +9787205034634 +9787205034757 +9787205035051 +9787205035068 +9787205035075 +9787205035082 +9787205035754 +9787205036119 +9787205036997 +9787205037031 +9787205037048 +9787205037369 +9787205037444 +9787205038601 +9787205038717 +9787205038939 +9787205039301 +9787205039455 +9787205039516 +9787205039868 +9787205039912 +9787205040178 +9787205040185 +9787205040284 +9787205040802 +9787205040987 +9787205041014 +9787205041373 +9787205041434 +9787205041441 +9787205041472 +9787205041489 +9787205041519 +9787205041632 +9787205041830 +9787205041922 +9787205042691 +9787205042950 +9787205043032 +9787205044374 +9787205044596 +9787205044909 +9787205045999 +9787205046392 +9787205046880 +9787205046897 +9787205046903 +9787205046910 +9787205047931 +9787205048662 +9787205048679 +9787205050863 +9787205051075 +9787205051181 +9787205052508 +9787205052584 +9787205052843 +9787205053291 +9787205053321 +9787205053338 +9787205053352 +9787205053369 +9787205053383 +9787205054106 +9787205054151 +9787205055295 +9787205057060 +9787205058012 +9787205058944 +9787205059613 +9787205059798 +9787205060213 +9787205065430 +9787205066338 +9787205067229 +9787205068073 +9787205070465 +9787205070540 +9787205070670 +9787205071448 +9787205071608 +9787205072117 +9787205072391 +9787205073152 +9787205073251 +9787205075392 +9787205075972 +9787205077617 +9787205077976 +9787205078652 +9787205079260 +9787205080051 +9787205080143 +9787205080174 +9787205080648 +9787205080914 +9787205081669 +9787205081720 +9787205084011 +9787205084387 +9787205087760 +9787205088651 +9787205090647 +9787205091187 +9787205092177 +9787205092306 +9787205092955 +9787205093617 +9787205094706 +9787205095871 +9787205097820 +9787205097899 +9787205098544 +9787205099008 +9787205099213 +9787205099848 +9787205100223 +9787205101794 +9787205103750 +9787205104023 +9787205104597 +9787205104764 +9787205105143 +9787205105273 +9787205105396 +9787205106720 +9787205107659 +9787205108038 +9787205108335 +9787205108373 +9787205108526 +9787205108588 +9787205108694 +9787205108717 +9787205108847 +9787205108892 +9787205109196 +9787205109677 +9787205109721 +9787205110055 +9787205110635 +9787205111632 +9787205111656 +9787205111854 +9787205112028 +9787205112110 +9787205112851 +9787205113131 +9787205113186 +9787205113261 +9787205113780 +9787205114145 +9787205114510 +9787205114848 +9787205114985 +9787205115487 +9787206000140 +9787206000386 +9787206000652 +9787206000683 +9787206000706 +9787206001154 +9787206001437 +9787206001468 +9787206001550 +9787206001567 +9787206001833 +9787206001888 +9787206001901 +9787206001949 +9787206002205 +9787206002243 +9787206002304 +9787206002816 +9787206003264 +9787206003578 +9787206004193 +9787206004346 +9787206004728 +9787206005077 +9787206005091 +9787206005459 +9787206005688 +9787206005824 +9787206005947 +9787206006685 +9787206007309 +9787206007347 +9787206007767 +9787206008726 +9787206008894 +9787206008955 +9787206009341 +9787206009747 +9787206010910 +9787206011016 +9787206011245 +9787206011702 +9787206011894 +9787206012150 +9787206012662 +9787206013058 +9787206013829 +9787206013836 +9787206014192 +9787206014246 +9787206014925 +9787206015021 +9787206015182 +9787206015380 +9787206015519 +9787206015588 +9787206017186 +9787206017568 +9787206017827 +9787206018145 +9787206018343 +9787206018527 +9787206018619 +9787206018886 +9787206019098 +9787206020285 +9787206020391 +9787206020490 +9787206020698 +9787206020797 +9787206021053 +9787206021961 +9787206022012 +9787206022050 +9787206022067 +9787206022234 +9787206022371 +9787206022395 +9787206022845 +9787206023019 +9787206023194 +9787206023439 +9787206023545 +9787206024115 +9787206024122 +9787206024351 +9787206024405 +9787206024580 +9787206024610 +9787206024719 +9787206024931 +9787206024993 +9787206025150 +9787206025471 +9787206025556 +9787206025594 +9787206025631 +9787206025655 +9787206025723 +9787206025792 +9787206025808 +9787206025815 +9787206025846 +9787206026140 +9787206026171 +9787206026447 +9787206026539 +9787206026690 +9787206026812 +9787206026829 +9787206026874 +9787206027017 +9787206027130 +9787206027307 +9787206027352 +9787206027369 +9787206027376 +9787206027680 +9787206027734 +9787206027765 +9787206028335 +9787206028519 +9787206028571 +9787206028632 +9787206028922 +9787206029103 +9787206029264 +9787206029943 +9787206029998 +9787206030086 +9787206030314 +9787206030376 +9787206030390 +9787206030406 +9787206030451 +9787206030468 +9787206030796 +9787206030802 +9787206030963 +9787206031007 +9787206031014 +9787206031021 +9787206031069 +9787206031083 +9787206031335 +9787206031342 +9787206031359 +9787206031977 +9787206032592 +9787206032745 +9787206032837 +9787206032851 +9787206032882 +9787206032899 +9787206033087 +9787206033117 +9787206033148 +9787206033315 +9787206033735 +9787206034473 +9787206034596 +9787206034954 +9787206035197 +9787206035494 +9787206035937 +9787206035999 +9787206036118 +9787206036149 +9787206036378 +9787206036569 +9787206036811 +9787206037238 +9787206037412 +9787206037450 +9787206038228 +9787206038402 +9787206038877 +9787206038884 +9787206039386 +9787206039683 +9787206039836 +9787206041587 +9787206041709 +9787206041761 +9787206041839 +9787206042201 +9787206043116 +9787206043161 +9787206044267 +9787206044274 +9787206044625 +9787206045042 +9787206047930 +9787206048418 +9787206048845 +9787206052279 +9787206057939 +9787206058073 +9787206059018 +9787206060465 +9787206061868 +9787206062384 +9787206062391 +9787206062858 +9787206063275 +9787206065286 +9787206066276 +9787206066856 +9787206067105 +9787206068980 +9787206069390 +9787206070136 +9787206070266 +9787206071713 +9787206073281 +9787206073533 +9787206074219 +9787206074783 +9787206074882 +9787206074943 +9787206075025 +9787206075032 +9787206075087 +9787206075162 +9787206075629 +9787206075773 +9787206075957 +9787206078408 +9787206078989 +9787206079856 +9787206079955 +9787206079962 +9787206080487 +9787206081033 +9787206081040 +9787206081354 +9787206081682 +9787206081903 +9787206082443 +9787206082825 +9787206082887 +9787206083242 +9787206085352 +9787206085574 +9787206088391 +9787206088643 +9787206090264 +9787206090462 +9787206091131 +9787206091407 +9787206091797 +9787206092152 +9787206092923 +9787206094194 +9787206095009 +9787206096686 +9787206098550 +9787206098932 +9787206099465 +9787206100697 +9787206101205 +9787206102035 +9787206102578 +9787206104480 +9787206104886 +9787206105456 +9787206107481 +9787206108211 +9787206113451 +9787206121357 +9787206126390 +9787206134524 +9787206141003 +9787206144974 +9787206147845 +9787206148392 +9787206150463 +9787206159121 +9787206164279 +9787206169113 +9787206169236 +9787206171116 +9787206172267 +9787206173967 +9787206179518 +9787206180132 +9787206181658 +9787206182099 +9787206184031 +9787206188114 +9787206195624 +9787206195631 +9787206195648 +9787206195679 +9787206200199 +9787206207501 +9787206207556 +9787206207570 +9787206208171 +9787206211256 +9787206214776 +9787206214868 +9787206216190 +9787207000033 +9787207000040 +9787207000545 +9787207000804 +9787207000828 +9787207001320 +9787207001368 +9787207001979 +9787207002273 +9787207002518 +9787207003096 +9787207003690 +9787207003706 +9787207003744 +9787207004031 +9787207004345 +9787207004543 +9787207004680 +9787207004741 +9787207005113 +9787207005243 +9787207005281 +9787207005311 +9787207005328 +9787207005984 +9787207006295 +9787207006325 +9787207006356 +9787207006363 +9787207007216 +9787207007353 +9787207007643 +9787207008145 +9787207008183 +9787207008602 +9787207008732 +9787207008909 +9787207008978 +9787207010438 +9787207010551 +9787207011244 +9787207012005 +9787207013057 +9787207013163 +9787207013347 +9787207013439 +9787207013590 +9787207014313 +9787207014528 +9787207014832 +9787207015204 +9787207015914 +9787207016195 +9787207016577 +9787207017093 +9787207017154 +9787207017932 +9787207018168 +9787207019424 +9787207019493 +9787207019851 +9787207019912 +9787207019943 +9787207020116 +9787207020123 +9787207021052 +9787207021359 +9787207021441 +9787207022103 +9787207022622 +9787207022752 +9787207023636 +9787207024572 +9787207024817 +9787207025074 +9787207025128 +9787207025326 +9787207025388 +9787207025869 +9787207025876 +9787207026156 +9787207026873 +9787207027115 +9787207027313 +9787207027344 +9787207027627 +9787207027870 +9787207028136 +9787207028563 +9787207029164 +9787207029171 +9787207029386 +9787207029423 +9787207029478 +9787207029621 +9787207029744 +9787207029751 +9787207030054 +9787207030481 +9787207030542 +9787207030641 +9787207031204 +9787207031488 +9787207031679 +9787207032065 +9787207032171 +9787207032225 +9787207032249 +9787207032379 +9787207032416 +9787207032430 +9787207032775 +9787207032805 +9787207033246 +9787207033277 +9787207033369 +9787207033444 +9787207033550 +9787207033642 +9787207033741 +9787207033758 +9787207033789 +9787207034571 +9787207034656 +9787207035516 +9787207035783 +9787207035912 +9787207036261 +9787207036292 +9787207036490 +9787207036766 +9787207037480 +9787207037756 +9787207037787 +9787207038111 +9787207038289 +9787207039156 +9787207039545 +9787207039576 +9787207039699 +9787207039705 +9787207039781 +9787207039897 +9787207040008 +9787207040046 +9787207040732 +9787207041203 +9787207041807 +9787207042187 +9787207042224 +9787207042286 +9787207042576 +9787207042729 +9787207042903 +9787207043214 +9787207043405 +9787207043863 +9787207047410 +9787207048370 +9787207048516 +9787207049063 +9787207049254 +9787207049599 +9787207049797 +9787207050441 +9787207051097 +9787207051240 +9787207051813 +9787207051868 +9787207051981 +9787207052223 +9787207052520 +9787207052858 +9787207053367 +9787207053374 +9787207053381 +9787207053527 +9787207053534 +9787207053930 +9787207054241 +9787207054265 +9787207054937 +9787207055682 +9787207055927 +9787207055934 +9787207056368 +9787207056665 +9787207057150 +9787207057280 +9787207057556 +9787207058041 +9787207058058 +9787207058324 +9787207058621 +9787207059048 +9787207059147 +9787207059505 +9787207059697 +9787207060679 +9787207060730 +9787207061331 +9787207061911 +9787207061980 +9787207062154 +9787207062666 +9787207062697 +9787207062956 +9787207063489 +9787207063953 +9787207064509 +9787207064561 +9787207065247 +9787207066053 +9787207066640 +9787207067548 +9787207067715 +9787207067906 +9787207068026 +9787207068408 +9787207069016 +9787207069771 +9787207069870 +9787207070142 +9787207070432 +9787207070630 +9787207070722 +9787207070845 +9787207071132 +9787207072467 +9787207072580 +9787207072641 +9787207073167 +9787207073198 +9787207074171 +9787207074379 +9787207074645 +9787207076502 +9787207077134 +9787207077561 +9787207077899 +9787207081278 +9787207081896 +9787207082022 +9787207082152 +9787207085733 +9787207087515 +9787207087645 +9787207087768 +9787207090973 +9787207091741 +9787207092137 +9787207093387 +9787207094032 +9787207094506 +9787207094780 +9787207095152 +9787207095213 +9787207095374 +9787207096043 +9787207096609 +9787207097187 +9787207097712 +9787207097859 +9787207099457 +9787207099778 +9787207100436 +9787207100849 +9787207101143 +9787207101259 +9787207101600 +9787207101617 +9787207101730 +9787207103987 +9787207104151 +9787207104267 +9787207104748 +9787207104830 +9787207106513 +9787207110343 +9787207111128 +9787207111197 +9787207115201 +9787207116345 +9787207117182 +9787207117267 +9787207118813 +9787207119575 +9787207119780 +9787207123459 +9787207123572 +9787207123763 +9787207123770 +9787207123787 +9787207123800 +9787207124098 +9787207124227 +9787207125729 +9787207127150 +9787207128416 +9787207128607 +9787208000278 +9787208000292 +9787208000308 +9787208000377 +9787208000452 +9787208000490 +9787208000537 +9787208000681 +9787208000711 +9787208000926 +9787208000940 +9787208000964 +9787208000971 +9787208001008 +9787208001046 +9787208001176 +9787208001299 +9787208001329 +9787208001442 +9787208001510 +9787208001619 +9787208001633 +9787208001749 +9787208001763 +9787208002050 +9787208002098 +9787208002418 +9787208002548 +9787208002623 +9787208002715 +9787208002951 +9787208002982 +9787208003057 +9787208003071 +9787208003088 +9787208003101 +9787208003514 +9787208003545 +9787208003569 +9787208003620 +9787208003675 +9787208003682 +9787208003712 +9787208003903 +9787208003910 +9787208004009 +9787208004160 +9787208004184 +9787208004528 +9787208004559 +9787208004580 +9787208004740 +9787208005075 +9787208005419 +9787208005464 +9787208005655 +9787208005662 +9787208005709 +9787208005730 +9787208005822 +9787208006256 +9787208006478 +9787208006645 +9787208006904 +9787208006980 +9787208007338 +9787208007345 +9787208007468 +9787208007529 +9787208007581 +9787208007741 +9787208008007 +9787208008212 +9787208008267 +9787208008489 +9787208008779 +9787208008885 +9787208008908 +9787208009011 +9787208009219 +9787208009318 +9787208009523 +9787208009585 +9787208009622 +9787208009653 +9787208009714 +9787208009783 +9787208010062 +9787208010116 +9787208010390 +9787208010628 +9787208010956 +9787208010970 +9787208011007 +9787208011076 +9787208011274 +9787208011403 +9787208011427 +9787208011465 +9787208011496 +9787208011540 +9787208011557 +9787208011748 +9787208011762 +9787208011779 +9787208011946 +9787208012158 +9787208012202 +9787208012240 +9787208012288 +9787208012356 +9787208012363 +9787208012400 +9787208012424 +9787208012455 +9787208012547 +9787208012622 +9787208012776 +9787208012806 +9787208012929 +9787208013179 +9787208013216 +9787208013247 +9787208013551 +9787208013650 +9787208013827 +9787208013834 +9787208013841 +9787208013940 +9787208014022 +9787208014121 +9787208014350 +9787208014541 +9787208014671 +9787208014800 +9787208015050 +9787208015074 +9787208015111 +9787208015128 +9787208015197 +9787208015371 +9787208015425 +9787208015494 +9787208015579 +9787208015838 +9787208015890 +9787208015951 +9787208016095 +9787208016392 +9787208016514 +9787208016576 +9787208016644 +9787208016880 +9787208016989 +9787208017085 +9787208017177 +9787208017634 +9787208017702 +9787208018372 +9787208018570 +9787208018600 +9787208018631 +9787208018747 +9787208018839 +9787208019294 +9787208019447 +9787208019508 +9787208019546 +9787208019577 +9787208019652 +9787208019744 +9787208019836 +9787208020078 +9787208020115 +9787208020207 +9787208020351 +9787208020450 +9787208020474 +9787208020771 +9787208020931 +9787208021075 +9787208021105 +9787208021112 +9787208021143 +9787208021204 +9787208021211 +9787208021242 +9787208021334 +9787208021419 +9787208021426 +9787208021501 +9787208021594 +9787208021723 +9787208022096 +9787208022133 +9787208022218 +9787208022348 +9787208022379 +9787208022393 +9787208022409 +9787208022485 +9787208022638 +9787208022645 +9787208022669 +9787208022676 +9787208022768 +9787208022942 +9787208023116 +9787208023277 +9787208023383 +9787208023390 +9787208023444 +9787208023468 +9787208023574 +9787208023642 +9787208023673 +9787208023772 +9787208023819 +9787208024267 +9787208024281 +9787208024298 +9787208024366 +9787208024403 +9787208024502 +9787208024977 +9787208025042 +9787208025097 +9787208025196 +9787208025219 +9787208025257 +9787208025387 +9787208025592 +9787208025653 +9787208025844 +9787208026032 +9787208026049 +9787208026117 +9787208026131 +9787208026179 +9787208026254 +9787208026353 +9787208026407 +9787208026421 +9787208026513 +9787208026834 +9787208026933 +9787208026971 +9787208026988 +9787208027251 +9787208027268 +9787208027312 +9787208027404 +9787208027428 +9787208027459 +9787208027480 +9787208027619 +9787208027718 +9787208027725 +9787208027848 +9787208027862 +9787208027930 +9787208027961 +9787208027985 +9787208028234 +9787208028463 +9787208028630 +9787208028654 +9787208028715 +9787208028876 +9787208028999 +9787208029002 +9787208029620 +9787208029712 +9787208029903 +9787208029910 +9787208029996 +9787208030084 +9787208030442 +9787208030633 +9787208030664 +9787208030930 +9787208031302 +9787208031333 +9787208031371 +9787208031418 +9787208031432 +9787208031470 +9787208031524 +9787208031548 +9787208031593 +9787208031609 +9787208031647 +9787208031845 +9787208032071 +9787208032095 +9787208032101 +9787208032248 +9787208032354 +9787208032545 +9787208032552 +9787208032583 +9787208032798 +9787208032828 +9787208032934 +9787208033078 +9787208033115 +9787208033290 +9787208033733 +9787208034372 +9787208034716 +9787208034761 +9787208034808 +9787208034976 +9787208035034 +9787208035133 +9787208035416 +9787208035447 +9787208035454 +9787208035669 +9787208035751 +9787208035997 +9787208036086 +9787208036093 +9787208036260 +9787208036277 +9787208036444 +9787208036598 +9787208036802 +9787208036819 +9787208036949 +9787208037038 +9787208037083 +9787208037106 +9787208037120 +9787208037168 +9787208037212 +9787208037250 +9787208037304 +9787208037403 +9787208037410 +9787208037427 +9787208037441 +9787208037472 +9787208038059 +9787208038080 +9787208038356 +9787208038448 +9787208038561 +9787208038950 +9787208039407 +9787208039513 +9787208039582 +9787208039766 +9787208039872 +9787208040014 +9787208040410 +9787208040526 +9787208040571 +9787208040601 +9787208040755 +9787208040830 +9787208040861 +9787208040939 +9787208040946 +9787208040977 +9787208041561 +9787208041981 +9787208042483 +9787208042865 +9787208043275 +9787208043343 +9787208044234 +9787208044661 +9787208044968 +9787208045149 +9787208045866 +9787208045934 +9787208046962 +9787208047020 +9787208047198 +9787208047204 +9787208047242 +9787208047679 +9787208048126 +9787208048133 +9787208048270 +9787208048515 +9787208048539 +9787208048584 +9787208049284 +9787208050136 +9787208050754 +9787208052383 +9787208052390 +9787208052864 +9787208053076 +9787208053175 +9787208053250 +9787208055407 +9787208055711 +9787208055940 +9787208056022 +9787208057180 +9787208057296 +9787208057586 +9787208058255 +9787208058378 +9787208059405 +9787208059573 +9787208059658 +9787208060920 +9787208061477 +9787208061552 +9787208063921 +9787208067219 +9787208067349 +9787208067554 +9787208072947 +9787208073333 +9787208073685 +9787208073753 +9787208075016 +9787208077584 +9787208080775 +9787208083097 +9787208083561 +9787208084926 +9787208085718 +9787208085787 +9787208087118 +9787208088085 +9787208088337 +9787208088481 +9787208089136 +9787208089297 +9787208090231 +9787208090361 +9787208091030 +9787208092020 +9787208094819 +9787208096035 +9787208096356 +9787208096905 +9787208097216 +9787208097285 +9787208098213 +9787208098336 +9787208099159 +9787208100046 +9787208100077 +9787208100206 +9787208101760 +9787208101784 +9787208101791 +9787208101807 +9787208101814 +9787208101821 +9787208103184 +9787208103351 +9787208104631 +9787208105249 +9787208106994 +9787208109063 +9787208111073 +9787208111943 +9787208112148 +9787208112209 +9787208112216 +9787208112803 +9787208113558 +9787208113572 +9787208115927 +9787208117549 +9787208121577 +9787208122819 +9787208123397 +9787208123571 +9787208124639 +9787208128040 +9787208128330 +9787208128545 +9787208128767 +9787208130142 +9787208133549 +9787208134492 +9787208138476 +9787208141797 +9787208146280 +9787208147744 +9787208148390 +9787208151291 +9787208152618 +9787208155015 +9787208156142 +9787208166691 +9787208168251 +9787208168268 +9787208168275 +9787208168282 +9787208168381 +9787208169210 +9787208169357 +9787208170131 +9787208171084 +9787208171442 +9787208171466 +9787208172395 +9787208174993 +9787208175808 +9787208176874 +9787208177550 +9787208178830 +9787208180185 +9787208181045 +9787208181595 +9787208182080 +9787208182547 +9787208182899 +9787208182905 +9787208183056 +9787208183278 +9787208183612 +9787208183650 +9787208183865 +9787208183926 +9787208184329 +9787208184459 +9787208184633 +9787208184664 +9787208185036 +9787208185555 +9787208185654 +9787208185777 +9787208186040 +9787208186323 +9787208186521 +9787208186743 +9787208186903 +9787208186958 +9787208187009 +9787208187023 +9787208187290 +9787208187368 +9787208187634 +9787208187870 +9787208188150 +9787208188426 +9787208188464 +9787208188518 +9787208188570 +9787208188631 +9787208188778 +9787208188914 +9787208188921 +9787208189133 +9787208189171 +9787208189225 +9787208189232 +9787208189263 +9787208189454 +9787208189492 +9787208189508 +9787208189539 +9787208189614 +9787208189669 +9787208189805 +9787208189898 +9787208189928 +9787208189997 +9787208190023 +9787208190108 +9787208190467 +9787208190603 +9787208190658 +9787208190665 +9787208190719 +9787208190788 +9787208190818 +9787208190948 +9787208190979 +9787208190986 +9787208191174 +9787208191273 +9787208191327 +9787208191419 +9787208191457 +9787208191501 +9787208191709 +9787208191815 +9787208191945 +9787208192065 +9787208192287 +9787208192294 +9787208192560 +9787208192577 +9787208192638 +9787208192713 +9787208192850 +9787208193116 +9787208193123 +9787208193178 +9787208193239 +9787208193253 +9787208193550 +9787208193598 +9787208193659 +9787208193840 +9787208193864 +9787208194120 +9787208194649 +9787208194779 +9787208194816 +9787208194939 +9787208195059 +9787208195530 +9787208195554 +9787208195622 +9787208196629 +9787208196889 +9787208196988 +9787208197473 +9787209000185 +9787209000512 +9787209001113 +9787209001250 +9787209001304 +9787209001366 +9787209001724 +9787209001823 +9787209001861 +9787209001908 +9787209003261 +9787209003674 +9787209003735 +9787209005036 +9787209006187 +9787209006453 +9787209006644 +9787209006828 +9787209007221 +9787209007368 +9787209008914 +9787209009676 +9787209009683 +9787209010047 +9787209010207 +9787209010481 +9787209010658 +9787209010931 +9787209011006 +9787209011204 +9787209011211 +9787209011303 +9787209011983 +9787209012027 +9787209012478 +9787209013314 +9787209013475 +9787209013628 +9787209013963 +9787209014908 +9787209015240 +9787209015578 +9787209015608 +9787209015752 +9787209015769 +9787209015783 +9787209016261 +9787209016360 +9787209016407 +9787209017060 +9787209017343 +9787209017619 +9787209017824 +9787209017992 +9787209018203 +9787209018425 +9787209018449 +9787209018463 +9787209018579 +9787209018609 +9787209018654 +9787209018777 +9787209018876 +9787209018906 +9787209019194 +9787209019330 +9787209019620 +9787209020282 +9787209020381 +9787209020442 +9787209020695 +9787209020701 +9787209020930 +9787209021333 +9787209021395 +9787209021739 +9787209021746 +9787209021777 +9787209021784 +9787209021845 +9787209022002 +9787209022040 +9787209022545 +9787209022682 +9787209023009 +9787209023160 +9787209023306 +9787209023955 +9787209024259 +9787209024266 +9787209024402 +9787209024938 +9787209025751 +9787209025942 +9787209025973 +9787209026086 +9787209026291 +9787209026468 +9787209027137 +9787209027144 +9787209027168 +9787209027205 +9787209027786 +9787209027977 +9787209028202 +9787209028639 +9787209028707 +9787209028721 +9787209028738 +9787209028844 +9787209029100 +9787209029483 +9787209029513 +9787209029872 +9787209032179 +9787209032322 +9787209033374 +9787209033916 +9787209035255 +9787209035354 +9787209035439 +9787209035453 +9787209035552 +9787209037174 +9787209037273 +9787209037655 +9787209038577 +9787209038720 +9787209039420 +9787209039758 +9787209039796 +9787209040273 +9787209041348 +9787209041973 +9787209044417 +9787209052726 +9787209056472 +9787209056656 +9787209058957 +9787209060936 +9787209060998 +9787209061339 +9787209061360 +9787209062602 +9787209064460 +9787209069731 +9787209069793 +9787209070829 +9787209070935 +9787209072083 +9787209072465 +9787209078238 +9787209078375 +9787209078481 +9787209081955 +9787209082754 +9787209082761 +9787209082815 +9787209083973 +9787209085380 +9787209087964 +9787209088596 +9787209088602 +9787209089135 +9787209090667 +9787209096058 +9787209096188 +9787209097529 +9787209098113 +9787209103015 +9787209104654 +9787209107099 +9787209108195 +9787209108577 +9787209108669 +9787209108751 +9787209109369 +9787209111331 +9787209111362 +9787209113236 +9787209113847 +9787209113854 +9787209114950 +9787209115094 +9787209115209 +9787209117081 +9787209117104 +9787209118064 +9787209118194 +9787209119153 +9787209119290 +9787209121064 +9787209122061 +9787209123792 +9787209124140 +9787209127059 +9787209127226 +9787209127240 +9787209127257 +9787209127974 +9787209128032 +9787209128100 +9787209128162 +9787209128940 +9787209128988 +9787209129794 +9787209129947 +9787209130042 +9787209130134 +9787209130301 +9787209130608 +9787209130615 +9787209130691 +9787209130790 +9787209131643 +9787209132060 +9787209133340 +9787209134934 +9787209135108 +9787209135894 +9787209138550 +9787209138703 +9787209139038 +9787209140430 +9787209140508 +9787209142762 +9787209142816 +9787209142830 +9787209142915 +9787209143097 +9787209143530 +9787209143769 +9787209143844 +9787209145602 +9787209146562 +9787209146869 +9787209147071 +9787209147156 +9787209147163 +9787209149334 +9787209150422 +9787209150644 +9787209151139 +9787209151894 +9787209152358 +9787209153782 +9787209153881 +9787209156165 +9787209156660 +9787209156684 +9787210000655 +9787210000662 +9787210000914 +9787210000945 +9787210000969 +9787210000983 +9787210001089 +9787210001157 +9787210001393 +9787210001720 +9787210001812 +9787210002192 +9787210002208 +9787210002628 +9787210002680 +9787210002710 +9787210002802 +9787210002963 +9787210003120 +9787210003748 +9787210003939 +9787210004899 +9787210004912 +9787210006008 +9787210006909 +9787210006978 +9787210007692 +9787210007845 +9787210008101 +9787210008712 +9787210008811 +9787210009405 +9787210009641 +9787210010104 +9787210010234 +9787210010241 +9787210011897 +9787210013112 +9787210013198 +9787210013204 +9787210013211 +9787210013549 +9787210013587 +9787210014225 +9787210015154 +9787210015635 +9787210015789 +9787210016007 +9787210016106 +9787210016151 +9787210016380 +9787210016441 +9787210016557 +9787210016687 +9787210017196 +9787210017264 +9787210017271 +9787210017448 +9787210017837 +9787210018018 +9787210018124 +9787210018308 +9787210018728 +9787210019060 +9787210019343 +9787210019527 +9787210020370 +9787210020387 +9787210021117 +9787210021186 +9787210021254 +9787210022923 +9787210022992 +9787210023050 +9787210023203 +9787210023753 +9787210023784 +9787210023821 +9787210023883 +9787210024484 +9787210024521 +9787210024538 +9787210024965 +9787210024996 +9787210025528 +9787210025887 +9787210026389 +9787210027638 +9787210028277 +9787210029410 +9787210030188 +9787210030300 +9787210030331 +9787210030447 +9787210030485 +9787210030584 +9787210031635 +9787210032793 +9787210033615 +9787210033684 +9787210034896 +9787210035121 +9787210035510 +9787210035565 +9787210035695 +9787210035817 +9787210036319 +9787210038290 +9787210038443 +9787210040552 +9787210041153 +9787210044215 +9787210046349 +9787210048503 +9787210048930 +9787210049371 +9787210050346 +9787210051480 +9787210052210 +9787210052920 +9787210055648 +9787210058946 +9787210060086 +9787210062288 +9787210062462 +9787210065043 +9787210066200 +9787210066354 +9787210067269 +9787210067337 +9787210070894 +9787210071761 +9787210078500 +9787210079248 +9787210079330 +9787210079484 +9787210080480 +9787210081395 +9787210081487 +9787210081647 +9787210082057 +9787210082583 +9787210085492 +9787210085508 +9787210086321 +9787210088622 +9787210097242 +9787210101666 +9787210107408 +9787210107644 +9787210108337 +9787210109723 +9787210109761 +9787210110231 +9787210112822 +9787210112884 +9787210113584 +9787210115052 +9787210115144 +9787210115298 +9787210118794 +9787210119722 +9787210120308 +9787210120711 +9787210120933 +9787210121091 +9787210121121 +9787210121923 +9787210122074 +9787210122364 +9787210123125 +9787210123149 +9787210124436 +9787210124634 +9787210127918 +9787210128052 +9787210129684 +9787210130307 +9787210130741 +9787210132653 +9787210134145 +9787210134282 +9787210134367 +9787210134572 +9787210135371 +9787210136729 +9787210138310 +9787210138549 +9787210138556 +9787210138563 +9787210138570 +9787210138587 +9787210138600 +9787210138617 +9787210138631 +9787210138662 +9787210140573 +9787210140740 +9787210140757 +9787210141877 +9787210141891 +9787210141914 +9787210142041 +9787210142065 +9787210143123 +9787210145356 +9787210146148 +9787210146377 +9787210146667 +9787210146674 +9787210146698 +9787210149033 +9787210151289 +9787210153214 +9787210154402 +9787210154433 +9787210154662 +9787210154730 +9787210156567 +9787210156581 +9787210159803 +9787210159827 +9787210166665 +9787211000128 +9787211000135 +9787211001729 +9787211002122 +9787211002894 +9787211003228 +9787211004638 +9787211007288 +9787211007707 +9787211007752 +9787211008414 +9787211009824 +9787211011391 +9787211011414 +9787211012497 +9787211013784 +9787211015092 +9787211015528 +9787211015931 +9787211017058 +9787211018215 +9787211018925 +9787211018970 +9787211019168 +9787211019533 +9787211019816 +9787211021468 +9787211021635 +9787211022052 +9787211027255 +9787211027699 +9787211027972 +9787211028344 +9787211028634 +9787211028665 +9787211029358 +9787211029433 +9787211029983 +9787211030842 +9787211031245 +9787211031498 +9787211031641 +9787211034628 +9787211035649 +9787211036035 +9787211036639 +9787211037124 +9787211037223 +9787211037414 +9787211037506 +9787211037612 +9787211037858 +9787211038015 +9787211039326 +9787211041992 +9787211042111 +9787211043156 +9787211046966 +9787211047550 +9787211050345 +9787211050406 +9787211051212 +9787211053070 +9787211056361 +9787211058518 +9787211060153 +9787211063185 +9787211063321 +9787211063642 +9787211064151 +9787211068289 +9787211068357 +9787211069729 +9787211069842 +9787211070220 +9787211073641 +9787211074563 +9787211074785 +9787211075492 +9787211076550 +9787211076642 +9787211076666 +9787211076871 +9787211076888 +9787211077397 +9787211078486 +9787211079278 +9787211080908 +9787211081325 +9787211081967 +9787211083398 +9787211083435 +9787211083459 +9787211083886 +9787211083893 +9787211083961 +9787211084623 +9787211084746 +9787211084753 +9787211085521 +9787211085545 +9787211089772 +9787211090204 +9787211091096 +9787211091133 +9787211091263 +9787211091300 +9787211091652 +9787211092147 +9787211092239 +9787211092826 +9787211093694 +9787211094660 +9787211095599 +9787211095612 +9787211096442 +9787211096985 +9787211098293 +9787211098347 +9787211098583 +9787212000004 +9787212000141 +9787212000196 +9787212000424 +9787212002428 +9787212003166 +9787212003616 +9787212004613 +9787212004651 +9787212005009 +9787212005306 +9787212006020 +9787212006303 +9787212006686 +9787212006785 +9787212007126 +9787212007225 +9787212007256 +9787212008123 +9787212008253 +9787212009519 +9787212010379 +9787212010638 +9787212012014 +9787212012120 +9787212012281 +9787212012687 +9787212012977 +9787212013493 +9787212014100 +9787212014117 +9787212014308 +9787212014339 +9787212014995 +9787212015107 +9787212015268 +9787212015282 +9787212015497 +9787212015565 +9787212015572 +9787212015596 +9787212015602 +9787212015824 +9787212015855 +9787212016173 +9787212016579 +9787212016623 +9787212016715 +9787212016920 +9787212016951 +9787212017019 +9787212017163 +9787212017378 +9787212017620 +9787212017767 +9787212017859 +9787212018764 +9787212019136 +9787212019396 +9787212019891 +9787212020491 +9787212020644 +9787212021764 +9787212022693 +9787212022839 +9787212022990 +9787212025120 +9787212026318 +9787212027100 +9787212027476 +9787212027650 +9787212028343 +9787212036492 +9787212036690 +9787212037611 +9787212041717 +9787212042981 +9787212043018 +9787212043025 +9787212043070 +9787212043094 +9787212043612 +9787212044114 +9787212044183 +9787212046071 +9787212047214 +9787212047429 +9787212048211 +9787212048273 +9787212048570 +9787212049713 +9787212052010 +9787212052089 +9787212052171 +9787212052393 +9787212052850 +9787212053512 +9787212053970 +9787212056179 +9787212056544 +9787212056698 +9787212056933 +9787212058616 +9787212060602 +9787212062705 +9787212062798 +9787212063115 +9787212063160 +9787212063610 +9787212063924 +9787212066253 +9787212068752 +9787212070533 +9787212071820 +9787212076238 +9787212076405 +9787212076696 +9787212082437 +9787212082611 +9787212089429 +9787212092535 +9787212094751 +9787212096878 +9787212097448 +9787212097806 +9787212098926 +9787212100353 +9787212100612 +9787212102388 +9787212104368 +9787212104832 +9787212105976 +9787212108458 +9787212108953 +9787212112011 +9787212112691 +9787212113582 +9787212114640 +9787212114886 +9787212115715 +9787212117245 +9787212118341 +9787212118433 +9787213000232 +9787213000379 +9787213000416 +9787213000683 +9787213000898 +9787213000911 +9787213001185 +9787213001420 +9787213001536 +9787213001673 +9787213001727 +9787213001741 +9787213001765 +9787213002205 +9787213002229 +9787213002304 +9787213002373 +9787213002915 +9787213002946 +9787213003028 +9787213003363 +9787213003707 +9787213003738 +9787213003790 +9787213003820 +9787213003868 +9787213003882 +9787213003936 +9787213003943 +9787213003967 +9787213004148 +9787213004216 +9787213004414 +9787213004452 +9787213004889 +9787213004902 +9787213005008 +9787213005022 +9787213005220 +9787213005237 +9787213005329 +9787213005350 +9787213005404 +9787213005596 +9787213005657 +9787213005725 +9787213005947 +9787213006135 +9787213006234 +9787213006661 +9787213006852 +9787213007217 +9787213007224 +9787213007231 +9787213007262 +9787213007293 +9787213007514 +9787213007576 +9787213007606 +9787213007637 +9787213007798 +9787213007958 +9787213008023 +9787213008306 +9787213008382 +9787213008467 +9787213008542 +9787213008672 +9787213008733 +9787213008757 +9787213008948 +9787213009020 +9787213009037 +9787213009082 +9787213009266 +9787213009525 +9787213009570 +9787213009624 +9787213009655 +9787213009686 +9787213009716 +9787213009846 +9787213009877 +9787213010132 +9787213010163 +9787213010347 +9787213011009 +9787213011139 +9787213011412 +9787213011542 +9787213011580 +9787213011764 +9787213011788 +9787213011825 +9787213011870 +9787213011986 +9787213012129 +9787213012242 +9787213012303 +9787213012440 +9787213012464 +9787213012570 +9787213012723 +9787213012983 +9787213013102 +9787213013164 +9787213013287 +9787213013294 +9787213013362 +9787213013379 +9787213013386 +9787213013393 +9787213013539 +9787213013546 +9787213013959 +9787213014017 +9787213014109 +9787213014123 +9787213014185 +9787213014277 +9787213014321 +9787213014369 +9787213014475 +9787213014482 +9787213014598 +9787213014604 +9787213014628 +9787213014635 +9787213014901 +9787213015397 +9787213015465 +9787213015533 +9787213015540 +9787213015755 +9787213015809 +9787213015991 +9787213016097 +9787213016240 +9787213016417 +9787213016448 +9787213016585 +9787213016721 +9787213016790 +9787213016936 +9787213017025 +9787213017247 +9787213017629 +9787213017735 +9787213017940 +9787213019289 +9787213019340 +9787213019470 +9787213019494 +9787213019517 +9787213019531 +9787213020117 +9787213020582 +9787213020681 +9787213021305 +9787213021671 +9787213021756 +9787213022159 +9787213022265 +9787213023040 +9787213023255 +9787213023590 +9787213023927 +9787213024009 +9787213024191 +9787213024993 +9787213025464 +9787213025556 +9787213025983 +9787213026393 +9787213026539 +9787213026751 +9787213026904 +9787213027833 +9787213029226 +9787213029233 +9787213030147 +9787213030345 +9787213030727 +9787213031106 +9787213031465 +9787213032004 +9787213032523 +9787213032608 +9787213033506 +9787213033889 +9787213033933 +9787213034589 +9787213035159 +9787213036460 +9787213036873 +9787213040801 +9787213041990 +9787213042546 +9787213043796 +9787213045110 +9787213045134 +9787213045356 +9787213046018 +9787213046209 +9787213046223 +9787213046582 +9787213046681 +9787213047329 +9787213049101 +9787213050121 +9787213050497 +9787213050954 +9787213051081 +9787213052620 +9787213052712 +9787213053320 +9787213053917 +9787213054945 +9787213055447 +9787213058318 +9787213058516 +9787213058899 +9787213059742 +9787213059971 +9787213060427 +9787213060649 +9787213062995 +9787213063046 +9787213063749 +9787213064715 +9787213064937 +9787213065736 +9787213071287 +9787213073007 +9787213073021 +9787213077043 +9787213079733 +9787213083921 +9787213084201 +9787213085987 +9787213086014 +9787213088063 +9787213088193 +9787213088742 +9787213088766 +9787213089992 +9787213093463 +9787213093500 +9787213094743 +9787213096822 +9787213098086 +9787213098383 +9787213098482 +9787213098819 +9787213098871 +9787213098994 +9787213099915 +9787213101830 +9787213103889 +9787213105425 +9787213106293 +9787213106736 +9787213106828 +9787213107405 +9787213107719 +9787213107757 +9787213108853 +9787213109850 +9787213109867 +9787213110092 +9787213110177 +9787213110368 +9787213110573 +9787213110610 +9787213110733 +9787213110795 +9787213110825 +9787213111334 +9787213111396 +9787213111747 +9787213111761 +9787213112058 +9787213112072 +9787213112195 +9787213112263 +9787213112461 +9787213112720 +9787213112911 +9787213112942 +9787213112959 +9787213113093 +9787213113208 +9787213113741 +9787213113765 +9787213113772 +9787213113819 +9787213114021 +9787213114045 +9787213114250 +9787213114694 +9787213114731 +9787213116230 +9787213116247 +9787213116391 +9787213116933 +9787213117046 +9787213117060 +9787213117077 +9787213117190 +9787213117206 +9787213117213 +9787213117329 +9787213117350 +9787213117459 +9787213117480 +9787213117510 +9787213117572 +9787213117633 +9787213117688 +9787213117848 +9787213117879 +9787213118159 +9787213118890 +9787213118920 +9787213119088 +9787213119309 +9787213119507 +9787213119545 +9787213119828 +9787213119927 +9787213120367 +9787214000002 +9787214000521 +9787214000651 +9787214000736 +9787214000781 +9787214000866 +9787214001047 +9787214001061 +9787214001214 +9787214001252 +9787214002136 +9787214002402 +9787214002501 +9787214002822 +9787214002877 +9787214004079 +9787214004642 +9787214004666 +9787214005113 +9787214005700 +9787214006219 +9787214006813 +9787214007407 +9787214007636 +9787214008077 +9787214008091 +9787214008602 +9787214008626 +9787214008978 +9787214009050 +9787214009227 +9787214009609 +9787214010193 +9787214010339 +9787214011541 +9787214011992 +9787214012029 +9787214012500 +9787214012685 +9787214012715 +9787214012739 +9787214013033 +9787214013095 +9787214013170 +9787214013668 +9787214013835 +9787214013910 +9787214013934 +9787214014689 +9787214015075 +9787214015136 +9787214015211 +9787214015242 +9787214015259 +9787214015310 +9787214015365 +9787214015501 +9787214015716 +9787214016027 +9787214016423 +9787214016577 +9787214016669 +9787214016676 +9787214016867 +9787214016881 +9787214016966 +9787214016997 +9787214017079 +9787214017475 +9787214017550 +9787214017611 +9787214017840 +9787214017925 +9787214017956 +9787214018106 +9787214018380 +9787214018564 +9787214018656 +9787214019523 +9787214019646 +9787214019653 +9787214019660 +9787214020413 +9787214020444 +9787214020451 +9787214020703 +9787214020963 +9787214021007 +9787214021205 +9787214021250 +9787214021427 +9787214021458 +9787214021601 +9787214021700 +9787214021748 +9787214022028 +9787214022066 +9787214022189 +9787214022257 +9787214022394 +9787214022561 +9787214022653 +9787214023001 +9787214023025 +9787214023032 +9787214023070 +9787214023162 +9787214023223 +9787214023452 +9787214023544 +9787214023582 +9787214023810 +9787214023872 +9787214023926 +9787214024572 +9787214024596 +9787214024619 +9787214024633 +9787214024664 +9787214024732 +9787214025050 +9787214025685 +9787214025777 +9787214026033 +9787214026934 +9787214027061 +9787214027115 +9787214027375 +9787214027467 +9787214027504 +9787214027511 +9787214027535 +9787214027566 +9787214027900 +9787214028020 +9787214028099 +9787214028136 +9787214028198 +9787214028341 +9787214028570 +9787214028693 +9787214029744 +9787214030733 +9787214031990 +9787214032232 +9787214032980 +9787214034014 +9787214034182 +9787214035004 +9787214036995 +9787214037275 +9787214037664 +9787214038432 +9787214038999 +9787214039781 +9787214039965 +9787214040329 +9787214041494 +9787214042637 +9787214043030 +9787214043115 +9787214045492 +9787214046604 +9787214046857 +9787214047694 +9787214049315 +9787214050700 +9787214051677 +9787214051806 +9787214054036 +9787214055408 +9787214055866 +9787214055897 +9787214056160 +9787214056214 +9787214057792 +9787214058607 +9787214059383 +9787214059796 +9787214060914 +9787214060983 +9787214061645 +9787214062482 +9787214065445 +9787214065780 +9787214066121 +9787214067258 +9787214069207 +9787214070449 +9787214070531 +9787214073464 +9787214073938 +9787214075314 +9787214075802 +9787214080936 +9787214083869 +9787214087911 +9787214088277 +9787214090386 +9787214096050 +9787214096067 +9787214096722 +9787214097101 +9787214102928 +9787214106605 +9787214106612 +9787214118875 +9787214121295 +9787214123695 +9787214130648 +9787214139740 +9787214139788 +9787214140524 +9787214149015 +9787214149459 +9787214167880 +9787214168368 +9787214168825 +9787214174000 +9787214175663 +9787214178619 +9787214178732 +9787214190598 +9787214201133 +9787214204042 +9787214204264 +9787214206039 +9787214210937 +9787214212672 +9787214216984 +9787214217820 +9787214219299 +9787214220400 +9787214221780 +9787214228499 +9787214231383 +9787214232144 +9787214233462 +9787214233585 +9787214236777 +9787214236982 +9787214237644 +9787214238320 +9787214238702 +9787214239136 +9787214240576 +9787214241801 +9787214242747 +9787214243683 +9787214245236 +9787214246189 +9787214251633 +9787214252661 +9787214253095 +9787214254207 +9787214256676 +9787214256799 +9787214256874 +9787214256997 +9787214257536 +9787214258250 +9787214260499 +9787214260604 +9787214261045 +9787214263728 +9787214263735 +9787214263759 +9787214263810 +9787214265579 +9787214268631 +9787214269690 +9787214270078 +9787214270795 +9787214271327 +9787214272713 +9787214273604 +9787214273635 +9787214274229 +9787214274311 +9787214276162 +9787214278333 +9787214278586 +9787214278692 +9787214280411 +9787214281104 +9787214281319 +9787214282477 +9787214282514 +9787214283009 +9787214283016 +9787214283399 +9787214283634 +9787214283641 +9787214283801 +9787214283849 +9787214283856 +9787214284020 +9787214284334 +9787214284501 +9787214284518 +9787214284525 +9787214284686 +9787214285034 +9787214285409 +9787214285645 +9787214287069 +9787214287434 +9787214287847 +9787214287892 +9787214288448 +9787214289971 +9787214289988 +9787214290212 +9787214290281 +9787214290335 +9787214290410 +9787214290687 +9787214290755 +9787214290878 +9787214291264 +9787214291639 +9787214292780 +9787214293121 +9787214293220 +9787214294234 +9787214295064 +9787214295101 +9787214295194 +9787214295200 +9787214295873 +9787214296061 +9787214296092 +9787214296450 +9787214296559 +9787214296764 +9787214297631 +9787214298461 +9787214301925 +9787214301970 +9787214307286 +9787214308146 +9787215000063 +9787215000100 +9787215000124 +9787215000193 +9787215000216 +9787215000230 +9787215000407 +9787215000421 +9787215000483 +9787215000551 +9787215000759 +9787215000780 +9787215000810 +9787215000902 +9787215001206 +9787215001329 +9787215001541 +9787215001596 +9787215001800 +9787215002111 +9787215002302 +9787215002319 +9787215002326 +9787215002357 +9787215002944 +9787215003026 +9787215003033 +9787215003071 +9787215003101 +9787215003194 +9787215003217 +9787215003293 +9787215003354 +9787215003385 +9787215003521 +9787215003668 +9787215005969 +9787215006034 +9787215006249 +9787215006294 +9787215006355 +9787215006775 +9787215007185 +9787215007482 +9787215008021 +9787215008298 +9787215008335 +9787215008656 +9787215008731 +9787215008823 +9787215008946 +9787215009165 +9787215010918 +9787215011458 +9787215011526 +9787215011588 +9787215011595 +9787215013322 +9787215013803 +9787215013810 +9787215014343 +9787215014534 +9787215015012 +9787215015029 +9787215015135 +9787215015197 +9787215015203 +9787215015265 +9787215015289 +9787215015456 +9787215015524 +9787215016057 +9787215016262 +9787215016927 +9787215017122 +9787215017542 +9787215018112 +9787215018372 +9787215018389 +9787215018396 +9787215018426 +9787215018587 +9787215018655 +9787215018785 +9787215019102 +9787215019669 +9787215019744 +9787215019881 +9787215020375 +9787215020702 +9787215020764 +9787215020849 +9787215021068 +9787215021181 +9787215021198 +9787215021235 +9787215021433 +9787215022003 +9787215022263 +9787215022645 +9787215023154 +9787215023284 +9787215023543 +9787215023727 +9787215023901 +9787215024014 +9787215024038 +9787215024328 +9787215024588 +9787215024700 +9787215024816 +9787215024892 +9787215025127 +9787215025158 +9787215025165 +9787215025363 +9787215025394 +9787215026209 +9787215026629 +9787215026797 +9787215028746 +9787215029033 +9787215029095 +9787215029996 +9787215030008 +9787215030206 +9787215030718 +9787215030930 +9787215031111 +9787215031746 +9787215032507 +9787215032569 +9787215033580 +9787215033702 +9787215033733 +9787215034426 +9787215034631 +9787215034655 +9787215034709 +9787215034723 +9787215034730 +9787215035058 +9787215035508 +9787215035959 +9787215035980 +9787215036055 +9787215036444 +9787215036734 +9787215036789 +9787215036932 +9787215036956 +9787215036970 +9787215038349 +9787215038561 +9787215038868 +9787215038912 +9787215038929 +9787215039735 +9787215040014 +9787215040038 +9787215040458 +9787215040618 +9787215040717 +9787215040731 +9787215041035 +9787215041097 +9787215041110 +9787215041127 +9787215041134 +9787215041479 +9787215041851 +9787215041905 +9787215042209 +9787215042278 +9787215042292 +9787215042308 +9787215042452 +9787215042490 +9787215042520 +9787215042575 +9787215042667 +9787215043695 +9787215043718 +9787215043732 +9787215043787 +9787215044111 +9787215044166 +9787215044197 +9787215044708 +9787215044876 +9787215044944 +9787215045026 +9787215045163 +9787215045330 +9787215045385 +9787215045927 +9787215046405 +9787215046474 +9787215046627 +9787215046689 +9787215046696 +9787215046795 +9787215046931 +9787215046948 +9787215047181 +9787215047372 +9787215047679 +9787215047839 +9787215047952 +9787215048232 +9787215048508 +9787215048713 +9787215048898 +9787215049185 +9787215049192 +9787215050372 +9787215050594 +9787215051126 +9787215052284 +9787215052536 +9787215052666 +9787215052871 +9787215053083 +9787215053090 +9787215053571 +9787215053779 +9787215054622 +9787215054691 +9787215054776 +9787215054783 +9787215055124 +9787215055179 +9787215056114 +9787215057098 +9787215057883 +9787215058224 +9787215058804 +9787215059634 +9787215060036 +9787215060531 +9787215061804 +9787215061811 +9787215061866 +9787215062429 +9787215065055 +9787215068032 +9787215068643 +9787215069398 +9787215069435 +9787215069497 +9787215070349 +9787215072534 +9787215072824 +9787215075443 +9787215076297 +9787215076440 +9787215076761 +9787215077065 +9787215078017 +9787215078314 +9787215078369 +9787215079250 +9787215080430 +9787215080850 +9787215081000 +9787215081239 +9787215081529 +9787215081727 +9787215082137 +9787215082168 +9787215083080 +9787215083356 +9787215083509 +9787215084803 +9787215085312 +9787215085480 +9787215085633 +9787215086449 +9787215086548 +9787215086685 +9787215087354 +9787215087514 +9787215087989 +9787215088108 +9787215088252 +9787215088450 +9787215088757 +9787215090842 +9787215091245 +9787215091276 +9787215091580 +9787215093331 +9787215093850 +9787215093942 +9787215094055 +9787215094147 +9787215095229 +9787215097711 +9787215101968 +9787215103016 +9787215105027 +9787215105997 +9787215106437 +9787215106628 +9787215109780 +9787215111141 +9787215117013 +9787215117099 +9787215117945 +9787215118713 +9787215118980 +9787215119550 +9787215120051 +9787215120068 +9787215120075 +9787215120099 +9787215120105 +9787215120129 +9787215120143 +9787215120204 +9787215120365 +9787215120723 +9787215121034 +9787215122055 +9787215122451 +9787215123298 +9787215123427 +9787215123953 +9787215124073 +9787215124363 +9787215124783 +9787215125056 +9787215127210 +9787215128811 +9787215130142 +9787215130692 +9787215133181 +9787215135178 +9787215137356 +9787216000055 +9787216000154 +9787216000222 +9787216000307 +9787216000352 +9787216000376 +9787216000383 +9787216000567 +9787216000710 +9787216000895 +9787216001267 +9787216001397 +9787216001601 +9787216002110 +9787216002219 +9787216002226 +9787216002417 +9787216002684 +9787216003056 +9787216003223 +9787216003247 +9787216003384 +9787216004015 +9787216004664 +9787216004770 +9787216004862 +9787216005203 +9787216005869 +9787216006118 +9787216006811 +9787216007436 +9787216007450 +9787216007894 +9787216008112 +9787216008792 +9787216009966 +9787216009973 +9787216010566 +9787216010788 +9787216010887 +9787216011587 +9787216011662 +9787216012003 +9787216012287 +9787216012393 +9787216012973 +9787216013338 +9787216013352 +9787216013376 +9787216013383 +9787216013444 +9787216013536 +9787216013567 +9787216013574 +9787216013901 +9787216014151 +9787216014212 +9787216014274 +9787216014496 +9787216014724 +9787216015042 +9787216015271 +9787216015592 +9787216015752 +9787216015776 +9787216015912 +9787216015974 +9787216016513 +9787216016605 +9787216017312 +9787216017381 +9787216017404 +9787216017527 +9787216017657 +9787216017718 +9787216017954 +9787216018081 +9787216018203 +9787216018272 +9787216018562 +9787216018609 +9787216018715 +9787216018739 +9787216018814 +9787216018852 +9787216018890 +9787216018937 +9787216019651 +9787216019675 +9787216020008 +9787216020084 +9787216020459 +9787216020527 +9787216020732 +9787216020787 +9787216020817 +9787216021081 +9787216021906 +9787216023030 +9787216023146 +9787216024228 +9787216024761 +9787216024860 +9787216025492 +9787216025607 +9787216025843 +9787216025898 +9787216026000 +9787216026017 +9787216026154 +9787216026215 +9787216026536 +9787216026710 +9787216026796 +9787216027731 +9787216027878 +9787216027885 +9787216028011 +9787216028158 +9787216028585 +9787216028684 +9787216028790 +9787216028967 +9787216029278 +9787216029575 +9787216029810 +9787216030946 +9787216031967 +9787216032018 +9787216032339 +9787216032636 +9787216033343 +9787216033374 +9787216033428 +9787216033466 +9787216034982 +9787216035811 +9787216036375 +9787216036382 +9787216036405 +9787216036511 +9787216036634 +9787216037594 +9787216037631 +9787216037679 +9787216037907 +9787216038508 +9787216038560 +9787216039659 +9787216039680 +9787216039789 +9787216039802 +9787216039949 +9787216041270 +9787216041706 +9787216041850 +9787216041959 +9787216042710 +9787216043106 +9787216043212 +9787216043250 +9787216043724 +9787216044349 +9787216044486 +9787216044790 +9787216044998 +9787216045827 +9787216046046 +9787216046152 +9787216046343 +9787216046862 +9787216047067 +9787216047135 +9787216047609 +9787216048224 +9787216050050 +9787216050708 +9787216050791 +9787216051378 +9787216051385 +9787216051392 +9787216051606 +9787216052689 +9787216053495 +9787216053617 +9787216053945 +9787216053990 +9787216054928 +9787216056229 +9787216057196 +9787216058445 +9787216058452 +9787216058759 +9787216059855 +9787216060141 +9787216060905 +9787216063074 +9787216063715 +9787216063777 +9787216064118 +9787216064477 +9787216064545 +9787216064774 +9787216065726 +9787216066648 +9787216066747 +9787216067218 +9787216067492 +9787216067867 +9787216067881 +9787216068055 +9787216068208 +9787216068628 +9787216068642 +9787216069076 +9787216069151 +9787216069182 +9787216070553 +9787216071062 +9787216072953 +9787216074896 +9787216075244 +9787216075572 +9787216075855 +9787216076906 +9787216077781 +9787216078801 +9787216078948 +9787216079419 +9787216080859 +9787216082075 +9787216083300 +9787216083423 +9787216083775 +9787216084499 +9787216084659 +9787216084970 +9787216085199 +9787216087933 +9787216088787 +9787216089692 +9787216089715 +9787216090179 +9787216090216 +9787216092296 +9787216092463 +9787216092517 +9787216094979 +9787216098205 +9787216099103 +9787216099370 +9787216100373 +9787216101257 +9787216102599 +9787216106177 +9787216106573 +9787216107327 +9787216109567 +9787217000023 +9787217000061 +9787217000115 +9787217000139 +9787217000184 +9787217000214 +9787217000320 +9787217000405 +9787217000429 +9787217000474 +9787217000559 +9787217000665 +9787217000788 +9787217000825 +9787217000870 +9787217000955 +9787217001259 +9787217001266 +9787217001334 +9787217001365 +9787217001464 +9787217001495 +9787217001549 +9787217001556 +9787217001624 +9787217002218 +9787217002232 +9787217002690 +9787217002805 +9787217002980 +9787217003024 +9787217003086 +9787217003123 +9787217003147 +9787217003178 +9787217003239 +9787217003253 +9787217003277 +9787217003475 +9787217003482 +9787217003796 +9787217003901 +9787217004038 +9787217004274 +9787217004571 +9787217005172 +9787217005349 +9787217005462 +9787217005509 +9787217005585 +9787217005653 +9787217005783 +9787217005875 +9787217006148 +9787217006179 +9787217006261 +9787217006360 +9787217006445 +9787217006681 +9787217006780 +9787218000183 +9787218000312 +9787218000411 +9787218000671 +9787218000695 +9787218000718 +9787218000763 +9787218000770 +9787218000848 +9787218001111 +9787218001302 +9787218001319 +9787218001876 +9787218001975 +9787218002378 +9787218002651 +9787218002811 +9787218003016 +9787218003344 +9787218003443 +9787218003474 +9787218004198 +9787218004228 +9787218004495 +9787218004761 +9787218005102 +9787218005157 +9787218005478 +9787218006031 +9787218006260 +9787218006413 +9787218006536 +9787218006666 +9787218006789 +9787218006857 +9787218007014 +9787218007229 +9787218007656 +9787218007885 +9787218008196 +9787218008875 +9787218009100 +9787218009377 +9787218009438 +9787218009599 +9787218009629 +9787218009803 +9787218010151 +9787218010199 +9787218011608 +9787218012292 +9787218013039 +9787218013619 +9787218013886 +9787218013985 +9787218014036 +9787218014067 +9787218014449 +9787218014463 +9787218014562 +9787218015248 +9787218015255 +9787218015415 +9787218015439 +9787218015521 +9787218015590 +9787218015682 +9787218015743 +9787218015811 +9787218016122 +9787218016467 +9787218016474 +9787218016726 +9787218017402 +9787218017525 +9787218017730 +9787218017945 +9787218018096 +9787218018263 +9787218018751 +9787218018799 +9787218019024 +9787218019505 +9787218019543 +9787218019604 +9787218019819 +9787218019864 +9787218020068 +9787218020273 +9787218020426 +9787218020730 +9787218020853 +9787218021201 +9787218021430 +9787218021553 +9787218021638 +9787218021652 +9787218021874 +9787218021935 +9787218021959 +9787218022277 +9787218022307 +9787218022628 +9787218022727 +9787218022734 +9787218023021 +9787218023113 +9787218023144 +9787218023212 +9787218023236 +9787218023342 +9787218023403 +9787218023564 +9787218023571 +9787218024011 +9787218025216 +9787218025414 +9787218025483 +9787218025667 +9787218025834 +9787218025858 +9787218025988 +9787218026084 +9787218026381 +9787218026909 +9787218027241 +9787218027524 +9787218027623 +9787218027654 +9787218028385 +9787218028392 +9787218028408 +9787218028460 +9787218028477 +9787218028712 +9787218028927 +9787218028941 +9787218029122 +9787218029283 +9787218029443 +9787218029726 +9787218029764 +9787218029900 +9787218030005 +9787218030333 +9787218030388 +9787218030395 +9787218030593 +9787218030951 +9787218031071 +9787218031347 +9787218031422 +9787218031538 +9787218031873 +9787218031996 +9787218032139 +9787218032146 +9787218032467 +9787218032573 +9787218032597 +9787218032689 +9787218032740 +9787218032887 +9787218032900 +9787218033280 +9787218033563 +9787218033815 +9787218033938 +9787218033976 +9787218034263 +9787218034270 +9787218034294 +9787218034423 +9787218034560 +9787218034577 +9787218034829 +9787218034874 +9787218035079 +9787218035208 +9787218035444 +9787218035505 +9787218035680 +9787218035802 +9787218036458 +9787218036472 +9787218036519 +9787218036700 +9787218037820 +9787218037943 +9787218038018 +9787218038186 +9787218038391 +9787218038773 +9787218040240 +9787218040288 +9787218040318 +9787218040769 +9787218040776 +9787218041179 +9787218041568 +9787218041636 +9787218042916 +9787218042992 +9787218043500 +9787218043876 +9787218044026 +9787218044149 +9787218044590 +9787218045122 +9787218045221 +9787218046136 +9787218046556 +9787218046938 +9787218047232 +9787218047904 +9787218047973 +9787218048451 +9787218049021 +9787218049106 +9787218049243 +9787218050409 +9787218051116 +9787218051482 +9787218051512 +9787218051710 +9787218051925 +9787218052083 +9787218052922 +9787218053493 +9787218054629 +9787218054964 +9787218055350 +9787218055763 +9787218056852 +9787218059105 +9787218059112 +9787218059723 +9787218059891 +9787218060040 +9787218060118 +9787218060255 +9787218060620 +9787218060866 +9787218060989 +9787218061023 +9787218061382 +9787218061412 +9787218061832 +9787218063799 +9787218066042 +9787218066417 +9787218067131 +9787218068480 +9787218070339 +9787218070414 +9787218070520 +9787218072463 +9787218072906 +9787218073118 +9787218073330 +9787218073675 +9787218073712 +9787218073880 +9787218076034 +9787218076713 +9787218078601 +9787218079035 +9787218081519 +9787218083698 +9787218083728 +9787218083872 +9787218084787 +9787218086217 +9787218086460 +9787218086774 +9787218087313 +9787218090504 +9787218090641 +9787218091211 +9787218091709 +9787218092515 +9787218092539 +9787218092546 +9787218092690 +9787218092928 +9787218093185 +9787218093215 +9787218093239 +9787218093468 +9787218093482 +9787218094298 +9787218094441 +9787218094458 +9787218094793 +9787218095622 +9787218097275 +9787218097992 +9787218099286 +9787218100418 +9787218100500 +9787218105253 +9787218105895 +9787218106847 +9787218107424 +9787218113838 +9787218114545 +9787218114880 +9787218114965 +9787218117638 +9787218119090 +9787218119663 +9787218120713 +9787218122274 +9787218123974 +9787218124339 +9787218125084 +9787218125091 +9787218125107 +9787218125909 +9787218125930 +9787218126326 +9787218127361 +9787218132648 +9787218132747 +9787218132839 +9787218133195 +9787218134970 +9787218137636 +9787218138329 +9787218138480 +9787218138817 +9787218138916 +9787218141213 +9787218142685 +9787218143347 +9787218143910 +9787218145709 +9787218146768 +9787218146775 +9787218148090 +9787218148816 +9787218149646 +9787218150635 +9787218150680 +9787218151380 +9787218151793 +9787218151953 +9787218152417 +9787218152554 +9787218152639 +9787218152905 +9787218153261 +9787218153445 +9787218153902 +9787218154275 +9787218155326 +9787218156415 +9787218157610 +9787218158334 +9787218158389 +9787218159027 +9787218159126 +9787218160726 +9787218160795 +9787218160931 +9787218161389 +9787218163086 +9787218163345 +9787218163727 +9787218163956 +9787218164434 +9787218164441 +9787218164502 +9787218164533 +9787218164564 +9787218164953 +9787218165028 +9787218165110 +9787218166117 +9787218166193 +9787218166223 +9787218167053 +9787218167251 +9787218167350 +9787218168333 +9787218168517 +9787218168739 +9787218169781 +9787218170022 +9787218170169 +9787218170220 +9787218170343 +9787218170367 +9787218170435 +9787218170879 +9787218171135 +9787218171432 +9787218171791 +9787218172002 +9787218172187 +9787218172705 +9787218172750 +9787218172798 +9787218173443 +9787218173887 +9787218174587 +9787218175423 +9787218175492 +9787218175515 +9787218175584 +9787218175768 +9787218176000 +9787218176017 +9787218176048 +9787218176215 +9787218176246 +9787218176499 +9787218176895 +9787218177694 +9787218177724 +9787218177731 +9787218177922 +9787218177977 +9787218178189 +9787218178332 +9787218178936 +9787218179223 +9787218179339 +9787218179421 +9787218179490 +9787218179551 +9787218180328 +9787218180366 +9787218180380 +9787218180410 +9787218180427 +9787218181141 +9787218181219 +9787218182469 +9787218182575 +9787218182896 +9787218183213 +9787218183282 +9787218183503 +9787218184661 +9787218185064 +9787218186146 +9787218186399 +9787219000625 +9787219000717 +9787219000953 +9787219001189 +9787219001202 +9787219001424 +9787219002223 +9787219002315 +9787219002322 +9787219002353 +9787219002544 +9787219002827 +9787219002940 +9787219002971 +9787219003190 +9787219003305 +9787219003459 +9787219003749 +9787219004395 +9787219004449 +9787219004722 +9787219004739 +9787219004791 +9787219004852 +9787219005026 +9787219005293 +9787219005408 +9787219005422 +9787219006665 +9787219006672 +9787219007341 +9787219007389 +9787219007532 +9787219007884 +9787219008164 +9787219008270 +9787219008461 +9787219010679 +9787219010846 +9787219011027 +9787219011072 +9787219011324 +9787219011478 +9787219011539 +9787219011966 +9787219012802 +9787219013335 +9787219013700 +9787219013977 +9787219015520 +9787219015568 +9787219015575 +9787219015872 +9787219016282 +9787219016404 +9787219017470 +9787219017494 +9787219017760 +9787219018064 +9787219019023 +9787219019047 +9787219019788 +9787219020401 +9787219020579 +9787219020913 +9787219021286 +9787219022047 +9787219022191 +9787219022887 +9787219023075 +9787219023419 +9787219024072 +9787219024539 +9787219024546 +9787219024751 +9787219024812 +9787219025017 +9787219025611 +9787219026021 +9787219026045 +9787219026717 +9787219026854 +9787219027554 +9787219027578 +9787219027837 +9787219027844 +9787219027875 +9787219027912 +9787219028193 +9787219028858 +9787219029688 +9787219030394 +9787219030844 +9787219031575 +9787219034569 +9787219034750 +9787219035276 +9787219035283 +9787219036358 +9787219036365 +9787219036464 +9787219036655 +9787219036860 +9787219036884 +9787219037010 +9787219037690 +9787219037980 +9787219038345 +9787219038543 +9787219038581 +9787219038819 +9787219039106 +9787219039601 +9787219039618 +9787219039625 +9787219039632 +9787219039649 +9787219039656 +9787219040164 +9787219040621 +9787219040980 +9787219041550 +9787219041819 +9787219042113 +9787219042762 +9787219043752 +9787219044384 +9787219044773 +9787219045039 +9787219045121 +9787219045145 +9787219045633 +9787219045985 +9787219048443 +9787219049594 +9787219049976 +9787219050378 +9787219050552 +9787219050569 +9787219051115 +9787219051139 +9787219053256 +9787219053836 +9787219053942 +9787219054086 +9787219054413 +9787219054567 +9787219054611 +9787219054727 +9787219056073 +9787219056295 +9787219056929 +9787219056943 +9787219056981 +9787219057100 +9787219057322 +9787219057803 +9787219057971 +9787219058992 +9787219059043 +9787219061084 +9787219061145 +9787219062555 +9787219063415 +9787219063422 +9787219063941 +9787219064153 +9787219065198 +9787219066317 +9787219066942 +9787219066959 +9787219067116 +9787219067338 +9787219069578 +9787219069646 +9787219069653 +9787219069806 +9787219069851 +9787219070185 +9787219070505 +9787219070802 +9787219072011 +9787219073285 +9787219073445 +9787219073599 +9787219074053 +9787219074428 +9787219074633 +9787219075265 +9787219075388 +9787219075630 +9787219077030 +9787219077139 +9787219077337 +9787219077733 +9787219078426 +9787219079744 +9787219080153 +9787219080283 +9787219080382 +9787219081341 +9787219081402 +9787219081969 +9787219082201 +9787219085042 +9787219085691 +9787219085745 +9787219088197 +9787219088227 +9787219089583 +9787219090480 +9787219090817 +9787219091180 +9787219091289 +9787219091500 +9787219091685 +9787219091753 +9787219092507 +9787219092613 +9787219092712 +9787219093436 +9787219094587 +9787219094884 +9787219095072 +9787219095225 +9787219097489 +9787219097915 +9787219099049 +9787219099780 +9787219100240 +9787219100622 +9787219101919 +9787219101926 +9787219103210 +9787219105948 +9787219106150 +9787219107966 +9787219108079 +9787219110515 +9787219112137 +9787219115053 +9787219115114 +9787219116845 +9787219117279 +9787219117989 +9787220000072 +9787220000218 +9787220000386 +9787220000409 +9787220000997 +9787220001024 +9787220001222 +9787220001864 +9787220002021 +9787220002205 +9787220002410 +9787220002441 +9787220002502 +9787220002564 +9787220002922 +9787220002984 +9787220003035 +9787220003400 +9787220003431 +9787220003646 +9787220003851 +9787220003875 +9787220004100 +9787220004193 +9787220005053 +9787220005169 +9787220005275 +9787220005428 +9787220006289 +9787220006319 +9787220006517 +9787220006661 +9787220007347 +9787220008252 +9787220008313 +9787220008375 +9787220008580 +9787220009358 +9787220009921 +9787220010286 +9787220010613 +9787220011207 +9787220011733 +9787220012051 +9787220012235 +9787220012785 +9787220012853 +9787220012907 +9787220013348 +9787220013720 +9787220014772 +9787220015007 +9787220015069 +9787220015526 +9787220016349 +9787220016356 +9787220016370 +9787220016561 +9787220016721 +9787220016875 +9787220016974 +9787220017155 +9787220017162 +9787220017216 +9787220017223 +9787220017261 +9787220017315 +9787220017353 +9787220017469 +9787220017735 +9787220018213 +9787220018268 +9787220018282 +9787220018329 +9787220018787 +9787220018800 +9787220018985 +9787220019142 +9787220019326 +9787220019395 +9787220019852 +9787220020094 +9787220020520 +9787220020650 +9787220020780 +9787220021046 +9787220021077 +9787220021220 +9787220021404 +9787220021411 +9787220021428 +9787220021435 +9787220021527 +9787220021596 +9787220021640 +9787220021657 +9787220021893 +9787220022265 +9787220022289 +9787220022340 +9787220022371 +9787220022432 +9787220022715 +9787220022883 +9787220023088 +9787220023217 +9787220023859 +9787220024450 +9787220024870 +9787220024931 +9787220024979 +9787220025075 +9787220025129 +9787220025235 +9787220025341 +9787220025358 +9787220025372 +9787220025389 +9787220025396 +9787220025471 +9787220025617 +9787220025624 +9787220025747 +9787220025853 +9787220025983 +9787220026409 +9787220026744 +9787220026881 +9787220026980 +9787220027031 +9787220027314 +9787220027321 +9787220027413 +9787220027437 +9787220027499 +9787220027550 +9787220027604 +9787220027710 +9787220027840 +9787220027901 +9787220027963 +9787220028069 +9787220028106 +9787220028366 +9787220028458 +9787220028533 +9787220028601 +9787220028632 +9787220028724 +9787220028731 +9787220029028 +9787220029035 +9787220029219 +9787220029349 +9787220029387 +9787220029486 +9787220029561 +9787220029769 +9787220030123 +9787220030161 +9787220030376 +9787220030468 +9787220030642 +9787220030833 +9787220031236 +9787220031243 +9787220031274 +9787220031397 +9787220031403 +9787220031427 +9787220031519 +9787220031533 +9787220031588 +9787220031625 +9787220031731 +9787220031786 +9787220031809 +9787220031816 +9787220031908 +9787220031939 +9787220031960 +9787220032264 +9787220032431 +9787220032516 +9787220032608 +9787220032622 +9787220032783 +9787220032790 +9787220032950 +9787220033025 +9787220033858 +9787220034060 +9787220034121 +9787220034251 +9787220034343 +9787220034473 +9787220034541 +9787220034756 +9787220034770 +9787220034817 +9787220034848 +9787220034855 +9787220034954 +9787220035111 +9787220035364 +9787220035418 +9787220035616 +9787220035647 +9787220035821 +9787220035852 +9787220035869 +9787220035890 +9787220035944 +9787220035975 +9787220036033 +9787220036057 +9787220036064 +9787220036576 +9787220036675 +9787220037023 +9787220037047 +9787220037153 +9787220037214 +9787220037221 +9787220037313 +9787220037658 +9787220037764 +9787220037870 +9787220037887 +9787220037931 +9787220038006 +9787220038013 +9787220038037 +9787220038143 +9787220038204 +9787220038433 +9787220038464 +9787220039102 +9787220039133 +9787220039799 +9787220039911 +9787220039935 +9787220040085 +9787220040092 +9787220040467 +9787220040641 +9787220041013 +9787220041136 +9787220041426 +9787220041433 +9787220041518 +9787220041532 +9787220041891 +9787220041990 +9787220042195 +9787220042348 +9787220042478 +9787220042652 +9787220042683 +9787220042898 +9787220042928 +9787220042997 +9787220043116 +9787220043147 +9787220043314 +9787220043604 +9787220043628 +9787220043642 +9787220044069 +9787220044113 +9787220044311 +9787220044427 +9787220044441 +9787220044540 +9787220044687 +9787220044922 +9787220045332 +9787220045493 +9787220045974 +9787220046124 +9787220046414 +9787220046674 +9787220047114 +9787220047190 +9787220047312 +9787220047343 +9787220047862 +9787220047879 +9787220047985 +9787220048326 +9787220048753 +9787220048937 +9787220048944 +9787220049095 +9787220049354 +9787220050633 +9787220050954 +9787220050985 +9787220051630 +9787220051821 +9787220052019 +9787220052378 +9787220052682 +9787220052712 +9787220052866 +9787220053061 +9787220053269 +9787220053320 +9787220053351 +9787220053528 +9787220053757 +9787220054242 +9787220054297 +9787220054358 +9787220054549 +9787220054617 +9787220055843 +9787220055867 +9787220055959 +9787220055973 +9787220056024 +9787220056369 +9787220056505 +9787220056550 +9787220056628 +9787220057052 +9787220057175 +9787220057229 +9787220057250 +9787220057847 +9787220057953 +9787220057977 +9787220058134 +9787220058271 +9787220058417 +9787220058820 +9787220059131 +9787220059483 +9787220061172 +9787220061547 +9787220061837 +9787220062162 +9787220062995 +9787220063312 +9787220063541 +9787220063725 +9787220064470 +9787220065293 +9787220065408 +9787220065477 +9787220066054 +9787220066160 +9787220066320 +9787220066337 +9787220066368 +9787220067075 +9787220067471 +9787220067990 +9787220068508 +9787220068799 +9787220068805 +9787220068980 +9787220069529 +9787220070068 +9787220070563 +9787220070747 +9787220071003 +9787220074158 +9787220075285 +9787220076619 +9787220076725 +9787220079863 +9787220080937 +9787220080951 +9787220081002 +9787220081132 +9787220083303 +9787220083389 +9787220083952 +9787220084423 +9787220084973 +9787220084980 +9787220085062 +9787220085086 +9787220085635 +9787220086175 +9787220086199 +9787220086304 +9787220087127 +9787220087165 +9787220087622 +9787220087653 +9787220088261 +9787220088841 +9787220089435 +9787220090165 +9787220090196 +9787220090226 +9787220090370 +9787220090424 +9787220090998 +9787220091261 +9787220091940 +9787220092206 +9787220093005 +9787220093098 +9787220093739 +9787220094101 +9787220094743 +9787220097065 +9787220098802 +9787220100840 +9787220100932 +9787220102752 +9787220106736 +9787220107016 +9787220108808 +9787220109713 +9787220110351 +9787220111006 +9787220112751 +9787220113161 +9787220114380 +9787220114403 +9787220114670 +9787220115677 +9787220117114 +9787220117572 +9787220118487 +9787220118814 +9787220119026 +9787220119088 +9787220119361 +9787220121968 +9787220122682 +9787220122743 +9787220123368 +9787220123399 +9787220123412 +9787220123436 +9787220123535 +9787220123979 +9787220124334 +9787220125003 +9787220126413 +9787220126840 +9787220126857 +9787220126871 +9787220127489 +9787220127601 +9787220128035 +9787220129049 +9787220129414 +9787220129827 +9787220129841 +9787220130151 +9787220131844 +9787220132087 +9787220132315 +9787220132476 +9787220133039 +9787220133701 +9787220133879 +9787220134371 +9787220134562 +9787220134739 +9787220134982 +9787220135453 +9787220135569 +9787220135590 +9787220135644 +9787220135705 +9787220136030 +9787220136412 +9787220136597 +9787220136801 +9787220136955 +9787220136986 +9787220137204 +9787220137211 +9787220137242 +9787220137259 +9787220137457 +9787220137617 +9787220137648 +9787220137891 +9787220137938 +9787220137952 +9787220137969 +9787220137983 +9787220137990 +9787220138171 +9787220138256 +9787220138379 +9787220138409 +9787220138782 +9787220138812 +9787220138959 +9787220138966 +9787220139055 +9787220140358 +9787220140396 +9787220140785 +9787220141584 +9787220141652 +9787221000118 +9787221000200 +9787221000422 +9787221000835 +9787221000880 +9787221001061 +9787221001337 +9787221001351 +9787221001641 +9787221001962 +9787221002952 +9787221004048 +9787221004369 +9787221004482 +9787221004581 +9787221005779 +9787221006660 +9787221006912 +9787221006943 +9787221007117 +9787221007346 +9787221009111 +9787221009944 +9787221010186 +9787221010483 +9787221010704 +9787221011633 +9787221012272 +9787221014658 +9787221015723 +9787221019592 +9787221019844 +9787221020093 +9787221021021 +9787221021403 +9787221021519 +9787221021588 +9787221021755 +9787221024107 +9787221024602 +9787221025029 +9787221025852 +9787221025906 +9787221026347 +9787221026521 +9787221026538 +9787221026941 +9787221027436 +9787221027542 +9787221027603 +9787221027764 +9787221027979 +9787221028150 +9787221028228 +9787221028402 +9787221028655 +9787221028846 +9787221028938 +9787221029256 +9787221029423 +9787221029614 +9787221030108 +9787221030139 +9787221030153 +9787221030788 +9787221030863 +9787221031082 +9787221031358 +9787221031457 +9787221031501 +9787221031631 +9787221031679 +9787221033215 +9787221033246 +9787221033406 +9787221033512 +9787221033642 +9787221033765 +9787221033864 +9787221034076 +9787221034243 +9787221034403 +9787221034434 +9787221034458 +9787221034465 +9787221034472 +9787221034564 +9787221034571 +9787221034625 +9787221034755 +9787221034861 +9787221035134 +9787221035141 +9787221035172 +9787221035653 +9787221035790 +9787221035936 +9787221036087 +9787221036704 +9787221036735 +9787221036971 +9787221036995 +9787221037411 +9787221037855 +9787221037879 +9787221037947 +9787221038005 +9787221038012 +9787221038029 +9787221038036 +9787221038067 +9787221038081 +9787221038364 +9787221038647 +9787221038760 +9787221038784 +9787221038807 +9787221038821 +9787221038845 +9787221038852 +9787221038869 +9787221038876 +9787221038975 +9787221038982 +9787221039187 +9787221039224 +9787221039293 +9787221039309 +9787221039316 +9787221039323 +9787221039330 +9787221039378 +9787221039385 +9787221039408 +9787221039415 +9787221039507 +9787221039729 +9787221040053 +9787221040077 +9787221040091 +9787221040107 +9787221040121 +9787221040138 +9787221040152 +9787221040381 +9787221040572 +9787221040749 +9787221040831 +9787221041050 +9787221041524 +9787221041593 +9787221042248 +9787221042422 +9787221042514 +9787221042583 +9787221042668 +9787221042699 +9787221043047 +9787221043207 +9787221043290 +9787221043375 +9787221043405 +9787221043429 +9787221043610 +9787221043689 +9787221043719 +9787221043924 +9787221044006 +9787221044334 +9787221044365 +9787221044518 +9787221044716 +9787221045027 +9787221045164 +9787221045553 +9787221045652 +9787221045683 +9787221046109 +9787221046321 +9787221046451 +9787221046659 +9787221047052 +9787221047113 +9787221047427 +9787221047816 +9787221048103 +9787221048158 +9787221048318 +9787221048554 +9787221049391 +9787221049421 +9787221049520 +9787221049582 +9787221050045 +9787221051585 +9787221052001 +9787221052070 +9787221052179 +9787221053244 +9787221053473 +9787221053923 +9787221054036 +9787221054623 +9787221054753 +9787221056047 +9787221057150 +9787221057532 +9787221057921 +9787221057969 +9787221057983 +9787221058225 +9787221059086 +9787221059185 +9787221059437 +9787221060358 +9787221060679 +9787221060723 +9787221060792 +9787221061324 +9787221061775 +9787221061904 +9787221061942 +9787221062215 +9787221064790 +9787221065445 +9787221065636 +9787221065797 +9787221067166 +9787221067661 +9787221068279 +9787221068309 +9787221068736 +9787221069351 +9787221070623 +9787221070968 +9787221071583 +9787221071590 +9787221072122 +9787221072474 +9787221073259 +9787221073624 +9787221074508 +9787221074799 +9787221077653 +9787221078766 +9787221078810 +9787221079459 +9787221079916 +9787221080547 +9787221080813 +9787221081414 +9787221081520 +9787221081988 +9787221082053 +9787221082121 +9787221082893 +9787221083838 +9787221083937 +9787221084248 +9787221084262 +9787221084316 +9787221084637 +9787221084927 +9787221085788 +9787221085795 +9787221085849 +9787221085856 +9787221085863 +9787221086075 +9787221087492 +9787221087515 +9787221087577 +9787221088185 +9787221088376 +9787221088512 +9787221088970 +9787221088987 +9787221089007 +9787221089120 +9787221089458 +9787221089625 +9787221089656 +9787221090461 +9787221090492 +9787221090607 +9787221090720 +9787221091079 +9787221091543 +9787221092434 +9787221092793 +9787221093103 +9787221093110 +9787221093127 +9787221093516 +9787221093554 +9787221093561 +9787221093608 +9787221093905 +9787221093998 +9787221094346 +9787221095107 +9787221095145 +9787221095152 +9787221095169 +9787221095190 +9787221095244 +9787221095473 +9787221095619 +9787221095633 +9787221095640 +9787221095657 +9787221095916 +9787221095947 +9787221096678 +9787221096715 +9787221096869 +9787221097125 +9787221097736 +9787221098207 +9787221098832 +9787221099006 +9787221099129 +9787221099228 +9787221100009 +9787221100184 +9787221101044 +9787221102058 +9787221102201 +9787221102225 +9787221102232 +9787221102256 +9787221102294 +9787221102324 +9787221102348 +9787221102355 +9787221102393 +9787221102416 +9787221102423 +9787221102447 +9787221102553 +9787221102898 +9787221103000 +9787221103154 +9787221104649 +9787221105721 +9787221107350 +9787221108463 +9787221108555 +9787221109514 +9787221109811 +9787221110060 +9787221110084 +9787221110206 +9787221110213 +9787221110435 +9787221110473 +9787221112637 +9787221112651 +9787221114228 +9787221115218 +9787221115331 +9787221115416 +9787221115522 +9787221115584 +9787221119179 +9787221119995 +9787221120342 +9787221120540 +9787221120779 +9787221121288 +9787221121295 +9787221121530 +9787221123350 +9787221123688 +9787221123992 +9787221124456 +9787221124821 +9787221126559 +9787221126610 +9787221126641 +9787221126726 +9787221128560 +9787221129499 +9787221131508 +9787221131560 +9787221132185 +9787221134387 +9787221135148 +9787221135155 +9787221135162 +9787221135186 +9787221138958 +9787221139955 +9787221140135 +9787221142139 +9787221142580 +9787221142689 +9787221145772 +9787221146304 +9787221146472 +9787221146762 +9787221147011 +9787221147974 +9787221147998 +9787221148452 +9787221150400 +9787221150462 +9787221150509 +9787221150516 +9787221151117 +9787221151872 +9787221151902 +9787221151919 +9787221151940 +9787221152060 +9787221152077 +9787221152091 +9787221152237 +9787221152244 +9787221152268 +9787221152275 +9787221152374 +9787221152633 +9787221152923 +9787221153555 +9787221154392 +9787221154415 +9787221156228 +9787221156594 +9787221156747 +9787221157973 +9787221158291 +9787221159144 +9787221159663 +9787221160416 +9787221161819 +9787221162656 +9787221163370 +9787221163455 +9787221163875 +9787221164032 +9787221165329 +9787221165336 +9787221165343 +9787221165602 +9787221165909 +9787221166968 +9787221168887 +9787221168993 +9787221169006 +9787221170842 +9787221171993 +9787221172396 +9787221172730 +9787221173577 +9787221173584 +9787221173614 +9787221173645 +9787221173652 +9787221173669 +9787221173928 +9787221174789 +9787221175441 +9787221175960 +9787221176288 +9787221176356 +9787221176967 +9787221177162 +9787221177315 +9787221177339 +9787221177827 +9787221177889 +9787221177933 +9787221178596 +9787221178800 +9787221178909 +9787221178930 +9787221178954 +9787221179265 +9787221179296 +9787221179326 +9787221179333 +9787221179357 +9787221179418 +9787221179470 +9787221179593 +9787221179753 +9787221180087 +9787221180094 +9787221180100 +9787221180117 +9787221180322 +9787221180353 +9787221180445 +9787221180490 +9787221182302 +9787221182838 +9787221182920 +9787221183262 +9787221183538 +9787221183637 +9787221183774 +9787221184245 +9787221184665 +9787221184726 +9787221184733 +9787221185228 +9787221185297 +9787221185372 +9787221185563 +9787221186164 +9787221186232 +9787221186249 +9787221186317 +9787221186331 +9787221187727 +9787221187734 +9787221187741 +9787221187826 +9787221187994 +9787221188960 +9787221189202 +9787221189325 +9787221189394 +9787221189714 +9787222000230 +9787222000285 +9787222000292 +9787222000360 +9787222000421 +9787222000599 +9787222000643 +9787222001046 +9787222001138 +9787222001497 +9787222001589 +9787222001787 +9787222001800 +9787222001855 +9787222001893 +9787222002098 +9787222002166 +9787222002210 +9787222002234 +9787222002388 +9787222002401 +9787222002975 +9787222003149 +9787222003323 +9787222003347 +9787222004054 +9787222004092 +9787222004146 +9787222004276 +9787222004412 +9787222004580 +9787222004603 +9787222004764 +9787222005389 +9787222005471 +9787222005709 +9787222006591 +9787222006881 +9787222006966 +9787222007499 +9787222007727 +9787222007970 +9787222008144 +9787222008243 +9787222008724 +9787222009356 +9787222009431 +9787222009783 +9787222009837 +9787222009844 +9787222010086 +9787222010246 +9787222010345 +9787222010758 +9787222011038 +9787222011533 +9787222012813 +9787222013087 +9787222013452 +9787222013520 +9787222013919 +9787222013957 +9787222014015 +9787222014305 +9787222014336 +9787222014602 +9787222014831 +9787222015197 +9787222015326 +9787222015821 +9787222015845 +9787222016293 +9787222016385 +9787222016811 +9787222017313 +9787222017597 +9787222017658 +9787222017924 +9787222017993 +9787222018044 +9787222018082 +9787222018167 +9787222018303 +9787222018402 +9787222018419 +9787222018426 +9787222018433 +9787222018655 +9787222019058 +9787222019515 +9787222019898 +9787222020023 +9787222020047 +9787222020054 +9787222020078 +9787222020085 +9787222020245 +9787222021211 +9787222021228 +9787222021259 +9787222021266 +9787222021921 +9787222022843 +9787222023222 +9787222023451 +9787222023475 +9787222023499 +9787222024243 +9787222024250 +9787222024267 +9787222024281 +9787222025233 +9787222025455 +9787222025622 +9787222026087 +9787222026148 +9787222026407 +9787222026421 +9787222026469 +9787222026476 +9787222026490 +9787222026513 +9787222026568 +9787222026582 +9787222026599 +9787222026605 +9787222026629 +9787222027329 +9787222027824 +9787222027954 +9787222027985 +9787222027992 +9787222028302 +9787222028388 +9787222028814 +9787222029408 +9787222029453 +9787222030114 +9787222030244 +9787222030275 +9787222030596 +9787222030602 +9787222030701 +9787222031227 +9787222032088 +9787222032453 +9787222032576 +9787222032910 +9787222033061 +9787222033771 +9787222033900 +9787222034297 +9787222034327 +9787222034396 +9787222034495 +9787222035065 +9787222035362 +9787222035775 +9787222035867 +9787222036604 +9787222036970 +9787222037571 +9787222037830 +9787222038660 +9787222039346 +9787222039582 +9787222040250 +9787222040687 +9787222042001 +9787222042285 +9787222042292 +9787222042964 +9787222043411 +9787222044043 +9787222044371 +9787222045576 +9787222047129 +9787222047136 +9787222047396 +9787222047600 +9787222047648 +9787222048379 +9787222049826 +9787222050143 +9787222050174 +9787222051508 +9787222052093 +9787222052819 +9787222053502 +9787222053519 +9787222053540 +9787222055605 +9787222056114 +9787222056183 +9787222057715 +9787222057869 +9787222058767 +9787222059245 +9787222059313 +9787222060791 +9787222061651 +9787222062719 +9787222063105 +9787222063228 +9787222063570 +9787222063662 +9787222063686 +9787222063914 +9787222064850 +9787222066502 +9787222066533 +9787222066632 +9787222066670 +9787222066960 +9787222067769 +9787222068322 +9787222068391 +9787222068476 +9787222068544 +9787222068612 +9787222068711 +9787222070455 +9787222071445 +9787222071797 +9787222073166 +9787222073593 +9787222073708 +9787222073913 +9787222077041 +9787222077140 +9787222077591 +9787222080010 +9787222080058 +9787222080324 +9787222080652 +9787222080768 +9787222081437 +9787222082144 +9787222082465 +9787222082939 +9787222083097 +9787222083462 +9787222083578 +9787222083882 +9787222083950 +9787222084926 +9787222085060 +9787222085572 +9787222086302 +9787222086920 +9787222087002 +9787222087460 +9787222087552 +9787222088412 +9787222088429 +9787222088498 +9787222088665 +9787222088764 +9787222088887 +9787222089969 +9787222090491 +9787222090514 +9787222091085 +9787222091108 +9787222091412 +9787222091801 +9787222091870 +9787222093195 +9787222098060 +9787222098329 +9787222098381 +9787222098435 +9787222102408 +9787222103207 +9787222103559 +9787222104242 +9787222104402 +9787222104815 +9787222104822 +9787222107328 +9787222108264 +9787222111646 +9787222111707 +9787222112094 +9787222112414 +9787222112827 +9787222113091 +9787222113497 +9787222113985 +9787222114876 +9787222116542 +9787222117631 +9787222117815 +9787222120396 +9787222120938 +9787222121683 +9787222122291 +9787222122383 +9787222122529 +9787222124660 +9787222124851 +9787222124912 +9787222125018 +9787222127661 +9787222128187 +9787222128286 +9787222128491 +9787222128637 +9787222128774 +9787222131446 +9787222132177 +9787222141100 +9787222144033 +9787222145474 +9787222162938 +9787222163591 +9787222163928 +9787222163966 +9787222165496 +9787222171701 +9787222174665 +9787222175310 +9787222179820 +9787222181519 +9787222182219 +9787222182363 +9787222182424 +9787222182431 +9787222182752 +9787222185388 +9787222188457 +9787222192140 +9787222192690 +9787222193185 +9787222193550 +9787222193680 +9787222194090 +9787222196643 +9787222197138 +9787222197886 +9787222198777 +9787222199088 +9787222201088 +9787222201651 +9787222203013 +9787222203044 +9787222204737 +9787222206533 +9787222207639 +9787222207868 +9787222209657 +9787222209701 +9787222210141 +9787222210646 +9787222210844 +9787222211568 +9787222211797 +9787222212978 +9787222213258 +9787222213845 +9787222214699 +9787222214743 +9787222214828 +9787222214996 +9787222215047 +9787222215146 +9787222215207 +9787222215283 +9787222215320 +9787222215870 +9787222217959 +9787222218642 +9787222219526 +9787222221246 +9787222221710 +9787222222137 +9787222222649 +9787222223684 +9787222223974 +9787222224049 +9787222224414 +9787222225275 +9787222225985 +9787222226180 +9787222227415 +9787222227491 +9787222229815 +9787222229891 +9787222230323 +9787222230415 +9787222231559 +9787222231610 +9787222233461 +9787222234963 +9787222235519 +9787222236424 +9787222236646 +9787222236684 +9787222237421 +9787222237728 +9787222406520 +9787223000055 +9787223003537 +9787223003834 +9787223004206 +9787223004558 +9787223005272 +9787223005722 +9787223006026 +9787223006316 +9787223007061 +9787223007245 +9787223007610 +9787223009027 +9787223009034 +9787223009041 +9787223009058 +9787223009140 +9787223009386 +9787223009447 +9787223009539 +9787223009546 +9787223009553 +9787223009577 +9787223009690 +9787223009775 +9787223009829 +9787223009836 +9787223009843 +9787223009911 +9787223010047 +9787223011037 +9787223011549 +9787223011556 +9787223011570 +9787223011624 +9787223011709 +9787223012300 +9787223012645 +9787223013055 +9787223013079 +9787223013086 +9787223014267 +9787223015349 +9787223015783 +9787223016612 +9787223017879 +9787223019040 +9787223019729 +9787223020510 +9787223020916 +9787223022569 +9787223022897 +9787223022996 +9787223023009 +9787223024433 +9787223025010 +9787223027359 +9787223028202 +9787223028349 +9787223028356 +9787223028660 +9787223028776 +9787223029896 +9787223030021 +9787223031417 +9787223031868 +9787223032704 +9787223033084 +9787223035620 +9787223035637 +9787223036405 +9787223037693 +9787223039956 +9787223043779 +9787223047159 +9787223056557 +9787223056564 +9787223056748 +9787223058407 +9787223059718 +9787223062091 +9787223064422 +9787223070072 +9787223072359 +9787223073196 +9787223076913 +9787223098298 +9787224000009 +9787224000160 +9787224000788 +9787224000887 +9787224000900 +9787224001495 +9787224001563 +9787224001587 +9787224001945 +9787224002195 +9787224002560 +9787224002850 +9787224003505 +9787224003765 +9787224003826 +9787224004212 +9787224004410 +9787224004984 +9787224005141 +9787224005158 +9787224005493 +9787224005509 +9787224005523 +9787224005868 +9787224005875 +9787224006278 +9787224006353 +9787224007183 +9787224007480 +9787224007879 +9787224008210 +9787224008876 +9787224008999 +9787224009644 +9787224010633 +9787224010831 +9787224010909 +9787224011500 +9787224012514 +9787224012675 +9787224013290 +9787224013870 +9787224013962 +9787224014617 +9787224014631 +9787224015850 +9787224016222 +9787224016536 +9787224016864 +9787224017489 +9787224017564 +9787224017953 +9787224018035 +9787224018066 +9787224018851 +9787224019346 +9787224019452 +9787224019834 +9787224020335 +9787224020649 +9787224020717 +9787224020878 +9787224021080 +9787224021202 +9787224021462 +9787224021707 +9787224022469 +9787224022643 +9787224022810 +9787224022872 +9787224022957 +9787224023626 +9787224023701 +9787224024326 +9787224024906 +9787224025378 +9787224026153 +9787224026863 +9787224027372 +9787224027655 +9787224027891 +9787224028287 +9787224028676 +9787224028805 +9787224029086 +9787224029116 +9787224029918 +9787224030075 +9787224030990 +9787224031010 +9787224031942 +9787224032185 +9787224034035 +9787224034271 +9787224034554 +9787224034660 +9787224034691 +9787224034776 +9787224034783 +9787224034875 +9787224035179 +9787224035384 +9787224035421 +9787224035476 +9787224035896 +9787224036091 +9787224036367 +9787224036770 +9787224037029 +9787224037050 +9787224037074 +9787224037173 +9787224037272 +9787224037296 +9787224037432 +9787224037555 +9787224037623 +9787224037661 +9787224037678 +9787224037760 +9787224037883 +9787224037982 +9787224038194 +9787224038286 +9787224038385 +9787224038491 +9787224038866 +9787224038996 +9787224039252 +9787224039269 +9787224039740 +9787224040715 +9787224041194 +9787224041316 +9787224041545 +9787224041583 +9787224041637 +9787224041989 +9787224042177 +9787224042245 +9787224042481 +9787224042498 +9787224043204 +9787224043518 +9787224043723 +9787224043785 +9787224044591 +9787224044966 +9787224045406 +9787224045420 +9787224045611 +9787224045628 +9787224046243 +9787224046274 +9787224046304 +9787224046601 +9787224046809 +9787224047073 +9787224048209 +9787224048605 +9787224049008 +9787224049404 +9787224049459 +9787224049886 +9787224050356 +9787224050912 +9787224052091 +9787224052251 +9787224052299 +9787224052558 +9787224052626 +9787224052657 +9787224053401 +9787224053647 +9787224053890 +9787224054286 +9787224054309 +9787224055177 +9787224055184 +9787224056068 +9787224057409 +9787224057423 +9787224058727 +9787224058840 +9787224059816 +9787224060102 +9787224061031 +9787224061055 +9787224061413 +9787224061505 +9787224061543 +9787224061710 +9787224061857 +9787224062106 +9787224062434 +9787224062526 +9787224063417 +9787224064544 +9787224064889 +9787224064957 +9787224065015 +9787224065077 +9787224065107 +9787224065275 +9787224066067 +9787224066258 +9787224066296 +9787224067408 +9787224067750 +9787224067880 +9787224068122 +9787224068320 +9787224069495 +9787224069617 +9787224070422 +9787224072044 +9787224072150 +9787224072235 +9787224072716 +9787224073546 +9787224073560 +9787224075779 +9787224077971 +9787224079524 +9787224079654 +9787224079821 +9787224080285 +9787224081251 +9787224082104 +9787224082524 +9787224082791 +9787224083231 +9787224083910 +9787224085099 +9787224085310 +9787224086782 +9787224087000 +9787224087062 +9787224087420 +9787224087888 +9787224088342 +9787224089776 +9787224090642 +9787224090833 +9787224090857 +9787224092462 +9787224092837 +9787224092875 +9787224093735 +9787224093902 +9787224094190 +9787224095227 +9787224095616 +9787224095999 +9787224096354 +9787224096613 +9787224096705 +9787224096910 +9787224097108 +9787224097641 +9787224097696 +9787224098075 +9787224098082 +9787224098358 +9787224098426 +9787224098730 +9787224099119 +9787224099546 +9787224100419 +9787224101003 +9787224101157 +9787224101492 +9787224101904 +9787224102116 +9787224103731 +9787224104110 +9787224104127 +9787224104479 +9787224104929 +9787224105193 +9787224105889 +9787224105940 +9787224106121 +9787224108354 +9787224108613 +9787224108637 +9787224111385 +9787224111736 +9787224112344 +9787224112696 +9787224113037 +9787224113303 +9787224113327 +9787224113884 +9787224114010 +9787224114393 +9787224115109 +9787224115499 +9787224116564 +9787224116748 +9787224117622 +9787224117714 +9787224117738 +9787224117974 +9787224118353 +9787224119060 +9787224119251 +9787224119411 +9787224119824 +9787224124699 +9787224124965 +9787224125320 +9787224125917 +9787224127935 +9787224129311 +9787224131253 +9787224131307 +9787224131345 +9787224131352 +9787224131895 +9787224133158 +9787224134469 +9787224135961 +9787224137217 +9787224138054 +9787224138917 +9787224140682 +9787224140798 +9787224141955 +9787224143560 +9787224143867 +9787224144413 +9787224144420 +9787224148282 +9787224148305 +9787224149234 +9787224149548 +9787224149906 +9787224149920 +9787224151268 +9787224151602 +9787224152005 +9787224152029 +9787224152326 +9787224152463 +9787224152616 +9787224153224 +9787224153965 +9787224154344 +9787224154658 +9787224154986 +9787224155143 +9787224155549 +9787224155686 +9787225000497 +9787225000848 +9787225000886 +9787225001456 +9787225001586 +9787225001685 +9787225001944 +9787225002187 +9787225002484 +9787225002644 +9787225003207 +9787225003788 +9787225003894 +9787225004082 +9787225004266 +9787225004488 +9787225004655 +9787225004679 +9787225005072 +9787225005126 +9787225005324 +9787225005713 +9787225005829 +9787225006437 +9787225006499 +9787225006758 +9787225006765 +9787225006772 +9787225006789 +9787225006796 +9787225006826 +9787225007076 +9787225007083 +9787225007120 +9787225007328 +9787225007526 +9787225007694 +9787225008288 +9787225009247 +9787225009346 +9787225009582 +9787225009681 +9787225010175 +9787225010182 +9787225010250 +9787225010748 +9787225010755 +9787225010809 +9787225010854 +9787225010885 +9787225010915 +9787225010922 +9787225010939 +9787225010946 +9787225010984 +9787225011028 +9787225011059 +9787225011066 +9787225011073 +9787225011080 +9787225011097 +9787225011172 +9787225011295 +9787225011356 +9787225011363 +9787225011387 +9787225011394 +9787225011431 +9787225011578 +9787225011622 +9787225011639 +9787225011677 +9787225011684 +9787225011783 +9787225011837 +9787225011882 +9787225012544 +9787225012674 +9787225013046 +9787225013435 +9787225013633 +9787225013831 +9787225013848 +9787225013916 +9787225013930 +9787225013954 +9787225013992 +9787225014012 +9787225014029 +9787225014074 +9787225014166 +9787225014203 +9787225014326 +9787225014333 +9787225014470 +9787225014524 +9787225014616 +9787225014647 +9787225014692 +9787225014739 +9787225014852 +9787225015019 +9787225015040 +9787225015057 +9787225015163 +9787225015200 +9787225015248 +9787225015279 +9787225015330 +9787225015422 +9787225015491 +9787225015545 +9787225015583 +9787225015620 +9787225015668 +9787225015972 +9787225015989 +9787225016061 +9787225016078 +9787225016115 +9787225016238 +9787225016399 +9787225016573 +9787225016627 +9787225016740 +9787225016900 +9787225016924 +9787225016931 +9787225016979 +9787225016986 +9787225016993 +9787225017013 +9787225017020 +9787225017099 +9787225017105 +9787225017280 +9787225017310 +9787225017327 +9787225017563 +9787225017617 +9787225018287 +9787225018584 +9787225018928 +9787225019086 +9787225019093 +9787225019178 +9787225019376 +9787225020150 +9787225020433 +9787225021201 +9787225022475 +9787225022666 +9787225022772 +9787225023229 +9787225023304 +9787225023540 +9787225023908 +9787225024356 +9787225024547 +9787225024615 +9787225025346 +9787225025858 +9787225026602 +9787225026626 +9787225026633 +9787225027067 +9787225028323 +9787225028675 +9787225028842 +9787225032160 +9787225032948 +9787225033945 +9787225035796 +9787225036168 +9787225036878 +9787225037516 +9787225038339 +9787225039138 +9787225039183 +9787225039381 +9787225039428 +9787225039930 +9787225040004 +9787225040196 +9787225040202 +9787225046327 +9787225047218 +9787225049311 +9787225050713 +9787225051741 +9787225053271 +9787225053363 +9787225065151 +9787225065472 +9787225067544 +9787225067643 +9787225068152 +9787225133225 +9787226000052 +9787226000106 +9787226000144 +9787226000366 +9787226000533 +9787226000601 +9787226000618 +9787226000632 +9787226000700 +9787226001004 +9787226001080 +9787226001233 +9787226001257 +9787226001424 +9787226001479 +9787226001486 +9787226001660 +9787226001769 +9787226001790 +9787226001820 +9787226001899 +9787226001950 +9787226002025 +9787226002056 +9787226002582 +9787226002643 +9787226002667 +9787226002704 +9787226002865 +9787226003206 +9787226003268 +9787226003312 +9787226003480 +9787226003558 +9787226003794 +9787226003831 +9787226003992 +9787226004159 +9787226004753 +9787226004760 +9787226004807 +9787226005026 +9787226005828 +9787226005927 +9787226006016 +9787226006252 +9787226006337 +9787226006399 +9787226007525 +9787226007532 +9787226007549 +9787226007716 +9787226007822 +9787226007983 +9787226008553 +9787226009147 +9787226009390 +9787226009444 +9787226009918 +9787226010099 +9787226010303 +9787226010495 +9787226010549 +9787226011478 +9787226011591 +9787226011720 +9787226012345 +9787226012758 +9787226012802 +9787226012888 +9787226012970 +9787226013038 +9787226013151 +9787226013410 +9787226013472 +9787226013618 +9787226013762 +9787226013816 +9787226013878 +9787226013885 +9787226013922 +9787226013960 +9787226014189 +9787226014424 +9787226014479 +9787226014639 +9787226014752 +9787226015186 +9787226015308 +9787226015681 +9787226015810 +9787226015834 +9787226015889 +9787226016015 +9787226016268 +9787226016725 +9787226017081 +9787226017166 +9787226017326 +9787226017388 +9787226017418 +9787226017722 +9787226017944 +9787226018323 +9787226018392 +9787226018606 +9787226019122 +9787226019481 +9787226019511 +9787226019818 +9787226020005 +9787226020289 +9787226020647 +9787226020821 +9787226021859 +9787226021958 +9787226022122 +9787226022160 +9787226022382 +9787226022597 +9787226022962 +9787226023303 +9787226023310 +9787226023327 +9787226023372 +9787226023563 +9787226023853 +9787226023938 +9787226024386 +9787226024430 +9787226024836 +9787226025291 +9787226026298 +9787226027127 +9787226027677 +9787226027813 +9787226027837 +9787226028537 +9787226028957 +9787226029718 +9787226031841 +9787226032398 +9787226032466 +9787226032817 +9787226033418 +9787226034149 +9787226034279 +9787226035542 +9787226035993 +9787226037072 +9787226037171 +9787226038819 +9787226040393 +9787226041161 +9787226042922 +9787226043868 +9787226046524 +9787226048016 +9787226050217 +9787226051481 +9787226052938 +9787226055762 +9787226056158 +9787226058367 +9787226059289 +9787226060148 +9787226060421 +9787226060438 +9787226061121 +9787226061244 +9787226062067 +9787227000099 +9787227000655 +9787227001737 +9787227001768 +9787227001867 +9787227001881 +9787227002086 +9787227002383 +9787227002437 +9787227002482 +9787227002864 +9787227002888 +9787227003090 +9787227003182 +9787227003632 +9787227003960 +9787227004394 +9787227005223 +9787227005247 +9787227006152 +9787227006916 +9787227006978 +9787227007128 +9787227007722 +9787227007753 +9787227007852 +9787227008200 +9787227008231 +9787227008378 +9787227009320 +9787227009351 +9787227009986 +9787227010692 +9787227010746 +9787227010814 +9787227011194 +9787227011231 +9787227012245 +9787227012269 +9787227012474 +9787227012504 +9787227012528 +9787227012535 +9787227012580 +9787227012634 +9787227012641 +9787227012825 +9787227012931 +9787227012955 +9787227012986 +9787227013037 +9787227013044 +9787227013150 +9787227013167 +9787227013181 +9787227013198 +9787227013310 +9787227013457 +9787227013822 +9787227013846 +9787227013938 +9787227014195 +9787227014478 +9787227014744 +9787227014775 +9787227014782 +9787227014843 +9787227014881 +9787227014959 +9787227014966 +9787227014980 +9787227015253 +9787227015895 +9787227015901 +9787227015963 +9787227016052 +9787227016519 +9787227016649 +9787227016861 +9787227017165 +9787227017400 +9787227017509 +9787227017912 +9787227018032 +9787227018094 +9787227018353 +9787227018827 +9787227019343 +9787227019732 +9787227019794 +9787227020769 +9787227021605 +9787227021711 +9787227021834 +9787227021841 +9787227021988 +9787227022343 +9787227022534 +9787227022558 +9787227022732 +9787227022909 +9787227022916 +9787227023845 +9787227023913 +9787227025658 +9787227026761 +9787227026877 +9787227027263 +9787227027713 +9787227028253 +9787227028284 +9787227028642 +9787227028734 +9787227030836 +9787227031338 +9787227031864 +9787227032168 +9787227038061 +9787227041795 +9787227043119 +9787227045014 +9787227046233 +9787227046783 +9787227047483 +9787227047896 +9787227047933 +9787227053378 +9787227058878 +9787227060994 +9787227061373 +9787227062233 +9787227068815 +9787227068822 +9787227070603 +9787227070757 +9787227071778 +9787227072218 +9787227072287 +9787227072416 +9787227072904 +9787227072928 +9787227073703 +9787227075325 +9787227077350 +9787227077718 +9787227078791 +9787227080183 +9787227080213 +9787227081739 +9787228000586 +9787228000623 +9787228003297 +9787228004003 +9787228008186 +9787228008360 +9787228014927 +9787228019427 +9787228021635 +9787228025329 +9787228030507 +9787228032327 +9787228032358 +9787228032402 +9787228033478 +9787228034208 +9787228035502 +9787228035823 +9787228035878 +9787228035885 +9787228035892 +9787228035946 +9787228036165 +9787228036318 +9787228036448 +9787228036462 +9787228036547 +9787228036554 +9787228036585 +9787228036592 +9787228036660 +9787228036677 +9787228036684 +9787228036868 +9787228036899 +9787228036912 +9787228039432 +9787228040292 +9787228040933 +9787228040940 +9787228041381 +9787228042029 +9787228042111 +9787228042326 +9787228043101 +9787228044252 +9787228044733 +9787228045402 +9787228046799 +9787228046881 +9787228047468 +9787228047864 +9787228048601 +9787228048625 +9787228048632 +9787228048649 +9787228048687 +9787228049691 +9787228049806 +9787228050185 +9787228051083 +9787228051090 +9787228051434 +9787228051595 +9787228051632 +9787228053186 +9787228053346 +9787228053926 +9787228054275 +9787228055692 +9787228056613 +9787228056637 +9787228057177 +9787228057283 +9787228057467 +9787228058013 +9787228058969 +9787228059188 +9787228060092 +9787228060337 +9787228060344 +9787228060498 +9787228060504 +9787228060511 +9787228060528 +9787228060542 +9787228060559 +9787228060566 +9787228060573 +9787228060580 +9787228060597 +9787228060610 +9787228060894 +9787228060924 +9787228061235 +9787228061846 +9787228061921 +9787228062133 +9787228062324 +9787228062461 +9787228062478 +9787228063567 +9787228063673 +9787228063765 +9787228063789 +9787228064724 +9787228064984 +9787228065134 +9787228065400 +9787228065936 +9787228065998 +9787228066162 +9787228067459 +9787228067763 +9787228067862 +9787228068234 +9787228068753 +9787228068999 +9787228069354 +9787228069385 +9787228069804 +9787228070022 +9787228070039 +9787228070114 +9787228070237 +9787228070398 +9787228070411 +9787228070619 +9787228070909 +9787228070947 +9787228071036 +9787228071388 +9787228071579 +9787228071685 +9787228072712 +9787228073078 +9787228073092 +9787228073252 +9787228073849 +9787228074006 +9787228074198 +9787228074808 +9787228075072 +9787228075645 +9787228075751 +9787228075966 +9787228075973 +9787228077182 +9787228077618 +9787228078189 +9787228079650 +9787228080595 +9787228080762 +9787228080885 +9787228081455 +9787228082322 +9787228082490 +9787228083220 +9787228083763 +9787228084166 +9787228084449 +9787228084746 +9787228084814 +9787228085040 +9787228085132 +9787228085293 +9787228085781 +9787228086559 +9787228086610 +9787228087105 +9787228087440 +9787228087846 +9787228089772 +9787228089901 +9787228091454 +9787228093854 +9787228094585 +9787228094592 +9787228096121 +9787228102150 +9787228102853 +9787228103317 +9787228104666 +9787228109616 +9787228109685 +9787228110759 +9787228116515 +9787228118540 +9787228121038 +9787228121267 +9787228123728 +9787228130283 +9787228132966 +9787228140749 +9787228142255 +9787228142750 +9787228143245 +9787228144211 +9787228145799 +9787228148646 +9787228150342 +9787228150656 +9787228151011 +9787228152445 +9787228152711 +9787228154982 +9787228155965 +9787228163564 +9787228165544 +9787228170661 +9787228172146 +9787228172313 +9787228172610 +9787228173860 +9787228174133 +9787228175925 +9787228176571 +9787228176670 +9787228176809 +9787228176816 +9787228177905 +9787228183111 +9787228185559 +9787228186327 +9787228193929 +9787228207053 +9787228207084 +9787228208449 +9787228209354 +9787228209385 +9787228211173 +9787228211210 +9787228211241 +9787228211579 +9787228213719 +9787229000202 +9787229001650 +9787229001902 +9787229002909 +9787229003609 +9787229003647 +9787229003753 +9787229003777 +9787229004026 +9787229004743 +9787229005900 +9787229005917 +9787229007935 +9787229009854 +9787229011277 +9787229012748 +9787229012892 +9787229012946 +9787229015411 +9787229019365 +9787229019426 +9787229019488 +9787229020552 +9787229023447 +9787229023690 +9787229024239 +9787229025496 +9787229029913 +9787229030506 +9787229031251 +9787229031565 +9787229035839 +9787229038373 +9787229040437 +9787229041250 +9787229041526 +9787229042134 +9787229042714 +9787229045364 +9787229045791 +9787229047191 +9787229047528 +9787229048358 +9787229048792 +9787229050290 +9787229053444 +9787229054410 +9787229056056 +9787229057107 +9787229057602 +9787229058722 +9787229059460 +9787229060220 +9787229061524 +9787229065003 +9787229065300 +9787229065898 +9787229067601 +9787229068387 +9787229069476 +9787229070274 +9787229070632 +9787229071943 +9787229074760 +9787229075446 +9787229076511 +9787229076566 +9787229077419 +9787229078102 +9787229078140 +9787229078812 +9787229080488 +9787229082833 +9787229084912 +9787229085155 +9787229087470 +9787229087784 +9787229088446 +9787229088644 +9787229088989 +9787229089580 +9787229091729 +9787229091781 +9787229094348 +9787229094447 +9787229094744 +9787229096014 +9787229098384 +9787229100629 +9787229101589 +9787229106638 +9787229109691 +9787229109868 +9787229110505 +9787229111847 +9787229113803 +9787229114824 +9787229115326 +9787229115678 +9787229116637 +9787229120528 +9787229120757 +9787229121617 +9787229121860 +9787229122607 +9787229124052 +9787229125691 +9787229125820 +9787229126742 +9787229127046 +9787229127084 +9787229131180 +9787229131685 +9787229135614 +9787229137120 +9787229137953 +9787229140137 +9787229142032 +9787229142315 +9787229143794 +9787229144050 +9787229144326 +9787229152185 +9787229155834 +9787229156046 +9787229159146 +9787229159726 +9787229162153 +9787229163204 +9787229163648 +9787229163679 +9787229163891 +9787229164751 +9787229164782 +9787229164799 +9787229164874 +9787229164904 +9787229164973 +9787229166663 +9787229166847 +9787229167622 +9787229171476 +9787229171551 +9787229171827 +9787229172886 +9787229173401 +9787229174484 +9787229174996 +9787229175351 +9787229175986 +9787229176129 +9787229176488 +9787229176853 +9787229177393 +9787229177607 +9787229178031 +9787229178345 +9787229179229 +9787229180409 +9787229180652 +9787229183189 +9787229183790 +9787229183974 +9787229184117 +9787229184223 +9787229184261 +9787229184865 +9787229184919 +9787229185152 +9787229185800 +9787229185817 +9787229185886 +9787229186296 +9787229186456 +9787229186883 +9787229187545 +9787229187873 +9787229187897 +9787229187903 +9787229187989 +9787229188214 +9787229188566 +9787229188658 +9787229188894 +9787229188900 +9787229189983 +9787229190033 +9787229190132 +9787229190170 +9787229190224 +9787229190491 +9787229190507 +9787229191085 +9787229191115 +9787229191276 +9787229191580 +9787229191733 +9787229191818 +9787229191832 +9787229191849 +9787229192464 +9787229192549 +9787229193034 +9787229194215 +9787229194628 +9787229195564 +9787229201142 +9787229203085 +9787229207137 +9787230000222 +9787230000406 +9787230000413 +9787230001625 +9787230002240 +9787230002790 +9787230003063 +9787230003995 +9787230005524 +9787230005548 +9787230006439 +9787230006767 +9787230007238 +9787230007382 +9787230010535 +9787230011808 +9787230014748 +9787230015172 +9787230015370 +9787230015387 +9787230017794 +9787230019682 +9787230021272 +9787230021647 +9787230025850 +9787230025874 +9787230027366 +9787230028479 +9787230028486 +9787230028738 +9787230028745 +9787230028837 +9787230028844 +9787230028868 +9787230029261 +9787230034913 +9787230034951 +9787230034982 +9787230041836 +9787230044158 +9787230044288 +9787230050050 +9787230050333 +9787230051781 +9787230052627 +9787230053570 +9787230054508 +9787230055925 +9787230057530 +9787230060073 +9787230061711 +9787230065689 +9787230067645 +9787230070461 +9787230080750 +9787231000498 +9787231008395 +9787246986411 +9787250634124 +9787254623179 +9787258055860 +9787258055884 +9787288079652 +9787288087824 +9787300000022 +9787300000046 +9787300000121 +9787300000176 +9787300000220 +9787300000701 +9787300000749 +9787300000817 +9787300000824 +9787300001296 +9787300001463 +9787300001470 +9787300001487 +9787300001548 +9787300001678 +9787300001852 +9787300001920 +9787300002156 +9787300002163 +9787300002255 +9787300002309 +9787300002361 +9787300002422 +9787300002552 +9787300002569 +9787300002583 +9787300002859 +9787300002958 +9787300003054 +9787300003146 +9787300003818 +9787300003863 +9787300003986 +9787300004037 +9787300004358 +9787300004556 +9787300004617 +9787300004624 +9787300004709 +9787300004990 +9787300005003 +9787300005010 +9787300005164 +9787300005270 +9787300005560 +9787300005669 +9787300005980 +9787300006345 +9787300006383 +9787300006413 +9787300006840 +9787300006857 +9787300006888 +9787300007106 +9787300007502 +9787300007854 +9787300008240 +9787300008257 +9787300008271 +9787300008424 +9787300009131 +9787300009155 +9787300009209 +9787300009414 +9787300009681 +9787300009865 +9787300009872 +9787300009957 +9787300010137 +9787300010175 +9787300010212 +9787300010304 +9787300010366 +9787300010465 +9787300010533 +9787300010618 +9787300010755 +9787300010762 +9787300010854 +9787300011127 +9787300011141 +9787300011202 +9787300011400 +9787300011417 +9787300011639 +9787300011790 +9787300011813 +9787300011844 +9787300011851 +9787300011882 +9787300012599 +9787300012759 +9787300012841 +9787300013336 +9787300013350 +9787300013473 +9787300013930 +9787300013985 +9787300013992 +9787300014081 +9787300014173 +9787300014197 +9787300014289 +9787300014906 +9787300014920 +9787300015040 +9787300015064 +9787300015248 +9787300015347 +9787300015408 +9787300015422 +9787300015477 +9787300015521 +9787300016221 +9787300016351 +9787300016436 +9787300016528 +9787300016597 +9787300016603 +9787300016719 +9787300017525 +9787300018287 +9787300018355 +9787300018560 +9787300018690 +9787300018706 +9787300019086 +9787300019383 +9787300019536 +9787300019574 +9787300020488 +9787300020495 +9787300020532 +9787300020624 +9787300021065 +9787300021386 +9787300021546 +9787300021669 +9787300021706 +9787300021737 +9787300021935 +9787300022000 +9787300022048 +9787300022178 +9787300023472 +9787300023649 +9787300024325 +9787300024707 +9787300025353 +9787300025407 +9787300025681 +9787300026008 +9787300026442 +9787300026589 +9787300026626 +9787300027197 +9787300028132 +9787300028422 +9787300028545 +9787300028583 +9787300028644 +9787300029115 +9787300029245 +9787300029542 +9787300029764 +9787300030203 +9787300031064 +9787300031231 +9787300031385 +9787300031934 +9787300032054 +9787300032221 +9787300032726 +9787300034140 +9787300034287 +9787300034805 +9787300035185 +9787300035376 +9787300035802 +9787300035826 +9787300036014 +9787300036021 +9787300036847 +9787300037301 +9787300037554 +9787300037592 +9787300037738 +9787300038544 +9787300038773 +9787300039206 +9787300039794 +9787300039961 +9787300040110 +9787300040806 +9787300040974 +9787300041018 +9787300043470 +9787300043517 +9787300044439 +9787300045740 +9787300046853 +9787300050102 +9787300052182 +9787300053721 +9787300054230 +9787300054643 +9787300055374 +9787300057149 +9787300057194 +9787300058764 +9787300059488 +9787300060224 +9787300063782 +9787300067124 +9787300067155 +9787300070278 +9787300070322 +9787300070742 +9787300073095 +9787300074207 +9787300074832 +9787300078687 +9787300079448 +9787300085883 +9787300086194 +9787300091655 +9787300092768 +9787300095752 +9787300096896 +9787300097022 +9787300097695 +9787300098548 +9787300100180 +9787300103730 +9787300104553 +9787300108858 +9787300109565 +9787300114323 +9787300114361 +9787300116303 +9787300122151 +9787300122878 +9787300122922 +9787300124735 +9787300125077 +9787300128443 +9787300129785 +9787300132655 +9787300133843 +9787300137681 +9787300138725 +9787300143026 +9787300143163 +9787300143446 +9787300144351 +9787300151632 +9787300153100 +9787300154091 +9787300157955 +9787300161266 +9787300162577 +9787300167336 +9787300168555 +9787300171715 +9787300177526 +9787300177724 +9787300187488 +9787300187624 +9787300187778 +9787300193212 +9787300196480 +9787300197265 +9787300199993 +9787300202044 +9787300206127 +9787300207865 +9787300210889 +9787300218854 +9787300227467 +9787300234496 +9787300236186 +9787300237695 +9787300240220 +9787300241098 +9787300241135 +9787300245485 +9787300246062 +9787300246222 +9787300246468 +9787300246505 +9787300246604 +9787300249575 +9787300249896 +9787300251929 +9787300252056 +9787300254241 +9787300257341 +9787300257808 +9787300260587 +9787300262406 +9787300266404 +9787300269153 +9787300271057 +9787300271521 +9787300271835 +9787300273679 +9787300274027 +9787300274669 +9787300275024 +9787300277516 +9787300277868 +9787300277998 +9787300278179 +9787300279039 +9787300280974 +9787300282824 +9787300287508 +9787300290560 +9787300293530 +9787300294810 +9787300295060 +9787300296807 +9787300297439 +9787300299204 +9787300299730 +9787300303451 +9787300304908 +9787300306261 +9787300309200 +9787300310411 +9787300312507 +9787300313375 +9787300314945 +9787300315461 +9787300317632 +9787300317793 +9787300318011 +9787300318349 +9787300318752 +9787300318882 +9787300319056 +9787300319667 +9787300319780 +9787300319872 +9787300319995 +9787300321639 +9787300321851 +9787300321998 +9787300322087 +9787300323183 +9787300323565 +9787300324418 +9787300324821 +9787300325033 +9787300325583 +9787300325750 +9787300325941 +9787300326108 +9787300326139 +9787300326153 +9787300326214 +9787300326238 +9787300326467 +9787300326580 +9787300326702 +9787300326757 +9787300326764 +9787300326870 +9787300326887 +9787300327044 +9787300327051 +9787300327099 +9787300327440 +9787300327495 +9787300327518 +9787300327532 +9787300327570 +9787300327648 +9787300327846 +9787300327853 +9787300327952 +9787300328171 +9787300328324 +9787300328393 +9787300328409 +9787300328423 +9787300328461 +9787300328478 +9787300328645 +9787300328676 +9787300328690 +9787300328737 +9787300328751 +9787300329109 +9787300329673 +9787300329680 +9787300329697 +9787300329758 +9787300329840 +9787300329956 +9787300329970 +9787300330174 +9787300330419 +9787300330440 +9787300330525 +9787300330624 +9787300330655 +9787300330785 +9787300330877 +9787300331096 +9787300331393 +9787300331515 +9787300331584 +9787300331676 +9787300331690 +9787300331829 +9787300331867 +9787300332048 +9787300332147 +9787300332192 +9787300332284 +9787300332482 +9787300332536 +9787300332567 +9787300332604 +9787300332796 +9787300332833 +9787300333014 +9787300333144 +9787300333304 +9787300333441 +9787300333489 +9787300333588 +9787300333625 +9787300333939 +9787300333991 +9787300334004 +9787300334028 +9787300334394 +9787300334479 +9787300334592 +9787300334639 +9787300334646 +9787300334691 +9787300334776 +9787300334783 +9787300334882 +9787300335377 +9787300335629 +9787300335667 +9787300335759 +9787300336015 +9787300336329 +9787300336466 +9787300336657 +9787300336664 +9787300336978 +9787300337029 +9787300337104 +9787300337142 +9787300337302 +9787300337395 +9787300337593 +9787300338293 +9787300338590 +9787300338620 +9787300339634 +9787300340289 +9787300340715 +9787300341484 +9787300341620 +9787300342597 +9787300344256 +9787301000090 +9787301000175 +9787301000199 +9787301000212 +9787301000236 +9787301000243 +9787301000274 +9787301000298 +9787301000441 +9787301000663 +9787301000885 +9787301001196 +9787301001202 +9787301001271 +9787301001646 +9787301002612 +9787301002919 +9787301002964 +9787301003121 +9787301003213 +9787301003374 +9787301003718 +9787301004548 +9787301004722 +9787301005125 +9787301005255 +9787301005279 +9787301005361 +9787301005408 +9787301005422 +9787301005545 +9787301005569 +9787301005705 +9787301006191 +9787301006238 +9787301006498 +9787301007495 +9787301007617 +9787301007969 +9787301008157 +9787301008249 +9787301008867 +9787301008935 +9787301009536 +9787301009680 +9787301009918 +9787301009925 +9787301009970 +9787301010044 +9787301010273 +9787301010327 +9787301010532 +9787301010556 +9787301011362 +9787301011522 +9787301011577 +9787301012741 +9787301012857 +9787301012970 +9787301013052 +9787301013090 +9787301013526 +9787301014356 +9787301014578 +9787301014721 +9787301015131 +9787301015179 +9787301015605 +9787301015872 +9787301016077 +9787301016183 +9787301016510 +9787301016589 +9787301016688 +9787301016848 +9787301017067 +9787301018484 +9787301018545 +9787301018675 +9787301018712 +9787301019115 +9787301019290 +9787301020333 +9787301020548 +9787301020555 +9787301020562 +9787301020616 +9787301020968 +9787301021019 +9787301021033 +9787301021798 +9787301021866 +9787301021941 +9787301022535 +9787301023358 +9787301023662 +9787301024096 +9787301024317 +9787301024621 +9787301024652 +9787301024683 +9787301024751 +9787301025369 +9787301025734 +9787301025925 +9787301026151 +9787301026199 +9787301026601 +9787301026847 +9787301027400 +9787301027691 +9787301027776 +9787301027882 +9787301027981 +9787301028292 +9787301028308 +9787301028421 +9787301028490 +9787301028575 +9787301028988 +9787301029343 +9787301029602 +9787301030363 +9787301031988 +9787301032046 +9787301032121 +9787301032459 +9787301032466 +9787301032497 +9787301032633 +9787301033012 +9787301033579 +9787301033586 +9787301033593 +9787301033999 +9787301034101 +9787301034347 +9787301034378 +9787301035153 +9787301035238 +9787301035245 +9787301035368 +9787301036150 +9787301037072 +9787301037089 +9787301037577 +9787301037621 +9787301037683 +9787301037874 +9787301037881 +9787301038512 +9787301038536 +9787301038574 +9787301038789 +9787301038925 +9787301039526 +9787301040034 +9787301040218 +9787301040492 +9787301040508 +9787301040959 +9787301041178 +9787301041208 +9787301041246 +9787301041598 +9787301041611 +9787301042489 +9787301042724 +9787301043486 +9787301044209 +9787301044261 +9787301044537 +9787301044544 +9787301044568 +9787301044599 +9787301045213 +9787301045329 +9787301047163 +9787301047767 +9787301048597 +9787301048726 +9787301048788 +9787301048818 +9787301049129 +9787301049488 +9787301050590 +9787301050828 +9787301051252 +9787301051474 +9787301051481 +9787301052495 +9787301053959 +9787301055434 +9787301055670 +9787301055762 +9787301056400 +9787301057810 +9787301058633 +9787301059234 +9787301059951 +9787301061992 +9787301062180 +9787301062661 +9787301062944 +9787301063194 +9787301064993 +9787301065723 +9787301065730 +9787301065808 +9787301066102 +9787301066348 +9787301067031 +9787301067086 +9787301068991 +9787301073650 +9787301075715 +9787301075814 +9787301077955 +9787301080146 +9787301082263 +9787301083017 +9787301084618 +9787301084649 +9787301084694 +9787301084984 +9787301089033 +9787301089972 +9787301090398 +9787301093702 +9787301094402 +9787301094921 +9787301096864 +9787301098608 +9787301099810 +9787301102244 +9787301106754 +9787301106914 +9787301106921 +9787301107270 +9787301109472 +9787301110737 +9787301122082 +9787301125533 +9787301125823 +9787301132333 +9787301137796 +9787301140918 +9787301142745 +9787301143124 +9787301144176 +9787301145005 +9787301146170 +9787301147993 +9787301156322 +9787301158661 +9787301163993 +9787301166895 +9787301168790 +9787301172537 +9787301173039 +9787301176146 +9787301176900 +9787301182383 +9787301187517 +9787301188286 +9787301188422 +9787301195024 +9787301201701 +9787301204672 +9787301206799 +9787301208496 +9787301210635 +9787301214084 +9787301215890 +9787301216583 +9787301217726 +9787301218006 +9787301222621 +9787301224946 +9787301228883 +9787301230664 +9787301231845 +9787301236413 +9787301236956 +9787301237175 +9787301238400 +9787301247082 +9787301296431 +9787301301302 +9787301307830 +9787301318201 +9787301326022 +9787301332153 +9787301332375 +9787301332382 +9787301333822 +9787301334003 +9787301335727 +9787301337110 +9787301337974 +9787301338056 +9787301339442 +9787301339633 +9787301341971 +9787301341988 +9787301342176 +9787301342206 +9787301342497 +9787301344057 +9787301344897 +9787301345740 +9787301346228 +9787301346303 +9787301346570 +9787301346624 +9787301347317 +9787301347928 +9787301348116 +9787301348208 +9787301348284 +9787301348291 +9787301348420 +9787301348604 +9787301348680 +9787301348888 +9787301349038 +9787301349663 +9787301350270 +9787301350331 +9787301350492 +9787301350614 +9787301350621 +9787301350652 +9787301350751 +9787301351253 +9787301351642 +9787301352007 +9787301352359 +9787301352762 +9787301352977 +9787301353189 +9787301353226 +9787301353271 +9787301353387 +9787301353417 +9787301353455 +9787301353523 +9787301353561 +9787301353752 +9787301353813 +9787301353899 +9787301353981 +9787301353998 +9787301354056 +9787301354193 +9787301354353 +9787301354384 +9787301354711 +9787301354742 +9787301354766 +9787301354858 +9787301355015 +9787301355039 +9787301355169 +9787301355350 +9787301355480 +9787301355497 +9787301355510 +9787301355565 +9787301355572 +9787301355589 +9787301355602 +9787301355619 +9787301355671 +9787301355695 +9787301355787 +9787301355794 +9787301355855 +9787301356111 +9787301356135 +9787301356227 +9787301356272 +9787301356289 +9787301356296 +9787301356364 +9787301356371 +9787301356517 +9787301356548 +9787301356562 +9787301356609 +9787301356678 +9787301356807 +9787301356937 +9787301356944 +9787301357125 +9787301357156 +9787301357309 +9787301357316 +9787301357330 +9787301357613 +9787301357651 +9787301357675 +9787301357743 +9787301357804 +9787301357897 +9787301357903 +9787301357965 +9787301358092 +9787301358191 +9787301358238 +9787301358276 +9787301358337 +9787301358399 +9787301358511 +9787301358535 +9787301358610 +9787301358993 +9787301359105 +9787301359136 +9787301359860 +9787301360033 +9787301360279 +9787301360477 +9787301360583 +9787301360613 +9787301360682 +9787301360811 +9787301360903 +9787301361108 +9787301361245 +9787301361320 +9787301361405 +9787301361634 +9787301361672 +9787301361740 +9787301361818 +9787301361986 +9787301362464 +9787301362549 +9787301363348 +9787301364611 +9787301364628 +9787302000143 +9787302000198 +9787302000273 +9787302001652 +9787302001782 +9787302002307 +9787302002574 +9787302002666 +9787302002734 +9787302002819 +9787302003601 +9787302003687 +9787302004134 +9787302004356 +9787302004554 +9787302004905 +9787302005155 +9787302005964 +9787302006268 +9787302006350 +9787302006947 +9787302007081 +9787302007128 +9787302007951 +9787302008064 +9787302008484 +9787302008514 +9787302008606 +9787302009528 +9787302010418 +9787302010548 +9787302010807 +9787302011781 +9787302012351 +9787302012610 +9787302012788 +9787302012801 +9787302013044 +9787302013204 +9787302014027 +9787302014225 +9787302014539 +9787302014881 +9787302015468 +9787302015673 +9787302016052 +9787302016182 +9787302016267 +9787302016274 +9787302016830 +9787302017011 +9787302017196 +9787302017202 +9787302018773 +9787302019121 +9787302019169 +9787302019329 +9787302019411 +9787302019473 +9787302019626 +9787302019688 +9787302020066 +9787302020127 +9787302020264 +9787302020981 +9787302021414 +9787302021513 +9787302021858 +9787302022688 +9787302022725 +9787302023449 +9787302023821 +9787302023951 +9787302023975 +9787302024118 +9787302024965 +9787302025467 +9787302025856 +9787302026198 +9787302026624 +9787302027225 +9787302027713 +9787302028307 +9787302028680 +9787302028710 +9787302028765 +9787302028918 +9787302029298 +9787302029595 +9787302029908 +9787302029922 +9787302029977 +9787302030058 +9787302030362 +9787302030584 +9787302030607 +9787302030737 +9787302031192 +9787302031581 +9787302031925 +9787302032359 +9787302032625 +9787302032649 +9787302032847 +9787302033042 +9787302033257 +9787302033431 +9787302034179 +9787302034216 +9787302034230 +9787302034377 +9787302035473 +9787302035480 +9787302035510 +9787302035534 +9787302035589 +9787302035602 +9787302035862 +9787302036234 +9787302036630 +9787302036661 +9787302037415 +9787302038689 +9787302038757 +9787302038870 +9787302039266 +9787302039761 +9787302039983 +9787302040217 +9787302040859 +9787302041290 +9787302041597 +9787302041764 +9787302041986 +9787302041993 +9787302042006 +9787302042037 +9787302042044 +9787302042068 +9787302042099 +9787302042112 +9787302042143 +9787302042327 +9787302042679 +9787302042891 +9787302043478 +9787302043690 +9787302043881 +9787302044000 +9787302044208 +9787302044246 +9787302044512 +9787302044772 +9787302045076 +9787302045267 +9787302045304 +9787302045434 +9787302045656 +9787302045816 +9787302046127 +9787302046653 +9787302047483 +9787302048183 +9787302048510 +9787302048824 +9787302050216 +9787302050643 +9787302050957 +9787302051299 +9787302051435 +9787302052609 +9787302052937 +9787302053132 +9787302053194 +9787302053569 +9787302055228 +9787302055358 +9787302055556 +9787302055563 +9787302056102 +9787302056898 +9787302057079 +9787302058571 +9787302059219 +9787302059745 +9787302059943 +9787302060208 +9787302061304 +9787302061434 +9787302061588 +9787302062653 +9787302062691 +9787302063032 +9787302063278 +9787302063391 +9787302063896 +9787302064145 +9787302064350 +9787302064848 +9787302065388 +9787302065470 +9787302066224 +9787302066835 +9787302067405 +9787302067610 +9787302067658 +9787302068532 +9787302068877 +9787302068952 +9787302069225 +9787302069416 +9787302069522 +9787302069607 +9787302070320 +9787302070597 +9787302072201 +9787302072775 +9787302073468 +9787302074793 +9787302075288 +9787302076308 +9787302076353 +9787302076391 +9787302077343 +9787302080916 +9787302081197 +9787302082330 +9787302082682 +9787302084808 +9787302086338 +9787302089551 +9787302091738 +9787302093190 +9787302093671 +9787302094340 +9787302095064 +9787302096337 +9787302100324 +9787302102069 +9787302102533 +9787302103783 +9787302104223 +9787302107163 +9787302108757 +9787302109747 +9787302110897 +9787302112969 +9787302113843 +9787302114857 +9787302120117 +9787302120377 +9787302120971 +9787302121657 +9787302123651 +9787302127505 +9787302131182 +9787302131359 +9787302139874 +9787302144830 +9787302152071 +9787302157090 +9787302159995 +9787302165804 +9787302169581 +9787302170280 +9787302170655 +9787302170716 +9787302178941 +9787302181842 +9787302183891 +9787302184089 +9787302186434 +9787302192381 +9787302192398 +9787302194644 +9787302199311 +9787302202127 +9787302203353 +9787302204855 +9787302205975 +9787302207399 +9787302209157 +9787302210986 +9787302220725 +9787302222385 +9787302226857 +9787302230939 +9787302231226 +9787302236238 +9787302244189 +9787302244462 +9787302247470 +9787302250500 +9787302252276 +9787302253471 +9787302257394 +9787302257561 +9787302257578 +9787302266204 +9787302268154 +9787302271512 +9787302271642 +9787302273080 +9787302279983 +9787302280132 +9787302288473 +9787302290841 +9787302291640 +9787302297062 +9787302298199 +9787302299776 +9787302306283 +9787302311539 +9787302312963 +9787302315087 +9787302318187 +9787302328001 +9787302331094 +9787302334613 +9787302335191 +9787302338437 +9787302338963 +9787302341918 +9787302346241 +9787302346487 +9787302348788 +9787302349679 +9787302350156 +9787302350170 +9787302350774 +9787302352778 +9787302363095 +9787302368083 +9787302370062 +9787302372080 +9787302379270 +9787302385257 +9787302392958 +9787302392972 +9787302399087 +9787302400639 +9787302401247 +9787302404125 +9787302405979 +9787302408307 +9787302409991 +9787302410447 +9787302414391 +9787302415138 +9787302417828 +9787302419662 +9787302427544 +9787302444404 +9787302444831 +9787302449768 +9787302450337 +9787302462040 +9787302474876 +9787302475859 +9787302482772 +9787302483014 +9787302483076 +9787302486220 +9787302488200 +9787302493259 +9787302494614 +9787302507840 +9787302508052 +9787302517337 +9787302518976 +9787302520405 +9787302521372 +9787302523062 +9787302525189 +9787302534679 +9787302536840 +9787302545194 +9787302545989 +9787302546771 +9787302554264 +9787302557289 +9787302560739 +9787302571261 +9787302573623 +9787302573951 +9787302575412 +9787302581413 +9787302582113 +9787302584162 +9787302586760 +9787302590637 +9787302591504 +9787302594994 +9787302597957 +9787302599241 +9787302599524 +9787302608189 +9787302608707 +9787302609322 +9787302612032 +9787302612827 +9787302614081 +9787302616382 +9787302616528 +9787302616887 +9787302617631 +9787302617723 +9787302618485 +9787302620235 +9787302620976 +9787302621348 +9787302621393 +9787302622802 +9787302623373 +9787302624172 +9787302624653 +9787302628163 +9787302630920 +9787302631767 +9787302632313 +9787302636625 +9787302638391 +9787302639237 +9787302639961 +9787302640257 +9787302641513 +9787302642671 +9787302643043 +9787302643258 +9787302643302 +9787302643371 +9787302643524 +9787302643555 +9787302643579 +9787302643746 +9787302643784 +9787302643876 +9787302645009 +9787302645252 +9787302646341 +9787302647003 +9787302647256 +9787302648147 +9787302648215 +9787302648420 +9787302648581 +9787302648932 +9787302649380 +9787302649427 +9787302649861 +9787302650126 +9787302651154 +9787302651383 +9787302652274 +9787302652328 +9787302652410 +9787302652786 +9787302653257 +9787302653332 +9787302653745 +9787302655060 +9787302655411 +9787302655756 +9787302655909 +9787302656142 +9787302656982 +9787302658009 +9787302658290 +9787302658757 +9787302658801 +9787302658931 +9787302659013 +9787302659242 +9787302659549 +9787302659914 +9787302659921 +9787302659938 +9787302660484 +9787302660507 +9787302660729 +9787302661153 +9787302661221 +9787302661290 +9787302661610 +9787302661672 +9787302661894 +9787302661955 +9787302662006 +9787302662211 +9787302662297 +9787302662419 +9787302662587 +9787302662617 +9787302663065 +9787302663195 +9787302663263 +9787302663447 +9787302663522 +9787302663669 +9787302664444 +9787302664659 +9787302664918 +9787302665120 +9787302665533 +9787302666226 +9787302666516 +9787302666677 +9787302666769 +9787302667100 +9787302667315 +9787302667995 +9787302668176 +9787302668190 +9787302668855 +9787302669197 +9787302669487 +9787302669586 +9787302669982 +9787302670032 +9787302670063 +9787302670650 +9787302670773 +9787302671084 +9787302671541 +9787302672104 +9787302672258 +9787302672531 +9787302672586 +9787302672814 +9787302672821 +9787302673262 +9787302673323 +9787302673620 +9787302673682 +9787302673835 +9787302673910 +9787302673958 +9787302673972 +9787302673989 +9787302674030 +9787302674153 +9787302674313 +9787302674320 +9787302674528 +9787302674535 +9787302674634 +9787302674719 +9787302674856 +9787302675129 +9787302675228 +9787302675303 +9787302675464 +9787302675488 +9787302675518 +9787302675532 +9787302675549 +9787302675730 +9787302675914 +9787302675945 +9787302676294 +9787302676348 +9787302676423 +9787302676690 +9787302676928 +9787302676942 +9787302677291 +9787302677383 +9787302677529 +9787302677673 +9787302677895 +9787302678182 +9787302678212 +9787302678311 +9787302678502 +9787302678991 +9787302679226 +9787302679332 +9787302679752 +9787302680017 +9787302680192 +9787302680512 +9787302680536 +9787302680598 +9787302680819 +9787302681120 +9787302681168 +9787302681243 +9787302681366 +9787302681564 +9787302681748 +9787302682011 +9787302682769 +9787302683315 +9787302683391 +9787302684114 +9787302684398 +9787302685050 +9787302685531 +9787302685722 +9787302686057 +9787302686873 +9787302687023 +9787302687351 +9787302688136 +9787302688181 +9787302688617 +9787302689393 +9787302689423 +9787302689973 +9787302690580 +9787302690788 +9787302691761 +9787302691877 +9787302692041 +9787302692157 +9787302692232 +9787303000302 +9787303000647 +9787303000722 +9787303001415 +9787303001545 +9787303001989 +9787303002191 +9787303002412 +9787303002481 +9787303003136 +9787303003488 +9787303003747 +9787303003846 +9787303003938 +9787303004515 +9787303004935 +9787303005185 +9787303005451 +9787303005529 +9787303005581 +9787303005598 +9787303005703 +9787303005888 +9787303005963 +9787303006007 +9787303006830 +9787303007998 +9787303008711 +9787303008742 +9787303008759 +9787303009510 +9787303010073 +9787303010578 +9787303011131 +9787303011148 +9787303012145 +9787303012329 +9787303012619 +9787303013531 +9787303013678 +9787303013784 +9787303013821 +9787303014750 +9787303015771 +9787303015788 +9787303016013 +9787303016976 +9787303017423 +9787303017874 +9787303017898 +9787303017904 +9787303017911 +9787303017959 +9787303018055 +9787303018604 +9787303018840 +9787303018871 +9787303018888 +9787303018895 +9787303018918 +9787303018925 +9787303018932 +9787303019052 +9787303019212 +9787303019625 +9787303020195 +9787303020201 +9787303020232 +9787303020348 +9787303020423 +9787303020461 +9787303020522 +9787303020652 +9787303020720 +9787303020737 +9787303020843 +9787303021000 +9787303021017 +9787303021031 +9787303021345 +9787303021642 +9787303021895 +9787303022229 +9787303022366 +9787303022403 +9787303022496 +9787303022700 +9787303022816 +9787303024018 +9787303024049 +9787303024476 +9787303024544 +9787303025350 +9787303025596 +9787303025602 +9787303025640 +9787303025770 +9787303026302 +9787303026371 +9787303026852 +9787303027774 +9787303028009 +9787303028320 +9787303028412 +9787303028641 +9787303028818 +9787303028993 +9787303029181 +9787303029976 +9787303030279 +9787303030286 +9787303030392 +9787303031580 +9787303031610 +9787303032907 +9787303034031 +9787303034123 +9787303034581 +9787303034598 +9787303035304 +9787303035755 +9787303035892 +9787303036752 +9787303037483 +9787303037643 +9787303037704 +9787303037858 +9787303037940 +9787303038695 +9787303039401 +9787303040483 +9787303041367 +9787303042517 +9787303043989 +9787303044115 +9787303044146 +9787303044436 +9787303044764 +9787303047123 +9787303047284 +9787303047406 +9787303048571 +9787303049899 +9787303050277 +9787303054282 +9787303055173 +9787303055562 +9787303057818 +9787303058167 +9787303058242 +9787303058686 +9787303058815 +9787303059621 +9787303060450 +9787303060672 +9787303061938 +9787303062690 +9787303063611 +9787303064724 +9787303066681 +9787303067534 +9787303067671 +9787303068579 +9787303069187 +9787303069200 +9787303076338 +9787303079414 +9787303080229 +9787303080656 +9787303080847 +9787303081806 +9787303082599 +9787303082605 +9787303082636 +9787303086344 +9787303093007 +9787303094431 +9787303094998 +9787303096183 +9787303096657 +9787303099030 +9787303102129 +9787303103539 +9787303106752 +9787303108084 +9787303109500 +9787303110889 +9787303114887 +9787303115754 +9787303118687 +9787303119585 +9787303123124 +9787303123254 +9787303123742 +9787303125012 +9787303125074 +9787303126682 +9787303134502 +9787303139088 +9787303140480 +9787303142286 +9787303145485 +9787303147090 +9787303147236 +9787303147250 +9787303147427 +9787303147458 +9787303149827 +9787303149865 +9787303150007 +9787303150144 +9787303153947 +9787303154012 +9787303155217 +9787303155323 +9787303156924 +9787303157624 +9787303160051 +9787303161218 +9787303161515 +9787303162208 +9787303166299 +9787303166992 +9787303167005 +9787303171354 +9787303171378 +9787303172313 +9787303174539 +9787303175987 +9787303176038 +9787303178841 +9787303181230 +9787303182695 +9787303182701 +9787303182725 +9787303185368 +9787303185375 +9787303185382 +9787303185399 +9787303185412 +9787303185429 +9787303185436 +9787303185542 +9787303191727 +9787303208524 +9787303208791 +9787303222230 +9787303224258 +9787303227365 +9787303229017 +9787303237289 +9787303238453 +9787303240920 +9787303242610 +9787303243686 +9787303244225 +9787303246526 +9787303247189 +9787303248155 +9787303248278 +9787303248377 +9787303249657 +9787303249985 +9787303250868 +9787303251988 +9787303252169 +9787303252398 +9787303257928 +9787303258819 +9787303260904 +9787303262526 +9787303262816 +9787303263578 +9787303264971 +9787303267279 +9787303267309 +9787303267408 +9787303268313 +9787303268719 +9787303268801 +9787303268856 +9787303271382 +9787303271931 +9787303272006 +9787303272952 +9787303275465 +9787303275908 +9787303277001 +9787303277278 +9787303277940 +9787303277988 +9787303278107 +9787303278831 +9787303279562 +9787303279784 +9787303279920 +9787303280384 +9787303280537 +9787303280759 +9787303280773 +9787303280940 +9787303281343 +9787303281695 +9787303283217 +9787303284559 +9787303287376 +9787303289080 +9787303292530 +9787303292912 +9787303293223 +9787303293384 +9787303293773 +9787303293834 +9787303293865 +9787303294060 +9787303294428 +9787303295128 +9787303295166 +9787303296330 +9787303296347 +9787303296378 +9787303296880 +9787303297900 +9787303298112 +9787303298303 +9787303298365 +9787303298617 +9787303298648 +9787303299683 +9787303299737 +9787303299744 +9787303300464 +9787303300662 +9787303301157 +9787303301676 +9787303302000 +9787303302659 +9787303302741 +9787303306084 +9787304001308 +9787304001391 +9787304001469 +9787304002060 +9787304002268 +9787304002299 +9787304003241 +9787304003258 +9787304003272 +9787304003647 +9787304003722 +9787304004002 +9787304005221 +9787304006891 +9787304006907 +9787304008987 +9787304009120 +9787304009397 +9787304009502 +9787304010201 +9787304010799 +9787304014216 +9787304014292 +9787304014353 +9787304016661 +9787304016876 +9787304018108 +9787304023560 +9787304024147 +9787304025595 +9787304026431 +9787304035471 +9787304036508 +9787304037321 +9787304038038 +9787304040475 +9787304041427 +9787304042325 +9787304044893 +9787304045371 +9787304047238 +9787304048532 +9787304050443 +9787304053062 +9787304057299 +9787304060060 +9787304060497 +9787304061975 +9787304064297 +9787304064372 +9787304064495 +9787304066529 +9787304067151 +9787304068721 +9787304069087 +9787304069179 +9787304069834 +9787304069971 +9787304070311 +9787304071127 +9787304071806 +9787304074814 +9787304075699 +9787304075712 +9787304075927 +9787304076894 +9787304078683 +9787304079383 +9787304080754 +9787304081874 +9787304082321 +9787304082390 +9787304082949 +9787304082970 +9787304082987 +9787304084264 +9787304085261 +9787304085513 +9787304085827 +9787304085995 +9787304086619 +9787304087654 +9787304087678 +9787304087760 +9787304087999 +9787304088262 +9787304089207 +9787304089276 +9787304089313 +9787304089337 +9787304089757 +9787304091798 +9787304092214 +9787304092276 +9787304093037 +9787304093389 +9787304093402 +9787304093556 +9787304093877 +9787304094119 +9787304094263 +9787304095178 +9787304095673 +9787304096014 +9787304096786 +9787304097905 +9787304098438 +9787304098469 +9787304098780 +9787304099022 +9787304099053 +9787304099480 +9787304100018 +9787304101510 +9787304102043 +9787304102760 +9787304102838 +9787304103002 +9787304103101 +9787304103231 +9787304104153 +9787304104351 +9787304104931 +9787304104986 +9787304105112 +9787304105587 +9787304105754 +9787304106201 +9787304106409 +9787304106416 +9787304106584 +9787304106607 +9787304106683 +9787304106690 +9787304106768 +9787304106829 +9787304107086 +9787304107970 +9787304108144 +9787304108199 +9787304108236 +9787304108243 +9787304108281 +9787304108403 +9787304108434 +9787304108717 +9787304109141 +9787304109295 +9787304109677 +9787304110208 +9787304110222 +9787304110260 +9787304110321 +9787304110826 +9787304110833 +9787304110932 +9787304110956 +9787304111021 +9787304111182 +9787304111304 +9787304111311 +9787304111373 +9787304111410 +9787304111632 +9787304111762 +9787304111809 +9787304111892 +9787304112134 +9787304112219 +9787304112257 +9787304112318 +9787304112745 +9787304112912 +9787304113018 +9787304113087 +9787304113209 +9787304113483 +9787304113568 +9787304113797 +9787304114077 +9787304114336 +9787304114381 +9787304114527 +9787304114671 +9787304114718 +9787304115005 +9787304115616 +9787304116033 +9787304116040 +9787304116057 +9787304116088 +9787304116095 +9787304116101 +9787304116484 +9787304117139 +9787304117160 +9787304117481 +9787304118198 +9787304118389 +9787304118556 +9787304120870 +9787304120894 +9787304121433 +9787304122065 +9787304122300 +9787304123932 +9787304124090 +9787304124311 +9787304125400 +9787304127084 +9787304127732 +9787304128265 +9787304130190 +9787305000171 +9787305000560 +9787305000577 +9787305001116 +9787305002168 +9787305002847 +9787305003097 +9787305003325 +9787305003424 +9787305003684 +9787305004414 +9787305005503 +9787305006760 +9787305007293 +9787305007392 +9787305008207 +9787305008801 +9787305010859 +9787305011900 +9787305012372 +9787305012464 +9787305014765 +9787305014819 +9787305015441 +9787305017520 +9787305018664 +9787305020193 +9787305020506 +9787305020834 +9787305021862 +9787305021978 +9787305022647 +9787305022906 +9787305023026 +9787305025075 +9787305025235 +9787305025907 +9787305026072 +9787305026096 +9787305027703 +9787305028748 +9787305028946 +9787305028953 +9787305029516 +9787305030116 +9787305030413 +9787305031205 +9787305032363 +9787305033261 +9787305033445 +9787305033469 +9787305033636 +9787305033964 +9787305034695 +9787305035333 +9787305036705 +9787305037405 +9787305037733 +9787305037931 +9787305038129 +9787305038945 +9787305039270 +9787305039935 +9787305043826 +9787305043918 +9787305044021 +9787305044038 +9787305045998 +9787305046551 +9787305046674 +9787305049309 +9787305051609 +9787305053153 +9787305053955 +9787305054365 +9787305055058 +9787305056376 +9787305056918 +9787305059513 +9787305061363 +9787305061684 +9787305064036 +9787305066757 +9787305068782 +9787305069123 +9787305069390 +9787305072369 +9787305073632 +9787305076640 +9787305083044 +9787305083280 +9787305084171 +9787305084782 +9787305088995 +9787305090400 +9787305090462 +9787305091568 +9787305094040 +9787305094309 +9787305094903 +9787305095467 +9787305095849 +9787305097027 +9787305097461 +9787305097812 +9787305102264 +9787305102318 +9787305105548 +9787305105845 +9787305108112 +9787305111419 +9787305112249 +9787305112874 +9787305113567 +9787305113857 +9787305113864 +9787305114311 +9787305114328 +9787305114335 +9787305114342 +9787305116933 +9787305117268 +9787305117893 +9787305119545 +9787305120565 +9787305122330 +9787305123412 +9787305123559 +9787305125423 +9787305127823 +9787305127885 +9787305128172 +9787305129940 +9787305130687 +9787305130823 +9787305131318 +9787305132414 +9787305136566 +9787305139802 +9787305140266 +9787305141799 +9787305143960 +9787305145476 +9787305146206 +9787305148996 +9787305149429 +9787305150999 +9787305151453 +9787305151583 +9787305151958 +9787305152627 +9787305156144 +9787305157882 +9787305157950 +9787305158063 +9787305158087 +9787305158698 +9787305159640 +9787305161476 +9787305162114 +9787305162350 +9787305164460 +9787305167430 +9787305168239 +9787305171185 +9787305171369 +9787305172830 +9787305175695 +9787305181566 +9787305181894 +9787305183225 +9787305184062 +9787305186462 +9787305188817 +9787305189456 +9787305191701 +9787305192364 +9787305192647 +9787305197215 +9787305198472 +9787305199820 +9787305200120 +9787305200960 +9787305200991 +9787305205163 +9787305205590 +9787305205880 +9787305206160 +9787305208874 +9787305210099 +9787305210334 +9787305212789 +9787305214523 +9787305217920 +9787305218958 +9787305219559 +9787305221118 +9787305221712 +9787305223617 +9787305224577 +9787305225215 +9787305225246 +9787305225253 +9787305225284 +9787305225314 +9787305225574 +9787305225598 +9787305225963 +9787305227592 +9787305230363 +9787305230790 +9787305230820 +9787305232688 +9787305232718 +9787305234385 +9787305234750 +9787305234835 +9787305234866 +9787305235269 +9787305235740 +9787305236570 +9787305236853 +9787305237010 +9787305237188 +9787305237218 +9787305237799 +9787305238369 +9787305238437 +9787305239243 +9787305239892 +9787305239939 +9787305239984 +9787305241017 +9787305241215 +9787305241246 +9787305242038 +9787305242151 +9787305242328 +9787305243073 +9787305243110 +9787305243202 +9787305243226 +9787305243950 +9787305243967 +9787305244445 +9787305244803 +9787305244940 +9787305245541 +9787305245947 +9787305246159 +9787305246340 +9787305247323 +9787305247576 +9787305247613 +9787305247705 +9787305248344 +9787305248597 +9787305248634 +9787305249440 +9787305249853 +9787305249884 +9787305250071 +9787305251160 +9787305253201 +9787305253515 +9787305254758 +9787305254765 +9787305254772 +9787305255144 +9787305255229 +9787305255281 +9787305255298 +9787305255380 +9787305255410 +9787305255724 +9787305255731 +9787305255748 +9787305256073 +9787305257629 +9787305257698 +9787305257988 +9787305259241 +9787305259708 +9787305259883 +9787305259999 +9787305260070 +9787305260254 +9787305260377 +9787305260407 +9787305260414 +9787305261114 +9787305261299 +9787305261992 +9787305262760 +9787305262838 +9787305263507 +9787305263736 +9787305263750 +9787305264283 +9787305264436 +9787305264597 +9787305264931 +9787305264955 +9787305264962 +9787305266683 +9787305267413 +9787305267598 +9787305267765 +9787305267772 +9787305267833 +9787305267970 +9787305268618 +9787305269165 +9787305269714 +9787305269745 +9787305270093 +9787305270727 +9787305270833 +9787305270963 +9787305271267 +9787305271663 +9787305271717 +9787305272004 +9787305272080 +9787305272271 +9787305272400 +9787305272455 +9787305272462 +9787305272486 +9787305272547 +9787305272813 +9787305273131 +9787305273667 +9787305273803 +9787305274213 +9787305274275 +9787305274992 +9787305275234 +9787305275371 +9787305275449 +9787305275500 +9787305275807 +9787305275975 +9787305277863 +9787305277931 +9787305279775 +9787305280160 +9787305280269 +9787305280405 +9787305280658 +9787305281143 +9787305281204 +9787305281396 +9787305281440 +9787305281488 +9787305281754 +9787305281846 +9787305282911 +9787305282942 +9787305282966 +9787305283093 +9787305283109 +9787305284199 +9787305284380 +9787305284731 +9787305287466 +9787305287589 +9787305294273 +9787306000910 +9787306001016 +9787306001030 +9787306001221 +9787306001801 +9787306002501 +9787306002914 +9787306003140 +9787306004475 +9787306004666 +9787306005199 +9787306005656 +9787306005786 +9787306005939 +9787306006646 +9787306006707 +9787306007353 +9787306007421 +9787306007896 +9787306008244 +9787306008947 +9787306009005 +9787306009418 +9787306009487 +9787306009760 +9787306009937 +9787306009982 +9787306010384 +9787306011039 +9787306011060 +9787306011152 +9787306011886 +9787306012210 +9787306012333 +9787306012364 +9787306012531 +9787306013088 +9787306013767 +9787306014511 +9787306014771 +9787306015518 +9787306015624 +9787306015709 +9787306016195 +9787306016225 +9787306016478 +9787306016522 +9787306016874 +9787306016942 +9787306017017 +9787306017024 +9787306017239 +9787306017741 +9787306017772 +9787306017901 +9787306018069 +9787306018748 +9787306019486 +9787306019844 +9787306020116 +9787306021113 +9787306023902 +9787306024237 +9787306025364 +9787306026637 +9787306026651 +9787306028730 +9787306029768 +9787306034458 +9787306035141 +9787306036384 +9787306036391 +9787306038739 +9787306038869 +9787306041807 +9787306043535 +9787306043559 +9787306050014 +9787306050403 +9787306051837 +9787306053176 +9787306053589 +9787306053688 +9787306054432 +9787306056610 +9787306057143 +9787306061324 +9787306063960 +9787306066251 +9787306066367 +9787306066954 +9787306068354 +9787306068378 +9787306069511 +9787306069641 +9787306070128 +9787306070623 +9787306070852 +9787306070869 +9787306070913 +9787306071507 +9787306072443 +9787306072665 +9787306073747 +9787306074010 +9787306074812 +9787306079404 +9787306079824 +9787306079961 +9787306079978 +9787306080004 +9787306080028 +9787306080042 +9787306080202 +9787306080264 +9787306080707 +9787306081612 +9787306081704 +9787306081780 +9787306082350 +9787306082381 +9787306082626 +9787306082862 +9787306084033 +9787307000032 +9787307000902 +9787307001299 +9787307001305 +9787307001558 +9787307001701 +9787307001893 +9787307003187 +9787307003484 +9787307005761 +9787307006942 +9787307007888 +9787307008106 +9787307009004 +9787307010079 +9787307012318 +9787307012455 +9787307012776 +9787307012783 +9787307013421 +9787307014251 +9787307014732 +9787307015487 +9787307016293 +9787307016521 +9787307016668 +9787307017672 +9787307017801 +9787307017818 +9787307017849 +9787307017856 +9787307018556 +9787307019560 +9787307020122 +9787307020146 +9787307020184 +9787307020658 +9787307020719 +9787307022164 +9787307022256 +9787307022478 +9787307022485 +9787307022669 +9787307024908 +9787307026087 +9787307026674 +9787307026858 +9787307027329 +9787307027701 +9787307028111 +9787307028203 +9787307029170 +9787307029880 +9787307030459 +9787307031272 +9787307033184 +9787307033597 +9787307033962 +9787307037069 +9787307037489 +9787307038363 +9787307038547 +9787307039742 +9787307041875 +9787307052512 +9787307053427 +9787307060241 +9787307061460 +9787307062269 +9787307065178 +9787307066304 +9787307070134 +9787307073746 +9787307074392 +9787307074613 +9787307075306 +9787307075986 +9787307077164 +9787307080775 +9787307081048 +9787307082021 +9787307083394 +9787307085138 +9787307085220 +9787307085404 +9787307085923 +9787307087132 +9787307089501 +9787307089662 +9787307090873 +9787307092020 +9787307092181 +9787307092655 +9787307095014 +9787307095465 +9787307096752 +9787307096981 +9787307100237 +9787307100909 +9787307102323 +9787307102736 +9787307104563 +9787307105454 +9787307106703 +9787307107137 +9787307107243 +9787307109896 +9787307110120 +9787307110953 +9787307118256 +9787307118652 +9787307119437 +9787307120600 +9787307120716 +9787307120778 +9787307120846 +9787307121706 +9787307122291 +9787307122383 +9787307123663 +9787307124790 +9787307125131 +9787307127111 +9787307127500 +9787307127562 +9787307127647 +9787307129290 +9787307132665 +9787307132689 +9787307133716 +9787307134102 +9787307134935 +9787307136212 +9787307136359 +9787307137967 +9787307138599 +9787307139039 +9787307139893 +9787307144033 +9787307144224 +9787307144736 +9787307147119 +9787307147829 +9787307149304 +9787307151376 +9787307152083 +9787307152168 +9787307152601 +9787307153400 +9787307153646 +9787307153899 +9787307159884 +9787307159976 +9787307166318 +9787307166325 +9787307167612 +9787307169562 +9787307172845 +9787307174795 +9787307177505 +9787307178953 +9787307180253 +9787307180291 +9787307181922 +9787307186408 +9787307186941 +9787307191433 +9787307195660 +9787307195813 +9787307195875 +9787307195882 +9787307198265 +9787307206922 +9787307210899 +9787307212657 +9787307214910 +9787307215917 +9787307217355 +9787307219397 +9787307221789 +9787307228962 +9787307232631 +9787307235755 +9787307236219 +9787307236806 +9787307237483 +9787307237834 +9787307239494 +9787307241817 +9787307242531 +9787307242654 +9787307243941 +9787307244139 +9787307245099 +9787307245310 +9787307246065 +9787307246256 +9787307246263 +9787307246362 +9787307248892 +9787307249349 +9787307249394 +9787307250192 +9787308000123 +9787308000222 +9787308000451 +9787308000956 +9787308001090 +9787308001908 +9787308001960 +9787308002561 +9787308003643 +9787308003834 +9787308005395 +9787308006941 +9787308007078 +9787308007252 +9787308008785 +9787308009324 +9787308010733 +9787308011860 +9787308012676 +9787308013871 +9787308015042 +9787308015783 +9787308016698 +9787308017060 +9787308018555 +9787308018722 +9787308018791 +9787308019705 +9787308020879 +9787308021104 +9787308021128 +9787308022279 +9787308022286 +9787308022453 +9787308022705 +9787308023252 +9787308023344 +9787308025409 +9787308026048 +9787308026703 +9787308027052 +9787308027199 +9787308030700 +9787308031790 +9787308032162 +9787308032759 +9787308033435 +9787308033510 +9787308033527 +9787308035705 +9787308036788 +9787308040549 +9787308040860 +9787308053723 +9787308061629 +9787308067621 +9787308069014 +9787308071215 +9787308071406 +9787308073769 +9787308076463 +9787308076951 +9787308081887 +9787308086844 +9787308094368 +9787308096195 +9787308097215 +9787308097918 +9787308099349 +9787308100977 +9787308101066 +9787308107501 +9787308114042 +9787308116794 +9787308122443 +9787308123952 +9787308124027 +9787308126649 +9787308128698 +9787308133135 +9787308133142 +9787308136020 +9787308137034 +9787308147095 +9787308148306 +9787308148788 +9787308149037 +9787308151641 +9787308151665 +9787308155311 +9787308156714 +9787308161268 +9787308161282 +9787308164191 +9787308166546 +9787308167345 +9787308169714 +9787308170260 +9787308175494 +9787308176132 +9787308176149 +9787308182249 +9787308184946 +9787308185738 +9787308185844 +9787308193078 +9787308199179 +9787308203043 +9787308203302 +9787308203500 +9787308205153 +9787308206679 +9787308208369 +9787308208475 +9787308209168 +9787308210775 +9787308210799 +9787308210805 +9787308210812 +9787308210843 +9787308210850 +9787308211369 +9787308211536 +9787308211598 +9787308213578 +9787308213981 +9787308214209 +9787308214230 +9787308214490 +9787308215862 +9787308218764 +9787308219341 +9787308220309 +9787308220408 +9787308221368 +9787308221931 +9787308223218 +9787308223300 +9787308223317 +9787308223379 +9787308225496 +9787308228213 +9787308228992 +9787308231541 +9787308231749 +9787308231824 +9787308235211 +9787308235402 +9787308235662 +9787308236690 +9787308236881 +9787308237468 +9787308237864 +9787308238618 +9787308238908 +9787308238946 +9787308239271 +9787308240154 +9787308240390 +9787308240512 +9787308240802 +9787308241311 +9787308242028 +9787308243421 +9787308243483 +9787308243889 +9787308244121 +9787308244633 +9787308245180 +9787308245456 +9787308245562 +9787308246378 +9787308246521 +9787308246835 +9787308247641 +9787308247733 +9787308247832 +9787308247924 +9787308248297 +9787308248839 +9787308249140 +9787308249454 +9787308249522 +9787308249577 +9787308249645 +9787308249706 +9787308250306 +9787308250351 +9787308251303 +9787308251518 +9787308252164 +9787308252256 +9787308252560 +9787308252621 +9787308252645 +9787308252775 +9787308252850 +9787308252911 +9787308253000 +9787308253123 +9787308253130 +9787308253604 +9787308253789 +9787308253987 +9787308254137 +9787308254250 +9787308254328 +9787308254335 +9787308254410 +9787308254502 +9787308254618 +9787308254656 +9787308254670 +9787308254830 +9787308254939 +9787308255264 +9787308255295 +9787308255486 +9787308255561 +9787308255745 +9787308255783 +9787308255912 +9787308256360 +9787308256469 +9787308256759 +9787308256971 +9787308257268 +9787308257350 +9787308257718 +9787308257787 +9787308257848 +9787308257954 +9787308259002 +9787308259385 +9787308259828 +9787308259910 +9787308260664 +9787308261135 +9787308261289 +9787308261920 +9787308262149 +9787308262224 +9787308262477 +9787308262613 +9787308262781 +9787308263603 +9787308264617 +9787308264778 +9787309000023 +9787309000092 +9787309000122 +9787309000580 +9787309000634 +9787309000917 +9787309001037 +9787309001303 +9787309001419 +9787309001624 +9787309001921 +9787309002355 +9787309003581 +9787309003727 +9787309004007 +9787309004021 +9787309004366 +9787309004540 +9787309005431 +9787309005448 +9787309005714 +9787309005752 +9787309005950 +9787309006650 +9787309006704 +9787309007053 +9787309007350 +9787309007701 +9787309007848 +9787309008265 +9787309008432 +9787309008579 +9787309008623 +9787309009019 +9787309009033 +9787309009446 +9787309009767 +9787309010343 +9787309010503 +9787309010565 +9787309010763 +9787309010800 +9787309011210 +9787309011333 +9787309012040 +9787309012125 +9787309012255 +9787309012279 +9787309012750 +9787309012781 +9787309012828 +9787309013177 +9787309013962 +9787309014143 +9787309014525 +9787309014600 +9787309014822 +9787309014921 +9787309015065 +9787309015140 +9787309015157 +9787309015195 +9787309015317 +9787309015782 +9787309015850 +9787309016048 +9787309016055 +9787309016109 +9787309016154 +9787309016321 +9787309016345 +9787309016413 +9787309016611 +9787309016666 +9787309016765 +9787309016789 +9787309016826 +9787309016987 +9787309017106 +9787309017328 +9787309017526 +9787309017861 +9787309018042 +9787309018127 +9787309018172 +9787309018219 +9787309018660 +9787309018677 +9787309019131 +9787309019223 +9787309019445 +9787309019483 +9787309019643 +9787309019698 +9787309019896 +9787309020373 +9787309020519 +9787309020748 +9787309020786 +9787309020809 +9787309020816 +9787309021325 +9787309021363 +9787309021448 +9787309021585 +9787309021639 +9787309021653 +9787309021745 +9787309021790 +9787309022247 +9787309022803 +9787309023299 +9787309023367 +9787309024326 +9787309025408 +9787309025446 +9787309025460 +9787309025569 +9787309025743 +9787309027167 +9787309027945 +9787309028140 +9787309028157 +9787309028720 +9787309028959 +9787309028997 +9787309029833 +9787309030457 +9787309030556 +9787309031898 +9787309032505 +9787309032963 +9787309033687 +9787309033816 +9787309034431 +9787309035780 +9787309036343 +9787309037326 +9787309038439 +9787309038804 +9787309040074 +9787309040579 +9787309042146 +9787309043594 +9787309043884 +9787309044911 +9787309045055 +9787309045772 +9787309045871 +9787309045925 +9787309046687 +9787309047028 +9787309047288 +9787309048186 +9787309049992 +9787309053982 +9787309058130 +9787309070439 +9787309070927 +9787309073522 +9787309082128 +9787309082517 +9787309085815 +9787309086454 +9787309090222 +9787309093445 +9787309093902 +9787309094039 +9787309094305 +9787309095142 +9787309095159 +9787309095173 +9787309095227 +9787309095289 +9787309095319 +9787309097894 +9787309102895 +9787309104479 +9787309107432 +9787309107784 +9787309108323 +9787309109313 +9787309110005 +9787309111965 +9787309118919 +9787309123265 +9787309123975 +9787309124682 +9787309125900 +9787309126075 +9787309128093 +9787309129007 +9787309132021 +9787309135312 +9787309136289 +9787309137965 +9787309139013 +9787309140873 +9787309142389 +9787309142624 +9787309143461 +9787309145496 +9787309147223 +9787309151657 +9787309152319 +9787309154559 +9787309154573 +9787309155242 +9787309155549 +9787309155693 +9787309155815 +9787309156089 +9787309156126 +9787309156508 +9787309156690 +9787309156966 +9787309157031 +9787309157048 +9787309157277 +9787309157505 +9787309157666 +9787309157734 +9787309157994 +9787309158137 +9787309158939 +9787309159912 +9787309160116 +9787309160123 +9787309160321 +9787309160598 +9787309160727 +9787309161335 +9787309162226 +9787309163452 +9787309164558 +9787309164565 +9787309165470 +9787309166620 +9787309166750 +9787309166781 +9787309166903 +9787309167474 +9787309167511 +9787309167801 +9787309168129 +9787309168150 +9787309168273 +9787309168488 +9787309168761 +9787309169041 +9787309169065 +9787309170658 +9787309170702 +9787309170801 +9787309170993 +9787309171778 +9787309172652 +9787309172928 +9787309173512 +9787309173710 +9787309174007 +9787309174885 +9787309175639 +9787309175943 +9787309176124 +9787309176346 +9787309176575 +9787309176582 +9787309176797 +9787309177220 +9787309177398 +9787309177459 +9787309178463 +9787309178913 +9787309180787 +9787309181012 +9787310000067 +9787310000654 +9787310000920 +9787310001248 +9787310001262 +9787310001330 +9787310001552 +9787310001729 +9787310002092 +9787310002245 +9787310002696 +9787310002733 +9787310003280 +9787310003389 +9787310003815 +9787310004164 +9787310004492 +9787310005000 +9787310005260 +9787310005857 +9787310006694 +9787310006700 +9787310007783 +9787310007844 +9787310008070 +9787310008377 +9787310009275 +9787310009572 +9787310009657 +9787310009961 +9787310010868 +9787310011162 +9787310012091 +9787310013586 +9787310014941 +9787310016785 +9787310017089 +9787310017348 +9787310020119 +9787310020553 +9787310020690 +9787310021529 +9787310021956 +9787310023769 +9787310024315 +9787310027781 +9787310030101 +9787310030736 +9787310032495 +9787310032662 +9787310033652 +9787310037179 +9787310037414 +9787310038305 +9787310038527 +9787310039432 +9787310039616 +9787310039838 +9787310040193 +9787310040292 +9787310044368 +9787310044481 +9787310047345 +9787310054039 +9787310054374 +9787310056613 +9787310056804 +9787310057405 +9787310057696 +9787310060320 +9787310061099 +9787310061211 +9787310062720 +9787310064533 +9787310065271 +9787310066476 +9787310066643 +9787311000011 +9787311001056 +9787311001377 +9787311002220 +9787311002565 +9787311003784 +9787311004934 +9787311005009 +9787311007034 +9787311007393 +9787311007522 +9787311007638 +9787311007683 +9787311007812 +9787311008246 +9787311008383 +9787311008574 +9787311008581 +9787311009625 +9787311009670 +9787311010553 +9787311011338 +9787311011857 +9787311011932 +9787311012106 +9787311013004 +9787311013042 +9787311013066 +9787311013165 +9787311014650 +9787311017040 +9787311017811 +9787311017903 +9787311018504 +9787311018900 +9787311019297 +9787311019303 +9787311019723 +9787311019914 +9787311020156 +9787311020163 +9787311020286 +9787311020545 +9787311020767 +9787311020774 +9787311021122 +9787311021665 +9787311022242 +9787311022303 +9787311023683 +9787311024147 +9787311024697 +9787311025311 +9787311025663 +9787311026738 +9787311028299 +9787311028336 +9787311028664 +9787311029180 +9787311029791 +9787311036300 +9787311036454 +9787311036478 +9787311039776 +9787311040130 +9787311040550 +9787311041342 +9787311042233 +9787311046149 +9787311047412 +9787311049539 +9787311049546 +9787311052850 +9787311056476 +9787311058142 +9787311060190 +9787311064785 +9787311065447 +9787311067748 +9787311067816 +9787312000003 +9787312000188 +9787312000256 +9787312000447 +9787312000508 +9787312000867 +9787312001208 +9787312001949 +9787312002250 +9787312002267 +9787312002397 +9787312002496 +9787312003127 +9787312003455 +9787312003851 +9787312004278 +9787312005978 +9787312006005 +9787312006036 +9787312006579 +9787312007613 +9787312008443 +9787312008931 +9787312009419 +9787312009730 +9787312010415 +9787312010750 +9787312010835 +9787312011122 +9787312012624 +9787312013065 +9787312016011 +9787312016028 +9787312017094 +9787312020179 +9787312030079 +9787312038075 +9787312040757 +9787312041853 +9787312046537 +9787312049583 +9787312050381 +9787312050428 +9787312050923 +9787312051036 +9787312051715 +9787312051753 +9787312052101 +9787312052293 +9787312052361 +9787312052613 +9787312052705 +9787312053221 +9787312054778 +9787312056864 +9787312059063 +9787312060014 +9787312060861 +9787312060946 +9787312061127 +9787312061394 +9787313001689 +9787313002921 +9787313003485 +9787313003652 +9787313003867 +9787313005243 +9787313005991 +9787313006202 +9787313006691 +9787313007162 +9787313009357 +9787313010315 +9787313010575 +9787313011510 +9787313011527 +9787313011558 +9787313011626 +9787313012654 +9787313012760 +9787313012777 +9787313012784 +9787313012920 +9787313012937 +9787313013200 +9787313013248 +9787313014368 +9787313014696 +9787313015105 +9787313015273 +9787313016959 +9787313017574 +9787313017789 +9787313018793 +9787313018847 +9787313019288 +9787313019769 +9787313020222 +9787313020307 +9787313020925 +9787313021410 +9787313021656 +9787313022028 +9787313022998 +9787313023339 +9787313023384 +9787313023544 +9787313023667 +9787313024398 +9787313025357 +9787313026040 +9787313026514 +9787313027528 +9787313027658 +9787313028686 +9787313029379 +9787313030290 +9787313032218 +9787313032669 +9787313033932 +9787313038098 +9787313038135 +9787313038166 +9787313038517 +9787313038609 +9787313039170 +9787313041807 +9787313042125 +9787313043184 +9787313048561 +9787313053473 +9787313054197 +9787313054456 +9787313055279 +9787313056559 +9787313064790 +9787313066336 +9787313068910 +9787313068934 +9787313071545 +9787313073129 +9787313074195 +9787313074737 +9787313074843 +9787313077233 +9787313078353 +9787313078513 +9787313078711 +9787313079312 +9787313080363 +9787313080639 +9787313082626 +9787313084026 +9787313085351 +9787313086242 +9787313091246 +9787313093936 +9787313094759 +9787313094988 +9787313101921 +9787313104656 +9787313106315 +9787313106834 +9787313108814 +9787313110749 +9787313112248 +9787313112644 +9787313112903 +9787313113115 +9787313113214 +9787313113924 +9787313113955 +9787313114891 +9787313115263 +9787313115959 +9787313116673 +9787313118387 +9787313119186 +9787313122797 +9787313122926 +9787313123398 +9787313123480 +9787313125200 +9787313126856 +9787313127778 +9787313128362 +9787313128591 +9787313128621 +9787313128706 +9787313129376 +9787313130532 +9787313131362 +9787313131881 +9787313133052 +9787313133281 +9787313133335 +9787313133755 +9787313134226 +9787313134257 +9787313134929 +9787313135377 +9787313136138 +9787313140357 +9787313140715 +9787313140746 +9787313142481 +9787313144270 +9787313144584 +9787313145567 +9787313146588 +9787313146731 +9787313147288 +9787313147295 +9787313148339 +9787313149367 +9787313151018 +9787313152435 +9787313153746 +9787313154088 +9787313154798 +9787313154804 +9787313156020 +9787313160881 +9787313161758 +9787313162281 +9787313162601 +9787313164803 +9787313165350 +9787313166333 +9787313168344 +9787313169709 +9787313170330 +9787313170941 +9787313171610 +9787313172334 +9787313172358 +9787313172365 +9787313172600 +9787313174185 +9787313174604 +9787313174703 +9787313174789 +9787313175090 +9787313175366 +9787313176790 +9787313176929 +9787313178084 +9787313178169 +9787313178244 +9787313178275 +9787313178428 +9787313179005 +9787313179296 +9787313180070 +9787313180797 +9787313182012 +9787313183194 +9787313183620 +9787313183972 +9787313184825 +9787313187246 +9787313187833 +9787313189059 +9787313190192 +9787313190628 +9787313190901 +9787313191052 +9787313191229 +9787313192448 +9787313194886 +9787313196200 +9787313196408 +9787313196453 +9787313197696 +9787313198150 +9787313198204 +9787313198228 +9787313199133 +9787313199676 +9787313201003 +9787313201355 +9787313202031 +9787313202956 +9787313204738 +9787313205636 +9787313207333 +9787313207920 +9787313208057 +9787313208552 +9787313208613 +9787313209122 +9787313209313 +9787313209696 +9787313210449 +9787313210517 +9787313211743 +9787313212818 +9787313212948 +9787313213105 +9787313214379 +9787313214485 +9787313214973 +9787313215192 +9787313215215 +9787313216069 +9787313216861 +9787313216953 +9787313217011 +9787313217189 +9787313218131 +9787313218476 +9787313218896 +9787313221049 +9787313221230 +9787313221599 +9787313221674 +9787313221940 +9787313222398 +9787313222428 +9787313222442 +9787313222541 +9787313222565 +9787313222589 +9787313223111 +9787313223517 +9787313223562 +9787313223579 +9787313224156 +9787313224408 +9787313224477 +9787313225047 +9787313227072 +9787313228598 +9787313228956 +9787313229069 +9787313229694 +9787313230355 +9787313231253 +9787313231499 +9787313232670 +9787313232724 +9787313232755 +9787313234124 +9787313234643 +9787313234766 +9787313235121 +9787313235886 +9787313235992 +9787313236487 +9787313236548 +9787313236609 +9787313237125 +9787313237330 +9787313237446 +9787313237514 +9787313237712 +9787313238269 +9787313239358 +9787313239419 +9787313239532 +9787313240040 +9787313242259 +9787313244314 +9787313244321 +9787313244680 +9787313245267 +9787313245632 +9787313245663 +9787313247643 +9787313247896 +9787313248008 +9787313248084 +9787313248114 +9787313248176 +9787313248275 +9787313248701 +9787313248800 +9787313248916 +9787313249319 +9787313249760 +9787313250148 +9787313250162 +9787313250223 +9787313250568 +9787313251541 +9787313252111 +9787313252234 +9787313252241 +9787313252517 +9787313252944 +9787313254511 +9787313256775 +9787313257437 +9787313257895 +9787313258731 +9787313258892 +9787313258960 +9787313259141 +9787313259271 +9787313259684 +9787313260246 +9787313260277 +9787313260307 +9787313261410 +9787313262776 +9787313262882 +9787313263001 +9787313263919 +9787313264046 +9787313264763 +9787313265357 +9787313265654 +9787313265739 +9787313266132 +9787313266453 +9787313266545 +9787313267115 +9787313267474 +9787313268051 +9787313268198 +9787313268372 +9787313268396 +9787313268402 +9787313269294 +9787313269379 +9787313269454 +9787313270160 +9787313270412 +9787313270436 +9787313270535 +9787313270733 +9787313271211 +9787313272270 +9787313272515 +9787313272522 +9787313273505 +9787313273611 +9787313273864 +9787313274175 +9787313274281 +9787313275141 +9787313275530 +9787313275561 +9787313276087 +9787313276094 +9787313276131 +9787313276766 +9787313276773 +9787313276780 +9787313277312 +9787313277398 +9787313278470 +9787313278746 +9787313278975 +9787313279194 +9787313279743 +9787313279767 +9787313279798 +9787313279811 +9787313279859 +9787313279880 +9787313280053 +9787313280138 +9787313280435 +9787313280589 +9787313281258 +9787313281470 +9787313281524 +9787313282637 +9787313282750 +9787313283030 +9787313283832 +9787313284204 +9787313284495 +9787313284792 +9787313284884 +9787313284907 +9787313284921 +9787313284945 +9787313285607 +9787313285881 +9787313287120 +9787313287779 +9787313287977 +9787313288004 +9787313288035 +9787313288455 +9787313288462 +9787313288752 +9787313288783 +9787313289490 +9787313289643 +9787313289797 +9787313289834 +9787313289858 +9787313290175 +9787313290588 +9787313291066 +9787313291134 +9787313291332 +9787313291455 +9787313291899 +9787313292117 +9787313292797 +9787313293251 +9787313293428 +9787313294159 +9787313294388 +9787313294838 +9787313295569 +9787313297259 +9787313297587 +9787313297617 +9787313297877 +9787313298126 +9787313299390 +9787313299680 +9787313300249 +9787313302212 +9787313302281 +9787313302298 +9787313302830 +9787313303752 +9787313304162 +9787313304940 +9787313305039 +9787313305541 +9787313305657 +9787313305664 +9787313305671 +9787313305824 +9787313305992 +9787313306142 +9787313307156 +9787313307361 +9787313307620 +9787313307644 +9787313307828 +9787313308139 +9787313308221 +9787313308634 +9787313308832 +9787313309051 +9787313309419 +9787313309532 +9787313309648 +9787313309709 +9787313310132 +9787313311078 +9787313311153 +9787313311474 +9787313312327 +9787313312464 +9787313313980 +9787313314130 +9787313314789 +9787313314864 +9787313315038 +9787313315373 +9787313315748 +9787313316127 +9787313316257 +9787313316653 +9787313316691 +9787313316882 +9787313317155 +9787313318114 +9787313318930 +9787313319944 +9787313324061 +9787313324559 +9787313324993 +9787314001817 +9787314001862 +9787314001916 +9787314003200 +9787314003408 +9787314003637 +9787314003729 +9787314003910 +9787314004665 +9787324212340 +9787327817351 +9787358953417 +9787369637917 +9787376872684 +9787405054135 +9787412630209 +9787500000471 +9787500000570 +9787500000631 +9787500000648 +9787500000679 +9787500000716 +9787500000822 +9787500000891 +9787500000969 +9787500001232 +9787500001539 +9787500001560 +9787500001676 +9787500001737 +9787500001751 +9787500001799 +9787500001812 +9787500001836 +9787500001843 +9787500001928 +9787500001935 +9787500001942 +9787500001959 +9787500001966 +9787500002048 +9787500002079 +9787500002093 +9787500002116 +9787500002147 +9787500002475 +9787500002581 +9787500002635 +9787500002666 +9787500002833 +9787500002857 +9787500002888 +9787500003069 +9787500003083 +9787500003090 +9787500003205 +9787500003229 +9787500003397 +9787500003502 +9787500003670 +9787500003731 +9787500003748 +9787500003861 +9787500003984 +9787500004011 +9787500004080 +9787500004134 +9787500004325 +9787500004431 +9787500004585 +9787500004653 +9787500004813 +9787500004820 +9787500050186 +9787500050292 +9787500050421 +9787500050452 +9787500050704 +9787500050803 +9787500050964 +9787500051084 +9787500051381 +9787500051510 +9787500051916 +9787500052241 +9787500052418 +9787500052470 +9787500052883 +9787500053002 +9787500053262 +9787500053293 +9787500053385 +9787500053392 +9787500053453 +9787500053569 +9787500053712 +9787500053774 +9787500054696 +9787500054719 +9787500056126 +9787500056164 +9787500056225 +9787500056515 +9787500056539 +9787500056607 +9787500056621 +9787500056638 +9787500056652 +9787500056669 +9787500056676 +9787500056683 +9787500056713 +9787500056744 +9787500056751 +9787500056782 +9787500057208 +9787500057482 +9787500058113 +9787500059035 +9787500059042 +9787500059066 +9787500059301 +9787500059318 +9787500059479 +9787500059554 +9787500059578 +9787500059615 +9787500059967 +9787500060352 +9787500060499 +9787500060604 +9787500060833 +9787500061021 +9787500061052 +9787500061151 +9787500061205 +9787500061328 +9787500061342 +9787500061380 +9787500061410 +9787500061502 +9787500061809 +9787500061991 +9787500062028 +9787500062035 +9787500062059 +9787500062103 +9787500062196 +9787500062202 +9787500062288 +9787500062813 +9787500063384 +9787500063889 +9787500064282 +9787500064473 +9787500064480 +9787500064527 +9787500064534 +9787500064893 +9787500064923 +9787500065449 +9787500065456 +9787500066088 +9787500066248 +9787500066255 +9787500066606 +9787500066613 +9787500066842 +9787500067856 +9787500067894 +9787500068440 +9787500069447 +9787500069522 +9787500069560 +9787500069584 +9787500069652 +9787500069799 +9787500069973 +9787500070054 +9787500071136 +9787500071389 +9787500071471 +9787500071990 +9787500072010 +9787500072027 +9787500072089 +9787500072485 +9787500072522 +9787500072614 +9787500072737 +9787500073215 +9787500073383 +9787500073758 +9787500073956 +9787500074045 +9787500074458 +9787500074809 +9787500075080 +9787500075547 +9787500075929 +9787500075967 +9787500076285 +9787500076636 +9787500076780 +9787500076841 +9787500077084 +9787500077091 +9787500077107 +9787500077114 +9787500077145 +9787500077435 +9787500077534 +9787500077572 +9787500077664 +9787500077732 +9787500077749 +9787500077770 +9787500077893 +9787500077923 +9787500077947 +9787500077961 +9787500077978 +9787500077985 +9787500078012 +9787500078104 +9787500078128 +9787500078135 +9787500078203 +9787500078494 +9787500078531 +9787500078586 +9787500078678 +9787500079354 +9787500079682 +9787500080008 +9787500081401 +9787500081500 +9787500082040 +9787500083290 +9787500084495 +9787500084648 +9787500085256 +9787500085478 +9787500086956 +9787500086987 +9787500086994 +9787500087007 +9787500087038 +9787500087045 +9787500087328 +9787500087724 +9787500087748 +9787500088066 +9787500088103 +9787500088110 +9787500088547 +9787500088585 +9787500088622 +9787500088912 +9787500089025 +9787500089056 +9787500089063 +9787500089452 +9787500089674 +9787500089735 +9787500090472 +9787500091035 +9787500091158 +9787500091301 +9787500091936 +9787500092001 +9787500092384 +9787500092605 +9787500092797 +9787500093602 +9787500093770 +9787500094388 +9787500094630 +9787500094647 +9787500094708 +9787500094753 +9787500094784 +9787500095255 +9787500095613 +9787500096351 +9787500096443 +9787500096979 +9787500097129 +9787500098188 +9787500098546 +9787500098645 +9787500098751 +9787500098775 +9787500100157 +9787500100164 +9787500100300 +9787500100720 +9787500101048 +9787500101079 +9787500101116 +9787500101185 +9787500101192 +9787500101239 +9787500101383 +9787500101451 +9787500101628 +9787500101895 +9787500102182 +9787500102205 +9787500102212 +9787500102236 +9787500102489 +9787500102649 +9787500102731 +9787500102762 +9787500102908 +9787500103141 +9787500103165 +9787500103356 +9787500103394 +9787500103424 +9787500103448 +9787500103462 +9787500103486 +9787500103530 +9787500103592 +9787500103837 +9787500103899 +9787500103943 +9787500103967 +9787500104018 +9787500104339 +9787500104407 +9787500104452 +9787500104520 +9787500104667 +9787500104674 +9787500104698 +9787500104704 +9787500104728 +9787500104797 +9787500104810 +9787500104834 +9787500105060 +9787500105251 +9787500105497 +9787500105640 +9787500105664 +9787500105831 +9787500106036 +9787500106227 +9787500106517 +9787500106777 +9787500106784 +9787500106869 +9787500106876 +9787500107156 +9787500107293 +9787500107545 +9787500107637 +9787500107897 +9787500107996 +9787500108337 +9787500108344 +9787500108382 +9787500108566 +9787500109396 +9787500109419 +9787500113409 +9787500113973 +9787500115359 +9787500117025 +9787500117568 +9787500117896 +9787500119098 +9787500119463 +9787500119548 +9787500119821 +9787500119913 +9787500121893 +9787500121954 +9787500122173 +9787500122197 +9787500123804 +9787500124351 +9787500128779 +9787500128960 +9787500130079 +9787500131786 +9787500132073 +9787500132134 +9787500132615 +9787500133803 +9787500133940 +9787500135562 +9787500137054 +9787500137108 +9787500137276 +9787500137337 +9787500138242 +9787500138266 +9787500138341 +9787500138846 +9787500138976 +9787500142294 +9787500143031 +9787500143291 +9787500143499 +9787500145936 +9787500147701 +9787500147756 +9787500149064 +9787500150206 +9787500150220 +9787500150237 +9787500151487 +9787500151678 +9787500151692 +9787500151708 +9787500152569 +9787500154280 +9787500154303 +9787500155102 +9787500155119 +9787500155638 +9787500156598 +9787500156734 +9787500156826 +9787500157144 +9787500157151 +9787500157175 +9787500157182 +9787500157236 +9787500157540 +9787500157564 +9787500157571 +9787500157595 +9787500157649 +9787500157656 +9787500157861 +9787500157946 +9787500158493 +9787500159254 +9787500159445 +9787500159452 +9787500159919 +9787500160311 +9787500160342 +9787500160410 +9787500160427 +9787500160953 +9787500161172 +9787500162025 +9787500162872 +9787500162940 +9787500162957 +9787500163244 +9787500163435 +9787500163527 +9787500163749 +9787500163794 +9787500164050 +9787500164104 +9787500164432 +9787500164937 +9787500164944 +9787500164982 +9787500165163 +9787500165910 +9787500166153 +9787500167020 +9787500167457 +9787500167730 +9787500170112 +9787500170730 +9787500171560 +9787500171577 +9787500173465 +9787500173915 +9787500173960 +9787500174127 +9787500174301 +9787500174424 +9787500174530 +9787500174752 +9787500174899 +9787500175155 +9787500175353 +9787500176114 +9787500176404 +9787500176824 +9787500176893 +9787500176916 +9787500177319 +9787500177340 +9787500177890 +9787500178118 +9787500178217 +9787500178606 +9787500178873 +9787500179320 +9787500179375 +9787500179559 +9787500179788 +9787500179795 +9787500179962 +9787500180005 +9787500180104 +9787500180128 +9787500180548 +9787500180630 +9787500180647 +9787500180760 +9787500180852 +9787500180869 +9787500180999 +9787500181064 +9787500181095 +9787500181118 +9787500181132 +9787500181316 +9787500181323 +9787500181330 +9787500181392 +9787500202158 +9787500202424 +9787500206040 +9787500211365 +9787500211747 +9787500212157 +9787500212164 +9787500212171 +9787500212560 +9787500212881 +9787500212935 +9787500212966 +9787500213185 +9787500213611 +9787500213635 +9787500214052 +9787500215172 +9787500216261 +9787500216544 +9787500217329 +9787500217398 +9787500217688 +9787500218012 +9787500218111 +9787500218340 +9787500218739 +9787500218876 +9787500219255 +9787500219569 +9787500220145 +9787500220848 +9787500224686 +9787500225447 +9787500225652 +9787500225669 +9787500225713 +9787500225966 +9787500226475 +9787500226499 +9787500226529 +9787500230793 +9787500235187 +9787500251361 +9787500251804 +9787500252863 +9787500260974 +9787500264316 +9787500264460 +9787500278641 +9787500296218 +9787500300014 +9787500300021 +9787500300052 +9787500300106 +9787500300175 +9787500300236 +9787500300281 +9787500300304 +9787500300359 +9787500300373 +9787500300441 +9787500300458 +9787500300519 +9787500300540 +9787500300601 +9787500300632 +9787500300717 +9787500300939 +9787500301028 +9787500301080 +9787500301103 +9787500301448 +9787500301455 +9787500301479 +9787500301516 +9787500301523 +9787500301578 +9787500301639 +9787500301714 +9787500301820 +9787500301936 +9787500302261 +9787500302322 +9787500302391 +9787500302407 +9787500302544 +9787500302575 +9787500302674 +9787500302704 +9787500302773 +9787500302841 +9787500303077 +9787500303305 +9787500303312 +9787500303329 +9787500303350 +9787500303503 +9787500303602 +9787500303879 +9787500304807 +9787500305040 +9787500305149 +9787500305316 +9787500305590 +9787500305637 +9787500305859 +9787500305873 +9787500305965 +9787500306160 +9787500306443 +9787500307037 +9787500307396 +9787500307495 +9787500307662 +9787500307846 +9787500307914 +9787500307945 +9787500308027 +9787500308089 +9787500308713 +9787500308737 +9787500308898 +9787500309246 +9787500309697 +9787500309819 +9787500310266 +9787500310952 +9787500311461 +9787500311577 +9787500311614 +9787500311973 +9787500311980 +9787500312215 +9787500312512 +9787500312741 +9787500312901 +9787500313151 +9787500313342 +9787500313854 +9787500314011 +9787500314066 +9787500314318 +9787500314431 +9787500314578 +9787500315070 +9787500315438 +9787500315865 +9787500317432 +9787500317685 +9787500317739 +9787500317845 +9787500318026 +9787500318545 +9787500319023 +9787500320265 +9787500320890 +9787500322139 +9787500322160 +9787500322542 +9787500322641 +9787500322672 +9787500322740 +9787500322795 +9787500323013 +9787500323105 +9787500323174 +9787500323259 +9787500323587 +9787500323730 +9787500324751 +9787500325161 +9787500325390 +9787500325499 +9787500325574 +9787500325598 +9787500325802 +9787500326076 +9787500326144 +9787500326410 +9787500326625 +9787500326649 +9787500326656 +9787500326892 +9787500400004 +9787500400257 +9787500400301 +9787500400318 +9787500400356 +9787500400417 +9787500400622 +9787500400721 +9787500400738 +9787500400844 +9787500400899 +9787500400912 +9787500401070 +9787500401391 +9787500401551 +9787500401582 +9787500401612 +9787500401797 +9787500401995 +9787500402121 +9787500402169 +9787500402374 +9787500402459 +9787500402541 +9787500402756 +9787500402985 +9787500403074 +9787500403210 +9787500403272 +9787500403326 +9787500403449 +9787500403685 +9787500403807 +9787500403982 +9787500404149 +9787500404200 +9787500404484 +9787500404521 +9787500404538 +9787500404569 +9787500404620 +9787500404637 +9787500404897 +9787500404941 +9787500405016 +9787500405047 +9787500405214 +9787500405313 +9787500405399 +9787500405481 +9787500405511 +9787500405719 +9787500405818 +9787500405825 +9787500406068 +9787500406136 +9787500406181 +9787500406259 +9787500406297 +9787500406303 +9787500406372 +9787500406426 +9787500406433 +9787500406501 +9787500406563 +9787500406631 +9787500406686 +9787500406730 +9787500406907 +9787500407003 +9787500407249 +9787500407768 +9787500408192 +9787500408239 +9787500408314 +9787500408376 +9787500408413 +9787500408604 +9787500408796 +9787500409014 +9787500409144 +9787500409175 +9787500409212 +9787500409274 +9787500409397 +9787500409533 +9787500409564 +9787500409571 +9787500409908 +9787500410157 +9787500410355 +9787500410430 +9787500410454 +9787500410645 +9787500410942 +9787500411048 +9787500411079 +9787500411086 +9787500411260 +9787500411352 +9787500411444 +9787500411529 +9787500411543 +9787500411598 +9787500411635 +9787500411703 +9787500411888 +9787500411949 +9787500411956 +9787500411970 +9787500412212 +9787500412380 +9787500412663 +9787500412809 +9787500412847 +9787500412946 +9787500413035 +9787500413059 +9787500413295 +9787500413370 +9787500413455 +9787500413868 +9787500414032 +9787500414193 +9787500414209 +9787500414407 +9787500414438 +9787500414513 +9787500414711 +9787500415121 +9787500415190 +9787500415237 +9787500415244 +9787500415251 +9787500415497 +9787500415527 +9787500415640 +9787500415695 +9787500415862 +9787500415893 +9787500416029 +9787500416036 +9787500416043 +9787500416081 +9787500416166 +9787500416265 +9787500416357 +9787500416371 +9787500416449 +9787500416692 +9787500416722 +9787500416807 +9787500416845 +9787500416883 +9787500417002 +9787500417019 +9787500417033 +9787500417040 +9787500417057 +9787500417064 +9787500417163 +9787500417217 +9787500417521 +9787500417781 +9787500417866 +9787500417897 +9787500417927 +9787500417941 +9787500417996 +9787500418009 +9787500418016 +9787500418115 +9787500418122 +9787500418320 +9787500418368 +9787500418382 +9787500418504 +9787500418542 +9787500418559 +9787500418566 +9787500418610 +9787500418658 +9787500418672 +9787500418771 +9787500418894 +9787500418979 +9787500419006 +9787500419211 +9787500419310 +9787500419358 +9787500419396 +9787500419402 +9787500419464 +9787500419471 +9787500419587 +9787500419600 +9787500419624 +9787500419723 +9787500419730 +9787500419808 +9787500419938 +9787500419952 +9787500419983 +9787500420071 +9787500420170 +9787500420194 +9787500420224 +9787500420231 +9787500420330 +9787500420354 +9787500420392 +9787500420408 +9787500420569 +9787500420576 +9787500420613 +9787500420620 +9787500420675 +9787500420705 +9787500420743 +9787500420859 +9787500420903 +9787500420989 +9787500421016 +9787500421023 +9787500421030 +9787500421283 +9787500421405 +9787500421443 +9787500421450 +9787500421535 +9787500421702 +9787500421801 +9787500421924 +9787500422075 +9787500422105 +9787500422167 +9787500422235 +9787500422570 +9787500422679 +9787500422693 +9787500422822 +9787500422839 +9787500422860 +9787500422921 +9787500422945 +9787500422969 +9787500422976 +9787500423034 +9787500423065 +9787500423072 +9787500423218 +9787500423270 +9787500423294 +9787500423324 +9787500423522 +9787500423546 +9787500423577 +9787500423584 +9787500423812 +9787500423829 +9787500423867 +9787500423928 +9787500424017 +9787500424314 +9787500424673 +9787500424710 +9787500424727 +9787500424741 +9787500424765 +9787500425168 +9787500425496 +9787500425601 +9787500425731 +9787500425861 +9787500426059 +9787500426066 +9787500426103 +9787500426127 +9787500426158 +9787500426202 +9787500426493 +9787500426622 +9787500426646 +9787500426691 +9787500426950 +9787500427063 +9787500427117 +9787500427124 +9787500427339 +9787500427391 +9787500427476 +9787500427483 +9787500427612 +9787500427643 +9787500427674 +9787500428237 +9787500428701 +9787500428886 +9787500428947 +9787500428985 +9787500428992 +9787500429012 +9787500429029 +9787500429111 +9787500429142 +9787500429173 +9787500429180 +9787500429296 +9787500429319 +9787500429340 +9787500429432 +9787500429562 +9787500429586 +9787500429654 +9787500429722 +9787500429791 +9787500429807 +9787500430087 +9787500430155 +9787500430162 +9787500430216 +9787500430353 +9787500430445 +9787500430476 +9787500430711 +9787500430957 +9787500431091 +9787500431466 +9787500431480 +9787500431541 +9787500431947 +9787500431961 +9787500431978 +9787500432005 +9787500432029 +9787500432074 +9787500432210 +9787500432234 +9787500432425 +9787500432548 +9787500432623 +9787500432838 +9787500432920 +9787500432975 +9787500433439 +9787500433804 +9787500434078 +9787500434153 +9787500434177 +9787500434450 +9787500434917 +9787500435037 +9787500435372 +9787500435433 +9787500435525 +9787500435747 +9787500435839 +9787500435945 +9787500436065 +9787500436119 +9787500436164 +9787500436218 +9787500436836 +9787500436843 +9787500437017 +9787500437055 +9787500437321 +9787500437499 +9787500437581 +9787500437673 +9787500438069 +9787500438168 +9787500438519 +9787500438687 +9787500439264 +9787500439530 +9787500439585 +9787500439783 +9787500440031 +9787500440185 +9787500440512 +9787500440574 +9787500440635 +9787500440710 +9787500440840 +9787500440932 +9787500441083 +9787500441106 +9787500441199 +9787500441403 +9787500441601 +9787500441847 +9787500442097 +9787500442110 +9787500442158 +9787500443421 +9787500443445 +9787500444398 +9787500444619 +9787500445449 +9787500446316 +9787500446408 +9787500446934 +9787500447030 +9787500447238 +9787500447337 +9787500447818 +9787500447856 +9787500448112 +9787500448129 +9787500448259 +9787500448471 +9787500450245 +9787500451440 +9787500452652 +9787500453253 +9787500453512 +9787500454052 +9787500454229 +9787500454595 +9787500455332 +9787500455493 +9787500456865 +9787500457008 +9787500457107 +9787500458319 +9787500459453 +9787500460152 +9787500460640 +9787500461296 +9787500462682 +9787500463443 +9787500464327 +9787500466024 +9787500467014 +9787500467311 +9787500467557 +9787500467809 +9787500468882 +9787500469025 +9787500470175 +9787500471868 +9787500471950 +9787500472209 +9787500473787 +9787500475248 +9787500475507 +9787500475651 +9787500476658 +9787500478188 +9787500478591 +9787500481416 +9787500482383 +9787500482420 +9787500482604 +9787500482680 +9787500483359 +9787500483892 +9787500488569 +9787500488699 +9787500488798 +9787500488934 +9787500490456 +9787500490579 +9787500494379 +9787500495550 +9787500498674 +9787500501800 +9787500501824 +9787500501848 +9787500502135 +9787500506324 +9787500506676 +9787500506683 +9787500507925 +9787500511168 +9787500516828 +9787500517672 +9787500517733 +9787500521136 +9787500521549 +9787500523543 +9787500524304 +9787500524694 +9787500524915 +9787500525264 +9787500525431 +9787500526636 +9787500527275 +9787500527367 +9787500527473 +9787500527978 +9787500528609 +9787500529859 +9787500530084 +9787500530527 +9787500533344 +9787500536512 +9787500536857 +9787500537014 +9787500537281 +9787500537298 +9787500538356 +9787500540618 +9787500541028 +9787500542100 +9787500543923 +9787500544371 +9787500544791 +9787500544838 +9787500546504 +9787500546689 +9787500546917 +9787500548867 +9787500552468 +9787500553465 +9787500553526 +9787500554448 +9787500554479 +9787500557906 +9787500558040 +9787500558576 +9787500560937 +9787500561408 +9787500562733 +9787500562757 +9787500563068 +9787500563990 +9787500564126 +9787500564133 +9787500564478 +9787500565161 +9787500566717 +9787500567967 +9787500568186 +9787500571025 +9787500571599 +9787500572749 +9787500574460 +9787500576815 +9787500579205 +9787500581079 +9787500581260 +9787500582366 +9787500585831 +9787500586678 +9787500587866 +9787500589815 +9787500597209 +9787500597247 +9787500599470 +9787500600046 +9787500600107 +9787500600121 +9787500600190 +9787500600268 +9787500600398 +9787500600701 +9787500600749 +9787500600756 +9787500600855 +9787500600909 +9787500600916 +9787500600985 +9787500601012 +9787500601159 +9787500601333 +9787500601425 +9787500601616 +9787500601623 +9787500601685 +9787500601708 +9787500601944 +9787500602125 +9787500602170 +9787500602187 +9787500602262 +9787500602637 +9787500602651 +9787500602750 +9787500602767 +9787500602897 +9787500602903 +9787500603009 +9787500603047 +9787500603085 +9787500603115 +9787500603313 +9787500603528 +9787500603559 +9787500603627 +9787500603825 +9787500603948 +9787500604037 +9787500604167 +9787500604297 +9787500604570 +9787500604631 +9787500604785 +9787500604815 +9787500605270 +9787500605362 +9787500605409 +9787500606239 +9787500606260 +9787500606291 +9787500606468 +9787500606512 +9787500606529 +9787500606543 +9787500606680 +9787500607021 +9787500607052 +9787500607090 +9787500607311 +9787500607328 +9787500607397 +9787500607571 +9787500607694 +9787500607700 +9787500607908 +9787500608158 +9787500608462 +9787500608547 +9787500608554 +9787500608813 +9787500609148 +9787500609315 +9787500609322 +9787500609339 +9787500609346 +9787500609384 +9787500609476 +9787500609513 +9787500609599 +9787500609605 +9787500609629 +9787500609667 +9787500609674 +9787500609681 +9787500609704 +9787500609759 +9787500609766 +9787500609797 +9787500609834 +9787500609841 +9787500609872 +9787500609889 +9787500609926 +9787500609995 +9787500610083 +9787500610236 +9787500610335 +9787500610434 +9787500610489 +9787500610496 +9787500610540 +9787500610557 +9787500610564 +9787500610588 +9787500610700 +9787500610762 +9787500610915 +9787500611035 +9787500611059 +9787500611219 +9787500611394 +9787500611400 +9787500611455 +9787500611585 +9787500611646 +9787500611660 +9787500611684 +9787500611738 +9787500611875 +9787500611929 +9787500611974 +9787500611998 +9787500612018 +9787500612131 +9787500612193 +9787500612230 +9787500612377 +9787500612889 +9787500612896 +9787500613060 +9787500613077 +9787500613138 +9787500613190 +9787500613206 +9787500613725 +9787500613848 +9787500613909 +9787500613916 +9787500613923 +9787500613954 +9787500613992 +9787500614005 +9787500614104 +9787500614142 +9787500614241 +9787500614401 +9787500614609 +9787500614920 +9787500614937 +9787500614975 +9787500614982 +9787500615040 +9787500615125 +9787500615156 +9787500615231 +9787500615248 +9787500615293 +9787500615439 +9787500615446 +9787500615644 +9787500615682 +9787500615712 +9787500615750 +9787500615781 +9787500615804 +9787500615811 +9787500615828 +9787500615835 +9787500616085 +9787500616153 +9787500616160 +9787500616276 +9787500616450 +9787500616504 +9787500616627 +9787500616634 +9787500616658 +9787500616771 +9787500616795 +9787500616986 +9787500617150 +9787500617273 +9787500617365 +9787500617518 +9787500617570 +9787500617587 +9787500617631 +9787500617662 +9787500617693 +9787500617716 +9787500617785 +9787500617792 +9787500618331 +9787500618348 +9787500618546 +9787500618553 +9787500618560 +9787500618591 +9787500618652 +9787500618782 +9787500618805 +9787500618898 +9787500618904 +9787500618911 +9787500618928 +9787500618942 +9787500619024 +9787500619048 +9787500619055 +9787500619062 +9787500619079 +9787500619093 +9787500619109 +9787500619260 +9787500619352 +9787500619413 +9787500619437 +9787500619444 +9787500619451 +9787500619468 +9787500619505 +9787500619574 +9787500619581 +9787500619598 +9787500619680 +9787500619741 +9787500619796 +9787500619932 +9787500619956 +9787500619987 +9787500620358 +9787500620389 +9787500620525 +9787500620549 +9787500620716 +9787500620723 +9787500620921 +9787500621058 +9787500621164 +9787500621171 +9787500621300 +9787500621348 +9787500621607 +9787500621706 +9787500621713 +9787500621720 +9787500621751 +9787500621775 +9787500621782 +9787500621911 +9787500621966 +9787500621997 +9787500622000 +9787500622024 +9787500622062 +9787500622093 +9787500622185 +9787500622192 +9787500622376 +9787500622406 +9787500622444 +9787500622574 +9787500622659 +9787500622796 +9787500622864 +9787500622888 +9787500622918 +9787500622956 +9787500622963 +9787500623274 +9787500623410 +9787500623441 +9787500623472 +9787500623502 +9787500623526 +9787500623649 +9787500623717 +9787500623724 +9787500623809 +9787500623915 +9787500623922 +9787500623946 +9787500624028 +9787500624240 +9787500624264 +9787500624288 +9787500624400 +9787500624530 +9787500624790 +9787500624929 +9787500624967 +9787500625018 +9787500625032 +9787500625056 +9787500625117 +9787500625209 +9787500625223 +9787500625322 +9787500625391 +9787500625421 +9787500625469 +9787500625711 +9787500625735 +9787500625742 +9787500625759 +9787500625834 +9787500626183 +9787500626237 +9787500626275 +9787500626282 +9787500626404 +9787500626428 +9787500626435 +9787500626909 +9787500626978 +9787500626985 +9787500627012 +9787500627036 +9787500627050 +9787500627067 +9787500627074 +9787500627128 +9787500627166 +9787500627210 +9787500627258 +9787500627463 +9787500627470 +9787500627609 +9787500627623 +9787500627630 +9787500627647 +9787500627661 +9787500627715 +9787500627722 +9787500627746 +9787500627753 +9787500628019 +9787500628026 +9787500628170 +9787500628231 +9787500628248 +9787500628262 +9787500628293 +9787500628316 +9787500628323 +9787500628439 +9787500628446 +9787500628453 +9787500628514 +9787500628521 +9787500628569 +9787500628583 +9787500628606 +9787500628613 +9787500628651 +9787500628699 +9787500628705 +9787500628798 +9787500628828 +9787500628859 +9787500628873 +9787500628903 +9787500628910 +9787500628927 +9787500628941 +9787500628958 +9787500628965 +9787500628996 +9787500629009 +9787500629016 +9787500629030 +9787500629054 +9787500629177 +9787500629276 +9787500629597 +9787500629672 +9787500629733 +9787500629788 +9787500629924 +9787500629993 +9787500630142 +9787500630487 +9787500630562 +9787500630593 +9787500630746 +9787500631156 +9787500631200 +9787500631279 +9787500631392 +9787500631705 +9787500631965 +9787500632009 +9787500632108 +9787500632122 +9787500632214 +9787500632221 +9787500632283 +9787500632306 +9787500632450 +9787500632566 +9787500632573 +9787500633006 +9787500633044 +9787500633075 +9787500633105 +9787500633112 +9787500633235 +9787500633242 +9787500633372 +9787500633440 +9787500633464 +9787500633488 +9787500633563 +9787500633655 +9787500633679 +9787500633686 +9787500633693 +9787500633730 +9787500633747 +9787500633839 +9787500633945 +9787500633990 +9787500634096 +9787500634119 +9787500634188 +9787500634232 +9787500634294 +9787500634317 +9787500634393 +9787500634430 +9787500634515 +9787500634614 +9787500634638 +9787500634645 +9787500634669 +9787500634676 +9787500634706 +9787500634744 +9787500634775 +9787500634836 +9787500634904 +9787500634935 +9787500635086 +9787500635130 +9787500635314 +9787500635369 +9787500635406 +9787500635444 +9787500635482 +9787500635789 +9787500635802 +9787500636021 +9787500636144 +9787500636168 +9787500636274 +9787500636427 +9787500636472 +9787500636540 +9787500636557 +9787500636618 +9787500636694 +9787500636823 +9787500637073 +9787500637134 +9787500637226 +9787500637479 +9787500637523 +9787500637639 +9787500637660 +9787500637851 +9787500637875 +9787500637974 +9787500637998 +9787500638018 +9787500638049 +9787500638087 +9787500638131 +9787500638155 +9787500638308 +9787500638315 +9787500638414 +9787500638452 +9787500638476 +9787500638582 +9787500638810 +9787500639190 +9787500639244 +9787500639268 +9787500639305 +9787500639565 +9787500639657 +9787500639671 +9787500639688 +9787500639718 +9787500639725 +9787500639817 +9787500639848 +9787500639862 +9787500639879 +9787500639930 +9787500639947 +9787500639954 +9787500639978 +9787500640097 +9787500640226 +9787500640455 +9787500640493 +9787500640547 +9787500640585 +9787500640592 +9787500640714 +9787500640837 +9787500640943 +9787500640950 +9787500641032 +9787500641063 +9787500641193 +9787500641339 +9787500641391 +9787500641452 +9787500641469 +9787500641605 +9787500641742 +9787500642145 +9787500642152 +9787500642336 +9787500642350 +9787500642367 +9787500642374 +9787500642497 +9787500642572 +9787500642596 +9787500642619 +9787500642756 +9787500642824 +9787500643142 +9787500643180 +9787500643265 +9787500643418 +9787500643449 +9787500643708 +9787500644118 +9787500644200 +9787500644286 +9787500644330 +9787500644408 +9787500644811 +9787500644880 +9787500644903 +9787500645122 +9787500645191 +9787500645467 +9787500645771 +9787500645788 +9787500645795 +9787500646068 +9787500646075 +9787500646143 +9787500646266 +9787500646303 +9787500646402 +9787500646433 +9787500646556 +9787500646785 +9787500646839 +9787500646860 +9787500647119 +9787500647140 +9787500647195 +9787500647249 +9787500647447 +9787500647492 +9787500647584 +9787500647935 +9787500648062 +9787500648093 +9787500648222 +9787500648253 +9787500648451 +9787500648581 +9787500648741 +9787500648840 +9787500648857 +9787500649014 +9787500649083 +9787500649328 +9787500649359 +9787500649380 +9787500649526 +9787500649717 +9787500650072 +9787500650119 +9787500650126 +9787500650492 +9787500650515 +9787500650607 +9787500650621 +9787500650683 +9787500650706 +9787500650768 +9787500650836 +9787500650904 +9787500651000 +9787500651086 +9787500651628 +9787500651659 +9787500651765 +9787500651864 +9787500651956 +9787500652076 +9787500652953 +9787500653035 +9787500653219 +9787500653288 +9787500653394 +9787500653639 +9787500653905 +9787500654322 +9787500654407 +9787500654490 +9787500654506 +9787500654681 +9787500654704 +9787500654957 +9787500654964 +9787500655060 +9787500655077 +9787500655138 +9787500655145 +9787500655350 +9787500655411 +9787500655428 +9787500655619 +9787500655626 +9787500655671 +9787500655688 +9787500655695 +9787500655749 +9787500655756 +9787500655923 +9787500656036 +9787500656531 +9787500656623 +9787500656715 +9787500656753 +9787500656913 +9787500656999 +9787500657019 +9787500657316 +9787500657330 +9787500657415 +9787500657552 +9787500657668 +9787500657699 +9787500657781 +9787500657972 +9787500658078 +9787500658108 +9787500658153 +9787500658269 +9787500658283 +9787500658429 +9787500658498 +9787500658771 +9787500659037 +9787500659082 +9787500659273 +9787500659297 +9787500659822 +9787500659839 +9787500659846 +9787500659938 +9787500660026 +9787500660378 +9787500660583 +9787500660675 +9787500660699 +9787500660798 +9787500660835 +9787500660842 +9787500660897 +9787500660927 +9787500661214 +9787500661252 +9787500661610 +9787500661627 +9787500661634 +9787500661795 +9787500662150 +9787500662235 +9787500662259 +9787500662280 +9787500662532 +9787500663065 +9787500663324 +9787500663355 +9787500664055 +9787500664239 +9787500664673 +9787500664833 +9787500664994 +9787500665007 +9787500665038 +9787500665045 +9787500665106 +9787500665168 +9787500665182 +9787500665359 +9787500665472 +9787500665731 +9787500665748 +9787500665830 +9787500665861 +9787500666318 +9787500666349 +9787500666417 +9787500666479 +9787500666585 +9787500666653 +9787500666684 +9787500666691 +9787500666905 +9787500667131 +9787500667148 +9787500667162 +9787500667230 +9787500667582 +9787500667957 +9787500667995 +9787500668077 +9787500668206 +9787500668268 +9787500668657 +9787500668664 +9787500669357 +9787500669401 +9787500669432 +9787500669524 +9787500669548 +9787500669760 +9787500670186 +9787500670537 +9787500670568 +9787500670698 +9787500670728 +9787500670964 +9787500671138 +9787500671275 +9787500671404 +9787500671411 +9787500671428 +9787500671503 +9787500671824 +9787500671893 +9787500672005 +9787500672029 +9787500672142 +9787500672159 +9787500672166 +9787500672265 +9787500672357 +9787500672401 +9787500672487 +9787500672500 +9787500672517 +9787500672531 +9787500672654 +9787500673026 +9787500673033 +9787500673453 +9787500673606 +9787500673712 +9787500673774 +9787500673828 +9787500674061 +9787500674085 +9787500674450 +9787500674931 +9787500675044 +9787500675068 +9787500675181 +9787500675365 +9787500675556 +9787500675679 +9787500675747 +9787500675754 +9787500675785 +9787500676034 +9787500676621 +9787500676942 +9787500677000 +9787500677062 +9787500677499 +9787500677567 +9787500677932 +9787500678007 +9787500678014 +9787500678670 +9787500678922 +9787500679455 +9787500679479 +9787500679608 +9787500679851 +9787500680000 +9787500680208 +9787500680246 +9787500680260 +9787500680420 +9787500680482 +9787500680734 +9787500680925 +9787500681007 +9787500681014 +9787500681021 +9787500682097 +9787500682387 +9787500682714 +9787500682776 +9787500682783 +9787500682929 +9787500682936 +9787500682967 +9787500682981 +9787500683094 +9787500683568 +9787500683599 +9787500683698 +9787500683858 +9787500684046 +9787500684589 +9787500684732 +9787500684794 +9787500684879 +9787500685074 +9787500685395 +9787500685500 +9787500685760 +9787500686071 +9787500686095 +9787500686132 +9787500686354 +9787500686484 +9787500686637 +9787500686774 +9787500686804 +9787500686989 +9787500687009 +9787500687122 +9787500687160 +9787500687214 +9787500687429 +9787500687771 +9787500688129 +9787500688648 +9787500688778 +9787500688785 +9787500688792 +9787500689058 +9787500689089 +9787500689119 +9787500689157 +9787500689379 +9787500689416 +9787500689478 +9787500689614 +9787500689799 +9787500690252 +9787500690412 +9787500690542 +9787500690924 +9787500691976 +9787500692072 +9787500692331 +9787500692423 +9787500692492 +9787500692553 +9787500692560 +9787500692591 +9787500692874 +9787500693055 +9787500693123 +9787500693451 +9787500693772 +9787500693888 +9787500694304 +9787500694366 +9787500694991 +9787500695707 +9787500695714 +9787500695745 +9787500695851 +9787500695868 +9787500695943 +9787500696087 +9787500696407 +9787500696476 +9787500696599 +9787500696919 +9787500697008 +9787500697039 +9787500697091 +9787500697565 +9787500697633 +9787500698104 +9787500698395 +9787500699071 +9787500699156 +9787500699293 +9787500699316 +9787500699392 +9787500699446 +9787500699453 +9787500699675 +9787500699682 +9787500699699 +9787500699781 +9787500700128 +9787500700371 +9787500700654 +9787500701781 +9787500702160 +9787500702184 +9787500702191 +9787500702207 +9787500702542 +9787500703808 +9787500703815 +9787500703884 +9787500704096 +9787500705000 +9787500705963 +9787500705970 +9787500707097 +9787500707134 +9787500708483 +9787500710325 +9787500710646 +9787500711148 +9787500711261 +9787500711421 +9787500713302 +9787500713319 +9787500713432 +9787500714019 +9787500714439 +9787500714903 +9787500715115 +9787500716020 +9787500716860 +9787500716884 +9787500720331 +9787500720645 +9787500720676 +9787500721376 +9787500721987 +9787500722038 +9787500722151 +9787500722205 +9787500722557 +9787500724049 +9787500724391 +9787500725664 +9787500725954 +9787500726555 +9787500726579 +9787500726753 +9787500727538 +9787500727545 +9787500729631 +9787500729792 +9787500729839 +9787500729884 +9787500731542 +9787500731849 +9787500732723 +9787500732730 +9787500733034 +9787500734055 +9787500734185 +9787500734314 +9787500734369 +9787500734635 +9787500734871 +9787500735274 +9787500735281 +9787500735311 +9787500735328 +9787500735786 +9787500737100 +9787500738466 +9787500739135 +9787500739548 +9787500740018 +9787500740131 +9787500740148 +9787500740544 +9787500740728 +9787500740797 +9787500740803 +9787500740919 +9787500741725 +9787500742401 +9787500742562 +9787500742807 +9787500742821 +9787500742838 +9787500742845 +9787500743842 +9787500744917 +9787500745051 +9787500745068 +9787500745273 +9787500745907 +9787500746119 +9787500746768 +9787500747352 +9787500747628 +9787500748250 +9787500748601 +9787500749127 +9787500749165 +9787500749615 +9787500749714 +9787500749738 +9787500749899 +9787500750093 +9787500750123 +9787500750581 +9787500750598 +9787500750611 +9787500750635 +9787500751106 +9787500751281 +9787500751496 +9787500751557 +9787500751946 +9787500752578 +9787500752622 +9787500752639 +9787500752776 +9787500753490 +9787500753520 +9787500753650 +9787500753667 +9787500753926 +9787500754404 +9787500754497 +9787500754695 +9787500754770 +9787500754794 +9787500754831 +9787500754886 +9787500755050 +9787500755166 +9787500755920 +9787500756163 +9787500756699 +9787500756842 +9787500757191 +9787500757221 +9787500757580 +9787500758228 +9787500758235 +9787500758396 +9787500758747 +9787500758754 +9787500758761 +9787500759140 +9787500760740 +9787500760801 +9787500760948 +9787500761556 +9787500762188 +9787500762270 +9787500762539 +9787500762829 +9787500763512 +9787500763628 +9787500763635 +9787500763703 +9787500764878 +9787500764908 +9787500765455 +9787500766421 +9787500766865 +9787500767299 +9787500769668 +9787500770060 +9787500771739 +9787500773535 +9787500773559 +9787500774594 +9787500776338 +9787500777267 +9787500780120 +9787500780236 +9787500780915 +9787500780953 +9787500781905 +9787500782049 +9787500782612 +9787500783091 +9787500784227 +9787500784623 +9787500784852 +9787500784951 +9787500785743 +9787500786184 +9787500786481 +9787500786689 +9787500786702 +9787500787945 +9787500788065 +9787500788522 +9787500789291 +9787500789727 +9787500789949 +9787500791607 +9787500792024 +9787500792062 +9787500792628 +9787500793427 +9787500793496 +9787500793632 +9787500794318 +9787500794912 +9787500795223 +9787500795247 +9787500795278 +9787500795599 +9787500795629 +9787500795643 +9787500795667 +9787500795902 +9787500796046 +9787500796077 +9787500796800 +9787500797456 +9787500797470 +9787500797784 +9787500798347 +9787500798361 +9787500798491 +9787500798644 +9787500798675 +9787500798835 +9787500798927 +9787500799115 +9787500800057 +9787500800217 +9787500800279 +9787500800446 +9787500800668 +9787500800774 +9787500800903 +9787500801146 +9787500801238 +9787500801474 +9787500801511 +9787500801610 +9787500801702 +9787500801795 +9787500801801 +9787500801863 +9787500801870 +9787500801955 +9787500801962 +9787500801979 +9787500801986 +9787500802303 +9787500802730 +9787500802761 +9787500802921 +9787500803164 +9787500803621 +9787500803706 +9787500803942 +9787500803980 +9787500804086 +9787500804475 +9787500804895 +9787500805052 +9787500805090 +9787500805113 +9787500805182 +9787500805212 +9787500805373 +9787500806042 +9787500806226 +9787500806349 +9787500806370 +9787500806714 +9787500806721 +9787500807698 +9787500807810 +9787500807858 +9787500807865 +9787500807872 +9787500807889 +9787500807919 +9787500808114 +9787500808336 +9787500808428 +9787500808466 +9787500808510 +9787500808619 +9787500808701 +9787500808817 +9787500809463 +9787500809647 +9787500809692 +9787500809784 +9787500809845 +9787500810001 +9787500810506 +9787500810698 +9787500810711 +9787500811084 +9787500811510 +9787500811640 +9787500811947 +9787500812142 +9787500812425 +9787500812449 +9787500812746 +9787500813323 +9787500813347 +9787500813798 +9787500813880 +9787500813972 +9787500814160 +9787500814450 +9787500814696 +9787500814818 +9787500815259 +9787500815624 +9787500815914 +9787500816195 +9787500816263 +9787500816782 +9787500817222 +9787500817260 +9787500817475 +9787500818236 +9787500818328 +9787500818359 +9787500818526 +9787500818687 +9787500819127 +9787500819363 +9787500819431 +9787500819554 +9787500819967 +9787500820307 +9787500820352 +9787500820703 +9787500820895 +9787500821045 +9787500821052 +9787500821090 +9787500821106 +9787500821236 +9787500821748 +9787500822202 +9787500822240 +9787500822776 +9787500822943 +9787500824190 +9787500824237 +9787500824268 +9787500824374 +9787500824411 +9787500824855 +9787500825104 +9787500825487 +9787500825500 +9787500825562 +9787500825678 +9787500825760 +9787500826064 +9787500826262 +9787500826378 +9787500826446 +9787500826453 +9787500826491 +9787500826682 +9787500826705 +9787500826750 +9787500826767 +9787500826910 +9787500827061 +9787500827559 +9787500827610 +9787500827849 +9787500828044 +9787500828143 +9787500828501 +9787500828648 +9787500828808 +9787500828891 +9787500828921 +9787500829393 +9787500829409 +9787500829850 +9787500830351 +9787500830825 +9787500831341 +9787500831792 +9787500831853 +9787500832300 +9787500833703 +9787500833710 +9787500833727 +9787500833956 +9787500833963 +9787500834007 +9787500834151 +9787500834205 +9787500834472 +9787500834670 +9787500834717 +9787500835134 +9787500836254 +9787500837213 +9787500837275 +9787500837497 +9787500837596 +9787500837602 +9787500838241 +9787500838593 +9787500839125 +9787500839279 +9787500840732 +9787500841067 +9787500841364 +9787500844983 +9787500845751 +9787500845928 +9787500846048 +9787500846352 +9787500847236 +9787500847755 +9787500848080 +9787500849629 +9787500850816 +9787500850984 +9787500851363 +9787500851653 +9787500852261 +9787500852872 +9787500853480 +9787500854326 +9787500854791 +9787500855682 +9787500857167 +9787500857709 +9787500858072 +9787500859628 +9787500859888 +9787500859932 +9787500860129 +9787500860150 +9787500860778 +9787500861195 +9787500862369 +9787500863052 +9787500863663 +9787500866633 +9787500867425 +9787500867890 +9787500868712 +9787500870708 +9787500871712 +9787500877189 +9787500877554 +9787500877660 +9787500878094 +9787500878896 +9787500880196 +9787500880271 +9787500880325 +9787500880493 +9787500882039 +9787500882084 +9787500882169 +9787500883210 +9787500885016 +9787500885160 +9787500886204 +9787500886327 +9787500900146 +9787500900207 +9787500900214 +9787500900276 +9787500900306 +9787500900399 +9787500900405 +9787500900528 +9787500900634 +9787500900658 +9787500900740 +9787500900856 +9787500900924 +9787500901433 +9787500901532 +9787500901556 +9787500901655 +9787500901884 +9787500901891 +9787500901907 +9787500901914 +9787500901921 +9787500901938 +9787500901969 +9787500901983 +9787500902041 +9787500902102 +9787500902157 +9787500902256 +9787500902317 +9787500902348 +9787500902393 +9787500902409 +9787500902423 +9787500902577 +9787500902614 +9787500902645 +9787500903215 +9787500903437 +9787500903468 +9787500903697 +9787500903734 +9787500903871 +9787500903918 +9787500903970 +9787500904038 +9787500904069 +9787500904090 +9787500904106 +9787500904120 +9787500904168 +9787500904229 +9787500904281 +9787500904304 +9787500904342 +9787500904496 +9787500904663 +9787500904670 +9787500904687 +9787500904700 +9787500904717 +9787500904724 +9787500904892 +9787500904946 +9787500905165 +9787500905219 +9787500905240 +9787500905288 +9787500905349 +9787500905363 +9787500905493 +9787500905509 +9787500905530 +9787500905547 +9787500905608 +9787500905622 +9787500905646 +9787500905653 +9787500905721 +9787500905844 +9787500905905 +9787500905912 +9787500905943 +9787500905998 +9787500906100 +9787500906216 +9787500906674 +9787500906735 +9787500906841 +9787500906865 +9787500907206 +9787500907213 +9787500907442 +9787500907459 +9787500907510 +9787500907589 +9787500907671 +9787500907688 +9787500907725 +9787500907992 +9787500908142 +9787500908159 +9787500908272 +9787500908531 +9787500908821 +9787500908975 +9787500908982 +9787500908999 +9787500909040 +9787500909064 +9787500909101 +9787500909149 +9787500909156 +9787500909170 +9787500909194 +9787500909217 +9787500909286 +9787500909316 +9787500909330 +9787500909453 +9787500909491 +9787500909514 +9787500909545 +9787500909637 +9787500910022 +9787500910121 +9787500910527 +9787500910756 +9787500910763 +9787500910770 +9787500910800 +9787500910831 +9787500910923 +9787500910961 +9787500910978 +9787500911074 +9787500911142 +9787500911210 +9787500911326 +9787500911456 +9787500911494 +9787500911654 +9787500911678 +9787500911753 +9787500911845 +9787500911944 +9787500911951 +9787500911968 +9787500911982 +9787500912118 +9787500912200 +9787500912460 +9787500912484 +9787500912545 +9787500912606 +9787500912620 +9787500912705 +9787500912743 +9787500912934 +9787500913009 +9787500913184 +9787500913290 +9787500913337 +9787500913351 +9787500913382 +9787500913436 +9787500914129 +9787500914136 +9787500914181 +9787500914235 +9787500914334 +9787500914372 +9787500914457 +9787500914525 +9787500914563 +9787500914600 +9787500914631 +9787500914716 +9787500914785 +9787500914792 +9787500914808 +9787500915201 +9787500915584 +9787500915591 +9787500915669 +9787500915744 +9787500915904 +9787500915928 +9787500915935 +9787500915942 +9787500915980 +9787500916055 +9787500916123 +9787500916147 +9787500916284 +9787500916376 +9787500916390 +9787500916475 +9787500916604 +9787500916680 +9787500916734 +9787500916765 +9787500916833 +9787500916956 +9787500917038 +9787500917083 +9787500917137 +9787500917229 +9787500917236 +9787500917342 +9787500917359 +9787500917472 +9787500917571 +9787500917601 +9787500917724 +9787500917885 +9787500917939 +9787500917991 +9787500918035 +9787500918066 +9787500918073 +9787500918196 +9787500918264 +9787500918356 +9787500918561 +9787500918653 +9787500918660 +9787500918967 +9787500919186 +9787500919353 +9787500919599 +9787500919636 +9787500919988 +9787500920113 +9787500920205 +9787500920427 +9787500920564 +9787500920717 +9787500920823 +9787500920953 +9787500921820 +9787500922230 +9787500922513 +9787500922568 +9787500922636 +9787500922674 +9787500922865 +9787500923282 +9787500923640 +9787500923688 +9787500924036 +9787500924258 +9787500924784 +9787500925019 +9787500925088 +9787500925187 +9787500925200 +9787500926566 +9787500926573 +9787500927112 +9787500927242 +9787500927372 +9787500927396 +9787500928379 +9787500928560 +9787500928706 +9787500929468 +9787500930440 +9787500931867 +9787500932154 +9787500932437 +9787500932659 +9787500933564 +9787500934493 +9787500934974 +9787500935315 +9787500935872 +9787500936107 +9787500936596 +9787500938057 +9787500939214 +9787500940425 +9787500941071 +9787500941477 +9787500941576 +9787500942115 +9787500942412 +9787500943358 +9787500943792 +9787500944249 +9787500944485 +9787500945055 +9787500947097 +9787500948278 +9787500951995 +9787500954767 +9787500956150 +9787500956389 +9787500956655 +9787500957355 +9787500958604 +9787500959175 +9787500959984 +9787500960133 +9787500960911 +9787500961284 +9787500961291 +9787500961307 +9787500962656 +9787500963004 +9787500963370 +9787500963462 +9787500963752 +9787500963967 +9787500964667 +9787500964872 +9787500964896 +9787500965145 +9787501000111 +9787501000296 +9787501000371 +9787501000562 +9787501000791 +9787501000838 +9787501000906 +9787501000937 +9787501000975 +9787501001026 +9787501001385 +9787501001514 +9787501001682 +9787501001965 +9787501002023 +9787501002511 +9787501002603 +9787501002832 +9787501002955 +9787501002986 +9787501003884 +9787501003914 +9787501004577 +9787501005475 +9787501005727 +9787501005901 +9787501005949 +9787501005987 +9787501006236 +9787501006274 +9787501006281 +9787501006366 +9787501006403 +9787501006564 +9787501006656 +9787501006915 +9787501007165 +9787501007783 +9787501007837 +9787501007936 +9787501008032 +9787501008124 +9787501008452 +9787501008490 +9787501008537 +9787501008568 +9787501008636 +9787501008643 +9787501008766 +9787501009305 +9787501009381 +9787501009763 +9787501009787 +9787501009817 +9787501009831 +9787501010042 +9787501010110 +9787501010165 +9787501010189 +9787501010295 +9787501010387 +9787501010813 +9787501010837 +9787501011070 +9787501011087 +9787501011124 +9787501011629 +9787501012022 +9787501012138 +9787501012824 +9787501012954 +9787501013135 +9787501013180 +9787501013500 +9787501015603 +9787501019304 +9787501019373 +9787501020591 +9787501022069 +9787501022571 +9787501022892 +9787501023271 +9787501025213 +9787501025848 +9787501027781 +9787501028962 +9787501029181 +9787501029853 +9787501030255 +9787501030286 +9787501030408 +9787501031450 +9787501031580 +9787501031696 +9787501031924 +9787501032259 +9787501032327 +9787501032648 +9787501032679 +9787501033232 +9787501033331 +9787501033843 +9787501033997 +9787501034468 +9787501036974 +9787501037292 +9787501038824 +9787501038978 +9787501041350 +9787501042104 +9787501043453 +9787501046522 +9787501046652 +9787501047727 +9787501056064 +9787501056118 +9787501056316 +9787501061167 +9787501061389 +9787501061624 +9787501062294 +9787501062317 +9787501062522 +9787501062560 +9787501063185 +9787501063307 +9787501063727 +9787501064113 +9787501064243 +9787501064403 +9787501064830 +9787501066070 +9787501066162 +9787501066537 +9787501066698 +9787501066704 +9787501066711 +9787501066728 +9787501066834 +9787501067992 +9787501068111 +9787501068241 +9787501068333 +9787501068418 +9787501068470 +9787501069064 +9787501069842 +9787501069958 +9787501070046 +9787501070121 +9787501070725 +9787501070909 +9787501071029 +9787501071364 +9787501071395 +9787501071401 +9787501071418 +9787501071890 +9787501072132 +9787501072224 +9787501072255 +9787501072361 +9787501072521 +9787501072620 +9787501072927 +9787501073528 +9787501073535 +9787501073542 +9787501073818 +9787501074334 +9787501075515 +9787501076062 +9787501077113 +9787501077144 +9787501077205 +9787501077670 +9787501077687 +9787501078080 +9787501078103 +9787501079148 +9787501079889 +9787501080151 +9787501080502 +9787501080656 +9787501081455 +9787501081547 +9787501081929 +9787501082247 +9787501082254 +9787501082766 +9787501082926 +9787501083138 +9787501083466 +9787501083589 +9787501083756 +9787501084180 +9787501084517 +9787501084692 +9787501084814 +9787501085019 +9787501085026 +9787501085040 +9787501085095 +9787501085460 +9787501085477 +9787501085613 +9787501085682 +9787501085699 +9787501085828 +9787501086115 +9787501086146 +9787501086184 +9787501086733 +9787501087372 +9787501087549 +9787501087617 +9787501100040 +9787501100255 +9787501100330 +9787501100347 +9787501100378 +9787501100422 +9787501100453 +9787501100477 +9787501100538 +9787501100620 +9787501100729 +9787501100866 +9787501100965 +9787501101139 +9787501101238 +9787501101467 +9787501101474 +9787501101504 +9787501101634 +9787501101665 +9787501101719 +9787501102068 +9787501102129 +9787501102235 +9787501102365 +9787501103102 +9787501103126 +9787501104062 +9787501104451 +9787501104468 +9787501104574 +9787501105106 +9787501105274 +9787501106073 +9787501106486 +9787501107100 +9787501107544 +9787501107551 +9787501107636 +9787501107810 +9787501108237 +9787501108251 +9787501108572 +9787501109357 +9787501109418 +9787501109555 +9787501109630 +9787501110186 +9787501110445 +9787501110582 +9787501110926 +9787501111176 +9787501111374 +9787501111428 +9787501111657 +9787501111749 +9787501112050 +9787501112081 +9787501112906 +9787501113040 +9787501113620 +9787501113781 +9787501114191 +9787501114719 +9787501115471 +9787501115716 +9787501116096 +9787501116225 +9787501116287 +9787501116355 +9787501116379 +9787501116393 +9787501116478 +9787501117604 +9787501117628 +9787501117666 +9787501118182 +9787501118366 +9787501120086 +9787501120284 +9787501121410 +9787501121663 +9787501121939 +9787501122059 +9787501123223 +9787501123377 +9787501123575 +9787501123704 +9787501123827 +9787501124053 +9787501124244 +9787501124282 +9787501124428 +9787501124442 +9787501125241 +9787501125333 +9787501125425 +9787501125586 +9787501125883 +9787501125999 +9787501126156 +9787501126309 +9787501127047 +9787501127078 +9787501127092 +9787501127405 +9787501127641 +9787501127658 +9787501127993 +9787501128266 +9787501128341 +9787501128471 +9787501128624 +9787501129225 +9787501129386 +9787501130351 +9787501131099 +9787501131396 +9787501131563 +9787501131600 +9787501131693 +9787501131709 +9787501132485 +9787501132508 +9787501132515 +9787501132522 +9787501133536 +9787501134649 +9787501134748 +9787501135578 +9787501135721 +9787501135868 +9787501136087 +9787501136421 +9787501136506 +9787501136520 +9787501136728 +9787501136872 +9787501137299 +9787501138302 +9787501138401 +9787501138661 +9787501138876 +9787501138890 +9787501138920 +9787501138975 +9787501139224 +9787501139231 +9787501139439 +9787501139491 +9787501139880 +9787501140077 +9787501140268 +9787501140282 +9787501140381 +9787501140602 +9787501140756 +9787501141043 +9787501141159 +9787501141166 +9787501141616 +9787501141654 +9787501141982 +9787501142347 +9787501142682 +9787501142736 +9787501142743 +9787501143238 +9787501143351 +9787501143498 +9787501143849 +9787501144624 +9787501144747 +9787501145164 +9787501145270 +9787501145409 +9787501145539 +9787501145591 +9787501145942 +9787501146130 +9787501146413 +9787501146475 +9787501146673 +9787501146789 +9787501146826 +9787501146833 +9787501146925 +9787501147182 +9787501147397 +9787501147441 +9787501147489 +9787501147519 +9787501147663 +9787501147717 +9787501147724 +9787501147830 +9787501148066 +9787501148325 +9787501148332 +9787501148349 +9787501148424 +9787501148523 +9787501148530 +9787501148615 +9787501148790 +9787501148837 +9787501148936 +9787501149100 +9787501149278 +9787501149308 +9787501149438 +9787501149629 +9787501149711 +9787501149865 +9787501149889 +9787501149896 +9787501149933 +9787501149964 +9787501150083 +9787501150120 +9787501150144 +9787501150403 +9787501150687 +9787501150724 +9787501151073 +9787501151103 +9787501151271 +9787501151349 +9787501151493 +9787501151516 +9787501151592 +9787501151738 +9787501152018 +9787501152148 +9787501152193 +9787501152209 +9787501152483 +9787501152506 +9787501152674 +9787501153169 +9787501153695 +9787501154104 +9787501154197 +9787501154418 +9787501154500 +9787501154623 +9787501154647 +9787501154692 +9787501154890 +9787501155019 +9787501155033 +9787501155095 +9787501155132 +9787501155149 +9787501155392 +9787501155682 +9787501155835 +9787501156047 +9787501157501 +9787501157839 +9787501158249 +9787501158362 +9787501158676 +9787501158683 +9787501158843 +9787501159062 +9787501159079 +9787501159741 +9787501159758 +9787501159765 +9787501159772 +9787501159789 +9787501160389 +9787501160518 +9787501160556 +9787501160808 +9787501160891 +9787501160976 +9787501161119 +9787501161287 +9787501161409 +9787501161867 +9787501162017 +9787501162086 +9787501162321 +9787501162369 +9787501162895 +9787501163069 +9787501164011 +9787501164028 +9787501164035 +9787501165452 +9787501165711 +9787501165902 +9787501165957 +9787501166640 +9787501166787 +9787501166800 +9787501166985 +9787501167678 +9787501167760 +9787501167906 +9787501168095 +9787501169276 +9787501169306 +9787501169801 +9787501170135 +9787501170708 +9787501171125 +9787501171972 +9787501172825 +9787501173037 +9787501173464 +9787501173921 +9787501174263 +9787501174652 +9787501177479 +9787501179497 +9787501179534 +9787501181100 +9787501182541 +9787501183487 +9787501183746 +9787501183791 +9787501184002 +9787501185306 +9787501185955 +9787501186280 +9787501186457 +9787501186464 +9787501186983 +9787501187119 +9787501187508 +9787501191307 +9787501191987 +9787501195152 +9787501195411 +9787501195695 +9787501196593 +9787501197040 +9787501197156 +9787501198764 +9787501199006 +9787501200016 +9787501200214 +9787501200221 +9787501200306 +9787501200405 +9787501200450 +9787501200467 +9787501201495 +9787501201501 +9787501201518 +9787501201525 +9787501201556 +9787501201907 +9787501202065 +9787501202119 +9787501202225 +9787501202386 +9787501202553 +9787501202591 +9787501202713 +9787501202928 +9787501202966 +9787501202973 +9787501202980 +9787501203000 +9787501203079 +9787501203154 +9787501203260 +9787501203307 +9787501203314 +9787501203383 +9787501203499 +9787501203543 +9787501203567 +9787501203598 +9787501203697 +9787501203819 +9787501203888 +9787501203895 +9787501203901 +9787501203918 +9787501203925 +9787501203963 +9787501204038 +9787501204052 +9787501204083 +9787501204090 +9787501204366 +9787501204410 +9787501204571 +9787501204601 +9787501204809 +9787501204854 +9787501204960 +9787501205028 +9787501205110 +9787501205172 +9787501205189 +9787501205486 +9787501205578 +9787501205691 +9787501205745 +9787501205752 +9787501205813 +9787501205837 +9787501205943 +9787501206049 +9787501206056 +9787501206216 +9787501206278 +9787501206292 +9787501206308 +9787501206315 +9787501206384 +9787501206391 +9787501206407 +9787501206421 +9787501206438 +9787501206445 +9787501206452 +9787501206490 +9787501206506 +9787501206513 +9787501206667 +9787501206674 +9787501206681 +9787501206711 +9787501206728 +9787501206735 +9787501206896 +9787501207008 +9787501207039 +9787501207046 +9787501207084 +9787501207107 +9787501207138 +9787501207176 +9787501207183 +9787501207190 +9787501207213 +9787501207220 +9787501207237 +9787501207244 +9787501207251 +9787501207268 +9787501207367 +9787501207374 +9787501207435 +9787501207763 +9787501207886 +9787501207909 +9787501207916 +9787501207923 +9787501208166 +9787501208463 +9787501208609 +9787501208616 +9787501208678 +9787501208715 +9787501208784 +9787501208791 +9787501208807 +9787501209200 +9787501209279 +9787501209514 +9787501209521 +9787501209699 +9787501209880 +9787501209958 +9787501210077 +9787501210107 +9787501210138 +9787501210527 +9787501210541 +9787501210565 +9787501211180 +9787501211395 +9787501211586 +9787501211647 +9787501211685 +9787501211777 +9787501211807 +9787501211852 +9787501211883 +9787501212026 +9787501212545 +9787501212750 +9787501212767 +9787501212804 +9787501212927 +9787501213337 +9787501213573 +9787501213634 +9787501213757 +9787501214044 +9787501214358 +9787501214778 +9787501214815 +9787501216123 +9787501216154 +9787501216178 +9787501216390 +9787501216475 +9787501216543 +9787501216826 +9787501216840 +9787501217076 +9787501217144 +9787501217779 +9787501218486 +9787501218677 +9787501219773 +9787501219889 +9787501220519 +9787501220885 +9787501221028 +9787501221127 +9787501221530 +9787501221899 +9787501222179 +9787501222438 +9787501222605 +9787501222643 +9787501223015 +9787501223077 +9787501223084 +9787501223091 +9787501223336 +9787501223657 +9787501223732 +9787501224876 +9787501224883 +9787501225132 +9787501225422 +9787501225989 +9787501226351 +9787501226443 +9787501227235 +9787501228850 +9787501228867 +9787501229475 +9787501229512 +9787501230990 +9787501231072 +9787501233496 +9787501233595 +9787501235216 +9787501236282 +9787501238606 +9787501239504 +9787501240357 +9787501240364 +9787501240418 +9787501240944 +9787501241880 +9787501241989 +9787501242825 +9787501242849 +9787501242979 +9787501244454 +9787501244881 +9787501244959 +9787501246441 +9787501246519 +9787501247448 +9787501247783 +9787501248308 +9787501249060 +9787501249091 +9787501250639 +9787501250707 +9787501251773 +9787501255290 +9787501255306 +9787501255627 +9787501255924 +9787501256259 +9787501256730 +9787501257706 +9787501257713 +9787501258611 +9787501258710 +9787501259915 +9787501260430 +9787501260508 +9787501260591 +9787501260836 +9787501260942 +9787501261567 +9787501261598 +9787501261673 +9787501261802 +9787501261833 +9787501261901 +9787501262021 +9787501262045 +9787501262083 +9787501262496 +9787501263004 +9787501263240 +9787501263738 +9787501264292 +9787501264827 +9787501264834 +9787501265114 +9787501265121 +9787501265541 +9787501266043 +9787501266197 +9787501266227 +9787501266319 +9787501266692 +9787501266883 +9787501266920 +9787501266982 +9787501267583 +9787501267613 +9787501267637 +9787501267798 +9787501268528 +9787501269174 +9787501269235 +9787501303335 +9787501303427 +9787501303434 +9787501304394 +9787501305490 +9787501305544 +9787501305575 +9787501305599 +9787501305872 +9787501306459 +9787501306961 +9787501307012 +9787501307982 +9787501308200 +9787501308224 +9787501308293 +9787501308576 +9787501308613 +9787501308972 +9787501309290 +9787501309498 +9787501309696 +9787501309740 +9787501309764 +9787501309962 +9787501310135 +9787501310401 +9787501310937 +9787501310999 +9787501311064 +9787501311132 +9787501311149 +9787501311156 +9787501311170 +9787501311651 +9787501311705 +9787501311743 +9787501311774 +9787501311972 +9787501312115 +9787501312146 +9787501312306 +9787501312344 +9787501312399 +9787501312566 +9787501312719 +9787501313044 +9787501313075 +9787501313433 +9787501313839 +9787501314294 +9787501314690 +9787501314980 +9787501315079 +9787501315215 +9787501315475 +9787501315857 +9787501315864 +9787501315970 +9787501317059 +9787501317196 +9787501317530 +9787501317899 +9787501318025 +9787501318162 +9787501318179 +9787501318254 +9787501318391 +9787501318728 +9787501318735 +9787501318933 +9787501319213 +9787501319329 +9787501319503 +9787501319572 +9787501319602 +9787501320219 +9787501320240 +9787501320714 +9787501321148 +9787501321384 +9787501321391 +9787501321414 +9787501321865 +9787501322022 +9787501322084 +9787501322350 +9787501324279 +9787501324491 +9787501324743 +9787501327294 +9787501327430 +9787501327515 +9787501331130 +9787501331154 +9787501331208 +9787501331215 +9787501331222 +9787501334193 +9787501335220 +9787501335398 +9787501336623 +9787501337804 +9787501338030 +9787501338320 +9787501338368 +9787501339662 +9787501343089 +9787501344079 +9787501346677 +9787501347889 +9787501348787 +9787501349807 +9787501350414 +9787501353903 +9787501355327 +9787501355419 +9787501355440 +9787501355617 +9787501356355 +9787501356485 +9787501358038 +9787501358656 +9787501361809 +9787501362257 +9787501363131 +9787501363483 +9787501363643 +9787501363650 +9787501364664 +9787501365456 +9787501365968 +9787501366262 +9787501366354 +9787501367054 +9787501367306 +9787501370764 +9787501371761 +9787501371914 +9787501373550 +9787501374106 +9787501374281 +9787501374465 +9787501374526 +9787501375790 +9787501378180 +9787501378210 +9787501378296 +9787501379316 +9787501380572 +9787501380596 +9787501380817 +9787501381234 +9787501381388 +9787501381777 +9787501383009 +9787501383054 +9787501385362 +9787501385782 +9787501385881 +9787501400324 +9787501400348 +9787501400669 +9787501400737 +9787501400768 +9787501400959 +9787501401208 +9787501401338 +9787501401604 +9787501401796 +9787501402021 +9787501402243 +9787501402328 +9787501402335 +9787501402830 +9787501402854 +9787501403141 +9787501403479 +9787501403585 +9787501403967 +9787501404186 +9787501404193 +9787501404285 +9787501404315 +9787501404766 +9787501405138 +9787501405541 +9787501405794 +9787501406098 +9787501406340 +9787501406487 +9787501407439 +9787501407668 +9787501408016 +9787501408146 +9787501408597 +9787501408993 +9787501409488 +9787501409495 +9787501409853 +9787501409969 +9787501410088 +9787501410156 +9787501410613 +9787501410880 +9787501411146 +9787501411160 +9787501411184 +9787501411191 +9787501411221 +9787501411276 +9787501411597 +9787501411634 +9787501411832 +9787501412266 +9787501412587 +9787501412594 +9787501412747 +9787501412792 +9787501412884 +9787501412907 +9787501413041 +9787501413379 +9787501413737 +9787501414079 +9787501414338 +9787501414536 +9787501414642 +9787501414758 +9787501414772 +9787501414871 +9787501414970 +9787501415007 +9787501415076 +9787501415168 +9787501415274 +9787501415403 +9787501415441 +9787501415465 +9787501415526 +9787501415601 +9787501415632 +9787501416035 +9787501416288 +9787501416301 +9787501416448 +9787501416738 +9787501416745 +9787501417049 +9787501417575 +9787501417582 +9787501417988 +9787501418121 +9787501418312 +9787501418336 +9787501418350 +9787501418442 +9787501418688 +9787501418718 +9787501418725 +9787501418961 +9787501419159 +9787501419272 +9787501419937 +9787501420087 +9787501420148 +9787501420193 +9787501421039 +9787501421183 +9787501421596 +9787501421633 +9787501422470 +9787501422586 +9787501422746 +9787501423095 +9787501423385 +9787501423552 +9787501423576 +9787501423590 +9787501423781 +9787501423958 +9787501424399 +9787501424740 +9787501425624 +9787501425631 +9787501426461 +9787501426492 +9787501427215 +9787501428106 +9787501428137 +9787501428489 +9787501428571 +9787501428625 +9787501428656 +9787501428748 +9787501428885 +9787501428953 +9787501429363 +9787501429585 +9787501429714 +9787501430369 +9787501430451 +9787501431359 +9787501432035 +9787501433100 +9787501433148 +9787501434039 +9787501434459 +9787501435296 +9787501435524 +9787501435531 +9787501436088 +9787501436101 +9787501436675 +9787501437573 +9787501440917 +9787501441228 +9787501442553 +9787501444212 +9787501445349 +9787501446216 +9787501447367 +9787501448029 +9787501448623 +9787501449972 +9787501450350 +9787501451142 +9787501453030 +9787501453900 +9787501455027 +9787501455157 +9787501458240 +9787501459742 +9787501461035 +9787501461929 +9787501463909 +9787501464357 +9787501500086 +9787501501694 +9787501501984 +9787501502080 +9787501502141 +9787501502172 +9787501502264 +9787501502288 +9787501502615 +9787501502776 +9787501503025 +9787501503193 +9787501503582 +9787501503766 +9787501503773 +9787501503957 +9787501504145 +9787501504190 +9787501504237 +9787501504244 +9787501504497 +9787501504602 +9787501504619 +9787501504961 +9787501505029 +9787501505067 +9787501505791 +9787501506002 +9787501506033 +9787501506149 +9787501506385 +9787501506552 +9787501506576 +9787501506743 +9787501506897 +9787501507160 +9787501507191 +9787501507269 +9787501507276 +9787501507290 +9787501508051 +9787501508150 +9787501508617 +9787501508624 +9787501508723 +9787501508808 +9787501508921 +9787501508969 +9787501509171 +9787501509188 +9787501509539 +9787501509591 +9787501510061 +9787501510122 +9787501510153 +9787501510184 +9787501510191 +9787501510306 +9787501510313 +9787501510726 +9787501510955 +9787501510979 +9787501511006 +9787501511082 +9787501511204 +9787501511273 +9787501511341 +9787501511457 +9787501511709 +9787501512430 +9787501512522 +9787501512911 +9787501512928 +9787501512966 +9787501513246 +9787501513598 +9787501513604 +9787501513680 +9787501513802 +9787501514328 +9787501514335 +9787501514533 +9787501514649 +9787501514786 +9787501515172 +9787501515349 +9787501515455 +9787501515738 +9787501516032 +9787501516049 +9787501516155 +9787501516742 +9787501516834 +9787501517404 +9787501518005 +9787501518012 +9787501518647 +9787501518906 +9787501519002 +9787501519064 +9787501519095 +9787501519118 +9787501519125 +9787501519132 +9787501519149 +9787501519163 +9787501520299 +9787501523177 +9787501523214 +9787501523481 +9787501524365 +9787501524549 +9787501524587 +9787501524594 +9787501524679 +9787501525690 +9787501525744 +9787501526109 +9787501526116 +9787501526178 +9787501526222 +9787501526420 +9787501526468 +9787501526536 +9787501526550 +9787501527182 +9787501528295 +9787501529728 +9787501530786 +9787501530939 +9787501532377 +9787501532728 +9787501533848 +9787501533855 +9787501534265 +9787501534319 +9787501535057 +9787501535101 +9787501535842 +9787501536764 +9787501536917 +9787501537730 +9787501539246 +9787501539468 +9787501540402 +9787501542116 +9787501550258 +9787501550272 +9787501551675 +9787501551866 +9787501552788 +9787501553204 +9787501554010 +9787501554416 +9787501554881 +9787501554973 +9787501555345 +9787501555376 +9787501555420 +9787501555925 +9787501555949 +9787501556014 +9787501556182 +9787501556205 +9787501556267 +9787501556397 +9787501556458 +9787501556540 +9787501556557 +9787501556854 +9787501556922 +9787501557707 +9787501557714 +9787501557936 +9787501558087 +9787501562077 +9787501562923 +9787501563401 +9787501566730 +9787501566747 +9787501566754 +9787501566792 +9787501567386 +9787501567430 +9787501568024 +9787501568420 +9787501569168 +9787501569984 +9787501572823 +9787501579006 +9787501580477 +9787501580651 +9787501581368 +9787501581573 +9787501582129 +9787501582143 +9787501582259 +9787501582273 +9787501582365 +9787501582518 +9787501584215 +9787501586790 +9787501586875 +9787501586905 +9787501587001 +9787501587032 +9787501587742 +9787501587896 +9787501588022 +9787501588695 +9787501589593 +9787501590223 +9787501590735 +9787501590872 +9787501590896 +9787501593071 +9787501593224 +9787501594870 +9787501595464 +9787501595495 +9787501595518 +9787501597703 +9787501598243 +9787501598588 +9787501598946 +9787501598991 +9787501599431 +9787501599967 +9787501600076 +9787501600298 +9787501600366 +9787501600496 +9787501600557 +9787501600588 +9787501600687 +9787501600960 +9787501601035 +9787501601493 +9787501601806 +9787501603534 +9787501603831 +9787501603855 +9787501603862 +9787501604951 +9787501606252 +9787501606276 +9787501607167 +9787501608263 +9787501608911 +9787501611287 +9787501612284 +9787501612567 +9787501612673 +9787501612758 +9787501612864 +9787501613038 +9787501613847 +9787501613946 +9787501613953 +9787501614592 +9787501614707 +9787501614783 +9787501614882 +9787501615186 +9787501615339 +9787501615551 +9787501615742 +9787501616343 +9787501618989 +9787501619351 +9787501619658 +9787501620227 +9787501620265 +9787501620272 +9787501620296 +9787501620609 +9787501620661 +9787501621491 +9787501621514 +9787501621583 +9787501621873 +9787501621903 +9787501622320 +9787501622429 +9787501622719 +9787501623297 +9787501623365 +9787501623440 +9787501623532 +9787501623587 +9787501624386 +9787501625406 +9787501700127 +9787501700523 +9787501700554 +9787501701285 +9787501701292 +9787501701612 +9787501701759 +9787501701766 +9787501702893 +9787501703128 +9787501703708 +9787501703951 +9787501704019 +9787501704330 +9787501704651 +9787501706648 +9787501707294 +9787501707850 +9787501707881 +9787501708482 +9787501708680 +9787501708772 +9787501709014 +9787501710140 +9787501711284 +9787501711413 +9787501711864 +9787501711888 +9787501711949 +9787501711956 +9787501712410 +9787501712762 +9787501713707 +9787501714216 +9787501714490 +9787501714575 +9787501715190 +9787501715350 +9787501715718 +9787501716852 +9787501717071 +9787501718108 +9787501718122 +9787501719150 +9787501719167 +9787501719174 +9787501719181 +9787501719198 +9787501719228 +9787501720989 +9787501721467 +9787501721528 +9787501721672 +9787501722334 +9787501724208 +9787501725724 +9787501726134 +9787501727124 +9787501727308 +9787501729241 +9787501729418 +9787501729739 +9787501729890 +9787501731695 +9787501732357 +9787501732364 +9787501732371 +9787501732456 +9787501732463 +9787501732494 +9787501732524 +9787501732531 +9787501732548 +9787501732555 +9787501732579 +9787501732753 +9787501733064 +9787501734030 +9787501734351 +9787501734368 +9787501734627 +9787501734634 +9787501735914 +9787501736140 +9787501736577 +9787501736867 +9787501736904 +9787501738502 +9787501738519 +9787501739257 +9787501739271 +9787501739387 +9787501740475 +9787501741144 +9787501742004 +9787501742035 +9787501742134 +9787501742189 +9787501742929 +9787501743193 +9787501743292 +9787501743674 +9787501743797 +9787501743841 +9787501744091 +9787501744688 +9787501744787 +9787501745142 +9787501745579 +9787501745715 +9787501745920 +9787501747313 +9787501747627 +9787501747931 +9787501748075 +9787501749416 +9787501750306 +9787501751105 +9787501751266 +9787501751273 +9787501751297 +9787501752348 +9787501752560 +9787501755394 +9787501756186 +9787501756797 +9787501756827 +9787501756933 +9787501756957 +9787501757015 +9787501757848 +9787501759224 +9787501760701 +9787501763832 +9787501766093 +9787501771059 +9787501772711 +9787501775941 +9787501776177 +9787501778072 +9787501778119 +9787501784691 +9787501785261 +9787501785360 +9787501790173 +9787501793952 +9787501900206 +9787501900220 +9787501900817 +9787501900824 +9787501901524 +9787501901890 +9787501901906 +9787501901982 +9787501902040 +9787501902293 +9787501902385 +9787501902545 +9787501902934 +9787501903238 +9787501903436 +9787501903832 +9787501904006 +9787501904372 +9787501904761 +9787501905065 +9787501905089 +9787501905348 +9787501905812 +9787501905843 +9787501905850 +9787501906031 +9787501906246 +9787501906314 +9787501906345 +9787501906659 +9787501906888 +9787501906970 +9787501907021 +9787501907366 +9787501908035 +9787501908097 +9787501908196 +9787501908202 +9787501908677 +9787501908776 +9787501909223 +9787501909285 +9787501909346 +9787501909391 +9787501909575 +9787501909742 +9787501909773 +9787501909919 +9787501910359 +9787501910748 +9787501910908 +9787501910946 +9787501910977 +9787501911226 +9787501911288 +9787501911516 +9787501912421 +9787501912612 +9787501912742 +9787501912933 +9787501913671 +9787501913718 +9787501914142 +9787501914173 +9787501914180 +9787501914562 +9787501914838 +9787501914883 +9787501915309 +9787501915491 +9787501916337 +9787501916498 +9787501916603 +9787501916771 +9787501917204 +9787501917266 +9787501917471 +9787501917563 +9787501917570 +9787501917648 +9787501918010 +9787501918027 +9787501918072 +9787501918188 +9787501918492 +9787501918669 +9787501918676 +9787501919802 +9787501919864 +9787501919932 +9787501919987 +9787501920013 +9787501920037 +9787501920068 +9787501921423 +9787501921614 +9787501922130 +9787501922147 +9787501922185 +9787501922789 +9787501922826 +9787501923403 +9787501923908 +9787501923977 +9787501924677 +9787501924943 +9787501924981 +9787501925070 +9787501925179 +9787501925209 +9787501925346 +9787501925377 +9787501925384 +9787501925520 +9787501925681 +9787501925698 +9787501926084 +9787501926497 +9787501926565 +9787501926923 +9787501926954 +9787501927654 +9787501927692 +9787501927739 +9787501927746 +9787501928248 +9787501928323 +9787501928392 +9787501928675 +9787501928859 +9787501929047 +9787501929108 +9787501929375 +9787501929870 +9787501929962 +9787501930173 +9787501930463 +9787501931057 +9787501931330 +9787501931439 +9787501931606 +9787501932504 +9787501932870 +9787501933303 +9787501934201 +9787501934775 +9787501935079 +9787501935109 +9787501935581 +9787501936199 +9787501936274 +9787501936335 +9787501936472 +9787501936519 +9787501936687 +9787501936892 +9787501937080 +9787501937943 +9787501937998 +9787501939114 +9787501939640 +9787501941445 +9787501941834 +9787501942374 +9787501943012 +9787501943081 +9787501943135 +9787501943166 +9787501944811 +9787501944958 +9787501945344 +9787501945382 +9787501946457 +9787501947126 +9787501947171 +9787501947188 +9787501947256 +9787501947324 +9787501947461 +9787501947584 +9787501947591 +9787501949267 +9787501951932 +9787501953790 +9787501954056 +9787501954209 +9787501954285 +9787501956784 +9787501956968 +9787501957163 +9787501960637 +9787501960910 +9787501965496 +9787501965779 +9787501966974 +9787501968961 +9787501969111 +9787501969173 +9787501970186 +9787501971336 +9787501972845 +9787501974917 +9787501975099 +9787501976102 +9787501977727 +9787501980550 +9787501988945 +9787501989379 +9787501989591 +9787501989829 +9787501990061 +9787501990085 +9787501993536 +9787501997688 +9787501998678 +9787502000011 +9787502000899 +9787502001186 +9787502003197 +9787502004118 +9787502005047 +9787502006396 +9787502006990 +9787502009083 +9787502013530 +9787502014421 +9787502015909 +9787502016180 +9787502018382 +9787502018641 +9787502018832 +9787502021184 +9787502025502 +9787502025588 +9787502026561 +9787502027766 +9787502034795 +9787502035792 +9787502038113 +9787502038908 +9787502039486 +9787502041984 +9787502045913 +9787502046927 +9787502049003 +9787502050184 +9787502054472 +9787502057459 +9787502060190 +9787502061425 +9787502064884 +9787502066031 +9787502066635 +9787502067182 +9787502070601 +9787502070991 +9787502071479 +9787502072490 +9787502072674 +9787502072735 +9787502072742 +9787502073640 +9787502074494 +9787502074883 +9787502074975 +9787502075637 +9787502076146 +9787502076597 +9787502076818 +9787502077235 +9787502077334 +9787502077709 +9787502077792 +9787502078355 +9787502078362 +9787502078706 +9787502078805 +9787502079000 +9787502079031 +9787502079055 +9787502079246 +9787502080761 +9787502081102 +9787502082079 +9787502082093 +9787502082109 +9787502082536 +9787502082949 +9787502083052 +9787502083472 +9787502083496 +9787502083519 +9787502083526 +9787502083595 +9787502083694 +9787502084448 +9787502084882 +9787502084950 +9787502085421 +9787502086466 +9787502086473 +9787502086480 +9787502086503 +9787502086558 +9787502086565 +9787502086589 +9787502086671 +9787502086855 +9787502087456 +9787502087890 +9787502087906 +9787502087975 +9787502088675 +9787502088767 +9787502089412 +9787502090586 +9787502090630 +9787502091439 +9787502091569 +9787502092665 +9787502093099 +9787502093372 +9787502093495 +9787502093570 +9787502093754 +9787502093761 +9787502094065 +9787502094225 +9787502095376 +9787502095925 +9787502096458 +9787502097288 +9787502098155 +9787502099091 +9787502099855 +9787502099879 +9787502099961 +9787502100049 +9787502101343 +9787502101701 +9787502102296 +9787502103439 +9787502105648 +9787502106676 +9787502107178 +9787502107444 +9787502108106 +9787502109431 +9787502109882 +9787502109967 +9787502110932 +9787502113537 +9787502115159 +9787502115708 +9787502116057 +9787502116750 +9787502117290 +9787502117504 +9787502117580 +9787502117733 +9787502118174 +9787502119133 +9787502119973 +9787502120740 +9787502120788 +9787502121280 +9787502123246 +9787502124328 +9787502124823 +9787502125059 +9787502125158 +9787502125585 +9787502125813 +9787502125967 +9787502126100 +9787502126827 +9787502128203 +9787502128906 +9787502129477 +9787502129712 +9787502130213 +9787502132156 +9787502132293 +9787502132491 +9787502132620 +9787502132835 +9787502132965 +9787502133412 +9787502134105 +9787502134877 +9787502136253 +9787502136291 +9787502137076 +9787502137175 +9787502138035 +9787502139186 +9787502141684 +9787502142421 +9787502143145 +9787502144180 +9787502145835 +9787502146252 +9787502146573 +9787502147747 +9787502148256 +9787502148690 +9787502151973 +9787502156015 +9787502162535 +9787502163198 +9787502163341 +9787502163457 +9787502163891 +9787502165482 +9787502166793 +9787502168483 +9787502169190 +9787502170998 +9787502171544 +9787502171704 +9787502173364 +9787502173517 +9787502177812 +9787502178239 +9787502182397 +9787502182519 +9787502189891 +9787502191306 +9787502193935 +9787502200091 +9787502200916 +9787502201555 +9787502202521 +9787502203948 +9787502204785 +9787502204822 +9787502204853 +9787502206062 +9787502206390 +9787502210151 +9787502212537 +9787502213473 +9787502213695 +9787502214074 +9787502214302 +9787502215248 +9787502215392 +9787502216054 +9787502216757 +9787502219338 +9787502222338 +9787502223328 +9787502223397 +9787502226763 +9787502226961 +9787502229559 +9787502230678 +9787502230906 +9787502233709 +9787502235123 +9787502236830 +9787502238346 +9787502238766 +9787502239626 +9787502242268 +9787502247676 +9787502247942 +9787502248291 +9787502248659 +9787502250348 +9787502258498 +9787502258801 +9787502259945 +9787502260972 +9787502261382 +9787502261948 +9787502263997 +9787502264437 +9787502264550 +9787502270360 +9787502273729 +9787502276249 +9787502276683 +9787502277376 +9787502279813 +9787502282219 +9787502283025 +9787502283988 +9787502287207 +9787502290405 +9787502293345 +9787502295400 +9787502296544 +9787502298050 +9787502299446 +9787502299606 +9787502300029 +9787502300197 +9787502300272 +9787502300869 +9787502301002 +9787502301255 +9787502301330 +9787502301347 +9787502301354 +9787502301361 +9787502301378 +9787502301491 +9787502301507 +9787502301859 +9787502302061 +9787502302351 +9787502302795 +9787502303068 +9787502303129 +9787502303396 +9787502303563 +9787502303617 +9787502303662 +9787502303693 +9787502303716 +9787502303754 +9787502303761 +9787502303792 +9787502303976 +9787502303983 +9787502304263 +9787502304706 +9787502304997 +9787502305147 +9787502305260 +9787502305406 +9787502305512 +9787502305598 +9787502305611 +9787502305765 +9787502305789 +9787502306397 +9787502306601 +9787502306755 +9787502306953 +9787502307950 +9787502308315 +9787502308445 +9787502308568 +9787502309510 +9787502309831 +9787502310004 +9787502310028 +9787502310134 +9787502310202 +9787502310240 +9787502310271 +9787502310479 +9787502310486 +9787502310622 +9787502311124 +9787502311421 +9787502311438 +9787502311568 +9787502311575 +9787502311650 +9787502312947 +9787502313241 +9787502313333 +9787502314347 +9787502314514 +9787502314729 +9787502314798 +9787502314835 +9787502315009 +9787502315054 +9787502315252 +9787502315276 +9787502315689 +9787502315740 +9787502316457 +9787502316464 +9787502316495 +9787502316624 +9787502316747 +9787502316754 +9787502316761 +9787502316839 +9787502316891 +9787502317355 +9787502317430 +9787502318000 +9787502318130 +9787502318406 +9787502318765 +9787502318789 +9787502318932 +9787502319052 +9787502319151 +9787502319441 +9787502319540 +9787502319915 +9787502319977 +9787502320300 +9787502320829 +9787502320836 +9787502320843 +9787502321321 +9787502321758 +9787502321895 +9787502322106 +9787502323844 +9787502323851 +9787502323868 +9787502324049 +9787502324056 +9787502324476 +9787502324902 +9787502324933 +9787502324940 +9787502325015 +9787502325206 +9787502325213 +9787502325220 +9787502325237 +9787502325480 +9787502326807 +9787502326814 +9787502327866 +9787502328474 +9787502328559 +9787502328726 +9787502329181 +9787502329310 +9787502329860 +9787502329877 +9787502329976 +9787502330125 +9787502330316 +9787502330781 +9787502330811 +9787502331115 +9787502331122 +9787502331139 +9787502331481 +9787502331672 +9787502331689 +9787502331719 +9787502331733 +9787502331818 +9787502332013 +9787502332150 +9787502332464 +9787502332570 +9787502332594 +9787502333522 +9787502333690 +9787502334000 +9787502334031 +9787502334567 +9787502334741 +9787502334932 +9787502334949 +9787502335045 +9787502335052 +9787502335366 +9787502336028 +9787502336318 +9787502336325 +9787502336547 +9787502336578 +9787502336639 +9787502336783 +9787502337070 +9787502337124 +9787502337131 +9787502337209 +9787502337377 +9787502337438 +9787502337520 +9787502337650 +9787502337698 +9787502337926 +9787502338107 +9787502338206 +9787502338244 +9787502338503 +9787502338527 +9787502338947 +9787502339319 +9787502339500 +9787502339661 +9787502339692 +9787502340612 +9787502341176 +9787502341190 +9787502341206 +9787502341220 +9787502341657 +9787502342180 +9787502342432 +9787502342661 +9787502342722 +9787502343040 +9787502343620 +9787502344122 +9787502344139 +9787502345297 +9787502345310 +9787502345433 +9787502346621 +9787502347024 +9787502347208 +9787502347369 +9787502347468 +9787502347482 +9787502347741 +9787502347772 +9787502349561 +9787502350598 +9787502350673 +9787502351274 +9787502351397 +9787502351687 +9787502352110 +9787502352677 +9787502353292 +9787502356033 +9787502356675 +9787502363772 +9787502368869 +9787502369040 +9787502369767 +9787502371180 +9787502371715 +9787502371722 +9787502371890 +9787502373528 +9787502374204 +9787502375409 +9787502376208 +9787502376406 +9787502377120 +9787502377151 +9787502377472 +9787502380014 +9787502380298 +9787502380304 +9787502381868 +9787502381912 +9787502382643 +9787502384050 +9787502386627 +9787502386986 +9787502387686 +9787502389833 +9787502391782 +9787502391829 +9787502393151 +9787502394592 +9787502394912 +9787502395339 +9787502397951 +9787502399177 +9787502399498 +9787502399559 +9787502399566 +9787502400569 +9787502402020 +9787502402204 +9787502402655 +9787502403638 +9787502403881 +9787502406905 +9787502408367 +9787502408565 +9787502408718 +9787502409104 +9787502410063 +9787502410094 +9787502410353 +9787502410506 +9787502411114 +9787502411275 +9787502412586 +9787502412944 +9787502415082 +9787502415754 +9787502415884 +9787502415907 +9787502416065 +9787502416324 +9787502416416 +9787502416492 +9787502417031 +9787502417314 +9787502417444 +9787502417628 +9787502417918 +9787502420987 +9787502422004 +9787502423568 +9787502424275 +9787502424473 +9787502425425 +9787502425432 +9787502425562 +9787502427283 +9787502427931 +9787502429126 +9787502429935 +9787502441692 +9787502448097 +9787502455835 +9787502456078 +9787502458409 +9787502464592 +9787502468606 +9787502469115 +9787502471576 +9787502472962 +9787502473617 +9787502476922 +9787502479763 +9787502482763 +9787502484927 +9787502485368 +9787502485375 +9787502485535 +9787502485542 +9787502485887 +9787502487300 +9787502487348 +9787502487355 +9787502487386 +9787502487522 +9787502488093 +9787502488499 +9787502488864 +9787502488895 +9787502498566 +9787502498726 +9787502498979 +9787502499174 +9787502499938 +9787502500399 +9787502500603 +9787502500825 +9787502500856 +9787502500948 +9787502501341 +9787502501549 +9787502501716 +9787502502324 +9787502502829 +9787502503055 +9787502503178 +9787502503994 +9787502504007 +9787502504038 +9787502504762 +9787502504830 +9787502505417 +9787502505448 +9787502505936 +9787502506018 +9787502507039 +9787502507046 +9787502507565 +9787502507961 +9787502508128 +9787502508166 +9787502508333 +9787502508494 +9787502508999 +9787502509071 +9787502509125 +9787502509200 +9787502509422 +9787502509729 +9787502510237 +9787502510503 +9787502511517 +9787502511753 +9787502512002 +9787502512552 +9787502513221 +9787502513337 +9787502513467 +9787502513498 +9787502513566 +9787502514747 +9787502515089 +9787502515270 +9787502515331 +9787502515386 +9787502515621 +9787502515690 +9787502516642 +9787502516901 +9787502517021 +9787502517304 +9787502517359 +9787502517496 +9787502518059 +9787502518073 +9787502518127 +9787502518158 +9787502518448 +9787502518677 +9787502518790 +9787502519254 +9787502519711 +9787502520366 +9787502520434 +9787502520489 +9787502520588 +9787502520748 +9787502520939 +9787502521165 +9787502522766 +9787502522889 +9787502522971 +9787502523107 +9787502523176 +9787502523589 +9787502523633 +9787502523695 +9787502523749 +9787502524326 +9787502524647 +9787502524685 +9787502524708 +9787502525491 +9787502525552 +9787502525569 +9787502526092 +9787502526184 +9787502526849 +9787502527099 +9787502527143 +9787502527211 +9787502527242 +9787502527365 +9787502527600 +9787502527730 +9787502527808 +9787502527822 +9787502527938 +9787502528317 +9787502528485 +9787502528829 +9787502528898 +9787502528904 +9787502529291 +9787502529420 +9787502529697 +9787502530020 +9787502530082 +9787502530259 +9787502530358 +9787502530365 +9787502530808 +9787502530891 +9787502530907 +9787502531096 +9787502531362 +9787502531676 +9787502531706 +9787502532086 +9787502532161 +9787502532543 +9787502532963 +9787502533199 +9787502534059 +9787502534110 +9787502534295 +9787502534394 +9787502534554 +9787502534639 +9787502534646 +9787502535896 +9787502535940 +9787502536008 +9787502536688 +9787502536848 +9787502536954 +9787502536992 +9787502537074 +9787502537432 +9787502537456 +9787502537531 +9787502537647 +9787502538095 +9787502538132 +9787502538194 +9787502538347 +9787502538415 +9787502538446 +9787502538477 +9787502538637 +9787502539702 +9787502539887 +9787502540043 +9787502540807 +9787502540869 +9787502541132 +9787502541743 +9787502541866 +9787502542054 +9787502543235 +9787502543365 +9787502543501 +9787502544218 +9787502544676 +9787502545048 +9787502545376 +9787502547158 +9787502547905 +9787502547929 +9787502548018 +9787502548179 +9787502548599 +9787502548988 +9787502549060 +9787502549503 +9787502551339 +9787502551438 +9787502551872 +9787502553173 +9787502553265 +9787502553463 +9787502554194 +9787502555436 +9787502556013 +9787502556396 +9787502556792 +9787502558352 +9787502558369 +9787502558901 +9787502559694 +9787502560874 +9787502562465 +9787502562700 +9787502566128 +9787502566944 +9787502569020 +9787502570132 +9787502574000 +9787502579982 +9787502581411 +9787502582340 +9787502583675 +9787502586683 +9787502586935 +9787502587895 +9787502588861 +9787502588878 +9787502589707 +9787502590611 +9787502595494 +9787502596729 +9787502600112 +9787502600501 +9787502600709 +9787502600808 +9787502601256 +9787502602239 +9787502603106 +9787502603311 +9787502603847 +9787502606039 +9787502606329 +9787502607456 +9787502607685 +9787502608286 +9787502609252 +9787502609276 +9787502610258 +9787502610470 +9787502610487 +9787502610517 +9787502611248 +9787502611491 +9787502611880 +9787502614003 +9787502614195 +9787502614324 +9787502617165 +9787502617424 +9787502617899 +9787502618087 +9787502618339 +9787502619206 +9787502619763 +9787502621636 +9787502622299 +9787502624477 +9787502625702 +9787502628512 +9787502629250 +9787502632533 +9787502632571 +9787502634094 +9787502634483 +9787502634728 +9787502635602 +9787502635831 +9787502636753 +9787502637675 +9787502640279 +9787502641290 +9787502641542 +9787502641672 +9787502641825 +9787502641979 +9787502642952 +9787502643423 +9787502645045 +9787502645656 +9787502645861 +9787502647414 +9787502647551 +9787502647667 +9787502648268 +9787502648350 +9787502649319 +9787502649982 +9787502650599 +9787502650605 +9787502651145 +9787502651961 +9787502653835 +9787502654863 +9787502655129 +9787502657925 +9787502704209 +9787502705237 +9787502707323 +9787502710019 +9787502710125 +9787502711160 +9787502712259 +9787502712969 +9787502713249 +9787502714291 +9787502716394 +9787502716837 +9787502716974 +9787502719104 +9787502719722 +9787502720711 +9787502721909 +9787502722128 +9787502722449 +9787502723217 +9787502723347 +9787502725204 +9787502729172 +9787502732332 +9787502733568 +9787502738143 +9787502738556 +9787502738600 +9787502738723 +9787502740184 +9787502740214 +9787502741006 +9787502741518 +9787502741716 +9787502742317 +9787502743840 +9787502745554 +9787502746506 +9787502747084 +9787502747428 +9787502747442 +9787502747923 +9787502749668 +9787502749750 +9787502750084 +9787502750459 +9787502750633 +9787502750930 +9787502751715 +9787502752255 +9787502753849 +9787502754686 +9787502754983 +9787502758622 +9787502760274 +9787502762193 +9787502762339 +9787502762698 +9787502762971 +9787502763244 +9787502763381 +9787502763398 +9787502764340 +9787502765026 +9787502766733 +9787502767006 +9787502769130 +9787502771980 +9787502772642 +9787502776350 +9787502779856 +9787502780012 +9787502783723 +9787502785390 +9787502787219 +9787502788988 +9787502790899 +9787502795665 +9787502800208 +9787502800314 +9787502800635 +9787502800789 +9787502801236 +9787502802424 +9787502803834 +9787502804596 +9787502806965 +9787502807412 +9787502807849 +9787502807900 +9787502807948 +9787502808198 +9787502808440 +9787502809775 +9787502809980 +9787502810108 +9787502810115 +9787502810368 +9787502811242 +9787502811273 +9787502811525 +9787502812171 +9787502812720 +9787502813963 +9787502814021 +9787502814069 +9787502814106 +9787502814946 +9787502815738 +9787502816148 +9787502817183 +9787502817220 +9787502817565 +9787502817787 +9787502818487 +9787502818814 +9787502818838 +9787502819057 +9787502819552 +9787502819712 +9787502820725 +9787502821081 +9787502821630 +9787502821876 +9787502822033 +9787502822408 +9787502822620 +9787502823047 +9787502823108 +9787502823115 +9787502823214 +9787502824389 +9787502824914 +9787502824921 +9787502825201 +9787502826529 +9787502826819 +9787502826826 +9787502827298 +9787502827625 +9787502827762 +9787502828035 +9787502828936 +9787502829377 +9787502829773 +9787502832025 +9787502833596 +9787502835057 +9787502836085 +9787502838348 +9787502839116 +9787502839635 +9787502841317 +9787502842338 +9787502842482 +9787502842529 +9787502843021 +9787502843069 +9787502843106 +9787502843151 +9787502843366 +9787502843717 +9787502843793 +9787502843816 +9787502846473 +9787502847708 +9787502849023 +9787502851279 +9787502852191 +9787502852535 +9787502856335 +9787502900014 +9787502902292 +9787502904760 +9787502905446 +9787502905736 +9787502906405 +9787502906634 +9787502908164 +9787502908591 +9787502910228 +9787502910372 +9787502910617 +9787502910747 +9787502912277 +9787502912512 +9787502912956 +9787502913816 +9787502913984 +9787502914431 +9787502914677 +9787502915230 +9787502916497 +9787502917913 +9787502918637 +9787502918873 +9787502918897 +9787502919122 +9787502919153 +9787502920708 +9787502920715 +9787502921279 +9787502921286 +9787502921477 +9787502921934 +9787502922412 +9787502922528 +9787502923457 +9787502923761 +9787502924638 +9787502924843 +9787502924942 +9787502925765 +9787502926045 +9787502926410 +9787502926441 +9787502927875 +9787502929398 +9787502929411 +9787502929633 +9787502930165 +9787502930516 +9787502932527 +9787502933364 +9787502933876 +9787502934477 +9787502938949 +9787502939885 +9787502940515 +9787502942182 +9787502942519 +9787502945480 +9787502946166 +9787502946326 +9787502946500 +9787502946739 +9787502946913 +9787502948290 +9787502948849 +9787502949051 +9787502949525 +9787502949693 +9787502950446 +9787502950644 +9787502952464 +9787502953218 +9787502953560 +9787502953683 +9787502954048 +9787502954734 +9787502956684 +9787502956738 +9787502957155 +9787502959067 +9787502959654 +9787502960469 +9787502960698 +9787502962395 +9787502962562 +9787502963231 +9787502968298 +9787502968748 +9787502970383 +9787502971977 +9787502982454 +9787502983475 +9787503001925 +9787503012839 +9787503019319 +9787503019494 +9787503023309 +9787503025891 +9787503025952 +9787503026010 +9787503027994 +9787503029943 +9787503030949 +9787503031441 +9787503032332 +9787503032998 +9787503034510 +9787503037368 +9787503042690 +9787503043758 +9787503100017 +9787503100406 +9787503100598 +9787503103049 +9787503103056 +9787503103261 +9787503105593 +9787503105647 +9787503105708 +9787503108860 +9787503110061 +9787503110696 +9787503116896 +9787503116902 +9787503117695 +9787503117954 +9787503118180 +9787503118289 +9787503119361 +9787503119507 +9787503119712 +9787503120695 +9787503121364 +9787503121401 +9787503121418 +9787503121463 +9787503121760 +9787503122118 +9787503122569 +9787503122590 +9787503122743 +9787503123511 +9787503123528 +9787503124310 +9787503125881 +9787503127021 +9787503127113 +9787503127199 +9787503129360 +9787503129384 +9787503135491 +9787503137440 +9787503137891 +9787503138942 +9787503139758 +9787503139765 +9787503140976 +9787503141607 +9787503141737 +9787503142048 +9787503143526 +9787503145681 +9787503153235 +9787503155000 +9787503159572 +9787503159794 +9787503161117 +9787503162244 +9787503163616 +9787503164217 +9787503165139 +9787503166174 +9787503166648 +9787503169786 +9787503171499 +9787503174506 +9787503176234 +9787503176623 +9787503178399 +9787503179334 +9787503181061 +9787503181436 +9787503183416 +9787503185199 +9787503185267 +9787503185861 +9787503185984 +9787503186974 +9787503189999 +9787503190193 +9787503191664 +9787503193446 +9787503193538 +9787503194207 +9787503194818 +9787503195631 +9787503197031 +9787503200083 +9787503200106 +9787503200229 +9787503200397 +9787503200571 +9787503200595 +9787503200601 +9787503200656 +9787503200854 +9787503200922 +9787503201042 +9787503201165 +9787503201288 +9787503201325 +9787503201349 +9787503201363 +9787503201387 +9787503201424 +9787503201493 +9787503201707 +9787503201783 +9787503201844 +9787503202025 +9787503202162 +9787503202193 +9787503202322 +9787503202452 +9787503202469 +9787503202513 +9787503202742 +9787503202803 +9787503202940 +9787503203794 +9787503203817 +9787503204739 +9787503204883 +9787503205941 +9787503206146 +9787503206160 +9787503206177 +9787503206184 +9787503206474 +9787503206948 +9787503206962 +9787503207235 +9787503207686 +9787503208195 +9787503208393 +9787503208409 +9787503208454 +9787503208669 +9787503208713 +9787503208850 +9787503208874 +9787503208935 +9787503209468 +9787503209727 +9787503210006 +9787503210013 +9787503210167 +9787503210181 +9787503210211 +9787503210587 +9787503210983 +9787503210990 +9787503211294 +9787503211423 +9787503211584 +9787503211836 +9787503211867 +9787503211874 +9787503211898 +9787503211911 +9787503212277 +9787503212598 +9787503212734 +9787503212826 +9787503212857 +9787503213007 +9787503213403 +9787503214134 +9787503214349 +9787503215148 +9787503215216 +9787503215247 +9787503215285 +9787503215506 +9787503215728 +9787503215803 +9787503216008 +9787503216060 +9787503216206 +9787503216312 +9787503216329 +9787503216749 +9787503216909 +9787503216916 +9787503216985 +9787503217814 +9787503217869 +9787503217937 +9787503217999 +9787503218446 +9787503218637 +9787503219573 +9787503220296 +9787503220302 +9787503221095 +9787503221248 +9787503221316 +9787503221460 +9787503222047 +9787503222382 +9787503223068 +9787503224034 +9787503224492 +9787503224652 +9787503224782 +9787503224997 +9787503225024 +9787503226427 +9787503226533 +9787503227806 +9787503228063 +9787503228971 +9787503230059 +9787503230066 +9787503230080 +9787503230479 +9787503231148 +9787503231339 +9787503232237 +9787503232329 +9787503233401 +9787503233432 +9787503233616 +9787503233685 +9787503234286 +9787503236327 +9787503236440 +9787503237218 +9787503239083 +9787503239243 +9787503239410 +9787503239786 +9787503240676 +9787503240843 +9787503242137 +9787503242151 +9787503242830 +9787503243776 +9787503244056 +9787503244087 +9787503244766 +9787503245008 +9787503245138 +9787503245435 +9787503246258 +9787503246623 +9787503248139 +9787503248245 +9787503249754 +9787503253485 +9787503254284 +9787503254291 +9787503254307 +9787503255083 +9787503255731 +9787503258244 +9787503258541 +9787503262500 +9787503264900 +9787503264986 +9787503265624 +9787503266461 +9787503266980 +9787503268052 +9787503270222 +9787503271229 +9787503271397 +9787503271441 +9787503273308 +9787503274213 +9787503274497 +9787503274954 +9787503275807 +9787503275821 +9787503275852 +9787503300349 +9787503300448 +9787503301186 +9787503301292 +9787503301452 +9787503301711 +9787503301957 +9787503302121 +9787503302565 +9787503302572 +9787503303265 +9787503303517 +9787503304323 +9787503304330 +9787503304538 +9787503304613 +9787503304712 +9787503304972 +9787503304989 +9787503305306 +9787503305689 +9787503306044 +9787503306303 +9787503306907 +9787503306945 +9787503307430 +9787503307447 +9787503307485 +9787503307799 +9787503307881 +9787503308055 +9787503308079 +9787503308093 +9787503308123 +9787503308239 +9787503308451 +9787503308543 +9787503308567 +9787503308581 +9787503308604 +9787503308611 +9787503308666 +9787503308925 +9787503308932 +9787503308949 +9787503309038 +9787503309113 +9787503309243 +9787503309373 +9787503309458 +9787503309564 +9787503309571 +9787503309588 +9787503309809 +9787503309854 +9787503309861 +9787503309922 +9787503310249 +9787503310584 +9787503310706 +9787503310768 +9787503310782 +9787503311710 +9787503311765 +9787503311888 +9787503311918 +9787503311970 +9787503312229 +9787503312434 +9787503312526 +9787503312656 +9787503312694 +9787503312724 +9787503312830 +9787503312885 +9787503313172 +9787503313363 +9787503313431 +9787503314087 +9787503314605 +9787503314629 +9787503315350 +9787503315862 +9787503316616 +9787503317200 +9787503317378 +9787503317637 +9787503319099 +9787503319235 +9787503320552 +9787503321733 +9787503322198 +9787503322914 +9787503322976 +9787503322990 +9787503323416 +9787503323430 +9787503323768 +9787503323775 +9787503324239 +9787503325397 +9787503326523 +9787503400001 +9787503400025 +9787503400070 +9787503400087 +9787503400094 +9787503400100 +9787503400186 +9787503400247 +9787503400322 +9787503400360 +9787503400445 +9787503400520 +9787503400551 +9787503400568 +9787503400582 +9787503400605 +9787503400636 +9787503400643 +9787503400650 +9787503400674 +9787503400698 +9787503400759 +9787503401008 +9787503401053 +9787503401114 +9787503401145 +9787503401343 +9787503401428 +9787503401473 +9787503401701 +9787503401756 +9787503401770 +9787503401817 +9787503401855 +9787503401862 +9787503401916 +9787503402272 +9787503402333 +9787503402340 +9787503402357 +9787503402371 +9787503402388 +9787503402470 +9787503402654 +9787503402685 +9787503402906 +9787503403040 +9787503403590 +9787503403606 +9787503403613 +9787503403842 +9787503403965 +9787503404016 +9787503404085 +9787503404221 +9787503404313 +9787503404429 +9787503404672 +9787503404887 +9787503405600 +9787503405655 +9787503405761 +9787503405808 +9787503405815 +9787503405853 +9787503405860 +9787503405884 +9787503405907 +9787503406140 +9787503406362 +9787503406737 +9787503406775 +9787503406812 +9787503406966 +9787503407031 +9787503407093 +9787503407109 +9787503407123 +9787503407185 +9787503407239 +9787503407260 +9787503407291 +9787503407307 +9787503407321 +9787503407451 +9787503407468 +9787503407482 +9787503407536 +9787503407550 +9787503407581 +9787503407598 +9787503407659 +9787503407888 +9787503407963 +9787503408021 +9787503408045 +9787503408083 +9787503408120 +9787503408137 +9787503408380 +9787503408489 +9787503408502 +9787503408526 +9787503408564 +9787503408700 +9787503408731 +9787503408786 +9787503408854 +9787503408946 +9787503409035 +9787503409073 +9787503409103 +9787503409134 +9787503409172 +9787503409240 +9787503409288 +9787503409394 +9787503409462 +9787503409523 +9787503409530 +9787503409592 +9787503409790 +9787503409967 +9787503410147 +9787503410154 +9787503410178 +9787503410185 +9787503410208 +9787503410369 +9787503410383 +9787503410413 +9787503410420 +9787503410512 +9787503410581 +9787503410635 +9787503410659 +9787503410697 +9787503410772 +9787503410857 +9787503410918 +9787503410994 +9787503411069 +9787503411168 +9787503411199 +9787503411281 +9787503411335 +9787503411366 +9787503411472 +9787503411526 +9787503411533 +9787503411762 +9787503411779 +9787503411786 +9787503411793 +9787503411816 +9787503411847 +9787503411922 +9787503411977 +9787503411984 +9787503412066 +9787503412097 +9787503412165 +9787503412240 +9787503412257 +9787503412264 +9787503412301 +9787503412486 +9787503412547 +9787503412639 +9787503412646 +9787503412776 +9787503412875 +9787503413179 +9787503413254 +9787503413315 +9787503413322 +9787503413407 +9787503413421 +9787503413476 +9787503413551 +9787503413742 +9787503413896 +9787503414039 +9787503414053 +9787503414206 +9787503414251 +9787503414336 +9787503414367 +9787503414398 +9787503414527 +9787503414633 +9787503414664 +9787503414695 +9787503414732 +9787503414855 +9787503414909 +9787503415005 +9787503415012 +9787503415036 +9787503415111 +9787503415197 +9787503415487 +9787503415494 +9787503415661 +9787503415692 +9787503415852 +9787503415883 +9787503415906 +9787503416064 +9787503416101 +9787503416163 +9787503416200 +9787503416224 +9787503416392 +9787503416422 +9787503416460 +9787503416613 +9787503416620 +9787503416828 +9787503416835 +9787503416965 +9787503416996 +9787503417054 +9787503417283 +9787503417290 +9787503417320 +9787503417368 +9787503417443 +9787503417658 +9787503417764 +9787503417795 +9787503417900 +9787503418303 +9787503418396 +9787503418419 +9787503418457 +9787503418969 +9787503419089 +9787503419409 +9787503419492 +9787503419539 +9787503419560 +9787503419829 +9787503419911 +9787503419966 +9787503420030 +9787503420085 +9787503420139 +9787503420184 +9787503420368 +9787503420382 +9787503420894 +9787503420917 +9787503421310 +9787503421679 +9787503421709 +9787503421730 +9787503421792 +9787503422003 +9787503422409 +9787503422546 +9787503422621 +9787503422850 +9787503423024 +9787503423390 +9787503423598 +9787503423642 +9787503423680 +9787503423697 +9787503423819 +9787503423864 +9787503423963 +9787503424014 +9787503424052 +9787503424069 +9787503424076 +9787503424151 +9787503424168 +9787503424359 +9787503424410 +9787503424588 +9787503424779 +9787503424908 +9787503424915 +9787503425158 +9787503425226 +9787503425578 +9787503425608 +9787503425905 +9787503425950 +9787503426162 +9787503426575 +9787503426803 +9787503426889 +9787503426919 +9787503426957 +9787503427497 +9787503427589 +9787503428623 +9787503428661 +9787503428746 +9787503429156 +9787503429545 +9787503430329 +9787503430541 +9787503430572 +9787503430916 +9787503430954 +9787503431326 +9787503431388 +9787503431401 +9787503431630 +9787503431722 +9787503431791 +9787503432408 +9787503432552 +9787503432644 +9787503432712 +9787503433023 +9787503433283 +9787503433405 +9787503434082 +9787503434341 +9787503434518 +9787503434532 +9787503434693 +9787503435010 +9787503435102 +9787503435119 +9787503435508 +9787503435898 +9787503436079 +9787503436130 +9787503436246 +9787503436338 +9787503436437 +9787503436802 +9787503437090 +9787503437472 +9787503437687 +9787503437694 +9787503438141 +9787503438400 +9787503438431 +9787503438684 +9787503438714 +9787503438745 +9787503438837 +9787503438899 +9787503439087 +9787503439490 +9787503439582 +9787503439612 +9787503439698 +9787503439940 +9787503440076 +9787503440328 +9787503440519 +9787503440564 +9787503440618 +9787503440632 +9787503440960 +9787503441189 +9787503441271 +9787503441561 +9787503442384 +9787503442391 +9787503442407 +9787503442476 +9787503442773 +9787503442858 +9787503442865 +9787503443046 +9787503443053 +9787503443824 +9787503443848 +9787503443855 +9787503443978 +9787503444210 +9787503444241 +9787503444418 +9787503444548 +9787503445644 +9787503445965 +9787503446092 +9787503446337 +9787503446863 +9787503446900 +9787503446948 +9787503447761 +9787503448478 +9787503448515 +9787503448799 +9787503450358 +9787503450396 +9787503450747 +9787503450792 +9787503450983 +9787503451034 +9787503451102 +9787503451157 +9787503451249 +9787503451614 +9787503451805 +9787503452123 +9787503452611 +9787503452895 +9787503453014 +9787503453052 +9787503453250 +9787503453311 +9787503453601 +9787503453779 +9787503454066 +9787503454073 +9787503454264 +9787503454400 +9787503455018 +9787503455407 +9787503455513 +9787503456008 +9787503456268 +9787503456404 +9787503456534 +9787503456800 +9787503456923 +9787503457128 +9787503457418 +9787503457647 +9787503457883 +9787503458781 +9787503458804 +9787503458965 +9787503459054 +9787503459085 +9787503459122 +9787503459603 +9787503460838 +9787503460852 +9787503461231 +9787503461668 +9787503463730 +9787503464218 +9787503465277 +9787503465628 +9787503466793 +9787503469961 +9787503473258 +9787503474903 +9787503479366 +9787503480546 +9787503482595 +9787503483646 +9787503484889 +9787503486586 +9787503487279 +9787503487484 +9787503488092 +9787503488108 +9787503488252 +9787503490859 +9787503491788 +9787503493539 +9787503493799 +9787503494024 +9787503494895 +9787503495540 +9787503497445 +9787503498732 +9787503499418 +9787503500145 +9787503500435 +9787503500442 +9787503500565 +9787503500886 +9787503501241 +9787503501555 +9787503501586 +9787503501630 +9787503501920 +9787503502026 +9787503502132 +9787503502460 +9787503502545 +9787503502583 +9787503502613 +9787503502675 +9787503502767 +9787503502798 +9787503502873 +9787503503115 +9787503503191 +9787503503252 +9787503503313 +9787503503610 +9787503503924 +9787503504006 +9787503504037 +9787503504044 +9787503504051 +9787503504235 +9787503504358 +9787503504426 +9787503504464 +9787503504471 +9787503504556 +9787503504655 +9787503504693 +9787503504891 +9787503504938 +9787503504976 +9787503505102 +9787503505133 +9787503505263 +9787503505270 +9787503505317 +9787503505355 +9787503505911 +9787503506147 +9787503506185 +9787503506598 +9787503506604 +9787503506673 +9787503506680 +9787503506710 +9787503506932 +9787503506994 +9787503507458 +9787503507465 +9787503507823 +9787503507861 +9787503507915 +9787503507960 +9787503508073 +9787503508233 +9787503508318 +9787503508424 +9787503508448 +9787503508523 +9787503508530 +9787503508721 +9787503508745 +9787503509100 +9787503509469 +9787503509995 +9787503510144 +9787503510205 +9787503510397 +9787503510557 +9787503510960 +9787503511202 +9787503511240 +9787503511431 +9787503511455 +9787503511547 +9787503511615 +9787503511721 +9787503511745 +9787503511806 +9787503511813 +9787503512209 +9787503512346 +9787503512568 +9787503513060 +9787503513138 +9787503513145 +9787503513176 +9787503513183 +9787503513206 +9787503513213 +9787503513237 +9787503513251 +9787503513312 +9787503513343 +9787503513411 +9787503513473 +9787503513510 +9787503513541 +9787503513657 +9787503513978 +9787503514104 +9787503514265 +9787503514340 +9787503514562 +9787503514623 +9787503514722 +9787503514838 +9787503514913 +9787503515002 +9787503515026 +9787503515088 +9787503515422 +9787503515477 +9787503515583 +9787503515620 +9787503515637 +9787503515651 +9787503515811 +9787503515934 +9787503516054 +9787503516245 +9787503516269 +9787503516375 +9787503516467 +9787503516474 +9787503516528 +9787503516627 +9787503516696 +9787503516863 +9787503517020 +9787503517167 +9787503517204 +9787503517235 +9787503517242 +9787503517259 +9787503517327 +9787503517761 +9787503518409 +9787503518706 +9787503518881 +9787503518898 +9787503518904 +9787503518997 +9787503519017 +9787503519130 +9787503519185 +9787503519321 +9787503520075 +9787503520310 +9787503520716 +9787503520778 +9787503521027 +9787503521324 +9787503521683 +9787503521775 +9787503521898 +9787503522109 +9787503522536 +9787503522666 +9787503522697 +9787503522857 +9787503524059 +9787503524448 +9787503525377 +9787503525551 +9787503526084 +9787503526176 +9787503526237 +9787503527180 +9787503527296 +9787503528040 +9787503529092 +9787503529436 +9787503529573 +9787503530968 +9787503531248 +9787503531378 +9787503532115 +9787503532870 +9787503533211 +9787503534355 +9787503535499 +9787503536816 +9787503537462 +9787503537486 +9787503537615 +9787503540233 +9787503541223 +9787503544194 +9787503544866 +9787503545290 +9787503546105 +9787503546792 +9787503546846 +9787503546938 +9787503546990 +9787503547508 +9787503548130 +9787503549571 +9787503549809 +9787503550270 +9787503550607 +9787503550829 +9787503551697 +9787503553110 +9787503553189 +9787503553745 +9787503553783 +9787503554315 +9787503554360 +9787503554544 +9787503555350 +9787503555695 +9787503556340 +9787503556791 +9787503557408 +9787503558290 +9787503558641 +9787503560552 +9787503560989 +9787503561207 +9787503561474 +9787503561627 +9787503562105 +9787503563003 +9787503563355 +9787503563621 +9787503564277 +9787503564789 +9787503565120 +9787503565403 +9787503565557 +9787503565564 +9787503566080 +9787503566110 +9787503566561 +9787503566585 +9787503567704 +9787503567803 +9787503568008 +9787503568145 +9787503568176 +9787503568695 +9787503568732 +9787503568909 +9787503568985 +9787503570087 +9787503570377 +9787503570568 +9787503570605 +9787503570674 +9787503571312 +9787503571930 +9787503572135 +9787503572340 +9787503573262 +9787503573330 +9787503573408 +9787503573422 +9787503573446 +9787503573743 +9787503574108 +9787503574344 +9787503574450 +9787503575136 +9787503575464 +9787503575860 +9787503600159 +9787503600272 +9787503601163 +9787503601538 +9787503601644 +9787503601859 +9787503602214 +9787503604393 +9787503604621 +9787503604737 +9787503605048 +9787503606397 +9787503606465 +9787503607608 +9787503608063 +9787503608124 +9787503608841 +9787503608872 +9787503609619 +9787503609893 +9787503610226 +9787503610486 +9787503610790 +9787503610844 +9787503611001 +9787503611254 +9787503612114 +9787503612145 +9787503614118 +9787503614774 +9787503614934 +9787503615146 +9787503615788 +9787503616075 +9787503616440 +9787503616754 +9787503618093 +9787503618314 +9787503618345 +9787503619656 +9787503619823 +9787503620515 +9787503620928 +9787503621055 +9787503621871 +9787503622144 +9787503622342 +9787503622755 +9787503623141 +9787503623868 +9787503624162 +9787503624797 +9787503625534 +9787503626609 +9787503627101 +9787503627156 +9787503627361 +9787503627712 +9787503627729 +9787503627927 +9787503629594 +9787503630682 +9787503630736 +9787503630934 +9787503630989 +9787503632044 +9787503632174 +9787503632563 +9787503634024 +9787503634512 +9787503634734 +9787503636530 +9787503639005 +9787503639326 +9787503641220 +9787503642432 +9787503644276 +9787503644658 +9787503645631 +9787503645921 +9787503646850 +9787503648076 +9787503649042 +9787503649059 +9787503649110 +9787503651335 +9787503652837 +9787503654145 +9787503655210 +9787503656552 +9787503656873 +9787503659249 +9787503661778 +9787503663185 +9787503669408 +9787503671470 +9787503678998 +9787503681554 +9787503682469 +9787503687013 +9787503687181 +9787503693731 +9787503696107 +9787503697715 +9787503700590 +9787503701795 +9787503707575 +9787503710391 +9787503710889 +9787503713538 +9787503715075 +9787503717192 +9787503717857 +9787503718571 +9787503719172 +9787503719240 +9787503719943 +9787503719950 +9787503723636 +9787503724060 +9787503724725 +9787503726842 +9787503729379 +9787503729423 +9787503730085 +9787503730290 +9787503731280 +9787503731327 +9787503731785 +9787503733543 +9787503733635 +9787503734861 +9787503735080 +9787503736513 +9787503736872 +9787503740992 +9787503742187 +9787503745232 +9787503745508 +9787503745515 +9787503748394 +9787503749032 +9787503759529 +9787503762055 +9787503764691 +9787503766152 +9787503772757 +9787503773402 +9787503784552 +9787503791987 +9787503793127 +9787503793172 +9787503793189 +9787503794025 +9787503794117 +9787503794544 +9787503795060 +9787503795107 +9787503796746 +9787503796807 +9787503797170 +9787503797712 +9787503797729 +9787503798412 +9787503800450 +9787503801778 +9787503803802 +9787503804106 +9787503804274 +9787503805479 +9787503805646 +9787503805950 +9787503806124 +9787503806360 +9787503806926 +9787503807374 +9787503808043 +9787503812538 +9787503813191 +9787503813214 +9787503813238 +9787503813382 +9787503814327 +9787503814747 +9787503816291 +9787503817090 +9787503817410 +9787503817762 +9787503818097 +9787503818349 +9787503818387 +9787503818950 +9787503819483 +9787503820182 +9787503820212 +9787503820243 +9787503821325 +9787503822117 +9787503823404 +9787503823480 +9787503824579 +9787503824609 +9787503825194 +9787503825248 +9787503825453 +9787503825781 +9787503826474 +9787503827488 +9787503828140 +9787503829802 +9787503831232 +9787503831614 +9787503833595 +9787503834356 +9787503834523 +9787503835780 +9787503836107 +9787503837302 +9787503837449 +9787503838446 +9787503838583 +9787503840593 +9787503841255 +9787503843501 +9787503846007 +9787503846014 +9787503855757 +9787503856631 +9787503858581 +9787503859342 +9787503861079 +9787503864582 +9787503869112 +9787503872235 +9787503872242 +9787503872846 +9787503873522 +9787503874994 +9787503879241 +9787503889066 +9787503892431 +9787503892851 +9787503894695 +9787503896842 +9787503897757 +9787503900068 +9787503900143 +9787503900358 +9787503900655 +9787503900778 +9787503900808 +9787503900891 +9787503900969 +9787503901034 +9787503901218 +9787503901256 +9787503901324 +9787503901546 +9787503901768 +9787503901867 +9787503901904 +9787503901959 +9787503901997 +9787503902024 +9787503902031 +9787503902123 +9787503902130 +9787503902161 +9787503902178 +9787503902277 +9787503902307 +9787503902369 +9787503902567 +9787503902727 +9787503902796 +9787503903069 +9787503903120 +9787503903212 +9787503903403 +9787503903670 +9787503903748 +9787503903939 +9787503904165 +9787503904639 +9787503904851 +9787503904899 +9787503904929 +9787503905285 +9787503905513 +9787503905636 +9787503905964 +9787503906145 +9787503906268 +9787503906404 +9787503906480 +9787503907210 +9787503907272 +9787503907289 +9787503907517 +9787503907678 +9787503907760 +9787503908088 +9787503908262 +9787503908309 +9787503908330 +9787503908484 +9787503908491 +9787503908583 +9787503909429 +9787503909528 +9787503909627 +9787503910104 +9787503910234 +9787503910258 +9787503910586 +9787503910999 +9787503911156 +9787503911231 +9787503911279 +9787503911309 +9787503911743 +9787503912023 +9787503912177 +9787503912214 +9787503912788 +9787503912931 +9787503912948 +9787503912955 +9787503912986 +9787503913143 +9787503913310 +9787503913402 +9787503913617 +9787503913624 +9787503913631 +9787503913884 +9787503913938 +9787503914225 +9787503914300 +9787503914331 +9787503914355 +9787503914409 +9787503914447 +9787503914461 +9787503914478 +9787503914485 +9787503914515 +9787503914522 +9787503914546 +9787503914652 +9787503914843 +9787503914881 +9787503914980 +9787503915048 +9787503915093 +9787503915109 +9787503915147 +9787503915246 +9787503915567 +9787503915598 +9787503915604 +9787503915697 +9787503915895 +9787503916427 +9787503916496 +9787503916694 +9787503916717 +9787503916724 +9787503917554 +9787503917592 +9787503917752 +9787503917776 +9787503917981 +9787503917998 +9787503918131 +9787503918230 +9787503918391 +9787503918537 +9787503918650 +9787503918827 +9787503919121 +9787503919190 +9787503919275 +9787503919374 +9787503919442 +9787503919916 +9787503920073 +9787503920097 +9787503920141 +9787503920295 +9787503920301 +9787503920332 +9787503920486 +9787503920578 +9787503920844 +9787503920905 +9787503920950 +9787503920998 +9787503921100 +9787503921179 +9787503921803 +9787503921957 +9787503922046 +9787503922190 +9787503922220 +9787503922251 +9787503922268 +9787503922619 +9787503922893 +9787503923241 +9787503923616 +9787503923791 +9787503923883 +9787503924019 +9787503924026 +9787503924200 +9787503925177 +9787503925634 +9787503925818 +9787503926099 +9787503927010 +9787503927638 +9787503927836 +9787503927843 +9787503927966 +9787503928079 +9787503928857 +9787503929793 +9787503931154 +9787503931376 +9787503931390 +9787503931703 +9787503932205 +9787503932304 +9787503932694 +9787503932731 +9787503933080 +9787503933172 +9787503933363 +9787503934780 +9787503935602 +9787503936302 +9787503936692 +9787503936937 +9787503937286 +9787503937545 +9787503937637 +9787503938450 +9787503938467 +9787503938870 +9787503939341 +9787503939358 +9787503939815 +9787503939860 +9787503940286 +9787503940385 +9787503940637 +9787503941573 +9787503941672 +9787503941795 +9787503941801 +9787503942426 +9787503942709 +9787503943102 +9787503943454 +9787503944147 +9787503945618 +9787503945922 +9787503946813 +9787503948367 +9787503948763 +9787503949258 +9787503949333 +9787503949357 +9787503949395 +9787503950728 +9787503950759 +9787503951107 +9787503951213 +9787503951350 +9787503952227 +9787503952616 +9787503952661 +9787503953286 +9787503953668 +9787503953897 +9787503954849 +9787503955051 +9787503955129 +9787503955327 +9787503958250 +9787503959417 +9787503962561 +9787503962776 +9787503963018 +9787503965890 +9787503966910 +9787503966941 +9787503966958 +9787503971006 +9787503973666 +9787503975943 +9787503976940 +9787503976995 +9787503977008 +9787503977404 +9787503977503 +9787503977589 +9787503978265 +9787504000040 +9787504000415 +9787504000514 +9787504000590 +9787504000606 +9787504000637 +9787504000828 +9787504000842 +9787504001238 +9787504002044 +9787504002075 +9787504002242 +9787504002426 +9787504002655 +9787504003188 +9787504003850 +9787504003874 +9787504003935 +9787504100153 +9787504100177 +9787504100726 +9787504101150 +9787504101419 +9787504101723 +9787504101778 +9787504103857 +9787504104991 +9787504105318 +9787504105677 +9787504105691 +9787504106926 +9787504107091 +9787504107206 +9787504108302 +9787504109378 +9787504110725 +9787504111036 +9787504111074 +9787504111524 +9787504111623 +9787504111692 +9787504111708 +9787504111807 +9787504112095 +9787504112132 +9787504114518 +9787504115133 +9787504116444 +9787504117038 +9787504117472 +9787504118356 +9787504118370 +9787504120137 +9787504120762 +9787504120823 +9787504120830 +9787504120922 +9787504121141 +9787504121196 +9787504121615 +9787504122643 +9787504123978 +9787504124142 +9787504124333 +9787504124890 +9787504125866 +9787504126955 +9787504131089 +9787504131096 +9787504136336 +9787504136688 +9787504141521 +9787504143686 +9787504144904 +9787504144928 +9787504144935 +9787504144942 +9787504146496 +9787504146519 +9787504146786 +9787504147233 +9787504154248 +9787504156488 +9787504156587 +9787504158512 +9787504159496 +9787504165046 +9787504166111 +9787504166425 +9787504167965 +9787504168535 +9787504168795 +9787504172846 +9787504173461 +9787504174734 +9787504177216 +9787504179050 +9787504184481 +9787504184498 +9787504184627 +9787504185327 +9787504185815 +9787504186850 +9787504187369 +9787504189394 +9787504192455 +9787504192837 +9787504193117 +9787504193469 +9787504195371 +9787504195760 +9787504196699 +9787504196712 +9787504197443 +9787504197641 +9787504197740 +9787504197795 +9787504198488 +9787504198648 +9787504198709 +9787504200143 +9787504200426 +9787504200464 +9787504200914 +9787504201614 +9787504201843 +9787504202581 +9787504202864 +9787504202925 +9787504202994 +9787504203083 +9787504203120 +9787504203281 +9787504203410 +9787504203427 +9787504203465 +9787504203717 +9787504203724 +9787504203731 +9787504203748 +9787504203779 +9787504203786 +9787504203977 +9787504204004 +9787504204332 +9787504205926 +9787504208705 +9787504208712 +9787504208729 +9787504210074 +9787504210500 +9787504210845 +9787504211149 +9787504211187 +9787504211262 +9787504211941 +9787504212146 +9787504212375 +9787504212696 +9787504213341 +9787504213839 +9787504213846 +9787504213853 +9787504214157 +9787504214423 +9787504214751 +9787504216205 +9787504217073 +9787504217585 +9787504217608 +9787504218919 +9787504222091 +9787504222992 +9787504223470 +9787504223548 +9787504225436 +9787504226525 +9787504226594 +9787504300034 +9787504300232 +9787504300652 +9787504300928 +9787504300980 +9787504301208 +9787504301307 +9787504301352 +9787504301468 +9787504301680 +9787504302144 +9787504302335 +9787504302434 +9787504302489 +9787504302847 +9787504303509 +9787504303523 +9787504304018 +9787504304186 +9787504304438 +9787504304797 +9787504305183 +9787504305404 +9787504305428 +9787504305565 +9787504305824 +9787504306159 +9787504306173 +9787504306418 +9787504306425 +9787504306470 +9787504306487 +9787504307323 +9787504307446 +9787504308009 +9787504308528 +9787504308580 +9787504308832 +9787504311948 +9787504312006 +9787504312013 +9787504312303 +9787504312990 +9787504313010 +9787504313263 +9787504313362 +9787504313454 +9787504313546 +9787504313560 +9787504313591 +9787504313676 +9787504313713 +9787504314062 +9787504314192 +9787504314994 +9787504315168 +9787504315526 +9787504315694 +9787504315748 +9787504315830 +9787504316004 +9787504316011 +9787504316134 +9787504317230 +9787504317445 +9787504317506 +9787504317636 +9787504317643 +9787504317865 +9787504318121 +9787504318190 +9787504318459 +9787504319067 +9787504319081 +9787504319159 +9787504319289 +9787504319531 +9787504319593 +9787504319630 +9787504320322 +9787504320346 +9787504320711 +9787504320735 +9787504321312 +9787504321336 +9787504321671 +9787504321718 +9787504321923 +9787504322449 +9787504323668 +9787504324115 +9787504324177 +9787504324252 +9787504324399 +9787504325648 +9787504325945 +9787504326539 +9787504327284 +9787504327345 +9787504327444 +9787504327475 +9787504327567 +9787504327581 +9787504327864 +9787504328083 +9787504328113 +9787504328144 +9787504328267 +9787504328410 +9787504328571 +9787504328601 +9787504329011 +9787504329394 +9787504329400 +9787504329837 +9787504329929 +9787504330314 +9787504330369 +9787504330482 +9787504330499 +9787504330925 +9787504331045 +9787504331267 +9787504331281 +9787504331304 +9787504331311 +9787504331328 +9787504331335 +9787504331342 +9787504331359 +9787504331380 +9787504331427 +9787504331991 +9787504332028 +9787504332042 +9787504332066 +9787504332226 +9787504332523 +9787504332585 +9787504332646 +9787504332721 +9787504334183 +9787504334190 +9787504334244 +9787504334503 +9787504334602 +9787504334787 +9787504334817 +9787504334879 +9787504335586 +9787504335975 +9787504336040 +9787504336415 +9787504337030 +9787504337573 +9787504337689 +9787504337757 +9787504338488 +9787504339317 +9787504339539 +9787504339560 +9787504339744 +9787504340924 +9787504341396 +9787504341440 +9787504341716 +9787504343000 +9787504343161 +9787504343550 +9787504344205 +9787504344335 +9787504346308 +9787504346988 +9787504347435 +9787504348692 +9787504350367 +9787504350831 +9787504351098 +9787504351265 +9787504355140 +9787504355201 +9787504355652 +9787504358776 +9787504359216 +9787504360779 +9787504360984 +9787504362223 +9787504363732 +9787504363787 +9787504366009 +9787504366108 +9787504366368 +9787504366863 +9787504367396 +9787504369550 +9787504370648 +9787504371232 +9787504371515 +9787504371683 +9787504372499 +9787504372628 +9787504373045 +9787504373953 +9787504374455 +9787504375124 +9787504375537 +9787504376619 +9787504378514 +9787504379641 +9787504383082 +9787504383365 +9787504383587 +9787504384515 +9787504384843 +9787504385093 +9787504385239 +9787504385307 +9787504385871 +9787504386168 +9787504386441 +9787504386977 +9787504387028 +9787504387813 +9787504387936 +9787504388360 +9787504388384 +9787504388414 +9787504388438 +9787504389060 +9787504389183 +9787504389473 +9787504391087 +9787504391414 +9787504392534 +9787504392626 +9787504392695 +9787504392794 +9787504400383 +9787504400406 +9787504401212 +9787504401359 +9787504401410 +9787504401519 +9787504401762 +9787504402523 +9787504402837 +9787504402851 +9787504403414 +9787504403988 +9787504404015 +9787504404848 +9787504404978 +9787504405272 +9787504405661 +9787504405838 +9787504406163 +9787504406729 +9787504406934 +9787504407245 +9787504407757 +9787504408501 +9787504408655 +9787504408976 +9787504409423 +9787504409560 +9787504410573 +9787504410795 +9787504410948 +9787504411075 +9787504411198 +9787504412256 +9787504412409 +9787504413376 +9787504413680 +9787504413871 +9787504414236 +9787504414243 +9787504414656 +9787504415462 +9787504415769 +9787504416209 +9787504417046 +9787504417923 +9787504418401 +9787504419576 +9787504421562 +9787504422262 +9787504422798 +9787504423009 +9787504423436 +9787504423757 +9787504424167 +9787504424464 +9787504424495 +9787504425102 +9787504426321 +9787504426727 +9787504428950 +9787504430915 +9787504431172 +9787504432377 +9787504432414 +9787504433336 +9787504433466 +9787504433855 +9787504436757 +9787504438003 +9787504438454 +9787504438478 +9787504440389 +9787504441171 +9787504441355 +9787504441508 +9787504441577 +9787504442901 +9787504443052 +9787504443823 +9787504443861 +9787504443953 +9787504444202 +9787504444400 +9787504444585 +9787504444684 +9787504445261 +9787504445339 +9787504445346 +9787504446114 +9787504447401 +9787504448552 +9787504449061 +9787504449795 +9787504450869 +9787504452139 +9787504452290 +9787504452955 +9787504454133 +9787504454225 +9787504455352 +9787504455482 +9787504455666 +9787504455789 +9787504456014 +9787504456076 +9787504456472 +9787504458490 +9787504458711 +9787504460820 +9787504461926 +9787504462046 +9787504462619 +9787504463364 +9787504463371 +9787504464156 +9787504464187 +9787504464217 +9787504464460 +9787504464910 +9787504464927 +9787504465450 +9787504465504 +9787504465696 +9787504467188 +9787504468994 +9787504469175 +9787504469489 +9787504469793 +9787504470164 +9787504472526 +9787504473394 +9787504474537 +9787504474735 +9787504475770 +9787504475817 +9787504475855 +9787504475978 +9787504476050 +9787504476609 +9787504476722 +9787504477262 +9787504477408 +9787504478078 +9787504478252 +9787504478306 +9787504478313 +9787504479143 +9787504479310 +9787504481474 +9787504484963 +9787504485588 +9787504492210 +9787504492548 +9787504493552 +9787504494344 +9787504494511 +9787504494788 +9787504495778 +9787504497901 +9787504498243 +9787504499431 +9787504499639 +9787504500069 +9787504502896 +9787504503701 +9787504504074 +9787504508300 +9787504508317 +9787504508324 +9787504509215 +9787504510556 +9787504510587 +9787504512536 +9787504513885 +9787504514394 +9787504515353 +9787504515360 +9787504515377 +9787504516183 +9787504516558 +9787504516695 +9787504518170 +9787504518705 +9787504519313 +9787504519382 +9787504525840 +9787504526151 +9787504526175 +9787504527523 +9787504528551 +9787504529565 +9787504530233 +9787504530240 +9787504530899 +9787504532015 +9787504532077 +9787504532824 +9787504532848 +9787504534064 +9787504534897 +9787504535702 +9787504536686 +9787504537652 +9787504541574 +9787504546012 +9787504549662 +9787504577511 +9787504583468 +9787504585417 +9787504586940 +9787504597076 +9787504599391 +9787504600585 +9787504600936 +9787504601483 +9787504601575 +9787504601650 +9787504602589 +9787504603234 +9787504603302 +9787504605658 +9787504606815 +9787504606891 +9787504607676 +9787504608178 +9787504608239 +9787504608994 +9787504609571 +9787504609847 +9787504610041 +9787504612199 +9787504613431 +9787504614186 +9787504614223 +9787504614315 +9787504615701 +9787504616241 +9787504616760 +9787504618429 +9787504620798 +9787504621047 +9787504621429 +9787504621764 +9787504621788 +9787504622280 +9787504622457 +9787504622648 +9787504623423 +9787504623492 +9787504623522 +9787504623638 +9787504623799 +9787504623843 +9787504624055 +9787504625274 +9787504625786 +9787504625939 +9787504626028 +9787504626424 +9787504627209 +9787504627438 +9787504627544 +9787504627711 +9787504628053 +9787504628121 +9787504628329 +9787504628657 +9787504628688 +9787504628763 +9787504629036 +9787504630117 +9787504630131 +9787504630261 +9787504630414 +9787504631138 +9787504631152 +9787504631299 +9787504631770 +9787504632111 +9787504632364 +9787504632555 +9787504633293 +9787504633422 +9787504634634 +9787504634788 +9787504634962 +9787504635501 +9787504635921 +9787504637178 +9787504638724 +9787504639974 +9787504640239 +9787504640437 +9787504641250 +9787504641434 +9787504641816 +9787504641854 +9787504644442 +9787504646583 +9787504648327 +9787504648846 +9787504648938 +9787504649522 +9787504655905 +9787504656339 +9787504657404 +9787504657848 +9787504658609 +9787504659460 +9787504659774 +9787504660107 +9787504660916 +9787504661548 +9787504661616 +9787504661623 +9787504661647 +9787504661661 +9787504661692 +9787504662736 +9787504662781 +9787504662941 +9787504663139 +9787504663504 +9787504663658 +9787504663740 +9787504664396 +9787504664419 +9787504665959 +9787504666635 +9787504666680 +9787504666697 +9787504666703 +9787504666819 +9787504666994 +9787504667687 +9787504667700 +9787504668486 +9787504669360 +9787504669735 +9787504671165 +9787504675453 +9787504675514 +9787504675545 +9787504675552 +9787504675613 +9787504675620 +9787504675637 +9787504676054 +9787504676597 +9787504679574 +9787504679581 +9787504679703 +9787504679932 +9787504683007 +9787504686046 +9787504686053 +9787504687876 +9787504690951 +9787504691941 +9787504692559 +9787504693839 +9787504693877 +9787504693952 +9787504694331 +9787504695963 +9787504696298 +9787504696946 +9787504697073 +9787504697240 +9787504697875 +9787504698322 +9787504698919 +9787504699299 +9787504699329 +9787504699411 +9787504699428 +9787504699794 +9787504700001 +9787504700360 +9787504700377 +9787504701459 +9787504702494 +9787504702579 +9787504702630 +9787504703101 +9787504705105 +9787504705983 +9787504706157 +9787504708786 +9787504708939 +9787504709080 +9787504710383 +9787504710437 +9787504711205 +9787504711649 +9787504712042 +9787504712479 +9787504712882 +9787504713131 +9787504713926 +9787504714008 +9787504714077 +9787504714268 +9787504714558 +9787504714985 +9787504715395 +9787504715449 +9787504715524 +9787504715593 +9787504716033 +9787504716125 +9787504716392 +9787504716408 +9787504716552 +9787504716569 +9787504716668 +9787504716736 +9787504716941 +9787504717696 +9787504718266 +9787504718273 +9787504720870 +9787504721112 +9787504721310 +9787504721358 +9787504722386 +9787504722539 +9787504722621 +9787504722836 +9787504723192 +9787504723307 +9787504723642 +9787504724007 +9787504724700 +9787504724878 +9787504726193 +9787504726292 +9787504726339 +9787504726421 +9787504726698 +9787504726995 +9787504727060 +9787504727145 +9787504727343 +9787504727428 +9787504727466 +9787504727862 +9787504728036 +9787504728203 +9787504728241 +9787504728562 +9787504728678 +9787504728913 +9787504729231 +9787504729514 +9787504729637 +9787504729668 +9787504729682 +9787504730138 +9787504730237 +9787504730435 +9787504730534 +9787504731487 +9787504731913 +9787504731920 +9787504732170 +9787504732590 +9787504732880 +9787504732972 +9787504733603 +9787504733856 +9787504733948 +9787504734013 +9787504734037 +9787504734327 +9787504734792 +9787504735263 +9787504735300 +9787504735904 +9787504736109 +9787504736123 +9787504736185 +9787504736277 +9787504736413 +9787504736512 +9787504736956 +9787504737069 +9787504737557 +9787504737687 +9787504737809 +9787504738295 +9787504738424 +9787504739322 +9787504739445 +9787504739889 +9787504740175 +9787504740557 +9787504740588 +9787504740779 +9787504741936 +9787504742131 +9787504742865 +9787504743176 +9787504743701 +9787504744746 +9787504744845 +9787504744883 +9787504745729 +9787504745750 +9787504746320 +9787504746535 +9787504746948 +9787504747129 +9787504747266 +9787504747884 +9787504748713 +9787504748898 +9787504749260 +9787504749277 +9787504749284 +9787504749291 +9787504749352 +9787504749413 +9787504749420 +9787504749963 +9787504749987 +9787504750471 +9787504750594 +9787504750600 +9787504752093 +9787504752185 +9787504752468 +9787504752567 +9787504753571 +9787504753656 +9787504753939 +9787504754127 +9787504754394 +9787504754769 +9787504754776 +9787504754790 +9787504754806 +9787504754882 +9787504754950 +9787504756145 +9787504756763 +9787504758309 +9787504759696 +9787504760050 +9787504760524 +9787504761514 +9787504762122 +9787504762498 +9787504762665 +9787504763266 +9787504764119 +9787504764324 +9787504765185 +9787504765246 +9787504766175 +9787504766571 +9787504767868 +9787504768100 +9787504768285 +9787504768513 +9787504768582 +9787504768865 +9787504769756 +9787504770219 +9787504770295 +9787504770547 +9787504771209 +9787504771490 +9787504771667 +9787504771728 +9787504771780 +9787504772435 +9787504772787 +9787504772817 +9787504772893 +9787504773494 +9787504774125 +9787504774774 +9787504775597 +9787504775610 +9787504775757 +9787504776778 +9787504776952 +9787504777003 +9787504777133 +9787504777539 +9787504777577 +9787504778642 +9787504779045 +9787504779342 +9787504779496 +9787504779564 +9787504780324 +9787504780362 +9787504780409 +9787504780645 +9787504780713 +9787504780744 +9787504781079 +9787504781376 +9787504781642 +9787504781659 +9787504781796 +9787504781994 +9787504782328 +9787504801104 +9787504801159 +9787504801203 +9787504801210 +9787504801333 +9787504802637 +9787504803214 +9787504803672 +9787504803689 +9787504803788 +9787504803795 +9787504803931 +9787504804020 +9787504804068 +9787504804075 +9787504804129 +9787504804228 +9787504804266 +9787504804280 +9787504804464 +9787504804808 +9787504804815 +9787504804952 +9787504805607 +9787504805751 +9787504805911 +9787504806604 +9787504806697 +9787504807380 +9787504807489 +9787504807717 +9787504807816 +9787504807960 +9787504808196 +9787504808257 +9787504808264 +9787504808523 +9787504808820 +9787504808837 +9787504808851 +9787504809186 +9787504809353 +9787504809537 +9787504810168 +9787504810687 +9787504811400 +9787504811653 +9787504811820 +9787504811875 +9787504811882 +9787504811998 +9787504812391 +9787504812636 +9787504812971 +9787504813503 +9787504813626 +9787504814418 +9787504814425 +9787504814487 +9787504814951 +9787504815118 +9787504815408 +9787504815927 +9787504815958 +9787504816153 +9787504816511 +9787504818195 +9787504818256 +9787504818669 +9787504818706 +9787504818959 +9787504819116 +9787504819369 +9787504819420 +9787504819604 +9787504819987 +9787504820112 +9787504820341 +9787504820389 +9787504820624 +9787504820730 +9787504821171 +9787504822390 +9787504822505 +9787504822543 +9787504822567 +9787504822574 +9787504823762 +9787504823991 +9787504825094 +9787504825162 +9787504825414 +9787504825940 +9787504825964 +9787504826336 +9787504826367 +9787504826527 +9787504826534 +9787504826862 +9787504827159 +9787504827203 +9787504827227 +9787504827623 +9787504828194 +9787504828903 +9787504829078 +9787504829313 +9787504829467 +9787504829627 +9787504830043 +9787504830067 +9787504830463 +9787504830517 +9787504830722 +9787504830746 +9787504830760 +9787504830814 +9787504831002 +9787504831514 +9787504831668 +9787504831989 +9787504832030 +9787504832054 +9787504832139 +9787504832573 +9787504832672 +9787504832788 +9787504832818 +9787504832870 +9787504833129 +9787504833907 +9787504835031 +9787504835178 +9787504836052 +9787504837066 +9787504838599 +9787504839701 +9787504841025 +9787504842473 +9787504842558 +9787504842848 +9787504843371 +9787504844125 +9787504845566 +9787504845740 +9787504845825 +9787504846198 +9787504847133 +9787504847140 +9787504847461 +9787504848451 +9787504848826 +9787504848956 +9787504849359 +9787504849960 +9787504850829 +9787504850836 +9787504851178 +9787504851246 +9787504852144 +9787504852793 +9787504853325 +9787504853349 +9787504853370 +9787504853509 +9787504853790 +9787504854223 +9787504854308 +9787504854889 +9787504855602 +9787504855961 +9787504857583 +9787504858450 +9787504858504 +9787504858603 +9787504858627 +9787504903174 +9787504904324 +9787504905543 +9787504907141 +9787504909008 +9787504909442 +9787504910431 +9787504910790 +9787504911087 +9787504911742 +9787504911902 +9787504912435 +9787504912640 +9787504912756 +9787504913043 +9787504913371 +9787504913913 +9787504914064 +9787504914873 +9787504915061 +9787504915153 +9787504915368 +9787504915740 +9787504916235 +9787504916358 +9787504916662 +9787504918109 +9787504918314 +9787504919830 +9787504919960 +9787504920157 +9787504920164 +9787504920188 +9787504920331 +9787504920584 +9787504920669 +9787504920928 +9787504921161 +9787504921208 +9787504921925 +9787504922328 +9787504922533 +9787504922557 +9787504923127 +9787504923219 +9787504923295 +9787504923356 +9787504923752 +9787504923868 +9787504923998 +9787504924513 +9787504924858 +9787504926340 +9787504926463 +9787504926654 +9787504927798 +9787504929556 +9787504930217 +9787504930538 +9787504930750 +9787504931528 +9787504931757 +9787504931948 +9787504932365 +9787504932730 +9787504933010 +9787504933782 +9787504934482 +9787504934727 +9787504934888 +9787504934918 +9787504935939 +9787504936936 +9787504937643 +9787504937940 +9787504938022 +9787504938831 +9787504939586 +9787504939661 +9787504940131 +9787504940285 +9787504940599 +9787504941688 +9787504942401 +9787504942968 +9787504943743 +9787504944603 +9787504945648 +9787504946171 +9787504946997 +9787504947727 +9787504947833 +9787504948144 +9787504948939 +9787504949271 +9787504949493 +9787504951519 +9787504951601 +9787504951656 +9787504952547 +9787504952615 +9787504952868 +9787504953278 +9787504953728 +9787504955524 +9787504955548 +9787504955555 +9787504956033 +9787504956118 +9787504956323 +9787504956828 +9787504957566 +9787504957610 +9787504957672 +9787504957924 +9787504958150 +9787504958372 +9787504958693 +9787504958877 +9787504959133 +9787504959164 +9787504959218 +9787504959249 +9787504959522 +9787504959614 +9787504959713 +9787504960238 +9787504960351 +9787504960436 +9787504960764 +9787504960801 +9787504961860 +9787504962010 +9787504962270 +9787504963475 +9787504963598 +9787504963635 +9787504964212 +9787504964281 +9787504964328 +9787504964601 +9787504965127 +9787504965509 +9787504965578 +9787504965950 +9787504966780 +9787504967305 +9787504967671 +9787504967985 +9787504968265 +9787504968319 +9787504968371 +9787504969101 +9787504969125 +9787504969316 +9787504969606 +9787504971128 +9787504971593 +9787504971678 +9787504971791 +9787504972156 +9787504974150 +9787504974365 +9787504974679 +9787504975041 +9787504975386 +9787504975911 +9787504976178 +9787504976369 +9787504976529 +9787504976840 +9787504977199 +9787504977328 +9787504977731 +9787504977809 +9787504977892 +9787504978219 +9787504978653 +9787504979247 +9787504979742 +9787504979902 +9787504979988 +9787504980151 +9787504980397 +9787504980496 +9787504981240 +9787504981912 +9787504982094 +9787504982100 +9787504982308 +9787504982353 +9787504983336 +9787504983503 +9787504984128 +9787504984142 +9787504984289 +9787504984456 +9787504984593 +9787504984944 +9787504985095 +9787504986436 +9787504986573 +9787504987471 +9787504987501 +9787504987556 +9787504987907 +9787504988102 +9787504988188 +9787504989123 +9787504990952 +9787504991287 +9787504991669 +9787504991751 +9787504991812 +9787504992024 +9787504993052 +9787504993243 +9787504993724 +9787504993786 +9787504994264 +9787504994455 +9787504994776 +9787504994837 +9787504994967 +9787504995414 +9787504995964 +9787504996510 +9787504996886 +9787504996916 +9787504997616 +9787504997906 +9787504997920 +9787504998163 +9787504998323 +9787504999306 +9787504999559 +9787504999740 +9787504999917 +9787504999993 +9787505000056 +9787505000223 +9787505000346 +9787505000605 +9787505000629 +9787505000650 +9787505000674 +9787505002012 +9787505002074 +9787505002128 +9787505002876 +9787505003781 +9787505004030 +9787505004252 +9787505004313 +9787505004382 +9787505005266 +9787505005808 +9787505007574 +9787505007666 +9787505007864 +9787505009448 +9787505100077 +9787505100084 +9787505100473 +9787505100787 +9787505100817 +9787505100886 +9787505100916 +9787505100923 +9787505101111 +9787505101166 +9787505101197 +9787505101258 +9787505101487 +9787505101678 +9787505101883 +9787505101937 +9787505102132 +9787505102187 +9787505102255 +9787505102323 +9787505102392 +9787505102408 +9787505102514 +9787505102521 +9787505102590 +9787505102620 +9787505102644 +9787505102675 +9787505102743 +9787505102859 +9787505102873 +9787505102880 +9787505102927 +9787505102941 +9787505102958 +9787505103009 +9787505103061 +9787505103788 +9787505103955 +9787505104167 +9787505104235 +9787505104426 +9787505104532 +9787505104716 +9787505104778 +9787505104983 +9787505105157 +9787505105652 +9787505106024 +9787505106383 +9787505106451 +9787505106604 +9787505106802 +9787505107021 +9787505107434 +9787505107533 +9787505107939 +9787505108332 +9787505108448 +9787505108516 +9787505108738 +9787505109315 +9787505109322 +9787505109858 +9787505110243 +9787505110281 +9787505110700 +9787505111806 +9787505111950 +9787505112940 +9787505113534 +9787505113558 +9787505113619 +9787505113831 +9787505114463 +9787505114876 +9787505114913 +9787505115743 +9787505115798 +9787505115804 +9787505116092 +9787505116153 +9787505116351 +9787505116405 +9787505116429 +9787505116467 +9787505116498 +9787505117174 +9787505117877 +9787505117938 +9787505118423 +9787505118676 +9787505119536 +9787505119802 +9787505119888 +9787505119994 +9787505120013 +9787505120099 +9787505120112 +9787505120228 +9787505120303 +9787505120433 +9787505120679 +9787505120853 +9787505120884 +9787505120891 +9787505120921 +9787505121089 +9787505121140 +9787505121201 +9787505121393 +9787505121614 +9787505121683 +9787505121829 +9787505121898 +9787505122017 +9787505122055 +9787505122116 +9787505122123 +9787505122345 +9787505122581 +9787505122673 +9787505122802 +9787505122833 +9787505123038 +9787505123311 +9787505123496 +9787505124745 +9787505124851 +9787505125629 +9787505126350 +9787505127593 +9787505127814 +9787505128132 +9787505128477 +9787505128484 +9787505128842 +9787505128866 +9787505129047 +9787505129498 +9787505129726 +9787505129825 +9787505130135 +9787505130180 +9787505130418 +9787505130630 +9787505130647 +9787505131491 +9787505131507 +9787505132696 +9787505132719 +9787505132894 +9787505133020 +9787505133341 +9787505133815 +9787505133839 +9787505133877 +9787505134089 +9787505134683 +9787505134836 +9787505135017 +9787505135239 +9787505135499 +9787505135703 +9787505136045 +9787505136113 +9787505136212 +9787505136991 +9787505138025 +9787505138131 +9787505138391 +9787505138421 +9787505138636 +9787505139053 +9787505139152 +9787505139176 +9787505139282 +9787505139343 +9787505139633 +9787505139725 +9787505140134 +9787505140172 +9787505140790 +9787505140806 +9787505140813 +9787505141537 +9787505142329 +9787505142428 +9787505142565 +9787505142626 +9787505143104 +9787505143166 +9787505143388 +9787505143418 +9787505143449 +9787505143890 +9787505144217 +9787505144347 +9787505145436 +9787505145672 +9787505145917 +9787505146426 +9787505146549 +9787505146570 +9787505146600 +9787505146648 +9787505146761 +9787505146884 +9787505147300 +9787505147560 +9787505147621 +9787505147874 +9787505147904 +9787505147959 +9787505148086 +9787505148093 +9787505148130 +9787505148185 +9787505148284 +9787505148376 +9787505148420 +9787505148475 +9787505148741 +9787505148819 +9787505148895 +9787505149007 +9787505149038 +9787505149106 +9787505149182 +9787505149199 +9787505149205 +9787505149359 +9787505149595 +9787505149632 +9787505149687 +9787505149991 +9787505150263 +9787505150355 +9787505150386 +9787505150478 +9787505150812 +9787505150980 +9787505151031 +9787505151475 +9787505151741 +9787505151789 +9787505151796 +9787505151963 +9787505152076 +9787505152335 +9787505152366 +9787505152571 +9787505152595 +9787505153110 +9787505153219 +9787505153301 +9787505153417 +9787505153455 +9787505153493 +9787505153509 +9787505153561 +9787505153721 +9787505153769 +9787505153776 +9787505153851 +9787505153974 +9787505153998 +9787505154032 +9787505154056 +9787505154063 +9787505154087 +9787505154162 +9787505154254 +9787505154278 +9787505154292 +9787505154339 +9787505200500 +9787505200609 +9787505200722 +9787505201712 +9787505201811 +9787505201859 +9787505202023 +9787505202030 +9787505202047 +9787505202054 +9787505202078 +9787505202115 +9787505202245 +9787505202290 +9787505202306 +9787505202337 +9787505202375 +9787505202382 +9787505202412 +9787505202481 +9787505202597 +9787505202627 +9787505202672 +9787505203013 +9787505203020 +9787505203235 +9787505203389 +9787505203532 +9787505203556 +9787505203655 +9787505203877 +9787505203914 +9787505203921 +9787505203938 +9787505203945 +9787505204096 +9787505204157 +9787505204164 +9787505204201 +9787505204232 +9787505204256 +9787505204263 +9787505204270 +9787505204379 +9787505204485 +9787505300132 +9787505300460 +9787505301474 +9787505302419 +9787505303065 +9787505303072 +9787505303188 +9787505303591 +9787505304475 +9787505305656 +9787505306875 +9787505307032 +9787505309494 +9787505312197 +9787505312203 +9787505315853 +9787505315914 +9787505316621 +9787505316836 +9787505318557 +9787505319233 +9787505319516 +9787505320291 +9787505320994 +9787505323322 +9787505324497 +9787505324817 +9787505329263 +9787505329362 +9787505329782 +9787505329881 +9787505329966 +9787505330184 +9787505330276 +9787505331105 +9787505331860 +9787505332874 +9787505333031 +9787505333253 +9787505333895 +9787505333949 +9787505334335 +9787505339569 +9787505339712 +9787505340589 +9787505341050 +9787505343351 +9787505344365 +9787505344778 +9787505345225 +9787505345560 +9787505345966 +9787505345980 +9787505346031 +9787505346864 +9787505348851 +9787505349728 +9787505349735 +9787505350083 +9787505350335 +9787505350601 +9787505350984 +9787505351004 +9787505351219 +9787505352322 +9787505353756 +9787505353916 +9787505354036 +9787505354814 +9787505354876 +9787505355255 +9787505355422 +9787505355750 +9787505356863 +9787505357259 +9787505357624 +9787505357815 +9787505358119 +9787505358553 +9787505358829 +9787505359154 +9787505359536 +9787505361010 +9787505362147 +9787505362185 +9787505363076 +9787505363434 +9787505363649 +9787505363670 +9787505364813 +9787505365278 +9787505365346 +9787505365865 +9787505367258 +9787505367920 +9787505369238 +9787505369733 +9787505370135 +9787505370456 +9787505370616 +9787505371125 +9787505371422 +9787505372856 +9787505373464 +9787505373624 +9787505373822 +9787505375147 +9787505375307 +9787505375383 +9787505375987 +9787505376403 +9787505378667 +9787505379312 +9787505380431 +9787505380578 +9787505381452 +9787505381698 +9787505382473 +9787505382626 +9787505382930 +9787505383012 +9787505383111 +9787505383425 +9787505383432 +9787505383456 +9787505383784 +9787505383845 +9787505383852 +9787505383975 +9787505384033 +9787505384644 +9787505385443 +9787505385740 +9787505385894 +9787505386396 +9787505386488 +9787505386587 +9787505386600 +9787505386686 +9787505387126 +9787505387744 +9787505388390 +9787505388475 +9787505389052 +9787505389205 +9787505389359 +9787505389786 +9787505390256 +9787505391062 +9787505391093 +9787505391154 +9787505391185 +9787505391758 +9787505391871 +9787505392045 +9787505392335 +9787505392434 +9787505392878 +9787505392892 +9787505393011 +9787505393127 +9787505393141 +9787505393639 +9787505393868 +9787505394117 +9787505394223 +9787505394391 +9787505394575 +9787505394872 +9787505395367 +9787505395428 +9787505395923 +9787505395954 +9787505396562 +9787505397347 +9787505397750 +9787505397958 +9787505397989 +9787505398382 +9787505398412 +9787505399587 +9787505399617 +9787505400801 +9787505401068 +9787505401198 +9787505401365 +9787505401853 +9787505401914 +9787505402331 +9787505402447 +9787505402805 +9787505403055 +9787505403277 +9787505403338 +9787505403536 +9787505403666 +9787505403789 +9787505403796 +9787505403895 +9787505404113 +9787505404311 +9787505405226 +9787505405387 +9787505405509 +9787505405585 +9787505405608 +9787505405820 +9787505405851 +9787505406001 +9787505406056 +9787505406087 +9787505406179 +9787505406483 +9787505406742 +9787505406766 +9787505406810 +9787505406872 +9787505406896 +9787505406926 +9787505406933 +9787505407008 +9787505407039 +9787505407077 +9787505407121 +9787505407145 +9787505407176 +9787505407206 +9787505407350 +9787505407381 +9787505407398 +9787505407473 +9787505407749 +9787505407787 +9787505407800 +9787505407879 +9787505407909 +9787505408029 +9787505408036 +9787505408111 +9787505408142 +9787505408562 +9787505408869 +9787505409804 +9787505409910 +9787505410244 +9787505410855 +9787505410916 +9787505411043 +9787505411463 +9787505411722 +9787505411739 +9787505411760 +9787505412125 +9787505412163 +9787505412323 +9787505412408 +9787505412415 +9787505412866 +9787505413146 +9787505413184 +9787505413191 +9787505413399 +9787505413443 +9787505413528 +9787505413542 +9787505413566 +9787505413580 +9787505413610 +9787505413665 +9787505413757 +9787505413801 +9787505413818 +9787505413832 +9787505413900 +9787505413955 +9787505414037 +9787505414129 +9787505414228 +9787505414235 +9787505414525 +9787505414532 +9787505414556 +9787505414563 +9787505414587 +9787505414600 +9787505414617 +9787505414754 +9787505414907 +9787505414952 +9787505414969 +9787505415003 +9787505415089 +9787505415188 +9787505415195 +9787505415447 +9787505415515 +9787505415522 +9787505415607 +9787505415621 +9787505415638 +9787505415683 +9787505415775 +9787505415805 +9787505415829 +9787505415881 +9787505416000 +9787505416109 +9787505416116 +9787505416178 +9787505416383 +9787505416390 +9787505416505 +9787505416543 +9787505416642 +9787505416666 +9787505416802 +9787505416857 +9787505416901 +9787505417229 +9787505417274 +9787505417397 +9787505417519 +9787505417618 +9787505417649 +9787505417656 +9787505417694 +9787505417717 +9787505417779 +9787505417786 +9787505417823 +9787505417885 +9787505418011 +9787505418141 +9787505418158 +9787505418202 +9787505418479 +9787505418578 +9787505418639 +9787505418691 +9787505418745 +9787505418752 +9787505418929 +9787505419032 +9787505419100 +9787505419193 +9787505419223 +9787505419308 +9787505419544 +9787505419728 +9787505419803 +9787505420038 +9787505420076 +9787505420083 +9787505420168 +9787505420182 +9787505420366 +9787505420618 +9787505420687 +9787505420755 +9787505420779 +9787505420991 +9787505421103 +9787505421219 +9787505421592 +9787505421844 +9787505422193 +9787505422278 +9787505422308 +9787505422506 +9787505422537 +9787505422629 +9787505422674 +9787505422858 +9787505422988 +9787505423145 +9787505423169 +9787505423176 +9787505423459 +9787505423619 +9787505423633 +9787505423831 +9787505423954 +9787505424166 +9787505424210 +9787505424227 +9787505424241 +9787505424531 +9787505424807 +9787505424838 +9787505425101 +9787505425385 +9787505425408 +9787505425842 +9787505426474 +9787505426504 +9787505426610 +9787505426634 +9787505426733 +9787505427112 +9787505427129 +9787505427501 +9787505427549 +9787505427839 +9787505427846 +9787505427914 +9787505427921 +9787505427938 +9787505427945 +9787505428003 +9787505428058 +9787505428065 +9787505428126 +9787505428171 +9787505428188 +9787505428201 +9787505428591 +9787505428614 +9787505428621 +9787505428638 +9787505428836 +9787505428881 +9787505428997 +9787505429451 +9787505429468 +9787505429475 +9787505429710 +9787505429772 +9787505429871 +9787505430372 +9787505430723 +9787505430778 +9787505430860 +9787505430877 +9787505430884 +9787505430907 +9787505430938 +9787505431133 +9787505431232 +9787505431515 +9787505432123 +9787505432291 +9787505432307 +9787505432314 +9787505432321 +9787505432338 +9787505432345 +9787505432352 +9787505432499 +9787505432512 +9787505432529 +9787505432550 +9787505432567 +9787505432574 +9787505432970 +9787505433359 +9787505433434 +9787505433441 +9787505433540 +9787505433557 +9787505433588 +9787505433656 +9787505433687 +9787505433694 +9787505434011 +9787505434363 +9787505434530 +9787505435377 +9787505435414 +9787505436251 +9787505436664 +9787505436671 +9787505436695 +9787505436916 +9787505437388 +9787505437531 +9787505437623 +9787505437630 +9787505437807 +9787505437876 +9787505437944 +9787505437982 +9787505438088 +9787505438248 +9787505438781 +9787505438910 +9787505438965 +9787505439009 +9787505439030 +9787505439412 +9787505439511 +9787505439764 +9787505439931 +9787505440128 +9787505440135 +9787505440159 +9787505440173 +9787505440272 +9787505440296 +9787505440302 +9787505440357 +9787505440388 +9787505440418 +9787505440456 +9787505440463 +9787505440470 +9787505440951 +9787505440975 +9787505440982 +9787505441088 +9787505441231 +9787505441361 +9787505441378 +9787505441590 +9787505441613 +9787505441736 +9787505441934 +9787505442085 +9787505442245 +9787505442344 +9787505442467 +9787505442849 +9787505443389 +9787505443433 +9787505443556 +9787505443563 +9787505444089 +9787505444133 +9787505444171 +9787505444287 +9787505444522 +9787505444621 +9787505444638 +9787505444911 +9787505445116 +9787505445222 +9787505445574 +9787505445598 +9787505446144 +9787505446205 +9787505446663 +9787505446908 +9787505446915 +9787505447110 +9787505447790 +9787505447875 +9787505447943 +9787505447998 +9787505448827 +9787505448865 +9787505448889 +9787505449060 +9787505449121 +9787505450271 +9787505450325 +9787505450387 +9787505450721 +9787505451247 +9787505451490 +9787505451520 +9787505451599 +9787505452091 +9787505452237 +9787505452299 +9787505452336 +9787505452374 +9787505452763 +9787505452817 +9787505452916 +9787505452923 +9787505453357 +9787505453395 +9787505454460 +9787505454781 +9787505454804 +9787505454828 +9787505454859 +9787505454989 +9787505455344 +9787505455443 +9787505455498 +9787505455566 +9787505455573 +9787505455627 +9787505455818 +9787505455825 +9787505500013 +9787505600003 +9787505600102 +9787505600225 +9787505600263 +9787505600287 +9787505600706 +9787505601451 +9787505601802 +9787505601819 +9787505602595 +9787505602854 +9787505603233 +9787505603295 +9787505603424 +9787505603462 +9787505603547 +9787505603615 +9787505603660 +9787505603769 +9787505603790 +9787505604049 +9787505604087 +9787505604193 +9787505604230 +9787505604315 +9787505604414 +9787505604438 +9787505605169 +9787505605183 +9787505605244 +9787505605305 +9787505605725 +9787505605855 +9787505606203 +9787505606319 +9787505606326 +9787505607071 +9787505607118 +9787505607170 +9787505607507 +9787505607590 +9787505607774 +9787505607828 +9787505607927 +9787505607934 +9787505607958 +9787505608030 +9787505608535 +9787505608580 +9787505608627 +9787505608832 +9787505608894 +9787505609167 +9787505609334 +9787505609358 +9787505609365 +9787505609389 +9787505609433 +9787505609471 +9787505609495 +9787505609518 +9787505609525 +9787505609549 +9787505609556 +9787505609570 +9787505609587 +9787505609600 +9787505609631 +9787505609648 +9787505609655 +9787505609693 +9787505609778 +9787505609785 +9787505609792 +9787505609884 +9787505609891 +9787505609907 +9787505609914 +9787505610026 +9787505610507 +9787505610552 +9787505610996 +9787505611023 +9787505611047 +9787505611078 +9787505611085 +9787505611115 +9787505611139 +9787505611177 +9787505611184 +9787505611245 +9787505611290 +9787505611443 +9787505611481 +9787505611498 +9787505611528 +9787505611542 +9787505611559 +9787505611726 +9787505611788 +9787505611887 +9787505612129 +9787505612136 +9787505612228 +9787505612235 +9787505612273 +9787505612280 +9787505612310 +9787505612327 +9787505612433 +9787505612594 +9787505612617 +9787505612655 +9787505612945 +9787505613416 +9787505613775 +9787505613836 +9787505613898 +9787505614109 +9787505614185 +9787505614222 +9787505614253 +9787505614536 +9787505614581 +9787505614628 +9787505614642 +9787505614659 +9787505614666 +9787505614680 +9787505614697 +9787505614765 +9787505614925 +9787505615052 +9787505615236 +9787505615281 +9787505615687 +9787505615717 +9787505615724 +9787505615731 +9787505615748 +9787505615823 +9787505615847 +9787505615908 +9787505616196 +9787505616271 +9787505616639 +9787505616691 +9787505616714 +9787505616745 +9787505616769 +9787505616806 +9787505617056 +9787505617063 +9787505617070 +9787505617087 +9787505617599 +9787505617711 +9787505617889 +9787505617988 +9787505618022 +9787505618213 +9787505618244 +9787505618275 +9787505618602 +9787505618695 +9787505618701 +9787505618770 +9787505619036 +9787505619401 +9787505619463 +9787505619500 +9787505619517 +9787505619531 +9787505619661 +9787505619715 +9787505619760 +9787505619777 +9787505619784 +9787505619791 +9787505619807 +9787505619852 +9787505619869 +9787505619876 +9787505619975 +9787505620148 +9787505620155 +9787505620162 +9787505620179 +9787505620193 +9787505620216 +9787505620254 +9787505620278 +9787505620292 +9787505620308 +9787505620322 +9787505620469 +9787505620476 +9787505620490 +9787505620681 +9787505620759 +9787505620933 +9787505620957 +9787505620971 +9787505620995 +9787505621312 +9787505621701 +9787505621763 +9787505621794 +9787505621848 +9787505621909 +9787505622012 +9787505622104 +9787505622432 +9787505622449 +9787505622494 +9787505622517 +9787505622647 +9787505622654 +9787505622807 +9787505622814 +9787505622821 +9787505622913 +9787505623132 +9787505623446 +9787505623620 +9787505623637 +9787505623651 +9787505623668 +9787505623699 +9787505623798 +9787505624023 +9787505624191 +9787505624221 +9787505624375 +9787505624399 +9787505624474 +9787505624559 +9787505624979 +9787505625129 +9787505625143 +9787505625181 +9787505625495 +9787505625518 +9787505625945 +9787505626041 +9787505626102 +9787505626362 +9787505626607 +9787505626645 +9787505626676 +9787505626683 +9787505626751 +9787505626874 +9787505627505 +9787505627666 +9787505627765 +9787505627864 +9787505628205 +9787505628359 +9787505628373 +9787505628380 +9787505628403 +9787505628489 +9787505628519 +9787505628830 +9787505629172 +9787505629240 +9787505629677 +9787505630130 +9787505630161 +9787505630253 +9787505630260 +9787505630314 +9787505630857 +9787505631069 +9787505631106 +9787505631137 +9787505631182 +9787505631199 +9787505631250 +9787505631304 +9787505631496 +9787505631533 +9787505631618 +9787505631687 +9787505632226 +9787505632370 +9787505632417 +9787505632431 +9787505632653 +9787505632899 +9787505632912 +9787505633261 +9787505633285 +9787505633452 +9787505633537 +9787505633643 +9787505633674 +9787505633766 +9787505633827 +9787505633902 +9787505634046 +9787505634176 +9787505634411 +9787505634688 +9787505634947 +9787505635128 +9787505635135 +9787505635210 +9787505635340 +9787505635364 +9787505635395 +9787505635500 +9787505635586 +9787505635654 +9787505635722 +9787505635791 +9787505635869 +9787505635920 +9787505636057 +9787505636132 +9787505636156 +9787505636491 +9787505636545 +9787505636637 +9787505636712 +9787505636941 +9787505636958 +9787505636972 +9787505637009 +9787505637023 +9787505637108 +9787505637139 +9787505637177 +9787505637191 +9787505637207 +9787505637214 +9787505637221 +9787505637252 +9787505637269 +9787505637283 +9787505637320 +9787505637337 +9787505637344 +9787505637351 +9787505637399 +9787505637405 +9787505637498 +9787505637511 +9787505637542 +9787505637603 +9787505637634 +9787505637979 +9787505638020 +9787505638037 +9787505638044 +9787505638051 +9787505638068 +9787505638082 +9787505638303 +9787505638358 +9787505638372 +9787505638419 +9787505638624 +9787505638761 +9787505638969 +9787505638983 +9787505639010 +9787505639294 +9787505639379 +9787505639515 +9787505639539 +9787505639584 +9787505639591 +9787505639607 +9787505639997 +9787505640009 +9787505640023 +9787505640030 +9787505640061 +9787505640078 +9787505640122 +9787505640184 +9787505640191 +9787505640214 +9787505640337 +9787505640368 +9787505640634 +9787505640801 +9787505640863 +9787505640887 +9787505640993 +9787505641136 +9787505641884 +9787505641891 +9787505641969 +9787505642157 +9787505642409 +9787505642447 +9787505642461 +9787505642485 +9787505700024 +9787505700109 +9787505700130 +9787505700246 +9787505700260 +9787505700291 +9787505700321 +9787505700413 +9787505700468 +9787505700529 +9787505700567 +9787505700727 +9787505700734 +9787505700796 +9787505700819 +9787505700833 +9787505700871 +9787505700901 +9787505700918 +9787505700932 +9787505700949 +9787505700987 +9787505701021 +9787505701045 +9787505701137 +9787505701205 +9787505701236 +9787505701274 +9787505701304 +9787505701359 +9787505701373 +9787505701380 +9787505701427 +9787505701434 +9787505701441 +9787505701489 +9787505701533 +9787505701755 +9787505701809 +9787505701816 +9787505701885 +9787505702011 +9787505702042 +9787505702073 +9787505702080 +9787505702134 +9787505702165 +9787505702226 +9787505702233 +9787505702356 +9787505702424 +9787505702448 +9787505702455 +9787505702561 +9787505702677 +9787505702790 +9787505702837 +9787505702868 +9787505702875 +9787505702882 +9787505702912 +9787505702943 +9787505702967 +9787505703025 +9787505703032 +9787505703049 +9787505703056 +9787505703063 +9787505703117 +9787505703155 +9787505703193 +9787505703209 +9787505703278 +9787505703292 +9787505703384 +9787505703414 +9787505703445 +9787505703476 +9787505703537 +9787505703766 +9787505703803 +9787505704022 +9787505704039 +9787505704053 +9787505704060 +9787505704077 +9787505704114 +9787505704190 +9787505704305 +9787505704497 +9787505704565 +9787505705203 +9787505705210 +9787505705227 +9787505705487 +9787505705500 +9787505705524 +9787505705623 +9787505705715 +9787505705722 +9787505705739 +9787505705746 +9787505705753 +9787505706071 +9787505706095 +9787505706101 +9787505706118 +9787505706125 +9787505706354 +9787505706361 +9787505706507 +9787505706514 +9787505706705 +9787505706842 +9787505706859 +9787505706996 +9787505707023 +9787505707184 +9787505707191 +9787505707207 +9787505707245 +9787505707290 +9787505707405 +9787505707412 +9787505707504 +9787505707634 +9787505707672 +9787505707689 +9787505707719 +9787505707740 +9787505707757 +9787505707764 +9787505707771 +9787505707849 +9787505707887 +9787505708020 +9787505708037 +9787505708167 +9787505708273 +9787505708297 +9787505708358 +9787505708372 +9787505708501 +9787505712607 +9787505712683 +9787505712690 +9787505712706 +9787505712713 +9787505712737 +9787505712744 +9787505712751 +9787505712782 +9787505712799 +9787505712805 +9787505712812 +9787505712829 +9787505712904 +9787505712911 +9787505712928 +9787505712935 +9787505712942 +9787505712959 +9787505712966 +9787505712980 +9787505712997 +9787505713000 +9787505713017 +9787505713024 +9787505713031 +9787505713048 +9787505713079 +9787505713093 +9787505713116 +9787505713161 +9787505713260 +9787505713352 +9787505713390 +9787505713413 +9787505713444 +9787505713482 +9787505713505 +9787505713512 +9787505713529 +9787505713611 +9787505713635 +9787505713659 +9787505713666 +9787505713697 +9787505713710 +9787505713727 +9787505713772 +9787505713796 +9787505713819 +9787505713888 +9787505713895 +9787505713987 +9787505714021 +9787505714083 +9787505714090 +9787505714113 +9787505714182 +9787505714199 +9787505714205 +9787505714281 +9787505714298 +9787505714328 +9787505714366 +9787505714458 +9787505714472 +9787505714519 +9787505714557 +9787505714632 +9787505714731 +9787505714748 +9787505714816 +9787505714847 +9787505714861 +9787505714878 +9787505714922 +9787505714953 +9787505714984 +9787505715035 +9787505715073 +9787505715080 +9787505715103 +9787505715127 +9787505715134 +9787505715141 +9787505715172 +9787505715219 +9787505715233 +9787505715264 +9787505715318 +9787505715349 +9787505715356 +9787505715387 +9787505715455 +9787505715486 +9787505715585 +9787505715592 +9787505715615 +9787505715622 +9787505715646 +9787505715820 +9787505715882 +9787505715899 +9787505715943 +9787505716032 +9787505716063 +9787505716131 +9787505716193 +9787505716209 +9787505716339 +9787505716476 +9787505716483 +9787505716490 +9787505716506 +9787505716599 +9787505716698 +9787505716742 +9787505716773 +9787505716810 +9787505716827 +9787505716872 +9787505716896 +9787505716926 +9787505716933 +9787505716957 +9787505716964 +9787505717008 +9787505717121 +9787505717190 +9787505717206 +9787505717213 +9787505717251 +9787505717299 +9787505717411 +9787505717442 +9787505717466 +9787505717473 +9787505717480 +9787505717497 +9787505717503 +9787505717510 +9787505717527 +9787505717534 +9787505717541 +9787505717770 +9787505717787 +9787505717794 +9787505717831 +9787505717862 +9787505717879 +9787505717954 +9787505718067 +9787505718111 +9787505718128 +9787505718319 +9787505718340 +9787505718388 +9787505718555 +9787505718654 +9787505718722 +9787505718807 +9787505719002 +9787505719064 +9787505719088 +9787505719101 +9787505719156 +9787505719279 +9787505719323 +9787505719545 +9787505719767 +9787505719774 +9787505719828 +9787505719910 +9787505719934 +9787505719941 +9787505720312 +9787505720329 +9787505720442 +9787505720602 +9787505720626 +9787505720671 +9787505720732 +9787505720749 +9787505720787 +9787505720909 +9787505721081 +9787505721265 +9787505721272 +9787505721357 +9787505721487 +9787505721586 +9787505721609 +9787505721630 +9787505721678 +9787505721692 +9787505721760 +9787505721784 +9787505721807 +9787505721821 +9787505721869 +9787505721937 +9787505721944 +9787505722095 +9787505722187 +9787505722194 +9787505722309 +9787505722392 +9787505722408 +9787505722538 +9787505722545 +9787505722552 +9787505722620 +9787505722804 +9787505722989 +9787505723078 +9787505723115 +9787505723207 +9787505723214 +9787505723320 +9787505723344 +9787505723382 +9787505723467 +9787505723474 +9787505723559 +9787505723641 +9787505723733 +9787505723771 +9787505723788 +9787505723863 +9787505723979 +9787505724129 +9787505724167 +9787505724303 +9787505724372 +9787505724532 +9787505724556 +9787505724624 +9787505724839 +9787505725041 +9787505725065 +9787505725072 +9787505725133 +9787505725188 +9787505725256 +9787505725317 +9787505725324 +9787505725355 +9787505725386 +9787505725447 +9787505725553 +9787505725577 +9787505725744 +9787505725768 +9787505725782 +9787505725843 +9787505725850 +9787505725874 +9787505725881 +9787505725904 +9787505725966 +9787505726017 +9787505726062 +9787505726130 +9787505726147 +9787505726215 +9787505726307 +9787505726529 +9787505726673 +9787505726796 +9787505726802 +9787505726932 +9787505726956 +9787505727021 +9787505727069 +9787505727113 +9787505727229 +9787505727298 +9787505727397 +9787505727502 +9787505728455 +9787505728851 +9787505729407 +9787505729452 +9787505729834 +9787505730090 +9787505730250 +9787505730335 +9787505730465 +9787505730663 +9787505730717 +9787505730731 +9787505730748 +9787505730939 +9787505731172 +9787505731240 +9787505731288 +9787505731301 +9787505731400 +9787505731431 +9787505731622 +9787505731714 +9787505731929 +9787505732841 +9787505733039 +9787505733367 +9787505733893 +9787505734357 +9787505735712 +9787505735880 +9787505735972 +9787505736191 +9787505736634 +9787505736764 +9787505736795 +9787505737488 +9787505737983 +9787505738706 +9787505740860 +9787505742123 +9787505743724 +9787505743885 +9787505745629 +9787505745803 +9787505746046 +9787505746534 +9787505746756 +9787505747456 +9787505747609 +9787505747616 +9787505747821 +9787505748064 +9787505748217 +9787505748248 +9787505748453 +9787505748491 +9787505748675 +9787505748835 +9787505748866 +9787505749191 +9787505749467 +9787505749603 +9787505749801 +9787505749849 +9787505750029 +9787505750647 +9787505750760 +9787505750838 +9787505751293 +9787505751378 +9787505751453 +9787505751521 +9787505751576 +9787505751729 +9787505751736 +9787505751781 +9787505751842 +9787505751880 +9787505751965 +9787505751972 +9787505752320 +9787505752382 +9787505752863 +9787505753808 +9787505753884 +9787505753938 +9787505754287 +9787505754447 +9787505754461 +9787505754676 +9787505754928 +9787505755840 +9787505755925 +9787505755970 +9787505756144 +9787505756212 +9787505756304 +9787505756328 +9787505756335 +9787505756380 +9787505756397 +9787505756410 +9787505756465 +9787505756472 +9787505756601 +9787505756816 +9787505756946 +9787505756991 +9787505757127 +9787505757141 +9787505757158 +9787505757189 +9787505757271 +9787505757295 +9787505757325 +9787505757363 +9787505757387 +9787505757462 +9787505757486 +9787505757493 +9787505757509 +9787505757530 +9787505757561 +9787505757592 +9787505757615 +9787505757691 +9787505757721 +9787505757745 +9787505757752 +9787505757837 +9787505757844 +9787505757912 +9787505757936 +9787505757981 +9787505758025 +9787505758032 +9787505758070 +9787505758100 +9787505758162 +9787505758285 +9787505758292 +9787505758315 +9787505758346 +9787505758384 +9787505758391 +9787505758445 +9787505758513 +9787505758544 +9787505758650 +9787505758698 +9787505758766 +9787505758803 +9787505758827 +9787505758926 +9787505758971 +9787505758988 +9787505759015 +9787505759022 +9787505759046 +9787505759138 +9787505759145 +9787505759220 +9787505759251 +9787505759374 +9787505759442 +9787505759459 +9787505759473 +9787505759503 +9787505759534 +9787505759541 +9787505759763 +9787505759770 +9787505759800 +9787505759817 +9787505759862 +9787505759886 +9787505759923 +9787505759947 +9787505759978 +9787505759992 +9787505760042 +9787505760141 +9787505760158 +9787505760165 +9787505760219 +9787505760257 +9787505760288 +9787505760295 +9787505760318 +9787505760332 +9787505760370 +9787505760400 +9787505760530 +9787505760547 +9787505760561 +9787505760608 +9787505760639 +9787505760660 +9787505760714 +9787505760721 +9787505760752 +9787505760813 +9787505760899 +9787505760912 +9787505760936 +9787505760943 +9787505760998 +9787505761025 +9787505761049 +9787505761087 +9787505761148 +9787505761155 +9787505800014 +9787505802858 +9787505803626 +9787505804036 +9787505804586 +9787505806603 +9787505806634 +9787505807440 +9787505807655 +9787505808133 +9787505808393 +9787505808775 +9787505808898 +9787505809727 +9787505809819 +9787505809994 +9787505810051 +9787505810341 +9787505810990 +9787505811829 +9787505811874 +9787505811935 +9787505812109 +9787505812451 +9787505812727 +9787505813182 +9787505813465 +9787505813557 +9787505814028 +9787505814479 +9787505814653 +9787505815360 +9787505815513 +9787505815629 +9787505815988 +9787505816138 +9787505816756 +9787505817081 +9787505817128 +9787505817227 +9787505817388 +9787505817494 +9787505817708 +9787505817746 +9787505818286 +9787505818309 +9787505818866 +9787505819177 +9787505819207 +9787505819405 +9787505819528 +9787505819559 +9787505819979 +9787505820296 +9787505820463 +9787505820920 +9787505821002 +9787505821026 +9787505821033 +9787505821040 +9787505821590 +9787505821613 +9787505821736 +9787505821958 +9787505822214 +9787505823099 +9787505823273 +9787505823365 +9787505823471 +9787505824232 +9787505824287 +9787505824553 +9787505824621 +9787505824669 +9787505825000 +9787505826281 +9787505826625 +9787505827516 +9787505827639 +9787505827868 +9787505828711 +9787505828742 +9787505828964 +9787505829633 +9787505829916 +9787505829992 +9787505830080 +9787505830370 +9787505831650 +9787505831704 +9787505833111 +9787505834125 +9787505834286 +9787505834958 +9787505834965 +9787505835849 +9787505835887 +9787505836426 +9787505836600 +9787505837829 +9787505837911 +9787505838017 +9787505838185 +9787505838260 +9787505838468 +9787505838598 +9787505839335 +9787505839380 +9787505839557 +9787505839649 +9787505839694 +9787505839915 +9787505840638 +9787505841413 +9787505841857 +9787505842915 +9787505842953 +9787505843714 +9787505843721 +9787505844025 +9787505844278 +9787505844315 +9787505845107 +9787505846524 +9787505846562 +9787505846906 +9787505848535 +9787505848580 +9787505848634 +9787505849389 +9787505849938 +9787505851238 +9787505851917 +9787505852136 +9787505852730 +9787505853119 +9787505853188 +9787505854062 +9787505854376 +9787505854604 +9787505854956 +9787505855014 +9787505855922 +9787505855991 +9787505856110 +9787505856318 +9787505856325 +9787505856806 +9787505857056 +9787505857155 +9787505858466 +9787505859258 +9787505859395 +9787505859722 +9787505861121 +9787505861541 +9787505861749 +9787505862197 +9787505862630 +9787505863132 +9787505863330 +9787505864610 +9787505866140 +9787505868212 +9787505868588 +9787505869387 +9787505869820 +9787505870277 +9787505871663 +9787505871793 +9787505871915 +9787505872011 +9787505873124 +9787505874244 +9787505877320 +9787505878563 +9787505880559 +9787505880801 +9787505881303 +9787505882232 +9787505883567 +9787505884168 +9787505884557 +9787505884823 +9787505885226 +9787505886667 +9787505888869 +9787505888883 +9787505889644 +9787505890961 +9787505891555 +9787505892521 +9787505892620 +9787505893429 +9787505893610 +9787505894211 +9787505896505 +9787505896628 +9787505897335 +9787505898400 +9787505900110 +9787505900127 +9787505900158 +9787505900196 +9787505900240 +9787505900257 +9787505900288 +9787505900448 +9787505900622 +9787505900752 +9787505900806 +9787505900868 +9787505900905 +9787505901018 +9787505901032 +9787505901070 +9787505901186 +9787505901223 +9787505901407 +9787505901452 +9787505901469 +9787505901537 +9787505901872 +9787505902039 +9787505902053 +9787505902138 +9787505902183 +9787505902213 +9787505902251 +9787505902275 +9787505902282 +9787505902299 +9787505902305 +9787505902312 +9787505902510 +9787505902640 +9787505903319 +9787505903340 +9787505903630 +9787505903814 +9787505903845 +9787505903920 +9787505903944 +9787505904002 +9787505904071 +9787505904088 +9787505904101 +9787505904378 +9787505904620 +9787505904668 +9787505904699 +9787505904712 +9787505904903 +9787505905108 +9787505905252 +9787505905399 +9787505905665 +9787505905726 +9787505906020 +9787505906310 +9787505906334 +9787505906778 +9787505906860 +9787505906877 +9787505907263 +9787505907294 +9787505907331 +9787505907355 +9787505907362 +9787505907744 +9787505907775 +9787505907829 +9787505907911 +9787505907997 +9787505908062 +9787505908208 +9787505908444 +9787505908635 +9787505908659 +9787505908826 +9787505909144 +9787505909175 +9787505909274 +9787505909328 +9787505909601 +9787505909861 +9787505910294 +9787505910584 +9787505910706 +9787505910744 +9787505910843 +9787505910911 +9787505911024 +9787505911420 +9787505911543 +9787505911550 +9787505911703 +9787505911796 +9787505911826 +9787505912267 +9787505912342 +9787505912595 +9787505912656 +9787505912663 +9787505912724 +9787505912762 +9787505913332 +9787505913547 +9787505913776 +9787505913806 +9787505913851 +9787505913950 +9787505913967 +9787505914179 +9787505914377 +9787505914810 +9787505914858 +9787505914926 +9787505914940 +9787505914988 +9787505915077 +9787505915251 +9787505915305 +9787505915336 +9787505915350 +9787505915374 +9787505915459 +9787505915640 +9787505916036 +9787505916104 +9787505916128 +9787505916258 +9787505916425 +9787505916760 +9787505916920 +9787505916944 +9787505917132 +9787505917170 +9787505917286 +9787505917606 +9787505917668 +9787505917699 +9787505917781 +9787505917811 +9787505917835 +9787505917972 +9787505917996 +9787505918061 +9787505918078 +9787505918092 +9787505918108 +9787505918382 +9787505918672 +9787505918801 +9787505918979 +9787505919204 +9787505919396 +9787505919747 +9787505919792 +9787505919846 +9787505919891 +9787505919914 +9787505919990 +9787505920392 +9787505920408 +9787505920422 +9787505920439 +9787505920484 +9787505920514 +9787505920521 +9787505920545 +9787505920583 +9787505920590 +9787505920651 +9787505920750 +9787505920798 +9787505920828 +9787505920873 +9787505920941 +9787505920958 +9787505921009 +9787505921023 +9787505921030 +9787505921078 +9787505921115 +9787505921153 +9787505921238 +9787505921405 +9787505921535 +9787505921542 +9787505921559 +9787505921573 +9787505921658 +9787505921702 +9787505921771 +9787505921849 +9787505921931 +9787505921986 +9787505922006 +9787505922013 +9787505922068 +9787505922082 +9787505922099 +9787505922105 +9787505922136 +9787505922259 +9787505922266 +9787505922310 +9787505922334 +9787505922426 +9787505922464 +9787505922518 +9787505922556 +9787505922563 +9787505922631 +9787505922747 +9787505922815 +9787505922822 +9787505922853 +9787505922907 +9787505922945 +9787505923157 +9787505923171 +9787505923249 +9787505923256 +9787505923430 +9787505923454 +9787505923478 +9787505923522 +9787505923546 +9787505923713 +9787505923737 +9787505923768 +9787505923805 +9787505923812 +9787505923829 +9787505923843 +9787505923874 +9787505923904 +9787505923966 +9787505923973 +9787505923980 +9787505924116 +9787505924154 +9787505924291 +9787505924390 +9787505924611 +9787505924628 +9787505924635 +9787505924666 +9787505924758 +9787505924826 +9787505924871 +9787505924901 +9787505924956 +9787505924994 +9787505925083 +9787505925168 +9787505925182 +9787505925243 +9787505925281 +9787505925298 +9787505925410 +9787505925533 +9787505925618 +9787505925632 +9787505925670 +9787505925700 +9787505925779 +9787505925847 +9787505925878 +9787505925885 +9787505925892 +9787505925908 +9787505925915 +9787505925922 +9787505925953 +9787505926059 +9787505926066 +9787505926103 +9787505926233 +9787505926332 +9787505926363 +9787505926394 +9787505926400 +9787505926448 +9787505926462 +9787505926493 +9787505926653 +9787505926684 +9787505926714 +9787505926776 +9787505926783 +9787505926875 +9787505926950 +9787505926981 +9787505927094 +9787505927124 +9787505927148 +9787505927186 +9787505927193 +9787505927216 +9787505927278 +9787505927346 +9787505927414 +9787505927490 +9787505927520 +9787505927537 +9787505927612 +9787505927711 +9787505927728 +9787505927735 +9787505927858 +9787505927940 +9787505927971 +9787505928022 +9787505928039 +9787505928121 +9787505928169 +9787505928220 +9787505928251 +9787505928275 +9787505928329 +9787505928343 +9787505928374 +9787505928428 +9787505928442 +9787505928466 +9787505928589 +9787505928619 +9787505928626 +9787505928695 +9787505928756 +9787505928763 +9787505929005 +9787505929012 +9787505929166 +9787505929173 +9787505929197 +9787505929289 +9787505929333 +9787505929357 +9787505929364 +9787505929432 +9787505929449 +9787505929456 +9787505929470 +9787505929500 +9787505929524 +9787505929555 +9787505929708 +9787505929722 +9787505929821 +9787505929838 +9787505929920 +9787505929937 +9787505930001 +9787505930131 +9787505930148 +9787505930209 +9787505930353 +9787505930407 +9787505930452 +9787505930520 +9787505930643 +9787505930650 +9787505930698 +9787505930711 +9787505930759 +9787505930766 +9787505930841 +9787505930872 +9787505930919 +9787505930926 +9787505930933 +9787505931084 +9787505931145 +9787505931213 +9787505931220 +9787505931275 +9787505931282 +9787505931428 +9787505931473 +9787505931541 +9787505931671 +9787505931718 +9787505931855 +9787505932180 +9787505932234 +9787505932241 +9787505932258 +9787505932289 +9787505932388 +9787505932418 +9787505932456 +9787505932463 +9787505932517 +9787505932548 +9787505932555 +9787505932586 +9787505932654 +9787505932661 +9787505932678 +9787505932722 +9787505932739 +9787505932753 +9787505932807 +9787505932869 +9787505932883 +9787505932951 +9787505932975 +9787505932982 +9787505933040 +9787505933071 +9787505933088 +9787505933118 +9787505933224 +9787505933231 +9787505933316 +9787505933422 +9787505933484 +9787505933507 +9787505933538 +9787505933880 +9787505933934 +9787505933965 +9787505934146 +9787505934214 +9787505934337 +9787505934436 +9787505934504 +9787505934580 +9787505934634 +9787505934665 +9787505934818 +9787505934832 +9787505934931 +9787505934962 +9787505934986 +9787505935013 +9787505935082 +9787505935099 +9787505935174 +9787505935228 +9787505935273 +9787505935563 +9787505935709 +9787505935730 +9787505935761 +9787505935778 +9787505935822 +9787505935846 +9787505935877 +9787505935983 +9787505936010 +9787505936089 +9787505936386 +9787505936409 +9787505936416 +9787505936461 +9787505936492 +9787505936669 +9787505936683 +9787505936706 +9787505936805 +9787505936874 +9787505937000 +9787505937017 +9787505937154 +9787505937161 +9787505937178 +9787505937192 +9787505937208 +9787505937222 +9787505937239 +9787505937246 +9787505937307 +9787505937352 +9787505937413 +9787505937468 +9787505937499 +9787505937512 +9787505937536 +9787505937550 +9787505937567 +9787505937697 +9787505937758 +9787505937789 +9787505937802 +9787505937857 +9787505937864 +9787505937963 +9787505938038 +9787505938090 +9787505938519 +9787505938571 +9787505938892 +9787505939073 +9787505939097 +9787505939158 +9787505939233 +9787505939264 +9787505939271 +9787505939288 +9787505939387 +9787505939417 +9787505939516 +9787505939561 +9787505939592 +9787505939721 +9787505939820 +9787505939882 +9787505940048 +9787505940130 +9787505940314 +9787505940352 +9787505940406 +9787505940444 +9787505940697 +9787505940895 +9787505941021 +9787505941090 +9787505941120 +9787505941281 +9787505941410 +9787505941458 +9787505941533 +9787505941632 +9787505941755 +9787505941762 +9787505941809 +9787505941892 +9787505941977 +9787505941991 +9787505942035 +9787505942110 +9787505942233 +9787505942264 +9787505942271 +9787505942400 +9787505942523 +9787505942578 +9787505942714 +9787505942912 +9787505943032 +9787505943087 +9787505943124 +9787505943148 +9787505943278 +9787505943384 +9787505943407 +9787505943421 +9787505943490 +9787505943568 +9787505943605 +9787505943636 +9787505943650 +9787505943698 +9787505943858 +9787505943940 +9787505943971 +9787505944107 +9787505944114 +9787505944145 +9787505944220 +9787505944237 +9787505944329 +9787505944381 +9787505944466 +9787505944503 +9787505944558 +9787505944886 +9787505944909 +9787505945043 +9787505945418 +9787505945463 +9787505945470 +9787505945715 +9787505945876 +9787505946026 +9787505946163 +9787505946231 +9787505946392 +9787505946453 +9787505946613 +9787505946996 +9787505947092 +9787505947412 +9787505947719 +9787505947726 +9787505947825 +9787505948006 +9787505948037 +9787505948044 +9787505948082 +9787505948105 +9787505948112 +9787505948174 +9787505948310 +9787505948518 +9787505948525 +9787505948617 +9787505948648 +9787505948716 +9787505948723 +9787505948730 +9787505948945 +9787505948976 +9787505949072 +9787505949102 +9787505949164 +9787505949218 +9787505949300 +9787505949324 +9787505949348 +9787505949416 +9787505949546 +9787505949720 +9787505949751 +9787505949829 +9787505949874 +9787505949928 +9787505949966 +9787505949973 +9787505950085 +9787505950207 +9787505950221 +9787505950702 +9787505950955 +9787505951389 +9787505951402 +9787505951921 +9787505951938 +9787505951990 +9787505952317 +9787505952348 +9787505952393 +9787505952676 +9787505952744 +9787505952904 +9787505952959 +9787505952966 +9787505953048 +9787505953338 +9787505953352 +9787505953420 +9787505953574 +9787505953628 +9787505953642 +9787505954175 +9787505954328 +9787505954984 +9787505955080 +9787505955370 +9787505955530 +9787505955561 +9787505955578 +9787505955608 +9787505955684 +9787505955721 +9787505955813 +9787505955820 +9787505955882 +9787505955912 +9787505955950 +9787505955967 +9787505956001 +9787505956124 +9787505956438 +9787505956780 +9787505957169 +9787505957718 +9787505957725 +9787505957770 +9787505957817 +9787505957831 +9787505957855 +9787505957886 +9787505957893 +9787505958074 +9787505958098 +9787505958111 +9787505958135 +9787505958180 +9787505958241 +9787505958364 +9787505958609 +9787505958630 +9787505958654 +9787505958791 +9787505958913 +9787505959323 +9787505959552 +9787505959927 +9787505959958 +9787505960022 +9787505960183 +9787505960213 +9787505960312 +9787505960336 +9787505960466 +9787505960633 +9787505960657 +9787505960800 +9787505960893 +9787505960930 +9787505961173 +9787505961388 +9787505961555 +9787505961722 +9787505961777 +9787505961890 +9787505961920 +9787505961944 +9787505962378 +9787505962392 +9787505962606 +9787505962705 +9787505962996 +9787505963276 +9787505963283 +9787505963320 +9787505963900 +9787505963931 +9787505963986 +9787505964020 +9787505964082 +9787505964143 +9787505964471 +9787505964563 +9787505964600 +9787505964686 +9787505964969 +9787505965225 +9787505965331 +9787505965362 +9787505966291 +9787505966383 +9787505966451 +9787505966482 +9787505966499 +9787505966574 +9787505966710 +9787505966918 +9787505966925 +9787505966949 +9787505967168 +9787505967304 +9787505967311 +9787505967465 +9787505967519 +9787505967526 +9787505967922 +9787505967977 +9787505968219 +9787505968332 +9787505968684 +9787505968868 +9787505969261 +9787505969469 +9787505969629 +9787505970007 +9787505970052 +9787505970243 +9787505970601 +9787505970625 +9787505970939 +9787505971240 +9787505971370 +9787505971424 +9787505971462 +9787505971554 +9787505971707 +9787505971714 +9787505971769 +9787505971790 +9787505972216 +9787505972551 +9787505972742 +9787505972766 +9787505972780 +9787505973183 +9787505973251 +9787505974494 +9787505974562 +9787505974982 +9787505975033 +9787505975200 +9787505975279 +9787505975316 +9787505975354 +9787505975415 +9787505975477 +9787505975484 +9787505975750 +9787505976115 +9787505976351 +9787505976467 +9787505976665 +9787505976993 +9787505977167 +9787505977211 +9787505977266 +9787505977389 +9787505977709 +9787505977716 +9787505977761 +9787505977815 +9787505978294 +9787505978461 +9787505978829 +9787505978867 +9787505980563 +9787505980822 +9787505980945 +9787505980969 +9787505981256 +9787505981294 +9787505981508 +9787505981737 +9787505982321 +9787505982499 +9787505982581 +9787505982864 +9787505983120 +9787505983458 +9787505983557 +9787505983656 +9787505984011 +9787505985506 +9787505985605 +9787505986008 +9787505986114 +9787505986152 +9787505986534 +9787505986626 +9787505986633 +9787505986688 +9787505986695 +9787505986787 +9787505986954 +9787505987234 +9787505987401 +9787505987562 +9787505989511 +9787505990005 +9787505990050 +9787505990074 +9787505990524 +9787505990593 +9787505991224 +9787505991279 +9787505991347 +9787505991484 +9787505991583 +9787505992771 +9787505992818 +9787505993259 +9787505993525 +9787505993655 +9787505993747 +9787505993891 +9787505994355 +9787505995321 +9787505995697 +9787505995758 +9787505995949 +9787505996182 +9787505996472 +9787505996724 +9787505997721 +9787505998179 +9787505998506 +9787505998971 +9787505999862 +9787506000017 +9787506000079 +9787506000109 +9787506000246 +9787506000307 +9787506000352 +9787506000420 +9787506000468 +9787506000505 +9787506000512 +9787506000536 +9787506000543 +9787506000581 +9787506000604 +9787506000642 +9787506000703 +9787506000758 +9787506000901 +9787506001045 +9787506001205 +9787506001427 +9787506001823 +9787506001847 +9787506001908 +9787506001991 +9787506002011 +9787506002073 +9787506002103 +9787506002141 +9787506002189 +9787506002288 +9787506002295 +9787506002301 +9787506002325 +9787506002356 +9787506002387 +9787506002455 +9787506002479 +9787506002493 +9787506002516 +9787506002608 +9787506002721 +9787506002844 +9787506002899 +9787506003063 +9787506003087 +9787506003261 +9787506003391 +9787506003414 +9787506003452 +9787506003544 +9787506003612 +9787506003636 +9787506003650 +9787506003742 +9787506003988 +9787506004046 +9787506004107 +9787506004305 +9787506004862 +9787506004961 +9787506005111 +9787506005180 +9787506005258 +9787506005289 +9787506005333 +9787506005340 +9787506005388 +9787506005432 +9787506005579 +9787506005753 +9787506005852 +9787506005876 +9787506005982 +9787506005999 +9787506006026 +9787506006156 +9787506006194 +9787506006200 +9787506006217 +9787506006248 +9787506006309 +9787506006491 +9787506006507 +9787506006521 +9787506006545 +9787506006569 +9787506006620 +9787506006644 +9787506006705 +9787506006736 +9787506006798 +9787506006880 +9787506006989 +9787506006996 +9787506007009 +9787506007016 +9787506007061 +9787506007078 +9787506007092 +9787506007122 +9787506007146 +9787506007177 +9787506007184 +9787506007245 +9787506007269 +9787506007276 +9787506007283 +9787506007306 +9787506007313 +9787506007320 +9787506007337 +9787506007351 +9787506007375 +9787506007382 +9787506007498 +9787506007504 +9787506007511 +9787506007566 +9787506007573 +9787506007597 +9787506007634 +9787506007719 +9787506007849 +9787506007887 +9787506007955 +9787506008044 +9787506008082 +9787506008143 +9787506008150 +9787506008167 +9787506008181 +9787506008198 +9787506008228 +9787506008235 +9787506008266 +9787506008280 +9787506008310 +9787506008396 +9787506008402 +9787506008518 +9787506008617 +9787506008624 +9787506008662 +9787506008686 +9787506008761 +9787506008792 +9787506008808 +9787506008846 +9787506008884 +9787506008983 +9787506008990 +9787506009003 +9787506009010 +9787506009126 +9787506009225 +9787506009249 +9787506009331 +9787506009386 +9787506009409 +9787506009430 +9787506009454 +9787506009485 +9787506009539 +9787506009553 +9787506009560 +9787506009577 +9787506009584 +9787506009805 +9787506009829 +9787506009911 +9787506009935 +9787506009942 +9787506009997 +9787506010054 +9787506010108 +9787506010115 +9787506010122 +9787506010214 +9787506010245 +9787506010269 +9787506010306 +9787506010313 +9787506010320 +9787506010344 +9787506010412 +9787506010535 +9787506010580 +9787506010597 +9787506010726 +9787506010849 +9787506010917 +9787506010955 +9787506011037 +9787506011051 +9787506011082 +9787506011099 +9787506011105 +9787506011112 +9787506011136 +9787506011143 +9787506011181 +9787506011198 +9787506011235 +9787506011259 +9787506011266 +9787506011273 +9787506011280 +9787506011457 +9787506011471 +9787506011488 +9787506011525 +9787506011563 +9787506011600 +9787506011631 +9787506011679 +9787506011686 +9787506011709 +9787506011778 +9787506011792 +9787506011822 +9787506011839 +9787506011921 +9787506011938 +9787506012072 +9787506012089 +9787506012096 +9787506012102 +9787506012126 +9787506012140 +9787506012256 +9787506012270 +9787506012300 +9787506012423 +9787506012430 +9787506012447 +9787506012461 +9787506012539 +9787506012690 +9787506012706 +9787506012713 +9787506012744 +9787506012799 +9787506012997 +9787506013031 +9787506013086 +9787506013178 +9787506013192 +9787506013314 +9787506013468 +9787506013529 +9787506013536 +9787506013598 +9787506013826 +9787506014045 +9787506014090 +9787506014106 +9787506014182 +9787506014236 +9787506014243 +9787506014304 +9787506014311 +9787506014328 +9787506014342 +9787506014359 +9787506014441 +9787506014465 +9787506014540 +9787506014687 +9787506014700 +9787506014793 +9787506014809 +9787506014922 +9787506014953 +9787506015110 +9787506015202 +9787506015240 +9787506015295 +9787506015318 +9787506015325 +9787506015363 +9787506015370 +9787506015431 +9787506015448 +9787506015455 +9787506015462 +9787506015608 +9787506015691 +9787506015745 +9787506015776 +9787506015783 +9787506015790 +9787506015813 +9787506015820 +9787506015905 +9787506015912 +9787506015981 +9787506016056 +9787506016179 +9787506016308 +9787506016322 +9787506016438 +9787506016490 +9787506016551 +9787506016568 +9787506016612 +9787506016636 +9787506016650 +9787506016704 +9787506016995 +9787506017084 +9787506017244 +9787506017268 +9787506017275 +9787506017305 +9787506017329 +9787506017381 +9787506017534 +9787506017565 +9787506017572 +9787506017602 +9787506017688 +9787506017732 +9787506017756 +9787506017817 +9787506017909 +9787506017930 +9787506017954 +9787506017992 +9787506018050 +9787506018067 +9787506018074 +9787506018081 +9787506018159 +9787506018197 +9787506018258 +9787506018456 +9787506018517 +9787506018548 +9787506018555 +9787506018647 +9787506018692 +9787506018708 +9787506018746 +9787506018807 +9787506018845 +9787506018906 +9787506018920 +9787506018975 +9787506019002 +9787506019057 +9787506019071 +9787506019163 +9787506019170 +9787506019200 +9787506019361 +9787506019415 +9787506019439 +9787506019491 +9787506019637 +9787506019750 +9787506019910 +9787506020046 +9787506020060 +9787506020107 +9787506020190 +9787506020206 +9787506020350 +9787506020428 +9787506020534 +9787506020558 +9787506020565 +9787506020701 +9787506020756 +9787506020831 +9787506020855 +9787506021043 +9787506021135 +9787506021197 +9787506021319 +9787506021340 +9787506021425 +9787506021432 +9787506021487 +9787506021623 +9787506021746 +9787506021760 +9787506022033 +9787506022040 +9787506022101 +9787506022118 +9787506022125 +9787506022149 +9787506022156 +9787506022200 +9787506022217 +9787506022231 +9787506022248 +9787506022262 +9787506022361 +9787506022385 +9787506022453 +9787506022507 +9787506022620 +9787506022644 +9787506022712 +9787506022774 +9787506022941 +9787506023023 +9787506023153 +9787506023207 +9787506023269 +9787506023351 +9787506023665 +9787506023726 +9787506023962 +9787506023993 +9787506024037 +9787506024105 +9787506024334 +9787506024358 +9787506024747 +9787506024846 +9787506024853 +9787506024860 +9787506024976 +9787506025041 +9787506025058 +9787506025171 +9787506025218 +9787506025454 +9787506025461 +9787506025492 +9787506025836 +9787506026079 +9787506026246 +9787506026253 +9787506026321 +9787506026444 +9787506026468 +9787506026482 +9787506026680 +9787506026710 +9787506026789 +9787506026802 +9787506026819 +9787506026864 +9787506026901 +9787506027014 +9787506027052 +9787506027083 +9787506027106 +9787506027137 +9787506027175 +9787506027199 +9787506027243 +9787506027250 +9787506027502 +9787506027519 +9787506027557 +9787506027595 +9787506027670 +9787506028011 +9787506028172 +9787506028561 +9787506028646 +9787506028776 +9787506028783 +9787506028806 +9787506028875 +9787506029094 +9787506029278 +9787506029322 +9787506029636 +9787506029735 +9787506029759 +9787506029766 +9787506029834 +9787506029841 +9787506030052 +9787506030182 +9787506030397 +9787506030496 +9787506030526 +9787506030533 +9787506030564 +9787506030748 +9787506030755 +9787506030786 +9787506030830 +9787506030892 +9787506030939 +9787506030946 +9787506031011 +9787506031035 +9787506031172 +9787506031271 +9787506031493 +9787506031608 +9787506031660 +9787506031721 +9787506031776 +9787506032285 +9787506032353 +9787506032544 +9787506032575 +9787506032605 +9787506032896 +9787506032926 +9787506032964 +9787506032988 +9787506033084 +9787506033282 +9787506033398 +9787506033459 +9787506033671 +9787506033756 +9787506033848 +9787506033855 +9787506034128 +9787506034210 +9787506034265 +9787506034463 +9787506034487 +9787506034555 +9787506034579 +9787506034647 +9787506034739 +9787506034944 +9787506035071 +9787506035644 +9787506035682 +9787506035781 +9787506035811 +9787506036184 +9787506036238 +9787506036528 +9787506036658 +9787506036696 +9787506036771 +9787506036801 +9787506036818 +9787506036832 +9787506036887 +9787506037013 +9787506037273 +9787506037587 +9787506038188 +9787506038546 +9787506038874 +9787506038881 +9787506039123 +9787506039208 +9787506039253 +9787506039345 +9787506039642 +9787506039741 +9787506039857 +9787506039987 +9787506039994 +9787506040136 +9787506040174 +9787506040310 +9787506040426 +9787506040716 +9787506040792 +9787506040983 +9787506040990 +9787506041461 +9787506041478 +9787506041485 +9787506041508 +9787506041515 +9787506041713 +9787506042093 +9787506042291 +9787506042321 +9787506042581 +9787506042628 +9787506042659 +9787506042857 +9787506042956 +9787506042963 +9787506043342 +9787506043489 +9787506043540 +9787506043595 +9787506043748 +9787506044042 +9787506044110 +9787506044134 +9787506044141 +9787506044257 +9787506044561 +9787506044608 +9787506044615 +9787506045063 +9787506045162 +9787506045216 +9787506045254 +9787506045551 +9787506045568 +9787506045889 +9787506046350 +9787506046442 +9787506046527 +9787506046619 +9787506047562 +9787506048385 +9787506048446 +9787506048453 +9787506049108 +9787506050777 +9787506050951 +9787506051194 +9787506051231 +9787506051538 +9787506052870 +9787506052979 +9787506053464 +9787506053969 +9787506055178 +9787506055185 +9787506055444 +9787506057455 +9787506059534 +9787506059589 +9787506059626 +9787506059657 +9787506059985 +9787506060431 +9787506060493 +9787506061391 +9787506061537 +9787506062138 +9787506062145 +9787506062152 +9787506062176 +9787506062213 +9787506062244 +9787506062251 +9787506062282 +9787506062930 +9787506063005 +9787506063142 +9787506063234 +9787506064446 +9787506064453 +9787506064460 +9787506064927 +9787506064989 +9787506065054 +9787506065108 +9787506065115 +9787506065122 +9787506065139 +9787506065146 +9787506066563 +9787506067546 +9787506068260 +9787506069243 +9787506069250 +9787506069281 +9787506069465 +9787506069557 +9787506069731 +9787506069915 +9787506070232 +9787506070300 +9787506070317 +9787506070638 +9787506070669 +9787506070744 +9787506070836 +9787506070928 +9787506071345 +9787506071727 +9787506071932 +9787506071963 +9787506072083 +9787506072694 +9787506073516 +9787506073578 +9787506073691 +9787506073707 +9787506073714 +9787506073721 +9787506074957 +9787506076036 +9787506076333 +9787506076357 +9787506077569 +9787506077798 +9787506078009 +9787506078856 +9787506079006 +9787506079020 +9787506079297 +9787506080118 +9787506080200 +9787506080347 +9787506080491 +9787506080576 +9787506081863 +9787506082020 +9787506082037 +9787506082112 +9787506082129 +9787506082228 +9787506082365 +9787506082563 +9787506082945 +9787506083706 +9787506083980 +9787506084260 +9787506084673 +9787506084895 +9787506085007 +9787506085076 +9787506085120 +9787506085182 +9787506085687 +9787506085700 +9787506086103 +9787506086134 +9787506086356 +9787506086431 +9787506086547 +9787506086882 +9787506086899 +9787506086905 +9787506086912 +9787506086936 +9787506087308 +9787506088183 +9787506088466 +9787506088565 +9787506088985 +9787506089296 +9787506089708 +9787506089944 +9787506090186 +9787506090537 +9787506090728 +9787506090957 +9787506091619 +9787506091626 +9787506092630 +9787506092807 +9787506093170 +9787506093187 +9787506093767 +9787506093798 +9787506094733 +9787506095082 +9787506095174 +9787506095228 +9787506095297 +9787506095570 +9787506095587 +9787506095730 +9787506095808 +9787506096249 +9787506096720 +9787506097888 +9787506098458 +9787506098618 +9787506098939 +9787506099554 +9787506101677 +9787506101820 +9787506101837 +9787506101875 +9787506102520 +9787506102650 +9787506102704 +9787506102759 +9787506102773 +9787506103091 +9787506103152 +9787506104654 +9787506106054 +9787506106207 +9787506106252 +9787506106276 +9787506106405 +9787506106658 +9787506106702 +9787506106719 +9787506106757 +9787506106832 +9787506107273 +9787506107358 +9787506107396 +9787506107532 +9787506107662 +9787506107914 +9787506108010 +9787506109550 +9787506200035 +9787506200066 +9787506200486 +9787506202121 +9787506202145 +9787506202350 +9787506202749 +9787506202886 +9787506203234 +9787506203258 +9787506203357 +9787506203500 +9787506203524 +9787506203548 +9787506204408 +9787506205863 +9787506206501 +9787506206518 +9787506207935 +9787506208536 +9787506208642 +9787506209519 +9787506209786 +9787506210003 +9787506210027 +9787506210034 +9787506210058 +9787506210225 +9787506210706 +9787506211987 +9787506212489 +9787506214445 +9787506214636 +9787506215565 +9787506216951 +9787506216982 +9787506218122 +9787506218177 +9787506218382 +9787506218542 +9787506218894 +9787506218900 +9787506218917 +9787506218924 +9787506219716 +9787506220040 +9787506220057 +9787506220170 +9787506220286 +9787506220309 +9787506220354 +9787506220378 +9787506220453 +9787506220569 +9787506220705 +9787506220750 +9787506220781 +9787506220798 +9787506221030 +9787506221092 +9787506221146 +9787506221252 +9787506221269 +9787506221276 +9787506221290 +9787506221306 +9787506221313 +9787506221719 +9787506221849 +9787506222006 +9787506222082 +9787506222174 +9787506223232 +9787506223249 +9787506223843 +9787506224390 +9787506225441 +9787506226004 +9787506226080 +9787506226264 +9787506226271 +9787506226288 +9787506226585 +9787506226608 +9787506227506 +9787506227537 +9787506227704 +9787506227742 +9787506227872 +9787506228008 +9787506228084 +9787506228091 +9787506228107 +9787506228114 +9787506228282 +9787506228299 +9787506228305 +9787506228312 +9787506228374 +9787506228442 +9787506228589 +9787506228817 +9787506229067 +9787506229159 +9787506229340 +9787506229371 +9787506229388 +9787506229685 +9787506229753 +9787506230544 +9787506230568 +9787506230605 +9787506231244 +9787506231275 +9787506231411 +9787506231558 +9787506231619 +9787506231671 +9787506231695 +9787506231763 +9787506231985 +9787506232050 +9787506232333 +9787506232357 +9787506232388 +9787506232401 +9787506232418 +9787506232524 +9787506232531 +9787506232982 +9787506233088 +9787506233101 +9787506233651 +9787506233699 +9787506233736 +9787506233774 +9787506233903 +9787506233927 +9787506234061 +9787506234672 +9787506234689 +9787506234696 +9787506235471 +9787506235518 +9787506235525 +9787506235556 +9787506235723 +9787506235778 +9787506235792 +9787506236003 +9787506236188 +9787506236959 +9787506236966 +9787506237161 +9787506237239 +9787506237307 +9787506237888 +9787506238175 +9787506238243 +9787506238809 +9787506239349 +9787506239950 +9787506240079 +9787506240109 +9787506240260 +9787506240413 +9787506240437 +9787506240598 +9787506240611 +9787506240628 +9787506240673 +9787506240680 +9787506240697 +9787506240703 +9787506241069 +9787506241281 +9787506241526 +9787506241779 +9787506241793 +9787506241809 +9787506241816 +9787506241823 +9787506241861 +9787506241953 +9787506242103 +9787506242325 +9787506242523 +9787506242530 +9787506243315 +9787506243339 +9787506243414 +9787506243452 +9787506243513 +9787506243629 +9787506243650 +9787506243759 +9787506243896 +9787506244053 +9787506244497 +9787506244695 +9787506245043 +9787506245180 +9787506245203 +9787506245265 +9787506245555 +9787506245616 +9787506245715 +9787506245807 +9787506246095 +9787506246149 +9787506246309 +9787506246484 +9787506246491 +9787506246798 +9787506246880 +9787506246941 +9787506247177 +9787506247191 +9787506247467 +9787506247504 +9787506247894 +9787506247955 +9787506248136 +9787506248242 +9787506248488 +9787506248693 +9787506248785 +9787506248952 +9787506249027 +9787506249041 +9787506249744 +9787506249782 +9787506249843 +9787506249850 +9787506249881 +9787506250139 +9787506250399 +9787506250429 +9787506250696 +9787506250856 +9787506251334 +9787506251594 +9787506251792 +9787506251891 +9787506251938 +9787506251952 +9787506252010 +9787506252027 +9787506252089 +9787506252195 +9787506252393 +9787506252478 +9787506252713 +9787506252720 +9787506253093 +9787506253598 +9787506253659 +9787506253987 +9787506254083 +9787506254113 +9787506254120 +9787506254250 +9787506254441 +9787506255202 +9787506255578 +9787506255646 +9787506255653 +9787506255769 +9787506255790 +9787506255806 +9787506255851 +9787506256032 +9787506256605 +9787506256810 +9787506256957 +9787506257008 +9787506257015 +9787506257022 +9787506257084 +9787506257114 +9787506257121 +9787506257138 +9787506257190 +9787506257343 +9787506257381 +9787506257527 +9787506257565 +9787506257671 +9787506257725 +9787506257732 +9787506258005 +9787506258180 +9787506258210 +9787506258302 +9787506258319 +9787506258685 +9787506258692 +9787506258951 +9787506259279 +9787506259484 +9787506260428 +9787506260442 +9787506260572 +9787506261173 +9787506261432 +9787506262194 +9787506262385 +9787506262408 +9787506262446 +9787506262484 +9787506262491 +9787506262712 +9787506262859 +9787506262910 +9787506263467 +9787506263535 +9787506263641 +9787506263658 +9787506263689 +9787506263726 +9787506264419 +9787506264426 +9787506264440 +9787506264525 +9787506264563 +9787506264594 +9787506264815 +9787506264839 +9787506264846 +9787506265553 +9787506265829 +9787506265942 +9787506266031 +9787506266192 +9787506266253 +9787506266536 +9787506266550 +9787506266581 +9787506266888 +9787506267243 +9787506267298 +9787506267649 +9787506267700 +9787506268707 +9787506268813 +9787506269070 +9787506269711 +9787506269827 +9787506269940 +9787506269995 +9787506270182 +9787506270663 +9787506270816 +9787506271134 +9787506272858 +9787506273039 +9787506273411 +9787506274067 +9787506274272 +9787506274531 +9787506274593 +9787506274609 +9787506274852 +9787506274869 +9787506274951 +9787506275057 +9787506275064 +9787506275804 +9787506275811 +9787506276221 +9787506276290 +9787506276313 +9787506276344 +9787506276443 +9787506276610 +9787506276948 +9787506276962 +9787506277082 +9787506277112 +9787506277334 +9787506277341 +9787506277457 +9787506277518 +9787506277631 +9787506277945 +9787506278263 +9787506278713 +9787506278744 +9787506278898 +9787506279253 +9787506279475 +9787506279567 +9787506279635 +9787506279789 +9787506279864 +9787506280235 +9787506280501 +9787506280648 +9787506280884 +9787506281119 +9787506281232 +9787506281409 +9787506281423 +9787506281478 +9787506281607 +9787506281881 +9787506281973 +9787506282116 +9787506282147 +9787506282826 +9787506282857 +9787506283632 +9787506283649 +9787506283663 +9787506283700 +9787506283830 +9787506283885 +9787506284011 +9787506284400 +9787506284875 +9787506285001 +9787506285056 +9787506285285 +9787506285315 +9787506285353 +9787506285452 +9787506286183 +9787506286237 +9787506286343 +9787506286619 +9787506286640 +9787506286657 +9787506287098 +9787506287210 +9787506287753 +9787506287807 +9787506287814 +9787506288316 +9787506288361 +9787506288552 +9787506288842 +9787506289573 +9787506289580 +9787506289610 +9787506290005 +9787506290203 +9787506290234 +9787506290258 +9787506290289 +9787506290302 +9787506290333 +9787506290661 +9787506290760 +9787506290944 +9787506291057 +9787506291163 +9787506291170 +9787506291187 +9787506291194 +9787506291224 +9787506291941 +9787506292139 +9787506292153 +9787506292399 +9787506292542 +9787506292856 +9787506293709 +9787506293877 +9787506294317 +9787506294461 +9787506295048 +9787506295253 +9787506295949 +9787506296618 +9787506296687 +9787506297042 +9787506297141 +9787506297202 +9787506297370 +9787506297387 +9787506297653 +9787506297714 +9787506297738 +9787506298223 +9787506298650 +9787506298742 +9787506299749 +9787506299893 +9787506300001 +9787506300018 +9787506300049 +9787506300094 +9787506300117 +9787506300131 +9787506300209 +9787506300223 +9787506300230 +9787506300261 +9787506300315 +9787506300339 +9787506300346 +9787506300414 +9787506300476 +9787506300513 +9787506300575 +9787506300599 +9787506300605 +9787506300612 +9787506300629 +9787506300674 +9787506300728 +9787506300797 +9787506300803 +9787506300827 +9787506300865 +9787506300872 +9787506300896 +9787506300933 +9787506300995 +9787506301022 +9787506301077 +9787506301121 +9787506301138 +9787506301268 +9787506301282 +9787506301305 +9787506301367 +9787506301404 +9787506301428 +9787506301497 +9787506301503 +9787506301527 +9787506301565 +9787506301596 +9787506301640 +9787506301749 +9787506301794 +9787506301893 +9787506301916 +9787506301978 +9787506302012 +9787506302029 +9787506302067 +9787506302098 +9787506302111 +9787506302135 +9787506302159 +9787506302197 +9787506302418 +9787506302616 +9787506302692 +9787506302708 +9787506302784 +9787506302791 +9787506302821 +9787506302838 +9787506302883 +9787506302975 +9787506302982 +9787506303163 +9787506303255 +9787506303323 +9787506303408 +9787506303439 +9787506303477 +9787506303521 +9787506303552 +9787506303606 +9787506303750 +9787506303767 +9787506303828 +9787506303835 +9787506303897 +9787506303910 +9787506303934 +9787506303965 +9787506304047 +9787506304108 +9787506304122 +9787506304160 +9787506304276 +9787506304313 +9787506304412 +9787506304467 +9787506304559 +9787506304566 +9787506304771 +9787506304795 +9787506304818 +9787506304849 +9787506304948 +9787506304993 +9787506305044 +9787506305051 +9787506305211 +9787506305266 +9787506305310 +9787506305341 +9787506305372 +9787506305587 +9787506305624 +9787506305662 +9787506305686 +9787506305709 +9787506305754 +9787506305808 +9787506305846 +9787506305860 +9787506305952 +9787506306058 +9787506306089 +9787506306126 +9787506306140 +9787506306270 +9787506306287 +9787506306300 +9787506306324 +9787506306362 +9787506306379 +9787506306447 +9787506306461 +9787506306478 +9787506306645 +9787506306652 +9787506306683 +9787506306706 +9787506306744 +9787506306768 +9787506306782 +9787506306805 +9787506306812 +9787506306836 +9787506306867 +9787506306881 +9787506307031 +9787506307062 +9787506307178 +9787506307192 +9787506307215 +9787506307390 +9787506307406 +9787506307413 +9787506307420 +9787506307468 +9787506307574 +9787506307642 +9787506307659 +9787506307666 +9787506307673 +9787506307734 +9787506307758 +9787506307772 +9787506307833 +9787506307864 +9787506307888 +9787506307994 +9787506308014 +9787506308038 +9787506308106 +9787506308113 +9787506308175 +9787506308199 +9787506308205 +9787506308243 +9787506308250 +9787506308274 +9787506308281 +9787506308335 +9787506308410 +9787506308427 +9787506308472 +9787506308540 +9787506308557 +9787506308564 +9787506308571 +9787506308588 +9787506308670 +9787506308748 +9787506308755 +9787506308762 +9787506308779 +9787506308793 +9787506308847 +9787506308939 +9787506308953 +9787506309011 +9787506309059 +9787506309110 +9787506309196 +9787506309219 +9787506309226 +9787506309233 +9787506309240 +9787506309301 +9787506309318 +9787506309332 +9787506309356 +9787506309370 +9787506309523 +9787506309547 +9787506309592 +9787506309608 +9787506309615 +9787506309790 +9787506309837 +9787506309844 +9787506309851 +9787506309868 +9787506309998 +9787506310017 +9787506310086 +9787506310093 +9787506310109 +9787506310154 +9787506310161 +9787506310178 +9787506310192 +9787506310208 +9787506310215 +9787506310246 +9787506310260 +9787506310277 +9787506310291 +9787506310338 +9787506310420 +9787506310437 +9787506310468 +9787506310482 +9787506310499 +9787506310505 +9787506310574 +9787506310611 +9787506310628 +9787506310666 +9787506310758 +9787506310765 +9787506310857 +9787506310888 +9787506310901 +9787506310925 +9787506310932 +9787506311014 +9787506311038 +9787506311045 +9787506311083 +9787506311175 +9787506311199 +9787506311267 +9787506311281 +9787506311298 +9787506311304 +9787506311427 +9787506311502 +9787506311526 +9787506311540 +9787506311588 +9787506311625 +9787506311656 +9787506311663 +9787506311687 +9787506311786 +9787506311809 +9787506311847 +9787506311861 +9787506311878 +9787506311960 +9787506311984 +9787506312028 +9787506312158 +9787506312172 +9787506312189 +9787506312202 +9787506312233 +9787506312257 +9787506312288 +9787506312295 +9787506312394 +9787506312509 +9787506312530 +9787506312554 +9787506312578 +9787506312707 +9787506312721 +9787506312738 +9787506312745 +9787506312790 +9787506312813 +9787506312837 +9787506312868 +9787506312875 +9787506312899 +9787506312943 +9787506313018 +9787506313131 +9787506313148 +9787506313155 +9787506313179 +9787506313278 +9787506313285 +9787506313308 +9787506313315 +9787506313322 +9787506313353 +9787506313377 +9787506313391 +9787506313407 +9787506313414 +9787506313476 +9787506313483 +9787506313490 +9787506313551 +9787506313674 +9787506313681 +9787506313704 +9787506313766 +9787506313797 +9787506313872 +9787506313919 +9787506314022 +9787506314046 +9787506314084 +9787506314107 +9787506314275 +9787506314299 +9787506314329 +9787506314367 +9787506314411 +9787506314435 +9787506314534 +9787506314541 +9787506314589 +9787506314657 +9787506314725 +9787506314831 +9787506314848 +9787506315036 +9787506315098 +9787506315241 +9787506315265 +9787506315289 +9787506315326 +9787506315340 +9787506315500 +9787506315562 +9787506315654 +9787506315661 +9787506315678 +9787506315722 +9787506315746 +9787506315821 +9787506315852 +9787506315869 +9787506315876 +9787506316019 +9787506316033 +9787506316118 +9787506316170 +9787506316187 +9787506316262 +9787506316309 +9787506316514 +9787506316620 +9787506316644 +9787506316668 +9787506316774 +9787506316927 +9787506317054 +9787506317085 +9787506317122 +9787506317177 +9787506317191 +9787506317238 +9787506317276 +9787506317306 +9787506317337 +9787506317436 +9787506317641 +9787506317665 +9787506317696 +9787506317757 +9787506317764 +9787506317849 +9787506317887 +9787506317894 +9787506318020 +9787506318143 +9787506318150 +9787506318181 +9787506318235 +9787506318303 +9787506318587 +9787506318594 +9787506318617 +9787506318686 +9787506318723 +9787506318761 +9787506318808 +9787506318945 +9787506319034 +9787506319126 +9787506319133 +9787506319218 +9787506319317 +9787506319348 +9787506319492 +9787506319508 +9787506319546 +9787506319621 +9787506319669 +9787506319676 +9787506319751 +9787506319768 +9787506319782 +9787506319867 +9787506319898 +9787506319911 +9787506319966 +9787506320054 +9787506320061 +9787506320092 +9787506320146 +9787506320160 +9787506320207 +9787506320375 +9787506320429 +9787506320436 +9787506320474 +9787506320542 +9787506320658 +9787506320757 +9787506320764 +9787506320795 +9787506320818 +9787506320849 +9787506321006 +9787506321013 +9787506321075 +9787506321181 +9787506321273 +9787506321280 +9787506321457 +9787506321525 +9787506321624 +9787506321655 +9787506321761 +9787506321822 +9787506321860 +9787506321938 +9787506321983 +9787506322041 +9787506322058 +9787506322188 +9787506322287 +9787506322331 +9787506322478 +9787506322485 +9787506322515 +9787506322584 +9787506322683 +9787506322690 +9787506322713 +9787506322737 +9787506322775 +9787506322850 +9787506322911 +9787506322935 +9787506322959 +9787506322966 +9787506322973 +9787506323000 +9787506323017 +9787506323031 +9787506323123 +9787506323208 +9787506323222 +9787506323260 +9787506323291 +9787506323314 +9787506323390 +9787506323420 +9787506323475 +9787506323505 +9787506323611 +9787506323697 +9787506323888 +9787506323949 +9787506323970 +9787506323987 +9787506323994 +9787506324083 +9787506324397 +9787506324434 +9787506324465 +9787506324496 +9787506324540 +9787506324571 +9787506324748 +9787506324823 +9787506324830 +9787506324847 +9787506324908 +9787506325073 +9787506325103 +9787506325226 +9787506325257 +9787506325264 +9787506325356 +9787506325448 +9787506325516 +9787506325530 +9787506325561 +9787506325660 +9787506325813 +9787506325844 +9787506325851 +9787506325929 +9787506325974 +9787506326032 +9787506326063 +9787506326148 +9787506326155 +9787506326193 +9787506326230 +9787506326346 +9787506326360 +9787506326476 +9787506326582 +9787506326605 +9787506326650 +9787506326735 +9787506326872 +9787506326919 +9787506326926 +9787506327091 +9787506327107 +9787506327169 +9787506327176 +9787506327237 +9787506327244 +9787506327282 +9787506327350 +9787506327381 +9787506327497 +9787506327619 +9787506327718 +9787506327848 +9787506327886 +9787506327893 +9787506327961 +9787506327978 +9787506328043 +9787506328340 +9787506328388 +9787506328432 +9787506328470 +9787506328531 +9787506328876 +9787506328975 +9787506329002 +9787506329019 +9787506329057 +9787506329118 +9787506329187 +9787506329385 +9787506329569 +9787506329729 +9787506329743 +9787506329767 +9787506330152 +9787506330367 +9787506330398 +9787506330428 +9787506330459 +9787506330480 +9787506330534 +9787506330718 +9787506330732 +9787506330756 +9787506330787 +9787506330947 +9787506330954 +9787506331104 +9787506331197 +9787506331227 +9787506331258 +9787506331265 +9787506331302 +9787506331319 +9787506331326 +9787506331364 +9787506331371 +9787506331449 +9787506331463 +9787506331524 +9787506331531 +9787506331661 +9787506331708 +9787506331722 +9787506331739 +9787506331876 +9787506331913 +9787506332088 +9787506332101 +9787506332187 +9787506332255 +9787506332408 +9787506332415 +9787506332422 +9787506332545 +9787506332552 +9787506332606 +9787506332699 +9787506332712 +9787506332729 +9787506332828 +9787506332880 +9787506332996 +9787506333016 +9787506333047 +9787506333078 +9787506333177 +9787506333238 +9787506333306 +9787506333344 +9787506333382 +9787506333436 +9787506333481 +9787506333498 +9787506333528 +9787506333542 +9787506333627 +9787506334013 +9787506334020 +9787506334068 +9787506334464 +9787506334501 +9787506334549 +9787506334587 +9787506334594 +9787506334761 +9787506334785 +9787506334884 +9787506335034 +9787506335355 +9787506335416 +9787506335447 +9787506335478 +9787506335799 +9787506335829 +9787506335867 +9787506335874 +9787506336048 +9787506336062 +9787506336086 +9787506336116 +9787506336147 +9787506336161 +9787506336253 +9787506336260 +9787506336291 +9787506336338 +9787506336444 +9787506336536 +9787506336758 +9787506336802 +9787506336888 +9787506336895 +9787506336956 +9787506337052 +9787506337199 +9787506337472 +9787506337717 +9787506337755 +9787506337809 +9787506337861 +9787506337946 +9787506338059 +9787506338271 +9787506338288 +9787506338387 +9787506338417 +9787506338424 +9787506338967 +9787506339056 +9787506339124 +9787506339193 +9787506339209 +9787506339278 +9787506339629 +9787506339926 +9787506340007 +9787506340298 +9787506340304 +9787506340939 +9787506341097 +9787506341189 +9787506341226 +9787506341363 +9787506341387 +9787506341509 +9787506341523 +9787506341530 +9787506341660 +9787506342100 +9787506342636 +9787506342698 +9787506343282 +9787506343572 +9787506344531 +9787506344715 +9787506344845 +9787506344906 +9787506344999 +9787506345262 +9787506345323 +9787506345415 +9787506345460 +9787506345743 +9787506346139 +9787506346788 +9787506346801 +9787506346818 +9787506347297 +9787506347853 +9787506347945 +9787506348225 +9787506348232 +9787506349161 +9787506350075 +9787506350082 +9787506350327 +9787506350365 +9787506350730 +9787506351140 +9787506351232 +9787506351522 +9787506351652 +9787506351744 +9787506351911 +9787506351966 +9787506353199 +9787506353342 +9787506353519 +9787506353854 +9787506353984 +9787506354868 +9787506355964 +9787506356183 +9787506356213 +9787506356947 +9787506357203 +9787506357579 +9787506357678 +9787506357760 +9787506357838 +9787506357968 +9787506357975 +9787506358156 +9787506358231 +9787506358361 +9787506359054 +9787506359450 +9787506359795 +9787506360012 +9787506360210 +9787506360234 +9787506360470 +9787506360517 +9787506360739 +9787506361552 +9787506361705 +9787506361989 +9787506362184 +9787506362542 +9787506362634 +9787506362665 +9787506362917 +9787506363105 +9787506363143 +9787506363167 +9787506363341 +9787506363631 +9787506363709 +9787506363938 +9787506365772 +9787506365925 +9787506365994 +9787506366281 +9787506367356 +9787506367394 +9787506368421 +9787506368483 +9787506368513 +9787506368544 +9787506369534 +9787506369916 +9787506370134 +9787506370288 +9787506370813 +9787506371049 +9787506373128 +9787506373319 +9787506373890 +9787506374293 +9787506374910 +9787506375542 +9787506377072 +9787506379717 +9787506380041 +9787506380782 +9787506382625 +9787506382847 +9787506382854 +9787506382861 +9787506382878 +9787506382885 +9787506382892 +9787506383370 +9787506383875 +9787506384100 +9787506385350 +9787506385572 +9787506386883 +9787506387194 +9787506387934 +9787506389457 +9787506391276 +9787506393959 +9787506394109 +9787506394192 +9787506394208 +9787506394222 +9787506394239 +9787506394246 +9787506394253 +9787506394260 +9787506394277 +9787506394291 +9787506394307 +9787506398466 +9787506399555 +9787506400596 +9787506401531 +9787506402484 +9787506403139 +9787506403634 +9787506404211 +9787506404426 +9787506405928 +9787506406086 +9787506406710 +9787506406727 +9787506407106 +9787506407335 +9787506407564 +9787506408127 +9787506408455 +9787506409230 +9787506409360 +9787506409377 +9787506409568 +9787506410298 +9787506410663 +9787506410762 +9787506411073 +9787506411103 +9787506411363 +9787506411486 +9787506411691 +9787506411943 +9787506412148 +9787506412285 +9787506412308 +9787506412476 +9787506412513 +9787506412643 +9787506412759 +9787506413145 +9787506413305 +9787506413312 +9787506413336 +9787506413893 +9787506413909 +9787506413923 +9787506414203 +9787506414210 +9787506414258 +9787506414319 +9787506414449 +9787506414654 +9787506415651 +9787506415705 +9787506415965 +9787506416030 +9787506416177 +9787506416283 +9787506416290 +9787506416375 +9787506416573 +9787506416603 +9787506416641 +9787506416689 +9787506416788 +9787506417068 +9787506417198 +9787506417297 +9787506417457 +9787506417655 +9787506417785 +9787506417921 +9787506418249 +9787506418270 +9787506418324 +9787506418416 +9787506418652 +9787506418942 +9787506418966 +9787506419086 +9787506419222 +9787506419239 +9787506419390 +9787506419499 +9787506419727 +9787506419888 +9787506420198 +9787506420396 +9787506420525 +9787506420532 +9787506420549 +9787506421188 +9787506421195 +9787506421447 +9787506421454 +9787506421850 +9787506422000 +9787506422062 +9787506422284 +9787506423267 +9787506423311 +9787506423373 +9787506423540 +9787506423700 +9787506424332 +9787506424356 +9787506424783 +9787506424899 +9787506424950 +9787506425247 +9787506425650 +9787506425810 +9787506426022 +9787506426091 +9787506426244 +9787506426282 +9787506426558 +9787506426619 +9787506426930 +9787506427135 +9787506427166 +9787506427272 +9787506427630 +9787506427890 +9787506427951 +9787506428170 +9787506428354 +9787506428385 +9787506428422 +9787506428538 +9787506428651 +9787506429726 +9787506430074 +9787506430159 +9787506430388 +9787506430395 +9787506430524 +9787506430661 +9787506430890 +9787506430975 +9787506430999 +9787506431019 +9787506431071 +9787506431408 +9787506431569 +9787506431651 +9787506431675 +9787506431705 +9787506431767 +9787506431941 +9787506431965 +9787506432030 +9787506432115 +9787506432320 +9787506432344 +9787506432566 +9787506432740 +9787506432795 +9787506433044 +9787506433532 +9787506433693 +9787506433730 +9787506433952 +9787506433976 +9787506434034 +9787506434171 +9787506434355 +9787506434508 +9787506434539 +9787506434584 +9787506434706 +9787506434775 +9787506434829 +9787506434843 +9787506434850 +9787506434874 +9787506435031 +9787506435062 +9787506435178 +9787506435260 +9787506435468 +9787506435550 +9787506435581 +9787506435734 +9787506435796 +9787506435918 +9787506436007 +9787506436038 +9787506436366 +9787506436373 +9787506436557 +9787506436618 +9787506436632 +9787506436700 +9787506436847 +9787506436892 +9787506436991 +9787506437035 +9787506437301 +9787506437493 +9787506437677 +9787506437752 +9787506437790 +9787506437820 +9787506437929 +9787506438384 +9787506439046 +9787506439077 +9787506439206 +9787506439244 +9787506439275 +9787506439381 +9787506439473 +9787506439725 +9787506439756 +9787506439862 +9787506439961 +9787506439985 +9787506440035 +9787506440202 +9787506440271 +9787506440486 +9787506440516 +9787506440578 +9787506440738 +9787506440813 +9787506440998 +9787506441216 +9787506441254 +9787506441308 +9787506441322 +9787506441711 +9787506441797 +9787506441810 +9787506441872 +9787506441957 +9787506441995 +9787506442299 +9787506442442 +9787506442718 +9787506443203 +9787506443241 +9787506443333 +9787506443364 +9787506443388 +9787506443456 +9787506443739 +9787506443845 +9787506443920 +9787506444026 +9787506444088 +9787506444095 +9787506444101 +9787506444309 +9787506444712 +9787506444767 +9787506444781 +9787506444927 +9787506444958 +9787506444996 +9787506445023 +9787506445054 +9787506445269 +9787506445276 +9787506445290 +9787506445320 +9787506445436 +9787506445627 +9787506445719 +9787506445924 +9787506446297 +9787506446341 +9787506446440 +9787506446556 +9787506447508 +9787506447560 +9787506447584 +9787506447867 +9787506448260 +9787506448307 +9787506448383 +9787506448451 +9787506448468 +9787506448475 +9787506448857 +9787506449045 +9787506449212 +9787506449236 +9787506449533 +9787506449816 +9787506449847 +9787506450362 +9787506450478 +9787506450768 +9787506450836 +9787506450904 +9787506450935 +9787506451185 +9787506451192 +9787506451659 +9787506452076 +9787506452526 +9787506452557 +9787506452564 +9787506452809 +9787506453417 +9787506453936 +9787506454261 +9787506454278 +9787506454377 +9787506454391 +9787506454414 +9787506454452 +9787506454704 +9787506455152 +9787506455398 +9787506455626 +9787506455824 +9787506455855 +9787506456142 +9787506456159 +9787506456180 +9787506456494 +9787506456692 +9787506456890 +9787506457002 +9787506457071 +9787506457125 +9787506457132 +9787506457606 +9787506457811 +9787506457873 +9787506457927 +9787506458641 +9787506459020 +9787506459037 +9787506459464 +9787506459495 +9787506459570 +9787506459617 +9787506459785 +9787506459891 +9787506459945 +9787506460538 +9787506460620 +9787506460866 +9787506460897 +9787506461078 +9787506461283 +9787506461320 +9787506461412 +9787506461757 +9787506461825 +9787506461948 +9787506462143 +9787506463010 +9787506463782 +9787506464123 +9787506464178 +9787506464222 +9787506464239 +9787506464857 +9787506464925 +9787506465588 +9787506465670 +9787506465779 +9787506465854 +9787506466219 +9787506466622 +9787506466813 +9787506466875 +9787506467582 +9787506467766 +9787506468114 +9787506468169 +9787506468183 +9787506468244 +9787506468299 +9787506468589 +9787506469739 +9787506471534 +9787506471732 +9787506471985 +9787506472104 +9787506472500 +9787506472647 +9787506472685 +9787506472760 +9787506473316 +9787506473378 +9787506473385 +9787506473460 +9787506475150 +9787506475839 +9787506476317 +9787506477352 +9787506477512 +9787506478175 +9787506478687 +9787506478847 +9787506478861 +9787506478908 +9787506479530 +9787506479769 +9787506479783 +9787506480031 +9787506480239 +9787506480352 +9787506480390 +9787506480826 +9787506480840 +9787506480864 +9787506480932 +9787506481137 +9787506481700 +9787506481724 +9787506482301 +9787506482844 +9787506483087 +9787506483889 +9787506484718 +9787506484770 +9787506485074 +9787506485692 +9787506486026 +9787506486965 +9787506487139 +9787506487269 +9787506487450 +9787506488105 +9787506488365 +9787506488471 +9787506488600 +9787506489294 +9787506489348 +9787506490085 +9787506490092 +9787506490108 +9787506490115 +9787506490276 +9787506490528 +9787506491020 +9787506491150 +9787506491396 +9787506491631 +9787506491822 +9787506492010 +9787506492058 +9787506492225 +9787506492294 +9787506492614 +9787506493000 +9787506493093 +9787506493123 +9787506493277 +9787506493352 +9787506493376 +9787506493420 +9787506493673 +9787506493710 +9787506493857 +9787506493871 +9787506494045 +9787506494328 +9787506494779 +9787506494915 +9787506495110 +9787506495448 +9787506495523 +9787506495677 +9787506496254 +9787506496711 +9787506496759 +9787506496766 +9787506497268 +9787506497510 +9787506497725 +9787506498043 +9787506498784 +9787506499057 +9787506499293 +9787506499323 +9787506499439 +9787506499484 +9787506499637 +9787506499781 +9787506499859 +9787506500043 +9787506500098 +9787506500241 +9787506500296 +9787506500326 +9787506500340 +9787506500364 +9787506500487 +9787506500517 +9787506500524 +9787506501149 +9787506501156 +9787506501767 +9787506501774 +9787506501866 +9787506501972 +9787506502924 +9787506502993 +9787506503129 +9787506503136 +9787506503495 +9787506503945 +9787506504249 +9787506504348 +9787506504607 +9787506504676 +9787506504751 +9787506505673 +9787506506083 +9787506506328 +9787506506380 +9787506506519 +9787506506748 +9787506506823 +9787506507196 +9787506507301 +9787506507325 +9787506507585 +9787506507738 +9787506507776 +9787506507868 +9787506508032 +9787506508063 +9787506508070 +9787506508438 +9787506508445 +9787506508469 +9787506508728 +9787506509039 +9787506509084 +9787506509152 +9787506509169 +9787506509183 +9787506509435 +9787506509527 +9787506509671 +9787506509701 +9787506509916 +9787506510141 +9787506510158 +9787506510196 +9787506510271 +9787506510561 +9787506510615 +9787506510677 +9787506511216 +9787506511230 +9787506511681 +9787506511933 +9787506512091 +9787506512107 +9787506512145 +9787506512343 +9787506512527 +9787506512824 +9787506513012 +9787506513036 +9787506513470 +9787506513807 +9787506514040 +9787506514248 +9787506514385 +9787506514590 +9787506514613 +9787506514620 +9787506514941 +9787506515191 +9787506515207 +9787506515399 +9787506516112 +9787506516266 +9787506516457 +9787506516754 +9787506516761 +9787506516839 +9787506516990 +9787506517058 +9787506517119 +9787506517256 +9787506517577 +9787506517652 +9787506517683 +9787506517935 +9787506517942 +9787506517959 +9787506517966 +9787506518031 +9787506518079 +9787506518130 +9787506518444 +9787506518512 +9787506518697 +9787506518840 +9787506519359 +9787506519403 +9787506519489 +9787506519496 +9787506519526 +9787506519762 +9787506519779 +9787506519878 +9787506520409 +9787506520515 +9787506520751 +9787506520959 +9787506520997 +9787506521437 +9787506521499 +9787506521505 +9787506521826 +9787506521864 +9787506522144 +9787506522212 +9787506522526 +9787506522922 +9787506522984 +9787506522991 +9787506523448 +9787506523547 +9787506523578 +9787506524421 +9787506525220 +9787506525237 +9787506525503 +9787506525619 +9787506525640 +9787506525657 +9787506525664 +9787506525671 +9787506526647 +9787506526753 +9787506526814 +9787506526968 +9787506527002 +9787506527033 +9787506527088 +9787506527095 +9787506527101 +9787506527132 +9787506527149 +9787506527156 +9787506527187 +9787506527293 +9787506527453 +9787506527514 +9787506527521 +9787506527538 +9787506529907 +9787506529952 +9787506530071 +9787506531559 +9787506531658 +9787506531672 +9787506531702 +9787506531801 +9787506531832 +9787506532082 +9787506532112 +9787506532150 +9787506532334 +9787506532433 +9787506532570 +9787506532624 +9787506532655 +9787506533188 +9787506533249 +9787506533287 +9787506533379 +9787506533393 +9787506533454 +9787506533560 +9787506533607 +9787506533652 +9787506533737 +9787506533744 +9787506533812 +9787506534055 +9787506534277 +9787506534413 +9787506534499 +9787506534543 +9787506534567 +9787506534673 +9787506534789 +9787506534963 +9787506535007 +9787506535038 +9787506535076 +9787506535199 +9787506535472 +9787506535762 +9787506535892 +9787506535960 +9787506536004 +9787506536011 +9787506536035 +9787506536165 +9787506536172 +9787506536189 +9787506536226 +9787506536509 +9787506536516 +9787506536523 +9787506536530 +9787506536554 +9787506536578 +9787506536660 +9787506536790 +9787506537056 +9787506537063 +9787506537162 +9787506537216 +9787506537230 +9787506537414 +9787506537469 +9787506537827 +9787506537971 +9787506537988 +9787506538725 +9787506539043 +9787506539197 +9787506539326 +9787506539364 +9787506539562 +9787506539722 +9787506539753 +9787506539852 +9787506539869 +9787506539999 +9787506540056 +9787506540070 +9787506540148 +9787506540346 +9787506540407 +9787506540414 +9787506540476 +9787506540506 +9787506540575 +9787506541008 +9787506541275 +9787506541404 +9787506541442 +9787506541510 +9787506541626 +9787506541718 +9787506541732 +9787506541756 +9787506541787 +9787506541794 +9787506541800 +9787506541886 +9787506541923 +9787506541954 +9787506541985 +9787506542067 +9787506542074 +9787506542081 +9787506542258 +9787506542630 +9787506542722 +9787506542739 +9787506542852 +9787506542869 +9787506542913 +9787506543002 +9787506543040 +9787506543156 +9787506543309 +9787506543583 +9787506543637 +9787506543644 +9787506543675 +9787506543767 +9787506543798 +9787506543859 +9787506543866 +9787506543958 +9787506544276 +9787506544306 +9787506544399 +9787506544450 +9787506544610 +9787506544658 +9787506544764 +9787506545129 +9787506545273 +9787506545297 +9787506545372 +9787506545419 +9787506545433 +9787506545464 +9787506545488 +9787506545495 +9787506545525 +9787506545792 +9787506545846 +9787506545945 +9787506546034 +9787506546126 +9787506546263 +9787506546287 +9787506546300 +9787506546379 +9787506546768 +9787506546782 +9787506546812 +9787506546843 +9787506546904 +9787506547000 +9787506547109 +9787506547123 +9787506547376 +9787506547451 +9787506547598 +9787506547604 +9787506547635 +9787506547666 +9787506547710 +9787506547734 +9787506547802 +9787506547970 +9787506548007 +9787506548052 +9787506548236 +9787506548472 +9787506548779 +9787506548816 +9787506548861 +9787506548892 +9787506548946 +9787506549233 +9787506549288 +9787506549370 +9787506549486 +9787506549714 +9787506549820 +9787506549844 +9787506550116 +9787506550314 +9787506550383 +9787506550444 +9787506550475 +9787506550536 +9787506550635 +9787506550727 +9787506550765 +9787506550925 +9787506550963 +9787506550994 +9787506551052 +9787506551106 +9787506551151 +9787506551243 +9787506551335 +9787506551625 +9787506551724 +9787506551953 +9787506552042 +9787506552059 +9787506552097 +9787506552134 +9787506552172 +9787506552233 +9787506552325 +9787506553193 +9787506553216 +9787506553339 +9787506553391 +9787506553513 +9787506553568 +9787506553735 +9787506553759 +9787506553773 +9787506553780 +9787506553827 +9787506553933 +9787506553988 +9787506554008 +9787506554053 +9787506554091 +9787506554251 +9787506554299 +9787506554343 +9787506554350 +9787506554404 +9787506554435 +9787506554510 +9787506554527 +9787506554541 +9787506554565 +9787506554572 +9787506554701 +9787506554718 +9787506554923 +9787506555029 +9787506555043 +9787506555050 +9787506555128 +9787506555258 +9787506555746 +9787506555753 +9787506555883 +9787506555906 +9787506555975 +9787506556026 +9787506556163 +9787506556194 +9787506556200 +9787506556262 +9787506556293 +9787506556415 +9787506556422 +9787506556439 +9787506556453 +9787506556590 +9787506556637 +9787506556828 +9787506556842 +9787506556897 +9787506556972 +9787506557061 +9787506557146 +9787506557290 +9787506557306 +9787506557313 +9787506557467 +9787506557474 +9787506557504 +9787506557511 +9787506557542 +9787506557559 +9787506557597 +9787506557795 +9787506557900 +9787506557917 +9787506557993 +9787506558129 +9787506558259 +9787506558334 +9787506558358 +9787506558396 +9787506558433 +9787506558464 +9787506558532 +9787506558709 +9787506558921 +9787506558976 +9787506559225 +9787506559669 +9787506559676 +9787506559706 +9787506559713 +9787506560030 +9787506560245 +9787506560313 +9787506560320 +9787506560337 +9787506560399 +9787506560580 +9787506560795 +9787506560986 +9787506561013 +9787506561105 +9787506561211 +9787506561228 +9787506561235 +9787506561273 +9787506561365 +9787506561389 +9787506561464 +9787506561570 +9787506561587 +9787506561600 +9787506561617 +9787506561679 +9787506561730 +9787506561853 +9787506561952 +9787506561983 +9787506562058 +9787506562072 +9787506562140 +9787506562157 +9787506562300 +9787506562362 +9787506562553 +9787506562645 +9787506562669 +9787506562690 +9787506562713 +9787506562720 +9787506562782 +9787506562904 +9787506562966 +9787506563284 +9787506563543 +9787506563604 +9787506563857 +9787506563864 +9787506563895 +9787506563932 +9787506563956 +9787506563963 +9787506564045 +9787506564052 +9787506564090 +9787506564427 +9787506564724 +9787506564731 +9787506564779 +9787506564830 +9787506564960 +9787506565134 +9787506565165 +9787506565257 +9787506565301 +9787506565325 +9787506565370 +9787506565417 +9787506566308 +9787506566759 +9787506566773 +9787506566827 +9787506567107 +9787506567121 +9787506567275 +9787506567374 +9787506567503 +9787506567510 +9787506567572 +9787506567596 +9787506567862 +9787506567947 +9787506567961 +9787506568043 +9787506568166 +9787506568197 +9787506568364 +9787506568371 +9787506568388 +9787506568401 +9787506568647 +9787506568685 +9787506568722 +9787506568777 +9787506568852 +9787506568869 +9787506568999 +9787506569019 +9787506569095 +9787506569118 +9787506569132 +9787506569149 +9787506569293 +9787506569392 +9787506569576 +9787506569859 +9787506569972 +9787506570053 +9787506570121 +9787506570251 +9787506570503 +9787506570541 +9787506570800 +9787506570862 +9787506570886 +9787506570947 +9787506571128 +9787506571166 +9787506571579 +9787506571586 +9787506571593 +9787506571876 +9787506572057 +9787506572095 +9787506572149 +9787506572545 +9787506572569 +9787506572613 +9787506573023 +9787506573054 +9787506573085 +9787506573139 +9787506573450 +9787506573467 +9787506573672 +9787506573900 +9787506574112 +9787506574136 +9787506574143 +9787506574419 +9787506574532 +9787506574792 +9787506574815 +9787506574839 +9787506575171 +9787506575508 +9787506575522 +9787506600897 +9787506602167 +9787506602518 +9787506602525 +9787506603355 +9787506610117 +9787506611572 +9787506612074 +9787506612180 +9787506613262 +9787506613606 +9787506614146 +9787506614313 +9787506614757 +9787506616577 +9787506616591 +9787506616867 +9787506617123 +9787506617758 +9787506617765 +9787506617772 +9787506618175 +9787506618731 +9787506618946 +9787506620505 +9787506620536 +9787506620543 +9787506620611 +9787506620727 +9787506621601 +9787506621748 +9787506622493 +9787506624138 +9787506624343 +9787506624398 +9787506624596 +9787506624954 +9787506625074 +9787506625135 +9787506625838 +9787506627139 +9787506628334 +9787506628693 +9787506629324 +9787506629713 +9787506629768 +9787506630252 +9787506631907 +9787506632225 +9787506632935 +9787506633482 +9787506633932 +9787506634793 +9787506634861 +9787506634977 +9787506635158 +9787506635271 +9787506635684 +9787506635745 +9787506636704 +9787506636766 +9787506636865 +9787506636940 +9787506637039 +9787506637152 +9787506637268 +9787506637893 +9787506638050 +9787506638296 +9787506638517 +9787506638685 +9787506638692 +9787506638944 +9787506639781 +9787506639958 +9787506639989 +9787506640367 +9787506640435 +9787506640459 +9787506641531 +9787506641746 +9787506641784 +9787506642309 +9787506642859 +9787506644051 +9787506644082 +9787506644136 +9787506644365 +9787506644570 +9787506645409 +9787506646383 +9787506646857 +9787506646895 +9787506646949 +9787506646956 +9787506647465 +9787506647564 +9787506647656 +9787506648103 +9787506648943 +9787506649032 +9787506649223 +9787506649230 +9787506649261 +9787506650441 +9787506650472 +9787506650755 +9787506650762 +9787506651158 +9787506651738 +9787506651844 +9787506651851 +9787506651868 +9787506652063 +9787506652278 +9787506652292 +9787506652759 +9787506654302 +9787506654517 +9787506656757 +9787506657518 +9787506657716 +9787506658607 +9787506658614 +9787506658973 +9787506661140 +9787506661317 +9787506661928 +9787506662062 +9787506662512 +9787506662703 +9787506663267 +9787506664295 +9787506664660 +9787506665711 +9787506666107 +9787506666404 +9787506667791 +9787506667906 +9787506668118 +9787506668187 +9787506668194 +9787506668217 +9787506668392 +9787506668866 +9787506668941 +9787506668965 +9787506669054 +9787506669979 +9787506670081 +9787506670593 +9787506670746 +9787506670869 +9787506671231 +9787506671262 +9787506671279 +9787506671804 +9787506672160 +9787506672856 +9787506673280 +9787506673884 +9787506674737 +9787506674904 +9787506675055 +9787506675154 +9787506675161 +9787506675253 +9787506675543 +9787506676038 +9787506676144 +9787506676175 +9787506677066 +9787506677295 +9787506677417 +9787506677660 +9787506677691 +9787506677882 +9787506678391 +9787506678629 +9787506678681 +9787506678865 +9787506679268 +9787506680103 +9787506680219 +9787506680349 +9787506680448 +9787506680509 +9787506680646 +9787506681056 +9787506681193 +9787506681254 +9787506681308 +9787506681353 +9787506681537 +9787506681711 +9787506681834 +9787506682169 +9787506682251 +9787506682282 +9787506683111 +9787506683227 +9787506683333 +9787506683340 +9787506683623 +9787506683913 +9787506683920 +9787506683951 +9787506683968 +9787506683982 +9787506684293 +9787506684354 +9787506685047 +9787506685061 +9787506685108 +9787506685238 +9787506685313 +9787506685771 +9787506686044 +9787506686211 +9787506686501 +9787506686754 +9787506686778 +9787506686839 +9787506686891 +9787506687027 +9787506688727 +9787506689656 +9787506689793 +9787506689809 +9787506689908 +9787506690171 +9787506690614 +9787506690744 +9787506691031 +9787506691352 +9787506691482 +9787506692038 +9787506692083 +9787506692212 +9787506692380 +9787506692403 +9787506692410 +9787506692458 +9787506692755 +9787506692878 +9787506693035 +9787506693059 +9787506693943 +9787506693981 +9787506694025 +9787506694490 +9787506694506 +9787506694520 +9787506694650 +9787506694902 +9787506695329 +9787506695343 +9787506696234 +9787506696579 +9787506696883 +9787506696890 +9787506697071 +9787506697187 +9787506697200 +9787506697231 +9787506697378 +9787506697415 +9787506697613 +9787506697736 +9787506697798 +9787506698092 +9787506698139 +9787506698146 +9787506698160 +9787506698382 +9787506698405 +9787506698535 +9787506698610 +9787506698801 +9787506698931 +9787506699327 +9787506699457 +9787506699464 +9787506699532 +9787506699747 +9787506699761 +9787506699839 +9787506699907 +9787506700153 +9787506700177 +9787506700191 +9787506700214 +9787506700238 +9787506700382 +9787506700535 +9787506700542 +9787506700580 +9787506700658 +9787506700702 +9787506700719 +9787506700764 +9787506700795 +9787506700955 +9787506701006 +9787506701082 +9787506701112 +9787506701198 +9787506701211 +9787506701327 +9787506701389 +9787506701433 +9787506701464 +9787506701471 +9787506701570 +9787506701600 +9787506701662 +9787506701730 +9787506701747 +9787506701792 +9787506701808 +9787506701815 +9787506701969 +9787506701983 +9787506702027 +9787506702294 +9787506702508 +9787506702546 +9787506702553 +9787506702591 +9787506702652 +9787506702805 +9787506702812 +9787506702829 +9787506702867 +9787506702874 +9787506702911 +9787506703048 +9787506703123 +9787506703284 +9787506703291 +9787506703413 +9787506703468 +9787506703499 +9787506703543 +9787506703581 +9787506703727 +9787506703765 +9787506703833 +9787506703840 +9787506703925 +9787506704298 +9787506704304 +9787506704359 +9787506704380 +9787506704434 +9787506704465 +9787506704526 +9787506704649 +9787506704670 +9787506704793 +9787506705042 +9787506705059 +9787506705066 +9787506705172 +9787506705349 +9787506705493 +9787506705561 +9787506705653 +9787506705660 +9787506705721 +9787506705837 +9787506705967 +9787506706001 +9787506706049 +9787506706216 +9787506706285 +9787506706322 +9787506706391 +9787506706421 +9787506706636 +9787506706698 +9787506706711 +9787506706766 +9787506706940 +9787506706957 +9787506707022 +9787506707060 +9787506707237 +9787506707299 +9787506707565 +9787506707572 +9787506707695 +9787506707701 +9787506707862 +9787506707909 +9787506708036 +9787506708067 +9787506708074 +9787506708081 +9787506708104 +9787506708111 +9787506708159 +9787506708272 +9787506708289 +9787506708357 +9787506708401 +9787506708470 +9787506708579 +9787506708609 +9787506708647 +9787506708920 +9787506708982 +9787506708999 +9787506709255 +9787506709279 +9787506709286 +9787506709491 +9787506709521 +9787506710213 +9787506710220 +9787506710329 +9787506710367 +9787506710381 +9787506710480 +9787506710589 +9787506710626 +9787506710633 +9787506710657 +9787506710671 +9787506710695 +9787506711012 +9787506711180 +9787506711197 +9787506711289 +9787506711388 +9787506711555 +9787506711807 +9787506711869 +9787506712033 +9787506712354 +9787506712415 +9787506712491 +9787506712538 +9787506712576 +9787506712590 +9787506712712 +9787506712729 +9787506712736 +9787506712743 +9787506712750 +9787506712767 +9787506712774 +9787506712880 +9787506712996 +9787506713030 +9787506713290 +9787506713306 +9787506713313 +9787506713405 +9787506713528 +9787506713726 +9787506713764 +9787506713856 +9787506713894 +9787506713924 +9787506713948 +9787506714013 +9787506714020 +9787506714037 +9787506714044 +9787506714051 +9787506714068 +9787506714075 +9787506714082 +9787506714099 +9787506714105 +9787506714112 +9787506714129 +9787506714136 +9787506714495 +9787506714587 +9787506714785 +9787506714990 +9787506715065 +9787506715133 +9787506715232 +9787506715386 +9787506716055 +9787506716079 +9787506716192 +9787506716215 +9787506716444 +9787506716451 +9787506716468 +9787506716482 +9787506716529 +9787506716826 +9787506716918 +9787506717090 +9787506717151 +9787506717274 +9787506717281 +9787506717342 +9787506717403 +9787506717434 +9787506717441 +9787506717458 +9787506717465 +9787506717571 +9787506717687 +9787506717762 +9787506718097 +9787506718189 +9787506718233 +9787506718257 +9787506718417 +9787506718554 +9787506718653 +9787506718660 +9787506718721 +9787506718790 +9787506718868 +9787506718899 +9787506718936 +9787506718950 +9787506719179 +9787506719278 +9787506719285 +9787506719339 +9787506719377 +9787506719551 +9787506719643 +9787506719759 +9787506719803 +9787506719919 +9787506719933 +9787506719971 +9787506719995 +9787506720137 +9787506720151 +9787506720366 +9787506720489 +9787506720717 +9787506720762 +9787506720793 +9787506720915 +9787506720953 +9787506721042 +9787506721110 +9787506721196 +9787506721318 +9787506721455 +9787506721578 +9787506721585 +9787506721592 +9787506721769 +9787506721967 +9787506722032 +9787506722056 +9787506722179 +9787506722223 +9787506722247 +9787506722476 +9787506722551 +9787506722940 +9787506722971 +9787506723039 +9787506723077 +9787506723091 +9787506723121 +9787506723169 +9787506723206 +9787506723329 +9787506723350 +9787506723404 +9787506723657 +9787506723725 +9787506723824 +9787506723916 +9787506724081 +9787506724234 +9787506724289 +9787506725026 +9787506725095 +9787506725149 +9787506725248 +9787506725347 +9787506725354 +9787506725453 +9787506725460 +9787506725583 +9787506725637 +9787506725781 +9787506725866 +9787506725897 +9787506725903 +9787506725958 +9787506725996 +9787506726016 +9787506726030 +9787506726245 +9787506726399 +9787506726450 +9787506726535 +9787506726542 +9787506726566 +9787506726641 +9787506726962 +9787506727129 +9787506727167 +9787506727303 +9787506727648 +9787506727655 +9787506728096 +9787506728119 +9787506728140 +9787506728362 +9787506728386 +9787506728430 +9787506728478 +9787506728553 +9787506728737 +9787506728775 +9787506729307 +9787506729338 +9787506729352 +9787506729659 +9787506729840 +9787506729864 +9787506729987 +9787506730099 +9787506730112 +9787506730235 +9787506730419 +9787506730457 +9787506730631 +9787506730860 +9787506730945 +9787506730983 +9787506731034 +9787506731072 +9787506731584 +9787506731898 +9787506731973 +9787506732079 +9787506732086 +9787506732109 +9787506732154 +9787506732673 +9787506732734 +9787506732765 +9787506732840 +9787506733083 +9787506733366 +9787506733496 +9787506733533 +9787506733755 +9787506733809 +9787506733939 +9787506734103 +9787506734189 +9787506734271 +9787506734370 +9787506734455 +9787506734554 +9787506734622 +9787506734820 +9787506735018 +9787506735025 +9787506735087 +9787506735438 +9787506735445 +9787506735575 +9787506735599 +9787506735759 +9787506735841 +9787506735896 +9787506736459 +9787506736824 +9787506736954 +9787506736985 +9787506737234 +9787506737456 +9787506737487 +9787506737661 +9787506737937 +9787506738026 +9787506738064 +9787506738118 +9787506738255 +9787506738514 +9787506739320 +9787506739368 +9787506739887 +9787506739917 +9787506740463 +9787506740517 +9787506740555 +9787506740593 +9787506740777 +9787506741040 +9787506741200 +9787506741255 +9787506741354 +9787506742061 +9787506742191 +9787506742887 +9787506743112 +9787506743266 +9787506743747 +9787506744171 +9787506744188 +9787506744324 +9787506744850 +9787506745239 +9787506747141 +9787506747950 +9787506749282 +9787506749329 +9787506749411 +9787506749497 +9787506750066 +9787506750189 +9787506750332 +9787506750943 +9787506750981 +9787506751803 +9787506752510 +9787506752954 +9787506753500 +9787506753524 +9787506754170 +9787506755184 +9787506755863 +9787506756303 +9787506756433 +9787506756518 +9787506756709 +9787506758895 +9787506760454 +9787506761468 +9787506762274 +9787506762311 +9787506762328 +9787506762953 +9787506763189 +9787506763738 +9787506765183 +9787506765701 +9787506765923 +9787506767415 +9787506767644 +9787506767675 +9787506767996 +9787506768955 +9787506768962 +9787506770811 +9787506771078 +9787506771689 +9787506772174 +9787506772334 +9787506772525 +9787506775427 +9787506776226 +9787506776509 +9787506776530 +9787506776813 +9787506778060 +9787506778275 +9787506789707 +9787506792479 +9787506793018 +9787506794114 +9787506797337 +9787506799973 +9787506800020 +9787506800143 +9787506800167 +9787506800174 +9787506800617 +9787506800655 +9787506800679 +9787506800747 +9787506800976 +9787506801003 +9787506801041 +9787506801102 +9787506801249 +9787506801362 +9787506801621 +9787506802048 +9787506802079 +9787506802246 +9787506802253 +9787506803014 +9787506803069 +9787506803236 +9787506803274 +9787506803878 +9787506803946 +9787506803977 +9787506804103 +9787506804110 +9787506804172 +9787506804226 +9787506805087 +9787506805193 +9787506805247 +9787506805278 +9787506805421 +9787506805445 +9787506805469 +9787506805483 +9787506805513 +9787506805704 +9787506805841 +9787506805902 +9787506806053 +9787506806060 +9787506806138 +9787506806374 +9787506806411 +9787506806459 +9787506806558 +9787506806701 +9787506806718 +9787506806725 +9787506806732 +9787506806770 +9787506806923 +9787506807005 +9787506807180 +9787506807333 +9787506807722 +9787506807739 +9787506807760 +9787506807814 +9787506807852 +9787506807999 +9787506808217 +9787506808965 +9787506808996 +9787506809085 +9787506809115 +9787506809139 +9787506809146 +9787506809160 +9787506809290 +9787506810791 +9787506810951 +9787506810968 +9787506810982 +9787506811071 +9787506811095 +9787506811101 +9787506811125 +9787506811378 +9787506811514 +9787506811866 +9787506812085 +9787506812092 +9787506812320 +9787506812351 +9787506812375 +9787506812399 +9787506812481 +9787506812498 +9787506812528 +9787506812559 +9787506812665 +9787506812689 +9787506812719 +9787506812825 +9787506812856 +9787506813020 +9787506813310 +9787506813358 +9787506813402 +9787506813419 +9787506813488 +9787506813518 +9787506813549 +9787506813617 +9787506813631 +9787506813730 +9787506813860 +9787506814072 +9787506814195 +9787506814331 +9787506814355 +9787506814362 +9787506814379 +9787506814867 +9787506815017 +9787506815055 +9787506815086 +9787506815130 +9787506815222 +9787506815239 +9787506815475 +9787506815512 +9787506815536 +9787506815567 +9787506815659 +9787506815703 +9787506816014 +9787506816106 +9787506816113 +9787506816304 +9787506816342 +9787506816366 +9787506816373 +9787506816427 +9787506816526 +9787506816588 +9787506816656 +9787506816786 +9787506816816 +9787506817219 +9787506817233 +9787506817257 +9787506817394 +9787506817455 +9787506817578 +9787506817608 +9787506817660 +9787506817684 +9787506817776 +9787506818322 +9787506818384 +9787506818803 +9787506819398 +9787506819572 +9787506819626 +9787506821667 +9787506821681 +9787506821766 +9787506822510 +9787506822541 +9787506822602 +9787506822732 +9787506822879 +9787506822916 +9787506823609 +9787506823661 +9787506823722 +9787506823739 +9787506824545 +9787506824736 +9787506824910 +9787506824965 +9787506824989 +9787506824996 +9787506825177 +9787506825320 +9787506825412 +9787506825894 +9787506826266 +9787506826297 +9787506826518 +9787506827003 +9787506827027 +9787506827041 +9787506827720 +9787506828116 +9787506828963 +9787506829175 +9787506829342 +9787506830157 +9787506830195 +9787506830560 +9787506830973 +9787506831895 +9787506832335 +9787506832816 +9787506833035 +9787506833561 +9787506833615 +9787506833721 +9787506833752 +9787506834063 +9787506834797 +9787506835190 +9787506835503 +9787506836180 +9787506836203 +9787506836210 +9787506836241 +9787506836258 +9787506836272 +9787506836296 +9787506836326 +9787506836340 +9787506836371 +9787506836463 +9787506836531 +9787506836692 +9787506836821 +9787506837187 +9787506837491 +9787506837514 +9787506837583 +9787506838344 +9787506838351 +9787506839006 +9787506839426 +9787506839471 +9787506839488 +9787506839839 +9787506839846 +9787506839884 +9787506839969 +9787506840033 +9787506840095 +9787506840439 +9787506840606 +9787506841405 +9787506841412 +9787506842082 +9787506842273 +9787506843119 +9787506843249 +9787506843461 +9787506843737 +9787506844178 +9787506844680 +9787506844888 +9787506845397 +9787506845434 +9787506845618 +9787506845922 +9787506846394 +9787506846448 +9787506846592 +9787506847025 +9787506847056 +9787506847155 +9787506847360 +9787506847391 +9787506847407 +9787506847438 +9787506847568 +9787506848176 +9787506849364 +9787506850261 +9787506850810 +9787506851855 +9787506852142 +9787506852159 +9787506852647 +9787506852661 +9787506852678 +9787506853194 +9787506853484 +9787506853750 +9787506854900 +9787506855419 +9787506855914 +9787506856669 +9787506856980 +9787506857000 +9787506857062 +9787506857239 +9787506857246 +9787506857802 +9787506858076 +9787506858243 +9787506858953 +9787506859288 +9787506859882 +9787506860314 +9787506860475 +9787506860536 +9787506860574 +9787506860611 +9787506860628 +9787506860819 +9787506861243 +9787506862943 +9787506862950 +9787506865456 +9787506865531 +9787506865968 +9787506866552 +9787506866996 +9787506867719 +9787506867863 +9787506868259 +9787506868655 +9787506868884 +9787506869805 +9787506870337 +9787506871006 +9787506871235 +9787506871273 +9787506871280 +9787506871662 +9787506871747 +9787506872058 +9787506872188 +9787506872379 +9787506872553 +9787506872799 +9787506872836 +9787506872874 +9787506872911 +9787506873321 +9787506873857 +9787506874809 +9787506874991 +9787506875288 +9787506875370 +9787506876865 +9787506876889 +9787506876919 +9787506876988 +9787506878296 +9787506878456 +9787506879057 +9787506879637 +9787506880633 +9787506880985 +9787506881623 +9787506882323 +9787506882675 +9787506883009 +9787506883122 +9787506883764 +9787506883993 +9787506884433 +9787506884525 +9787506884648 +9787506884976 +9787506886024 +9787506886383 +9787506886598 +9787506887410 +9787506888035 +9787506888080 +9787506888110 +9787506888165 +9787506888202 +9787506888387 +9787506888493 +9787506888578 +9787506888660 +9787506889094 +9787506889452 +9787506889490 +9787506889605 +9787506890328 +9787506890373 +9787506890694 +9787506890717 +9787506892209 +9787506893008 +9787506893428 +9787506893596 +9787506893725 +9787506894036 +9787506894289 +9787506894319 +9787506894371 +9787506894425 +9787506894661 +9787506894678 +9787506894715 +9787506894906 +9787506895262 +9787506895415 +9787506896207 +9787506897334 +9787506897471 +9787506897549 +9787506897860 +9787506898386 +9787506898621 +9787506899147 +9787506899741 +9787506899765 +9787506900478 +9787506900614 +9787506900812 +9787506900829 +9787506900874 +9787506900881 +9787506900898 +9787506901086 +9787506901208 +9787506901284 +9787506901536 +9787506901659 +9787506901697 +9787506901819 +9787506902007 +9787506902014 +9787506902021 +9787506902182 +9787507000115 +9787507100655 +9787507100716 +9787507100938 +9787507101201 +9787507101270 +9787507101454 +9787507101515 +9787507101546 +9787507101638 +9787507101744 +9787507101850 +9787507102093 +9787507102147 +9787507102314 +9787507102376 +9787507102383 +9787507102406 +9787507102413 +9787507102451 +9787507102550 +9787507102628 +9787507102727 +9787507102802 +9787507102895 +9787507102987 +9787507103199 +9787507103229 +9787507103250 +9787507103281 +9787507103342 +9787507103588 +9787507103892 +9787507103915 +9787507103922 +9787507103939 +9787507104080 +9787507104110 +9787507104158 +9787507104219 +9787507104226 +9787507104264 +9787507104271 +9787507104288 +9787507104295 +9787507104301 +9787507104387 +9787507104394 +9787507104400 +9787507104561 +9787507104714 +9787507104783 +9787507104813 +9787507104851 +9787507104868 +9787507104882 +9787507104950 +9787507104974 +9787507105124 +9787507105131 +9787507105292 +9787507105391 +9787507105407 +9787507105414 +9787507105483 +9787507105667 +9787507105827 +9787507105858 +9787507105865 +9787507105889 +9787507105896 +9787507105902 +9787507105964 +9787507115192 +9787507125962 +9787507125993 +9787507126389 +9787507126396 +9787507126662 +9787507136975 +9787507137330 +9787507200645 +9787507200959 +9787507201161 +9787507201178 +9787507201444 +9787507201451 +9787507201468 +9787507201499 +9787507201505 +9787507201529 +9787507201543 +9787507201550 +9787507201567 +9787507201574 +9787507201703 +9787507201949 +9787507201994 +9787507202021 +9787507202199 +9787507202212 +9787507202236 +9787507202267 +9787507202311 +9787507202342 +9787507203080 +9787507203097 +9787507203165 +9787507203196 +9787507203202 +9787507203219 +9787507203356 +9787507203639 +9787507204094 +9787507204285 +9787507204834 +9787507205008 +9787507205091 +9787507205350 +9787507205626 +9787507205640 +9787507205664 +9787507205671 +9787507205688 +9787507205855 +9787507205985 +9787507206005 +9787507206012 +9787507206159 +9787507206173 +9787507206470 +9787507206722 +9787507206814 +9787507206845 +9787507206944 +9787507207019 +9787507207262 +9787507207347 +9787507207422 +9787507207477 +9787507207514 +9787507207545 +9787507207729 +9787507207750 +9787507207767 +9787507207798 +9787507207804 +9787507207941 +9787507207996 +9787507208016 +9787507208030 +9787507208054 +9787507208160 +9787507208207 +9787507208214 +9787507208221 +9787507208245 +9787507208252 +9787507208320 +9787507208337 +9787507208344 +9787507208351 +9787507208368 +9787507208375 +9787507208443 +9787507208498 +9787507208504 +9787507208542 +9787507208559 +9787507208566 +9787507208597 +9787507208689 +9787507208849 +9787507208900 +9787507208917 +9787507208924 +9787507208955 +9787507208979 +9787507209082 +9787507209143 +9787507209259 +9787507209280 +9787507209341 +9787507209358 +9787507209365 +9787507209372 +9787507209433 +9787507209464 +9787507209471 +9787507209488 +9787507209518 +9787507209617 +9787507209662 +9787507209709 +9787507210095 +9787507210217 +9787507210231 +9787507210262 +9787507210286 +9787507210392 +9787507210415 +9787507210422 +9787507210453 +9787507210569 +9787507210606 +9787507210637 +9787507210668 +9787507210675 +9787507210750 +9787507210774 +9787507211009 +9787507211023 +9787507211306 +9787507211382 +9787507211818 +9787507211825 +9787507211887 +9787507211979 +9787507211986 +9787507212075 +9787507212082 +9787507212143 +9787507212396 +9787507212983 +9787507213058 +9787507213706 +9787507213805 +9787507214246 +9787507214253 +9787507214338 +9787507214802 +9787507215120 +9787507215397 +9787507215717 +9787507215724 +9787507215779 +9787507216288 +9787507216479 +9787507216578 +9787507216592 +9787507216622 +9787507217124 +9787507218213 +9787507218268 +9787507218404 +9787507218428 +9787507218541 +9787507218619 +9787507218756 +9787507218992 +9787507219289 +9787507219357 +9787507219470 +9787507219708 +9787507219722 +9787507219883 +9787507219890 +9787507220070 +9787507220162 +9787507220261 +9787507220353 +9787507220513 +9787507221046 +9787507221084 +9787507221183 +9787507221213 +9787507221527 +9787507221558 +9787507221787 +9787507222012 +9787507222074 +9787507222128 +9787507222135 +9787507222364 +9787507222968 +9787507223316 +9787507223347 +9787507223361 +9787507223439 +9787507223545 +9787507223569 +9787507223682 +9787507223705 +9787507224153 +9787507224535 +9787507224832 +9787507224849 +9787507224856 +9787507224917 +9787507225020 +9787507225099 +9787507225327 +9787507225372 +9787507225389 +9787507225587 +9787507225617 +9787507225624 +9787507225631 +9787507225655 +9787507225754 +9787507225983 +9787507226126 +9787507226195 +9787507226355 +9787507226409 +9787507226607 +9787507226621 +9787507226775 +9787507226843 +9787507226881 +9787507226980 +9787507227017 +9787507227147 +9787507227253 +9787507227277 +9787507227390 +9787507227437 +9787507227451 +9787507227642 +9787507227734 +9787507227741 +9787507227857 +9787507227925 +9787507227932 +9787507228106 +9787507228311 +9787507228335 +9787507228441 +9787507228465 +9787507228571 +9787507228595 +9787507228601 +9787507228632 +9787507228694 +9787507228731 +9787507228748 +9787507228861 +9787507228892 +9787507228908 +9787507228915 +9787507228922 +9787507228939 +9787507228991 +9787507229004 +9787507229035 +9787507229042 +9787507229066 +9787507229103 +9787507229141 +9787507229158 +9787507229196 +9787507229240 +9787507229257 +9787507229448 +9787507229479 +9787507229493 +9787507229516 +9787507229585 +9787507229608 +9787507230024 +9787507230130 +9787507230161 +9787507230208 +9787507230420 +9787507230444 +9787507230529 +9787507230628 +9787507230680 +9787507230734 +9787507230857 +9787507230871 +9787507231007 +9787507231014 +9787507231069 +9787507231120 +9787507231144 +9787507231151 +9787507231250 +9787507231267 +9787507231304 +9787507231359 +9787507231366 +9787507231380 +9787507231465 +9787507231472 +9787507231809 +9787507231847 +9787507231915 +9787507231991 +9787507232035 +9787507232042 +9787507232226 +9787507232257 +9787507232318 +9787507232387 +9787507232455 +9787507232479 +9787507232509 +9787507232639 +9787507232714 +9787507232905 +9787507232950 +9787507232981 +9787507233018 +9787507233100 +9787507233278 +9787507233339 +9787507233605 +9787507233636 +9787507233797 +9787507233865 +9787507233933 +9787507234138 +9787507234329 +9787507234428 +9787507234435 +9787507234459 +9787507234541 +9787507234664 +9787507234992 +9787507235029 +9787507235173 +9787507235326 +9787507235425 +9787507235531 +9787507235616 +9787507235753 +9787507235838 +9787507235876 +9787507236194 +9787507236217 +9787507236224 +9787507236361 +9787507236699 +9787507237078 +9787507237085 +9787507237399 +9787507238143 +9787507300000 +9787507300024 +9787507300031 +9787507300130 +9787507300147 +9787507300161 +9787507300185 +9787507300192 +9787507300208 +9787507300314 +9787507300321 +9787507300338 +9787507300406 +9787507300413 +9787507300451 +9787507300468 +9787507300512 +9787507300536 +9787507300543 +9787507300550 +9787507300604 +9787507300611 +9787507300642 +9787507300703 +9787507300727 +9787507300734 +9787507300741 +9787507300833 +9787507300888 +9787507300918 +9787507300963 +9787507301021 +9787507301175 +9787507301212 +9787507301298 +9787507301359 +9787507301441 +9787507301465 +9787507301519 +9787507301526 +9787507301571 +9787507301588 +9787507301625 +9787507301823 +9787507301984 +9787507302042 +9787507302097 +9787507302158 +9787507302172 +9787507302233 +9787507302301 +9787507302349 +9787507302486 +9787507302493 +9787507302554 +9787507302660 +9787507302691 +9787507302714 +9787507302745 +9787507302929 +9787507302943 +9787507302974 +9787507303025 +9787507303032 +9787507303094 +9787507303117 +9787507303131 +9787507303193 +9787507303216 +9787507303223 +9787507303230 +9787507303315 +9787507303353 +9787507303438 +9787507303629 +9787507303681 +9787507303759 +9787507303858 +9787507303919 +9787507304053 +9787507304060 +9787507304077 +9787507304121 +9787507304138 +9787507304169 +9787507304176 +9787507304299 +9787507304305 +9787507304381 +9787507304435 +9787507304527 +9787507304534 +9787507304565 +9787507304596 +9787507304664 +9787507304718 +9787507304725 +9787507304787 +9787507304824 +9787507304848 +9787507305050 +9787507305197 +9787507305302 +9787507305333 +9787507305371 +9787507305401 +9787507305500 +9787507306095 +9787507306118 +9787507306194 +9787507306705 +9787507306712 +9787507306743 +9787507306804 +9787507306835 +9787507306842 +9787507306880 +9787507306910 +9787507306958 +9787507306972 +9787507307023 +9787507307030 +9787507307085 +9787507307115 +9787507307238 +9787507307252 +9787507307276 +9787507307283 +9787507307443 +9787507307474 +9787507307528 +9787507307559 +9787507307634 +9787507307658 +9787507307702 +9787507307764 +9787507307788 +9787507307849 +9787507308150 +9787507308204 +9787507308280 +9787507308327 +9787507308426 +9787507308631 +9787507308662 +9787507308679 +9787507308846 +9787507308860 +9787507308921 +9787507308952 +9787507309003 +9787507309232 +9787507309287 +9787507309300 +9787507309348 +9787507309447 +9787507309515 +9787507309577 +9787507309591 +9787507309638 +9787507309706 +9787507309737 +9787507309867 +9787507309997 +9787507310016 +9787507310047 +9787507310177 +9787507310344 +9787507310399 +9787507310450 +9787507310542 +9787507310580 +9787507310597 +9787507310696 +9787507310726 +9787507310818 +9787507310962 +9787507311006 +9787507311068 +9787507311075 +9787507311112 +9787507311167 +9787507311235 +9787507311303 +9787507311532 +9787507311617 +9787507311785 +9787507311846 +9787507311884 +9787507312072 +9787507312157 +9787507312317 +9787507312355 +9787507312416 +9787507312430 +9787507312478 +9787507312508 +9787507312683 +9787507312805 +9787507312904 +9787507312973 +9787507312980 +9787507313048 +9787507313116 +9787507313123 +9787507313154 +9787507313215 +9787507313222 +9787507313307 +9787507313338 +9787507313451 +9787507313925 +9787507314052 +9787507314151 +9787507314373 +9787507314465 +9787507314519 +9787507314816 +9787507314823 +9787507314885 +9787507315028 +9787507315066 +9787507315073 +9787507315110 +9787507315127 +9787507315202 +9787507315509 +9787507315707 +9787507315813 +9787507315844 +9787507315875 +9787507315899 +9787507315912 +9787507316155 +9787507316261 +9787507316605 +9787507316704 +9787507316711 +9787507316742 +9787507316933 +9787507316995 +9787507317053 +9787507317220 +9787507317374 +9787507317381 +9787507317527 +9787507317657 +9787507317800 +9787507317848 +9787507317893 +9787507317947 +9787507317961 +9787507317985 +9787507318067 +9787507318098 +9787507318296 +9787507318524 +9787507318562 +9787507318609 +9787507318685 +9787507318753 +9787507318760 +9787507318784 +9787507318845 +9787507318876 +9787507319026 +9787507319057 +9787507319095 +9787507319132 +9787507319231 +9787507319323 +9787507319361 +9787507319408 +9787507319422 +9787507319477 +9787507319590 +9787507319606 +9787507319699 +9787507319842 +9787507319866 +9787507319941 +9787507320015 +9787507320039 +9787507320084 +9787507320220 +9787507320275 +9787507320282 +9787507320312 +9787507320572 +9787507320657 +9787507320695 +9787507320749 +9787507321005 +9787507321067 +9787507321098 +9787507321166 +9787507321258 +9787507321302 +9787507321388 +9787507321487 +9787507321678 +9787507321753 +9787507321760 +9787507321838 +9787507321852 +9787507321982 +9787507322286 +9787507322347 +9787507322361 +9787507322385 +9787507322514 +9787507322552 +9787507322583 +9787507322781 +9787507322828 +9787507322965 +9787507322972 +9787507323184 +9787507323221 +9787507323283 +9787507323351 +9787507323412 +9787507323757 +9787507323795 +9787507323917 +9787507324075 +9787507324136 +9787507324204 +9787507324211 +9787507324266 +9787507324402 +9787507324488 +9787507324556 +9787507324617 +9787507324693 +9787507324709 +9787507324716 +9787507324723 +9787507324785 +9787507324792 +9787507324891 +9787507324907 +9787507324952 +9787507324969 +9787507325027 +9787507325034 +9787507325201 +9787507325256 +9787507325485 +9787507325591 +9787507325621 +9787507325676 +9787507325843 +9787507325966 +9787507326260 +9787507326499 +9787507326505 +9787507326697 +9787507326758 +9787507326772 +9787507327380 +9787507327397 +9787507327403 +9787507327441 +9787507327670 +9787507327724 +9787507327779 +9787507327816 +9787507327915 +9787507327977 +9787507328035 +9787507328103 +9787507328196 +9787507328271 +9787507328400 +9787507328417 +9787507328530 +9787507328684 +9787507328745 +9787507329087 +9787507329230 +9787507329667 +9787507329780 +9787507329827 +9787507329940 +9787507329964 +9787507329988 +9787507330021 +9787507330212 +9787507330410 +9787507330427 +9787507330441 +9787507330526 +9787507330571 +9787507330588 +9787507330663 +9787507330717 +9787507330731 +9787507330748 +9787507330755 +9787507330830 +9787507330847 +9787507330885 +9787507331110 +9787507331158 +9787507331226 +9787507331349 +9787507331387 +9787507331578 +9787507331585 +9787507331592 +9787507331608 +9787507331660 +9787507331677 +9787507331707 +9787507331738 +9787507332179 +9787507332285 +9787507332292 +9787507332353 +9787507332414 +9787507332537 +9787507332612 +9787507332704 +9787507333022 +9787507333039 +9787507333275 +9787507333367 +9787507333466 +9787507333510 +9787507333640 +9787507333725 +9787507333749 +9787507333763 +9787507334098 +9787507334135 +9787507334197 +9787507334388 +9787507334425 +9787507334487 +9787507334562 +9787507334982 +9787507335026 +9787507335071 +9787507335187 +9787507335248 +9787507335262 +9787507335309 +9787507335354 +9787507335378 +9787507335477 +9787507335576 +9787507335637 +9787507335767 +9787507335958 +9787507335989 +9787507336160 +9787507336214 +9787507336306 +9787507336399 +9787507336443 +9787507336818 +9787507337082 +9787507337303 +9787507337471 +9787507337488 +9787507337525 +9787507337907 +9787507338003 +9787507338133 +9787507338218 +9787507338324 +9787507338454 +9787507338560 +9787507338683 +9787507338843 +9787507338881 +9787507339017 +9787507339130 +9787507339178 +9787507339277 +9787507339451 +9787507339505 +9787507339659 +9787507339673 +9787507339956 +9787507340013 +9787507340075 +9787507340082 +9787507340525 +9787507340594 +9787507340600 +9787507340808 +9787507340884 +9787507340907 +9787507340914 +9787507341034 +9787507341089 +9787507341096 +9787507341126 +9787507341171 +9787507341232 +9787507341409 +9787507341485 +9787507341683 +9787507341768 +9787507341799 +9787507341805 +9787507341812 +9787507341898 +9787507342079 +9787507342154 +9787507342208 +9787507342369 +9787507342550 +9787507342659 +9787507342697 +9787507342710 +9787507342765 +9787507342949 +9787507342987 +9787507343007 +9787507343014 +9787507343205 +9787507343342 +9787507343564 +9787507344011 +9787507344028 +9787507344035 +9787507344356 +9787507344493 +9787507344530 +9787507344615 +9787507344677 +9787507344790 +9787507344813 +9787507344882 +9787507344929 +9787507345070 +9787507345407 +9787507345414 +9787507345421 +9787507345551 +9787507345704 +9787507345711 +9787507345810 +9787507345827 +9787507345841 +9787507345889 +9787507345940 +9787507345957 +9787507345971 +9787507345995 +9787507346008 +9787507346275 +9787507346282 +9787507346299 +9787507346312 +9787507346343 +9787507346350 +9787507346558 +9787507346602 +9787507346848 +9787507346916 +9787507347029 +9787507347074 +9787507347081 +9787507347135 +9787507347180 +9787507347197 +9787507347319 +9787507347326 +9787507347425 +9787507347432 +9787507347449 +9787507347500 +9787507347555 +9787507347579 +9787507347616 +9787507347692 +9787507347753 +9787507347814 +9787507348101 +9787507348149 +9787507348156 +9787507348163 +9787507348200 +9787507348279 +9787507348347 +9787507348361 +9787507348422 +9787507348491 +9787507348507 +9787507348613 +9787507348736 +9787507348743 +9787507348866 +9787507348903 +9787507348965 +9787507348996 +9787507349047 +9787507349054 +9787507349115 +9787507349122 +9787507349146 +9787507349313 +9787507349337 +9787507349375 +9787507349382 +9787507349436 +9787507349474 +9787507349511 +9787507349542 +9787507349559 +9787507349566 +9787507349597 +9787507349610 +9787507349627 +9787507349689 +9787507349696 +9787507349719 +9787507349733 +9787507349740 +9787507349801 +9787507349818 +9787507349832 +9787507349849 +9787507349856 +9787507349863 +9787507349887 +9787507349900 +9787507349931 +9787507350005 +9787507350111 +9787507350128 +9787507350142 +9787507350197 +9787507350265 +9787507350296 +9787507350326 +9787507350395 +9787507350418 +9787507350463 +9787507350470 +9787507350548 +9787507350616 +9787507350623 +9787507350753 +9787507350807 +9787507350838 +9787507350845 +9787507400496 +9787507400809 +9787507401004 +9787507401028 +9787507401288 +9787507401646 +9787507401905 +9787507402124 +9787507402728 +9787507402803 +9787507403350 +9787507403695 +9787507403763 +9787507404265 +9787507404432 +9787507404517 +9787507405613 +9787507406016 +9787507407006 +9787507407013 +9787507407204 +9787507407273 +9787507407464 +9787507407587 +9787507407662 +9787507407679 +9787507407693 +9787507407754 +9787507407839 +9787507408027 +9787507408218 +9787507408355 +9787507408546 +9787507408775 +9787507408904 +9787507409031 +9787507409055 +9787507409123 +9787507409246 +9787507409345 +9787507409475 +9787507409581 +9787507409642 +9787507409765 +9787507409796 +9787507409840 +9787507409895 +9787507410013 +9787507410099 +9787507410105 +9787507410129 +9787507410136 +9787507410204 +9787507410235 +9787507410372 +9787507410488 +9787507410563 +9787507410587 +9787507410624 +9787507410631 +9787507410693 +9787507410747 +9787507410822 +9787507410884 +9787507410891 +9787507410990 +9787507411126 +9787507411195 +9787507411249 +9787507411331 +9787507411355 +9787507411393 +9787507411454 +9787507411546 +9787507411645 +9787507411683 +9787507411799 +9787507411867 +9787507412048 +9787507412062 +9787507412116 +9787507412222 +9787507412369 +9787507412420 +9787507412840 +9787507412918 +9787507412925 +9787507412994 +9787507413649 +9787507413700 +9787507413953 +9787507413977 +9787507414042 +9787507414134 +9787507414363 +9787507414455 +9787507414462 +9787507414608 +9787507414707 +9787507414714 +9787507414752 +9787507414813 +9787507414820 +9787507414844 +9787507414875 +9787507414950 +9787507415063 +9787507415094 +9787507415124 +9787507415285 +9787507415322 +9787507415391 +9787507415407 +9787507415438 +9787507415551 +9787507415674 +9787507415742 +9787507415995 +9787507416053 +9787507416091 +9787507416145 +9787507416282 +9787507416343 +9787507416381 +9787507416534 +9787507416558 +9787507416589 +9787507416633 +9787507416848 +9787507416855 +9787507416909 +9787507416947 +9787507417203 +9787507417326 +9787507417463 +9787507417647 +9787507417654 +9787507417661 +9787507417739 +9787507417876 +9787507417906 +9787507417951 +9787507417968 +9787507418163 +9787507418262 +9787507418323 +9787507418415 +9787507418545 +9787507418569 +9787507418651 +9787507418736 +9787507418897 +9787507418934 +9787507418972 +9787507419085 +9787507419269 +9787507419290 +9787507419368 +9787507419399 +9787507419467 +9787507419498 +9787507419535 +9787507419597 +9787507419641 +9787507419672 +9787507419726 +9787507419863 +9787507419979 +9787507419993 +9787507420142 +9787507420203 +9787507420227 +9787507420333 +9787507420401 +9787507420661 +9787507420722 +9787507420821 +9787507421026 +9787507421132 +9787507421217 +9787507421224 +9787507421347 +9787507421354 +9787507421507 +9787507421545 +9787507421552 +9787507421583 +9787507421682 +9787507421996 +9787507422009 +9787507422184 +9787507422252 +9787507422269 +9787507422344 +9787507422351 +9787507422399 +9787507422429 +9787507422481 +9787507422597 +9787507422610 +9787507422627 +9787507422849 +9787507422962 +9787507423129 +9787507423150 +9787507423167 +9787507423327 +9787507423334 +9787507423341 +9787507423365 +9787507424058 +9787507424447 +9787507424461 +9787507424614 +9787507424690 +9787507424874 +9787507424997 +9787507425260 +9787507425604 +9787507425741 +9787507425758 +9787507426021 +9787507426236 +9787507426410 +9787507426472 +9787507426625 +9787507426847 +9787507426991 +9787507427257 +9787507427356 +9787507427363 +9787507427585 +9787507427639 +9787507427813 +9787507427875 +9787507427899 +9787507427905 +9787507427929 +9787507428179 +9787507428346 +9787507428391 +9787507428513 +9787507428568 +9787507429367 +9787507429435 +9787507429558 +9787507429565 +9787507429756 +9787507429954 +9787507430400 +9787507431155 +9787507431469 +9787507431711 +9787507432381 +9787507433692 +9787507434682 +9787507434941 +9787507434958 +9787507435023 +9787507435030 +9787507435382 +9787507435399 +9787507435610 +9787507435733 +9787507435863 +9787507435870 +9787507435979 +9787507436129 +9787507436273 +9787507436358 +9787507436594 +9787507436709 +9787507436716 +9787507436761 +9787507436815 +9787507437171 +9787507437300 +9787507437348 +9787507437416 +9787507437492 +9787507500066 +9787507500110 +9787507500134 +9787507500141 +9787507500172 +9787507500189 +9787507500196 +9787507500202 +9787507500219 +9787507500271 +9787507500332 +9787507500349 +9787507500387 +9787507500486 +9787507500509 +9787507500554 +9787507500691 +9787507500721 +9787507500738 +9787507500820 +9787507500936 +9787507501056 +9787507501070 +9787507501131 +9787507501162 +9787507501186 +9787507501339 +9787507501407 +9787507501490 +9787507501520 +9787507501827 +9787507501919 +9787507501933 +9787507501971 +9787507502398 +9787507502411 +9787507502435 +9787507502442 +9787507502473 +9787507502688 +9787507502992 +9787507503036 +9787507503074 +9787507503494 +9787507503739 +9787507503913 +9787507504125 +9787507504149 +9787507504217 +9787507504231 +9787507504248 +9787507504255 +9787507504279 +9787507504286 +9787507504293 +9787507504316 +9787507504323 +9787507504453 +9787507504484 +9787507504514 +9787507504552 +9787507504576 +9787507504712 +9787507504774 +9787507504903 +9787507504972 +9787507505085 +9787507505108 +9787507505139 +9787507505146 +9787507505153 +9787507505177 +9787507505184 +9787507505214 +9787507505399 +9787507505474 +9787507505528 +9787507505603 +9787507505634 +9787507505665 +9787507505696 +9787507505719 +9787507505788 +9787507505795 +9787507505832 +9787507505856 +9787507505863 +9787507505887 +9787507505931 +9787507506082 +9787507506099 +9787507506150 +9787507506211 +9787507506235 +9787507506280 +9787507506358 +9787507506464 +9787507506525 +9787507506594 +9787507506617 +9787507506679 +9787507506693 +9787507506716 +9787507506723 +9787507506747 +9787507506754 +9787507506839 +9787507506945 +9787507506976 +9787507507164 +9787507507171 +9787507507201 +9787507507218 +9787507507249 +9787507507324 +9787507507454 +9787507507522 +9787507507621 +9787507507683 +9787507507737 +9787507507744 +9787507507812 +9787507507829 +9787507507935 +9787507507942 +9787507508055 +9787507508079 +9787507508093 +9787507508185 +9787507508215 +9787507508413 +9787507508468 +9787507508604 +9787507508642 +9787507508857 +9787507508987 +9787507508994 +9787507509007 +9787507509069 +9787507509083 +9787507509274 +9787507509298 +9787507509403 +9787507509502 +9787507509779 +9787507509809 +9787507509892 +9787507509960 +9787507509977 +9787507510089 +9787507510232 +9787507510270 +9787507510430 +9787507510652 +9787507510676 +9787507510713 +9787507510836 +9787507510874 +9787507511017 +9787507511079 +9787507511130 +9787507511154 +9787507511161 +9787507511239 +9787507511253 +9787507511383 +9787507511413 +9787507511420 +9787507511482 +9787507511529 +9787507511802 +9787507511826 +9787507511840 +9787507511932 +9787507512069 +9787507512250 +9787507512281 +9787507512298 +9787507512304 +9787507512342 +9787507512373 +9787507512458 +9787507512472 +9787507512519 +9787507512564 +9787507512649 +9787507512908 +9787507513028 +9787507513042 +9787507513059 +9787507513097 +9787507513127 +9787507513141 +9787507513301 +9787507513332 +9787507513400 +9787507513424 +9787507513523 +9787507513592 +9787507513608 +9787507513707 +9787507513714 +9787507513721 +9787507513745 +9787507513912 +9787507513967 +9787507514025 +9787507514032 +9787507514087 +9787507514353 +9787507514407 +9787507514438 +9787507514445 +9787507514452 +9787507514544 +9787507514636 +9787507514711 +9787507514728 +9787507514803 +9787507514810 +9787507514933 +9787507515077 +9787507515244 +9787507515299 +9787507515367 +9787507515442 +9787507515466 +9787507515589 +9787507515640 +9787507515725 +9787507515916 +9787507515992 +9787507516012 +9787507516197 +9787507516234 +9787507516401 +9787507516418 +9787507516470 +9787507516678 +9787507516685 +9787507516807 +9787507516821 +9787507517163 +9787507517194 +9787507517224 +9787507517262 +9787507517354 +9787507517361 +9787507517415 +9787507517446 +9787507517460 +9787507517583 +9787507517590 +9787507517606 +9787507517644 +9787507518085 +9787507518092 +9787507518207 +9787507518245 +9787507518283 +9787507518344 +9787507518443 +9787507518498 +9787507518511 +9787507518603 +9787507518726 +9787507518733 +9787507518788 +9787507518955 +9787507518979 +9787507518986 +9787507519068 +9787507519174 +9787507519440 +9787507519457 +9787507519532 +9787507519747 +9787507519754 +9787507519761 +9787507519853 +9787507519860 +9787507519945 +9787507519990 +9787507520187 +9787507520231 +9787507520248 +9787507520262 +9787507520316 +9787507520521 +9787507520651 +9787507520682 +9787507520774 +9787507521009 +9787507521030 +9787507521078 +9787507521085 +9787507521115 +9787507521238 +9787507521283 +9787507521405 +9787507521511 +9787507521528 +9787507521696 +9787507522112 +9787507522143 +9787507522211 +9787507522266 +9787507522341 +9787507522457 +9787507522525 +9787507522600 +9787507522655 +9787507522723 +9787507522860 +9787507522914 +9787507523034 +9787507523058 +9787507523089 +9787507523164 +9787507523256 +9787507523287 +9787507523362 +9787507523416 +9787507523447 +9787507523485 +9787507523522 +9787507523539 +9787507523553 +9787507523584 +9787507523737 +9787507523782 +9787507523805 +9787507523812 +9787507523959 +9787507523973 +9787507524055 +9787507524369 +9787507524376 +9787507524413 +9787507524482 +9787507524505 +9787507524536 +9787507524642 +9787507524826 +9787507524949 +9787507524963 +9787507524970 +9787507525335 +9787507525526 +9787507525564 +9787507525618 +9787507525663 +9787507525748 +9787507525809 +9787507525847 +9787507525878 +9787507525984 +9787507526042 +9787507526097 +9787507526325 +9787507526400 +9787507526486 +9787507526554 +9787507526561 +9787507526585 +9787507526684 +9787507526691 +9787507526738 +9787507526844 +9787507526936 +9787507526950 +9787507527032 +9787507527087 +9787507527124 +9787507527308 +9787507527360 +9787507527490 +9787507527599 +9787507527605 +9787507527612 +9787507527728 +9787507527735 +9787507528039 +9787507528282 +9787507528367 +9787507528398 +9787507528404 +9787507528411 +9787507528459 +9787507528671 +9787507528923 +9787507529012 +9787507529104 +9787507529234 +9787507529326 +9787507529340 +9787507529357 +9787507529517 +9787507529999 +9787507530124 +9787507530155 +9787507530216 +9787507530315 +9787507530339 +9787507530384 +9787507530483 +9787507530513 +9787507531077 +9787507531299 +9787507531381 +9787507531602 +9787507531640 +9787507531688 +9787507531800 +9787507531831 +9787507532029 +9787507532142 +9787507532371 +9787507532395 +9787507532425 +9787507532463 +9787507532531 +9787507532678 +9787507532753 +9787507532760 +9787507533064 +9787507533439 +9787507533804 +9787507533873 +9787507534009 +9787507534436 +9787507534603 +9787507534832 +9787507535181 +9787507535341 +9787507535358 +9787507535365 +9787507535372 +9787507535846 +9787507536089 +9787507536300 +9787507536416 +9787507536522 +9787507536553 +9787507536645 +9787507536690 +9787507537291 +9787507537338 +9787507537659 +9787507538267 +9787507538274 +9787507538281 +9787507538311 +9787507538502 +9787507538519 +9787507538700 +9787507538717 +9787507539035 +9787507539073 +9787507539196 +9787507539431 +9787507539592 +9787507539707 +9787507539868 +9787507539967 +9787507540239 +9787507540505 +9787507540567 +9787507540734 +9787507540796 +9787507541052 +9787507541267 +9787507541274 +9787507541335 +9787507541601 +9787507541694 +9787507541915 +9787507541939 +9787507541953 +9787507542103 +9787507542448 +9787507542738 +9787507542752 +9787507542813 +9787507543001 +9787507543063 +9787507543186 +9787507543209 +9787507543568 +9787507543629 +9787507544206 +9787507544282 +9787507544404 +9787507544909 +9787507544916 +9787507544923 +9787507545142 +9787507545203 +9787507545579 +9787507545593 +9787507545746 +9787507545838 +9787507545845 +9787507545876 +9787507545937 +9787507545944 +9787507546071 +9787507546088 +9787507546620 +9787507546644 +9787507546705 +9787507546798 +9787507546811 +9787507547085 +9787507547108 +9787507547665 +9787507547689 +9787507548068 +9787507548211 +9787507548402 +9787507548419 +9787507548761 +9787507548990 +9787507549454 +9787507550481 +9787507550634 +9787507550993 +9787507551129 +9787507551426 +9787507551501 +9787507551655 +9787507551952 +9787507552027 +9787507552409 +9787507552416 +9787507552959 +9787507553031 +9787507553093 +9787507553260 +9787507553277 +9787507553703 +9787507553833 +9787507554175 +9787507554380 +9787507554410 +9787507554465 +9787507554489 +9787507554519 +9787507554618 +9787507554632 +9787507555165 +9787507555448 +9787507555653 +9787507556094 +9787507556278 +9787507556315 +9787507556322 +9787507556612 +9787507556735 +9787507556810 +9787507556889 +9787507556940 +9787507557008 +9787507557121 +9787507557169 +9787507557305 +9787507557329 +9787507557695 +9787507557701 +9787507557909 +9787507557954 +9787507558296 +9787507558364 +9787507558388 +9787507558401 +9787507558418 +9787507558449 +9787507558470 +9787507558487 +9787507558821 +9787507558876 +9787507558890 +9787507558906 +9787507558944 +9787507558999 +9787507559019 +9787507559040 +9787507559057 +9787507559064 +9787507559095 +9787507559118 +9787507559149 +9787507559156 +9787507559309 +9787507559330 +9787507559354 +9787507559422 +9787507559446 +9787507559545 +9787507559552 +9787507559576 +9787507559651 +9787507559750 +9787507559767 +9787507559828 +9787507559941 +9787507560077 +9787507560220 +9787507560282 +9787507560336 +9787507560435 +9787507560459 +9787507560497 +9787507560503 +9787507560527 +9787507560916 +9787507560923 +9787507560930 +9787507561654 +9787507600766 +9787507600797 +9787507600858 +9787507601039 +9787507601077 +9787507601459 +9787507601480 +9787507601527 +9787507601619 +9787507601671 +9787507601770 +9787507601817 +9787507601992 +9787507602029 +9787507602036 +9787507602180 +9787507602197 +9787507602319 +9787507602494 +9787507602548 +9787507602609 +9787507602630 +9787507602746 +9787507602937 +9787507603040 +9787507603224 +9787507603361 +9787507700015 +9787507700336 +9787507700480 +9787507700497 +9787507700633 +9787507700824 +9787507701302 +9787507701487 +9787507701579 +9787507701586 +9787507701708 +9787507701746 +9787507701845 +9787507701869 +9787507701876 +9787507701913 +9787507701944 +9787507702255 +9787507702279 +9787507702293 +9787507702415 +9787507702453 +9787507702569 +9787507702590 +9787507703184 +9787507703207 +9787507703375 +9787507703467 +9787507703634 +9787507703818 +9787507703825 +9787507703917 +9787507703924 +9787507703931 +9787507704013 +9787507704150 +9787507704211 +9787507704303 +9787507704457 +9787507704501 +9787507704709 +9787507704730 +9787507704785 +9787507704884 +9787507705188 +9787507705201 +9787507705300 +9787507705386 +9787507705478 +9787507705584 +9787507705973 +9787507706024 +9787507706352 +9787507706376 +9787507706383 +9787507706406 +9787507706680 +9787507706697 +9787507706987 +9787507706994 +9787507707083 +9787507707465 +9787507707489 +9787507707625 +9787507707694 +9787507707892 +9787507708073 +9787507708165 +9787507708295 +9787507708431 +9787507708592 +9787507708615 +9787507708622 +9787507708660 +9787507708691 +9787507708707 +9787507708752 +9787507708820 +9787507708899 +9787507709278 +9787507709285 +9787507709438 +9787507709452 +9787507709469 +9787507709568 +9787507709605 +9787507709704 +9787507709742 +9787507709858 +9787507709865 +9787507709902 +9787507710014 +9787507710120 +9787507710212 +9787507710243 +9787507710250 +9787507710267 +9787507710403 +9787507710557 +9787507710748 +9787507710755 +9787507710762 +9787507710953 +9787507710960 +9787507711073 +9787507711080 +9787507711103 +9787507711271 +9787507711387 +9787507711400 +9787507711462 +9787507711523 +9787507711547 +9787507711554 +9787507711646 +9787507711707 +9787507711714 +9787507711745 +9787507711752 +9787507711936 +9787507711974 +9787507712025 +9787507712278 +9787507712322 +9787507712636 +9787507712643 +9787507712667 +9787507712681 +9787507712858 +9787507712902 +9787507712926 +9787507712988 +9787507713138 +9787507713152 +9787507713169 +9787507713237 +9787507713244 +9787507713404 +9787507713473 +9787507713558 +9787507713787 +9787507713879 +9787507713886 +9787507713947 +9787507714005 +9787507714173 +9787507714449 +9787507714463 +9787507714647 +9787507714678 +9787507714739 +9787507714944 +9787507714951 +9787507715088 +9787507715125 +9787507715149 +9787507715156 +9787507715187 +9787507715194 +9787507715200 +9787507715217 +9787507715224 +9787507715231 +9787507715279 +9787507715316 +9787507715323 +9787507715422 +9787507715521 +9787507715736 +9787507715781 +9787507715842 +9787507715880 +9787507716023 +9787507716139 +9787507716269 +9787507716580 +9787507716757 +9787507716788 +9787507716955 +9787507716962 +9787507717006 +9787507717211 +9787507717235 +9787507717440 +9787507718126 +9787507718225 +9787507718232 +9787507718256 +9787507718287 +9787507718331 +9787507718423 +9787507718676 +9787507718805 +9787507718904 +9787507719185 +9787507719192 +9787507719215 +9787507719307 +9787507719321 +9787507719369 +9787507719390 +9787507719406 +9787507719482 +9787507719499 +9787507719765 +9787507719819 +9787507719826 +9787507720037 +9787507720051 +9787507720242 +9787507720389 +9787507720396 +9787507720457 +9787507720525 +9787507720532 +9787507720556 +9787507720587 +9787507720600 +9787507720808 +9787507720839 +9787507720846 +9787507720853 +9787507720891 +9787507721003 +9787507721324 +9787507721331 +9787507721539 +9787507721621 +9787507721652 +9787507721706 +9787507721799 +9787507721911 +9787507721973 +9787507722185 +9787507722321 +9787507722420 +9787507722512 +9787507722833 +9787507722857 +9787507722895 +9787507722949 +9787507722987 +9787507723090 +9787507723311 +9787507723328 +9787507723410 +9787507723472 +9787507723519 +9787507723656 +9787507723915 +9787507724011 +9787507724721 +9787507724745 +9787507725001 +9787507725087 +9787507725223 +9787507725773 +9787507725919 +9787507725933 +9787507725957 +9787507726077 +9787507726107 +9787507726121 +9787507726138 +9787507726145 +9787507726152 +9787507726169 +9787507726350 +9787507726428 +9787507726442 +9787507726466 +9787507726480 +9787507726510 +9787507726633 +9787507726657 +9787507726725 +9787507726732 +9787507727005 +9787507727050 +9787507727425 +9787507727432 +9787507727562 +9787507728040 +9787507728064 +9787507728101 +9787507728118 +9787507728156 +9787507728361 +9787507728453 +9787507728583 +9787507728590 +9787507729146 +9787507729184 +9787507729252 +9787507729306 +9787507729320 +9787507729528 +9787507729542 +9787507729702 +9787507729788 +9787507729818 +9787507731088 +9787507731309 +9787507731620 +9787507731910 +9787507731965 +9787507731996 +9787507732023 +9787507732061 +9787507732351 +9787507732580 +9787507732610 +9787507732658 +9787507732788 +9787507733174 +9787507733303 +9787507733327 +9787507733495 +9787507733631 +9787507733648 +9787507733921 +9787507734324 +9787507734362 +9787507734768 +9787507734775 +9787507734843 +9787507735031 +9787507735253 +9787507736182 +9787507736380 +9787507736427 +9787507736632 +9787507737516 +9787507737646 +9787507737776 +9787507737790 +9787507738193 +9787507738339 +9787507738490 +9787507738551 +9787507738995 +9787507739206 +9787507739251 +9787507739411 +9787507739565 +9787507739671 +9787507739909 +9787507739947 +9787507739954 +9787507739985 +9787507740059 +9787507740226 +9787507740868 +9787507741018 +9787507741469 +9787507741483 +9787507741612 +9787507741629 +9787507741759 +9787507741919 +9787507742169 +9787507742343 +9787507742442 +9787507742480 +9787507742664 +9787507742817 +9787507743302 +9787507743333 +9787507743463 +9787507743890 +9787507744125 +9787507744576 +9787507744750 +9787507744804 +9787507744941 +9787507745139 +9787507745184 +9787507745467 +9787507745498 +9787507745924 +9787507746273 +9787507746334 +9787507746358 +9787507746693 +9787507746716 +9787507746983 +9787507747003 +9787507747140 +9787507747249 +9787507747539 +9787507747713 +9787507747744 +9787507747829 +9787507748109 +9787507748253 +9787507748406 +9787507748437 +9787507748451 +9787507748505 +9787507748512 +9787507748598 +9787507748659 +9787507748956 +9787507749175 +9787507749243 +9787507749267 +9787507749434 +9787507749465 +9787507749557 +9787507749588 +9787507749816 +9787507749946 +9787507750010 +9787507750157 +9787507750188 +9787507750355 +9787507750409 +9787507750416 +9787507750522 +9787507750713 +9787507750881 +9787507750973 +9787507751000 +9787507751505 +9787507751697 +9787507751710 +9787507752021 +9787507752090 +9787507752182 +9787507752335 +9787507752588 +9787507752656 +9787507753097 +9787507753240 +9787507753349 +9787507753844 +9787507754254 +9787507754285 +9787507754377 +9787507755237 +9787507755381 +9787507755619 +9787507755664 +9787507755695 +9787507755817 +9787507756791 +9787507756890 +9787507756968 +9787507757132 +9787507758085 +9787507758092 +9787507758108 +9787507758337 +9787507758566 +9787507758573 +9787507758719 +9787507758740 +9787507758832 +9787507758900 +9787507758931 +9787507759044 +9787507759150 +9787507759303 +9787507759372 +9787507759549 +9787507759693 +9787507759983 +9787507760071 +9787507760125 +9787507760736 +9787507760804 +9787507760897 +9787507760958 +9787507761276 +9787507761351 +9787507761887 +9787507762105 +9787507762129 +9787507762143 +9787507762273 +9787507762372 +9787507762419 +9787507762556 +9787507762730 +9787507762846 +9787507763768 +9787507764437 +9787507764499 +9787507764666 +9787507764734 +9787507764857 +9787507764918 +9787507765199 +9787507765229 +9787507765823 +9787507765908 +9787507765915 +9787507766127 +9787507766295 +9787507766356 +9787507766363 +9787507766370 +9787507766431 +9787507766448 +9787507766455 +9787507766738 +9787507767001 +9787507767216 +9787507767308 +9787507767445 +9787507767476 +9787507767544 +9787507767599 +9787507767759 +9787507767964 +9787507767995 +9787507768237 +9787507768503 +9787507768527 +9787507768633 +9787507768718 +9787507769005 +9787507769098 +9787507769111 +9787507769173 +9787507769357 +9787507769449 +9787507769531 +9787507769630 +9787507769678 +9787507769869 +9787507770018 +9787507770155 +9787507770421 +9787507770476 +9787507770728 +9787507771343 +9787507780123 +9787507800142 +9787507800166 +9787507800647 +9787507800685 +9787507800746 +9787507801156 +9787507801637 +9787507801682 +9787507801897 +9787507802917 +9787507803013 +9787507803181 +9787507803464 +9787507803648 +9787507803853 +9787507803860 +9787507803891 +9787507804171 +9787507804485 +9787507804690 +9787507804713 +9787507804768 +9787507804829 +9787507804928 +9787507804966 +9787507805079 +9787507805390 +9787507805413 +9787507805659 +9787507805727 +9787507805765 +9787507806038 +9787507806137 +9787507806298 +9787507806519 +9787507806724 +9787507807110 +9787507807257 +9787507808063 +9787507808162 +9787507808940 +9787507809572 +9787507809626 +9787507809732 +9787507810011 +9787507810134 +9787507810325 +9787507810585 +9787507810608 +9787507810646 +9787507810721 +9787507810929 +9787507811261 +9787507811308 +9787507811803 +9787507811957 +9787507811988 +9787507811995 +9787507812015 +9787507812022 +9787507812039 +9787507812060 +9787507812589 +9787507813111 +9787507813173 +9787507813180 +9787507813227 +9787507813432 +9787507813555 +9787507813678 +9787507814064 +9787507814613 +9787507814644 +9787507814705 +9787507814828 +9787507814842 +9787507814859 +9787507814934 +9787507815399 +9787507815498 +9787507815634 +9787507815641 +9787507815733 +9787507815917 +9787507815931 +9787507816266 +9787507816280 +9787507816303 +9787507816334 +9787507816365 +9787507816372 +9787507816617 +9787507816785 +9787507817003 +9787507817027 +9787507817164 +9787507817232 +9787507817300 +9787507817324 +9787507817386 +9787507817539 +9787507817607 +9787507817621 +9787507817881 +9787507817973 +9787507818352 +9787507818406 +9787507818475 +9787507818505 +9787507818567 +9787507818666 +9787507818949 +9787507818987 +9787507819113 +9787507819182 +9787507819212 +9787507819380 +9787507819540 +9787507819571 +9787507819670 +9787507820058 +9787507820065 +9787507820133 +9787507820140 +9787507820539 +9787507820850 +9787507821093 +9787507821215 +9787507821314 +9787507821505 +9787507821611 +9787507821628 +9787507821673 +9787507821833 +9787507821925 +9787507822014 +9787507822359 +9787507822601 +9787507823158 +9787507823240 +9787507823288 +9787507823431 +9787507823448 +9787507823653 +9787507823660 +9787507823837 +9787507823950 +9787507824230 +9787507824551 +9787507824599 +9787507824780 +9787507824827 +9787507824926 +9787507824933 +9787507824940 +9787507824957 +9787507825626 +9787507825640 +9787507825657 +9787507825756 +9787507826029 +9787507826210 +9787507826449 +9787507826463 +9787507826517 +9787507826562 +9787507826654 +9787507826807 +9787507826821 +9787507827064 +9787507827095 +9787507827170 +9787507827187 +9787507827248 +9787507827262 +9787507827323 +9787507827330 +9787507827712 +9787507827811 +9787507828047 +9787507828078 +9787507828085 +9787507828580 +9787507828603 +9787507828696 +9787507828788 +9787507829464 +9787507829501 +9787507829525 +9787507829938 +9787507830071 +9787507830118 +9787507830125 +9787507830149 +9787507830378 +9787507830729 +9787507830972 +9787507831429 +9787507831436 +9787507831474 +9787507831481 +9787507831504 +9787507831566 +9787507831924 +9787507832273 +9787507832372 +9787507832891 +9787507832921 +9787507833126 +9787507833256 +9787507833621 +9787507833690 +9787507833805 +9787507833935 +9787507834161 +9787507834451 +9787507834529 +9787507834604 +9787507834628 +9787507834642 +9787507834772 +9787507835052 +9787507835816 +9787507835878 +9787507836172 +9787507836240 +9787507836257 +9787507837018 +9787507837032 +9787507837049 +9787507837063 +9787507837247 +9787507837278 +9787507837285 +9787507837308 +9787507837322 +9787507837391 +9787507837698 +9787507837810 +9787507837902 +9787507837988 +9787507838015 +9787507838077 +9787507838176 +9787507838220 +9787507838237 +9787507838275 +9787507838305 +9787507838381 +9787507838480 +9787507838497 +9787507838855 +9787507839081 +9787507839104 +9787507839784 +9787507839906 +9787507840216 +9787507840247 +9787507840544 +9787507840995 +9787507841015 +9787507841169 +9787507841374 +9787507842593 +9787507842647 +9787507843118 +9787507843668 +9787507844320 +9787507844641 +9787507844696 +9787507846317 +9787507847291 +9787507848793 +9787507848823 +9787507848984 +9787507848991 +9787507849004 +9787507849547 +9787507849738 +9787507850284 +9787507850895 +9787507850932 +9787507851557 +9787507851564 +9787507851601 +9787507852271 +9787507852660 +9787507853353 +9787507853582 +9787507853599 +9787507853728 +9787507853735 +9787507853919 +9787507854527 +9787507855401 +9787507855616 +9787507855814 +9787507856118 +9787507857573 +9787507857580 +9787507857597 +9787507857603 +9787508000121 +9787508000794 +9787508000985 +9787508001012 +9787508001029 +9787508001043 +9787508001128 +9787508001166 +9787508001173 +9787508001197 +9787508001203 +9787508001517 +9787508001548 +9787508001586 +9787508001609 +9787508001753 +9787508002002 +9787508002019 +9787508002118 +9787508002330 +9787508002514 +9787508002712 +9787508002743 +9787508002750 +9787508002828 +9787508003047 +9787508003078 +9787508003214 +9787508003221 +9787508003511 +9787508003566 +9787508003580 +9787508003603 +9787508003986 +9787508004129 +9787508004433 +9787508004471 +9787508004570 +9787508004860 +9787508005089 +9787508005195 +9787508005331 +9787508005447 +9787508005454 +9787508005478 +9787508005515 +9787508005539 +9787508005560 +9787508005652 +9787508005690 +9787508005720 +9787508005874 +9787508005881 +9787508005928 +9787508005942 +9787508005973 +9787508006017 +9787508006024 +9787508006031 +9787508006048 +9787508006055 +9787508006062 +9787508006079 +9787508006086 +9787508006093 +9787508006116 +9787508006185 +9787508006192 +9787508006222 +9787508006239 +9787508006246 +9787508006277 +9787508006512 +9787508006635 +9787508006765 +9787508006826 +9787508006833 +9787508006840 +9787508006857 +9787508006864 +9787508006871 +9787508006895 +9787508006901 +9787508006925 +9787508006932 +9787508007021 +9787508007106 +9787508007113 +9787508007120 +9787508007137 +9787508007144 +9787508007168 +9787508007182 +9787508007199 +9787508007601 +9787508007663 +9787508007700 +9787508007724 +9787508007731 +9787508007748 +9787508007762 +9787508007830 +9787508007854 +9787508007892 +9787508007991 +9787508008011 +9787508008028 +9787508008035 +9787508008073 +9787508008080 +9787508008158 +9787508008165 +9787508008172 +9787508008189 +9787508008202 +9787508008219 +9787508008226 +9787508008233 +9787508008240 +9787508008257 +9787508008295 +9787508008301 +9787508008318 +9787508008325 +9787508008332 +9787508008356 +9787508008493 +9787508008509 +9787508008752 +9787508008806 +9787508008813 +9787508009292 +9787508009308 +9787508009315 +9787508009353 +9787508009384 +9787508009469 +9787508009797 +9787508010038 +9787508010045 +9787508010199 +9787508010281 +9787508010298 +9787508010304 +9787508010335 +9787508010342 +9787508010472 +9787508010489 +9787508010502 +9787508010656 +9787508010724 +9787508010731 +9787508010748 +9787508010816 +9787508010953 +9787508011011 +9787508011059 +9787508011103 +9787508011219 +9787508011516 +9787508011554 +9787508011561 +9787508011578 +9787508011585 +9787508011608 +9787508011615 +9787508011714 +9787508011738 +9787508011752 +9787508011936 +9787508011981 +9787508012162 +9787508012438 +9787508012452 +9787508012469 +9787508012483 +9787508012520 +9787508012582 +9787508013077 +9787508013084 +9787508013213 +9787508013251 +9787508013299 +9787508013305 +9787508013312 +9787508013329 +9787508013336 +9787508013510 +9787508013534 +9787508013541 +9787508013596 +9787508013862 +9787508013909 +9787508013923 +9787508013985 +9787508014135 +9787508014296 +9787508014340 +9787508014463 +9787508014500 +9787508014555 +9787508014562 +9787508014685 +9787508014715 +9787508014739 +9787508014746 +9787508014814 +9787508014968 +9787508015125 +9787508015149 +9787508015170 +9787508015217 +9787508015248 +9787508015279 +9787508015309 +9787508015354 +9787508015392 +9787508015446 +9787508015453 +9787508015705 +9787508015736 +9787508015866 +9787508015873 +9787508015958 +9787508016054 +9787508016092 +9787508016139 +9787508016146 +9787508016184 +9787508016191 +9787508016269 +9787508016306 +9787508016351 +9787508016399 +9787508016405 +9787508016412 +9787508016429 +9787508016504 +9787508016542 +9787508016566 +9787508016665 +9787508016740 +9787508016955 +9787508016979 +9787508017181 +9787508017297 +9787508017365 +9787508017730 +9787508017747 +9787508017815 +9787508017891 +9787508017969 +9787508017976 +9787508018119 +9787508018171 +9787508018225 +9787508018232 +9787508018317 +9787508018348 +9787508018379 +9787508018614 +9787508018744 +9787508018904 +9787508019260 +9787508019369 +9787508019437 +9787508019444 +9787508019499 +9787508019505 +9787508019604 +9787508019734 +9787508019741 +9787508019772 +9787508019833 +9787508019840 +9787508019857 +9787508019895 +9787508020273 +9787508020310 +9787508020495 +9787508020747 +9787508020754 +9787508020815 +9787508020822 +9787508020877 +9787508021034 +9787508021072 +9787508021171 +9787508021218 +9787508021379 +9787508021393 +9787508021423 +9787508021461 +9787508021737 +9787508021829 +9787508021836 +9787508021867 +9787508021904 +9787508021980 +9787508021997 +9787508022222 +9787508022369 +9787508022376 +9787508022437 +9787508022468 +9787508022512 +9787508022567 +9787508022659 +9787508022673 +9787508022697 +9787508022864 +9787508022925 +9787508022932 +9787508022949 +9787508022956 +9787508023021 +9787508023090 +9787508023229 +9787508023250 +9787508023311 +9787508023328 +9787508023359 +9787508023366 +9787508023373 +9787508023380 +9787508023427 +9787508023458 +9787508023465 +9787508023472 +9787508023526 +9787508023564 +9787508023793 +9787508023854 +9787508023861 +9787508023878 +9787508024011 +9787508024035 +9787508024042 +9787508024288 +9787508024363 +9787508024493 +9787508024561 +9787508025131 +9787508025209 +9787508025261 +9787508025308 +9787508025346 +9787508025353 +9787508025421 +9787508025483 +9787508025490 +9787508025537 +9787508025599 +9787508025605 +9787508025667 +9787508025735 +9787508025834 +9787508025872 +9787508025995 +9787508026008 +9787508026015 +9787508026022 +9787508026060 +9787508026121 +9787508026138 +9787508026213 +9787508026411 +9787508026459 +9787508026527 +9787508026602 +9787508026671 +9787508026688 +9787508026695 +9787508026893 +9787508026978 +9787508027173 +9787508027357 +9787508027449 +9787508027456 +9787508027524 +9787508027555 +9787508027623 +9787508027654 +9787508027760 +9787508027777 +9787508027852 +9787508027913 +9787508027968 +9787508027982 +9787508028118 +9787508028279 +9787508028354 +9787508028415 +9787508028453 +9787508028637 +9787508028644 +9787508028699 +9787508028705 +9787508028712 +9787508028736 +9787508028743 +9787508028897 +9787508029177 +9787508029658 +9787508029986 +9787508030333 +9787508030425 +9787508030456 +9787508030524 +9787508030548 +9787508030593 +9787508030623 +9787508030760 +9787508030906 +9787508031125 +9787508031156 +9787508031194 +9787508031248 +9787508031613 +9787508031675 +9787508031682 +9787508031699 +9787508031743 +9787508031781 +9787508031828 +9787508031859 +9787508031873 +9787508031910 +9787508031927 +9787508032023 +9787508032054 +9787508032139 +9787508032405 +9787508032603 +9787508032832 +9787508032894 +9787508032917 +9787508032931 +9787508033129 +9787508033228 +9787508033600 +9787508033655 +9787508033716 +9787508033891 +9787508033990 +9787508034003 +9787508034010 +9787508034034 +9787508034119 +9787508034164 +9787508034171 +9787508034645 +9787508034829 +9787508034836 +9787508034843 +9787508035055 +9787508035253 +9787508035260 +9787508035307 +9787508035642 +9787508035673 +9787508035727 +9787508035758 +9787508035901 +9787508035987 +9787508035994 +9787508036014 +9787508036052 +9787508036113 +9787508036144 +9787508036151 +9787508036250 +9787508036359 +9787508036366 +9787508036427 +9787508036502 +9787508036526 +9787508036557 +9787508036564 +9787508036571 +9787508036588 +9787508036717 +9787508036731 +9787508036748 +9787508036786 +9787508037141 +9787508037479 +9787508037554 +9787508037974 +9787508038063 +9787508038131 +9787508038247 +9787508038292 +9787508038322 +9787508038339 +9787508038346 +9787508038377 +9787508038384 +9787508038407 +9787508038445 +9787508038469 +9787508038476 +9787508038537 +9787508038643 +9787508038698 +9787508038810 +9787508038865 +9787508038919 +9787508038926 +9787508038933 +9787508039107 +9787508039251 +9787508039275 +9787508039282 +9787508039343 +9787508039374 +9787508039435 +9787508039589 +9787508039596 +9787508039718 +9787508039749 +9787508039770 +9787508039855 +9787508039879 +9787508039909 +9787508039923 +9787508039978 +9787508040042 +9787508040059 +9787508040066 +9787508040189 +9787508040356 +9787508040646 +9787508040653 +9787508040677 +9787508041131 +9787508041179 +9787508041216 +9787508041391 +9787508041476 +9787508041872 +9787508042206 +9787508042350 +9787508042367 +9787508042381 +9787508042398 +9787508042404 +9787508042435 +9787508042442 +9787508042671 +9787508042954 +9787508042992 +9787508043036 +9787508043074 +9787508043210 +9787508043265 +9787508043319 +9787508043418 +9787508043500 +9787508043708 +9787508043746 +9787508043760 +9787508043883 +9787508043913 +9787508044064 +9787508044149 +9787508044224 +9787508044422 +9787508044682 +9787508044736 +9787508044767 +9787508044774 +9787508044972 +9787508045078 +9787508045085 +9787508045238 +9787508045320 +9787508045528 +9787508045641 +9787508045658 +9787508045825 +9787508046129 +9787508046198 +9787508046440 +9787508046471 +9787508046525 +9787508046693 +9787508046709 +9787508046716 +9787508046723 +9787508046785 +9787508047706 +9787508047713 +9787508047737 +9787508047744 +9787508047775 +9787508048079 +9787508048130 +9787508048260 +9787508048604 +9787508048703 +9787508048741 +9787508048888 +9787508048932 +9787508049069 +9787508049267 +9787508049588 +9787508050065 +9787508050263 +9787508050317 +9787508050362 +9787508050379 +9787508050614 +9787508050843 +9787508050935 +9787508051178 +9787508051185 +9787508051277 +9787508051321 +9787508051406 +9787508051475 +9787508051529 +9787508051598 +9787508052038 +9787508052052 +9787508052090 +9787508052120 +9787508052144 +9787508052212 +9787508052236 +9787508052366 +9787508052694 +9787508052700 +9787508052762 +9787508053059 +9787508053615 +9787508053974 +9787508053998 +9787508054018 +9787508054087 +9787508054117 +9787508054148 +9787508054179 +9787508054209 +9787508054223 +9787508054278 +9787508054315 +9787508054445 +9787508054834 +9787508054919 +9787508054964 +9787508055282 +9787508055312 +9787508055404 +9787508055565 +9787508055954 +9787508055961 +9787508056067 +9787508056470 +9787508057002 +9787508057392 +9787508057552 +9787508057590 +9787508057668 +9787508057675 +9787508057798 +9787508057828 +9787508057835 +9787508057866 +9787508058429 +9787508058665 +9787508058672 +9787508058832 +9787508058863 +9787508059211 +9787508059228 +9787508059334 +9787508059365 +9787508059426 +9787508059488 +9787508059570 +9787508059976 +9787508060033 +9787508060101 +9787508060187 +9787508060408 +9787508060729 +9787508061177 +9787508061412 +9787508061696 +9787508061702 +9787508061719 +9787508062181 +9787508062242 +9787508062433 +9787508062617 +9787508062730 +9787508062761 +9787508062983 +9787508063041 +9787508063065 +9787508063102 +9787508063560 +9787508064000 +9787508064208 +9787508064598 +9787508064734 +9787508065052 +9787508065670 +9787508065762 +9787508065823 +9787508065915 +9787508066066 +9787508066196 +9787508066264 +9787508066387 +9787508066431 +9787508066561 +9787508066691 +9787508066837 +9787508067643 +9787508067735 +9787508068602 +9787508068770 +9787508069005 +9787508069104 +9787508069562 +9787508069685 +9787508070148 +9787508070155 +9787508070476 +9787508070483 +9787508070810 +9787508071084 +9787508071107 +9787508071169 +9787508071732 +9787508071763 +9787508071992 +9787508072289 +9787508072395 +9787508072784 +9787508072913 +9787508072920 +9787508073002 +9787508073415 +9787508073460 +9787508073477 +9787508073972 +9787508074436 +9787508074474 +9787508074481 +9787508074498 +9787508074511 +9787508074641 +9787508074924 +9787508075631 +9787508075747 +9787508075792 +9787508075983 +9787508076126 +9787508076270 +9787508076485 +9787508076492 +9787508076829 +9787508078342 +9787508078618 +9787508078946 +9787508078984 +9787508079127 +9787508079257 +9787508079264 +9787508079370 +9787508079585 +9787508079684 +9787508080307 +9787508080406 +9787508081106 +9787508081229 +9787508081373 +9787508081946 +9787508082257 +9787508082479 +9787508082493 +9787508082592 +9787508082714 +9787508082851 +9787508083094 +9787508083254 +9787508083339 +9787508083643 +9787508083681 +9787508083872 +9787508083926 +9787508084053 +9787508084077 +9787508084398 +9787508084442 +9787508084473 +9787508084534 +9787508084572 +9787508084640 +9787508085357 +9787508085364 +9787508085975 +9787508086217 +9787508086248 +9787508086446 +9787508086477 +9787508086521 +9787508086712 +9787508086804 +9787508087030 +9787508087047 +9787508087061 +9787508087122 +9787508087139 +9787508087382 +9787508087474 +9787508087481 +9787508087573 +9787508088105 +9787508088747 +9787508088914 +9787508089065 +9787508089157 +9787508089836 +9787508089850 +9787508089874 +9787508090177 +9787508090306 +9787508090443 +9787508091242 +9787508091341 +9787508091730 +9787508092010 +9787508092652 +9787508092775 +9787508092829 +9787508092843 +9787508093185 +9787508093314 +9787508093413 +9787508093468 +9787508093741 +9787508093871 +9787508094113 +9787508094281 +9787508094397 +9787508094625 +9787508094816 +9787508094977 +9787508095011 +9787508095295 +9787508095318 +9787508095325 +9787508095363 +9787508095462 +9787508095479 +9787508095486 +9787508095516 +9787508095592 +9787508096483 +9787508096728 +9787508096759 +9787508097275 +9787508097305 +9787508097428 +9787508097435 +9787508097572 +9787508097602 +9787508097657 +9787508097800 +9787508097831 +9787508097862 +9787508097954 +9787508097992 +9787508098036 +9787508098296 +9787508098326 +9787508098432 +9787508098845 +9787508098944 +9787508099101 +9787508099170 +9787508099354 +9787508099644 +9787508099705 +9787508099897 +9787508099927 +9787508099958 +9787508100555 +9787508100883 +9787508101934 +9787508102603 +9787508200071 +9787508200200 +9787508200248 +9787508200422 +9787508200484 +9787508200545 +9787508200576 +9787508200613 +9787508200668 +9787508200828 +9787508200880 +9787508200910 +9787508200965 +9787508201047 +9787508201115 +9787508201153 +9787508201207 +9787508201221 +9787508201320 +9787508201351 +9787508201382 +9787508201429 +9787508201597 +9787508201641 +9787508201665 +9787508201689 +9787508201726 +9787508201764 +9787508201887 +9787508201894 +9787508201924 +9787508201979 +9787508202129 +9787508202136 +9787508202242 +9787508202297 +9787508202310 +9787508202402 +9787508202457 +9787508202464 +9787508202549 +9787508202556 +9787508202624 +9787508202655 +9787508202662 +9787508202679 +9787508202716 +9787508202761 +9787508202785 +9787508202877 +9787508202884 +9787508202945 +9787508203027 +9787508203102 +9787508203270 +9787508203287 +9787508203317 +9787508203379 +9787508203386 +9787508203454 +9787508203584 +9787508203621 +9787508203669 +9787508203805 +9787508203836 +9787508203874 +9787508203904 +9787508203966 +9787508203980 +9787508204000 +9787508204314 +9787508204437 +9787508204444 +9787508204659 +9787508204697 +9787508204710 +9787508204734 +9787508204758 +9787508204765 +9787508204925 +9787508204956 +9787508204970 +9787508205076 +9787508205250 +9787508205410 +9787508205489 +9787508205656 +9787508205663 +9787508205717 +9787508205847 +9787508205861 +9787508205885 +9787508205984 +9787508206103 +9787508206127 +9787508206158 +9787508206318 +9787508206578 +9787508206615 +9787508206653 +9787508206752 +9787508206806 +9787508206837 +9787508206950 +9787508206981 +9787508207001 +9787508207025 +9787508207032 +9787508207117 +9787508207261 +9787508207278 +9787508207445 +9787508207469 +9787508207506 +9787508207667 +9787508207698 +9787508207766 +9787508207995 +9787508208053 +9787508208060 +9787508208077 +9787508208114 +9787508208121 +9787508208220 +9787508208251 +9787508208343 +9787508208404 +9787508208442 +9787508208480 +9787508208510 +9787508208527 +9787508208596 +9787508208633 +9787508208657 +9787508208756 +9787508208770 +9787508208855 +9787508209173 +9787508209234 +9787508209241 +9787508209258 +9787508209388 +9787508209401 +9787508209418 +9787508209425 +9787508209449 +9787508209456 +9787508209470 +9787508209692 +9787508209739 +9787508209760 +9787508209876 +9787508209883 +9787508210018 +9787508210117 +9787508210186 +9787508210247 +9787508210292 +9787508210308 +9787508210315 +9787508210339 +9787508210346 +9787508210421 +9787508210438 +9787508210476 +9787508210568 +9787508210575 +9787508210582 +9787508210667 +9787508210674 +9787508210728 +9787508210797 +9787508210810 +9787508210827 +9787508210841 +9787508210940 +9787508210971 +9787508210988 +9787508211015 +9787508211053 +9787508211077 +9787508211084 +9787508211091 +9787508211121 +9787508211220 +9787508211237 +9787508211367 +9787508211435 +9787508211442 +9787508211473 +9787508211480 +9787508211503 +9787508211510 +9787508211626 +9787508211640 +9787508211664 +9787508211688 +9787508211701 +9787508211718 +9787508211817 +9787508211916 +9787508211947 +9787508211985 +9787508212043 +9787508212074 +9787508212098 +9787508212128 +9787508212135 +9787508212227 +9787508212647 +9787508212654 +9787508212661 +9787508212692 +9787508212715 +9787508212760 +9787508212852 +9787508212883 +9787508213057 +9787508213088 +9787508213286 +9787508213354 +9787508213361 +9787508213453 +9787508213460 +9787508213514 +9787508213521 +9787508213590 +9787508213613 +9787508213668 +9787508213705 +9787508213859 +9787508213910 +9787508214009 +9787508214030 +9787508214054 +9787508214245 +9787508214252 +9787508214344 +9787508214368 +9787508214375 +9787508214511 +9787508214559 +9787508214658 +9787508214689 +9787508214702 +9787508214719 +9787508214764 +9787508214795 +9787508214856 +9787508214993 +9787508215013 +9787508215068 +9787508215082 +9787508215297 +9787508215327 +9787508215440 +9787508215488 +9787508215648 +9787508215761 +9787508215976 +9787508216133 +9787508216157 +9787508216201 +9787508216324 +9787508216492 +9787508216553 +9787508216560 +9787508216577 +9787508216607 +9787508216614 +9787508216683 +9787508216782 +9787508216799 +9787508216805 +9787508216942 +9787508217208 +9787508217222 +9787508217291 +9787508217321 +9787508217550 +9787508217567 +9787508217574 +9787508217758 +9787508217765 +9787508217789 +9787508217925 +9787508217987 +9787508218038 +9787508218212 +9787508218311 +9787508218328 +9787508218342 +9787508218359 +9787508218366 +9787508218397 +9787508218465 +9787508218502 +9787508218557 +9787508218571 +9787508218632 +9787508218656 +9787508218793 +9787508218847 +9787508218892 +9787508219158 +9787508219288 +9787508219424 +9787508219455 +9787508219592 +9787508219790 +9787508219806 +9787508219950 +9787508219967 +9787508219981 +9787508220154 +9787508220321 +9787508220413 +9787508220512 +9787508220703 +9787508220734 +9787508220772 +9787508220826 +9787508220857 +9787508221625 +9787508221649 +9787508221878 +9787508221892 +9787508221960 +9787508222226 +9787508222301 +9787508222431 +9787508222455 +9787508222523 +9787508222561 +9787508222646 +9787508222776 +9787508222912 +9787508223018 +9787508223032 +9787508223124 +9787508223414 +9787508223438 +9787508223568 +9787508223599 +9787508223674 +9787508223681 +9787508223865 +9787508223940 +9787508223995 +9787508224770 +9787508224800 +9787508225111 +9787508225562 +9787508225609 +9787508225654 +9787508225715 +9787508225722 +9787508225739 +9787508225753 +9787508226361 +9787508226453 +9787508226583 +9787508226859 +9787508226866 +9787508226910 +9787508226927 +9787508226934 +9787508227016 +9787508227061 +9787508227085 +9787508227177 +9787508227245 +9787508227320 +9787508227337 +9787508227443 +9787508227450 +9787508227870 +9787508227887 +9787508227955 +9787508228013 +9787508228037 +9787508228105 +9787508228747 +9787508228822 +9787508228938 +9787508228952 +9787508229065 +9787508229102 +9787508229232 +9787508229263 +9787508229478 +9787508229546 +9787508229560 +9787508229577 +9787508229638 +9787508229706 +9787508229805 +9787508229829 +9787508229881 +9787508229904 +9787508229942 +9787508229966 +9787508229980 +9787508230474 +9787508230481 +9787508231310 +9787508231365 +9787508231389 +9787508231983 +9787508232249 +9787508232348 +9787508232546 +9787508232621 +9787508232638 +9787508232669 +9787508232805 +9787508232843 +9787508232867 +9787508232898 +9787508232942 +9787508233024 +9787508233550 +9787508233604 +9787508234175 +9787508234236 +9787508234267 +9787508234274 +9787508234328 +9787508234342 +9787508234502 +9787508234816 +9787508234847 +9787508235141 +9787508235578 +9787508235585 +9787508235592 +9787508235615 +9787508235677 +9787508235684 +9787508235707 +9787508235745 +9787508235752 +9787508235899 +9787508235905 +9787508235981 +9787508236230 +9787508236247 +9787508236537 +9787508236698 +9787508236759 +9787508236834 +9787508236865 +9787508236957 +9787508237077 +9787508237190 +9787508237213 +9787508237268 +9787508237275 +9787508237350 +9787508237367 +9787508237381 +9787508237398 +9787508237404 +9787508237435 +9787508237459 +9787508237596 +9787508237701 +9787508237718 +9787508237817 +9787508237824 +9787508237909 +9787508237947 +9787508238746 +9787508238777 +9787508238883 +9787508239019 +9787508239057 +9787508239293 +9787508239545 +9787508239590 +9787508239644 +9787508239651 +9787508239675 +9787508239682 +9787508239965 +9787508240022 +9787508240121 +9787508240145 +9787508240220 +9787508240299 +9787508240398 +9787508240497 +9787508240671 +9787508240763 +9787508240817 +9787508240879 +9787508240978 +9787508241227 +9787508241586 +9787508241661 +9787508241685 +9787508241722 +9787508241807 +9787508241838 +9787508241869 +9787508242033 +9787508242071 +9787508242125 +9787508242255 +9787508242729 +9787508242743 +9787508242781 +9787508242842 +9787508243252 +9787508243276 +9787508243306 +9787508243436 +9787508243634 +9787508243665 +9787508243900 +9787508244211 +9787508244228 +9787508244297 +9787508244365 +9787508244372 +9787508244501 +9787508244525 +9787508244587 +9787508244853 +9787508244914 +9787508244990 +9787508245041 +9787508245065 +9787508245072 +9787508245126 +9787508245249 +9787508245355 +9787508245362 +9787508245461 +9787508245539 +9787508245768 +9787508245881 +9787508245973 +9787508246109 +9787508246185 +9787508246260 +9787508246406 +9787508246741 +9787508246758 +9787508246796 +9787508246802 +9787508246826 +9787508246857 +9787508246895 +9787508246987 +9787508247298 +9787508247311 +9787508247335 +9787508247489 +9787508247496 +9787508247533 +9787508247595 +9787508247793 +9787508247915 +9787508247946 +9787508247977 +9787508248806 +9787508248899 +9787508249001 +9787508249070 +9787508249308 +9787508249339 +9787508249698 +9787508250205 +9787508250823 +9787508250861 +9787508250885 +9787508251271 +9787508251394 +9787508251554 +9787508251882 +9787508252377 +9787508252384 +9787508252643 +9787508252773 +9787508253220 +9787508253244 +9787508253251 +9787508253350 +9787508253596 +9787508253619 +9787508253633 +9787508253992 +9787508254036 +9787508254050 +9787508254111 +9787508254357 +9787508254432 +9787508254630 +9787508255149 +9787508255354 +9787508255378 +9787508255392 +9787508255514 +9787508255538 +9787508255590 +9787508255637 +9787508255651 +9787508255729 +9787508255767 +9787508255774 +9787508255835 +9787508256023 +9787508256276 +9787508256337 +9787508256351 +9787508256436 +9787508256542 +9787508256696 +9787508256801 +9787508256818 +9787508256870 +9787508256917 +9787508256924 +9787508256931 +9787508256955 +9787508256962 +9787508257013 +9787508257068 +9787508257075 +9787508257082 +9787508257105 +9787508257594 +9787508257662 +9787508257747 +9787508258188 +9787508258539 +9787508258683 +9787508258928 +9787508258997 +9787508259109 +9787508259130 +9787508259161 +9787508259369 +9787508259390 +9787508259536 +9787508259543 +9787508259819 +9787508260327 +9787508260839 +9787508261027 +9787508261058 +9787508261133 +9787508261171 +9787508261300 +9787508261584 +9787508261836 +9787508261850 +9787508261997 +9787508262567 +9787508262604 +9787508262840 +9787508262987 +9787508263397 +9787508263588 +9787508263854 +9787508264202 +9787508264370 +9787508264677 +9787508264776 +9787508264790 +9787508265094 +9787508265148 +9787508265445 +9787508265766 +9787508265889 +9787508266381 +9787508266671 +9787508266855 +9787508267197 +9787508267395 +9787508267418 +9787508267456 +9787508267685 +9787508267715 +9787508267722 +9787508267807 +9787508268064 +9787508268101 +9787508268132 +9787508268200 +9787508268217 +9787508268286 +9787508268880 +9787508268972 +9787508268996 +9787508269207 +9787508269214 +9787508269702 +9787508270524 +9787508270586 +9787508270784 +9787508270906 +9787508271125 +9787508271170 +9787508271507 +9787508271545 +9787508271552 +9787508271644 +9787508271774 +9787508272054 +9787508272207 +9787508272320 +9787508272467 +9787508272597 +9787508272764 +9787508272870 +9787508272900 +9787508272924 +9787508273372 +9787508273808 +9787508273822 +9787508274188 +9787508274515 +9787508274560 +9787508274621 +9787508274645 +9787508274683 +9787508274706 +9787508274744 +9787508275000 +9787508275161 +9787508275666 +9787508276038 +9787508276335 +9787508276618 +9787508276984 +9787508277233 +9787508277608 +9787508278117 +9787508278223 +9787508278322 +9787508278476 +9787508278483 +9787508278520 +9787508278612 +9787508278698 +9787508278865 +9787508278919 +9787508279213 +9787508279299 +9787508279411 +9787508279466 +9787508279619 +9787508279824 +9787508280165 +9787508280240 +9787508280264 +9787508280288 +9787508281094 +9787508281117 +9787508281230 +9787508281445 +9787508281520 +9787508281582 +9787508281728 +9787508282176 +9787508282312 +9787508282329 +9787508282435 +9787508282459 +9787508282510 +9787508282589 +9787508283036 +9787508283159 +9787508283371 +9787508283425 +9787508283807 +9787508283838 +9787508283883 +9787508284033 +9787508284088 +9787508284149 +9787508284231 +9787508284996 +9787508285696 +9787508285771 +9787508286013 +9787508286105 +9787508286280 +9787508286310 +9787508286327 +9787508286358 +9787508286372 +9787508286495 +9787508286655 +9787508287089 +9787508287829 +9787508287843 +9787508287980 +9787508288093 +9787508288161 +9787508288314 +9787508288796 +9787508289120 +9787508289168 +9787508289229 +9787508289250 +9787508289328 +9787508289380 +9787508289458 +9787508289670 +9787508289694 +9787508289892 +9787508290089 +9787508290270 +9787508290508 +9787508290560 +9787508290614 +9787508290621 +9787508290775 +9787508290980 +9787508291314 +9787508291475 +9787508291536 +9787508291567 +9787508291628 +9787508291659 +9787508291840 +9787508292052 +9787508292106 +9787508292373 +9787508292465 +9787508292472 +9787508292823 +9787508292946 +9787508294001 +9787508294179 +9787508294261 +9787508294353 +9787508294384 +9787508294506 +9787508294773 +9787508294797 +9787508295121 +9787508295138 +9787508295176 +9787508295749 +9787508296227 +9787508296241 +9787508296500 +9787508296524 +9787508296715 +9787508296746 +9787508296807 +9787508296920 +9787508296999 +9787508297040 +9787508297149 +9787508297408 +9787508297477 +9787508297606 +9787508297613 +9787508297620 +9787508297637 +9787508298047 +9787508298191 +9787508298320 +9787508298337 +9787508298719 +9787508298979 +9787508299839 +9787508299969 +9787508300184 +9787508300375 +9787508300481 +9787508300900 +9787508301495 +9787508303093 +9787508303802 +9787508303932 +9787508304328 +9787508304694 +9787508304700 +9787508304748 +9787508304786 +9787508304823 +9787508305103 +9787508305127 +9787508305417 +9787508305929 +9787508306599 +9787508306735 +9787508306858 +9787508306957 +9787508307220 +9787508307411 +9787508307817 +9787508307824 +9787508307909 +9787508307985 +9787508308357 +9787508308715 +9787508308753 +9787508308845 +9787508309040 +9787508309088 +9787508309651 +9787508310060 +9787508310459 +9787508310589 +9787508310930 +9787508310985 +9787508311074 +9787508311104 +9787508311340 +9787508311609 +9787508311616 +9787508311692 +9787508311784 +9787508311944 +9787508311968 +9787508311975 +9787508311982 +9787508312019 +9787508312248 +9787508312729 +9787508312941 +9787508312996 +9787508313191 +9787508313511 +9787508314358 +9787508314440 +9787508314549 +9787508314815 +9787508315034 +9787508316031 +9787508316628 +9787508316697 +9787508317045 +9787508317175 +9787508317274 +9787508317410 +9787508317502 +9787508317946 +9787508318011 +9787508318141 +9787508318615 +9787508318752 +9787508318974 +9787508319292 +9787508319568 +9787508319896 +9787508319995 +9787508320045 +9787508320151 +9787508321387 +9787508321585 +9787508321851 +9787508321905 +9787508322056 +9787508322070 +9787508322490 +9787508323367 +9787508323411 +9787508323978 +9787508324227 +9787508324388 +9787508325446 +9787508325651 +9787508326498 +9787508327778 +9787508328256 +9787508328522 +9787508328546 +9787508328591 +9787508329369 +9787508330778 +9787508330846 +9787508331638 +9787508332734 +9787508332741 +9787508333304 +9787508333830 +9787508334479 +9787508334929 +9787508335230 +9787508335483 +9787508335957 +9787508336619 +9787508336725 +9787508337210 +9787508337425 +9787508337715 +9787508337777 +9787508338156 +9787508338170 +9787508338262 +9787508339320 +9787508339894 +9787508339931 +9787508340388 +9787508340432 +9787508340555 +9787508340999 +9787508341255 +9787508341972 +9787508342290 +9787508342634 +9787508342658 +9787508343501 +9787508343730 +9787508344683 +9787508345024 +9787508345444 +9787508345727 +9787508345772 +9787508345918 +9787508346878 +9787508347165 +9787508347417 +9787508347455 +9787508348100 +9787508348117 +9787508348421 +9787508348919 +9787508349183 +9787508350073 +9787508350257 +9787508351889 +9787508352237 +9787508352343 +9787508352565 +9787508352787 +9787508352930 +9787508353722 +9787508353890 +9787508354750 +9787508354811 +9787508355047 +9787508355740 +9787508357027 +9787508357355 +9787508357461 +9787508357966 +9787508359670 +9787508359700 +9787508360287 +9787508360690 +9787508361048 +9787508361222 +9787508361529 +9787508361963 +9787508362328 +9787508364810 +9787508364964 +9787508365572 +9787508366425 +9787508366920 +9787508367217 +9787508367224 +9787508367705 +9787508367712 +9787508367736 +9787508367781 +9787508368375 +9787508369075 +9787508369143 +9787508369266 +9787508369358 +9787508370170 +9787508370422 +9787508370569 +9787508370620 +9787508371290 +9787508373171 +9787508373225 +9787508373881 +9787508374819 +9787508374932 +9787508375571 +9787508375724 +9787508375892 +9787508376271 +9787508376783 +9787508377131 +9787508377285 +9787508377476 +9787508377544 +9787508378312 +9787508378442 +9787508378558 +9787508378640 +9787508379500 +9787508379531 +9787508380216 +9787508381022 +9787508381510 +9787508383446 +9787508383538 +9787508384306 +9787508384344 +9787508384443 +9787508384665 +9787508385006 +9787508385068 +9787508385945 +9787508386928 +9787508387659 +9787508387710 +9787508387765 +9787508388120 +9787508389264 +9787508389752 +9787508390314 +9787508390413 +9787508390475 +9787508391045 +9787508391052 +9787508391304 +9787508391311 +9787508391465 +9787508391625 +9787508392844 +9787508393810 +9787508394053 +9787508394077 +9787508394381 +9787508394978 +9787508395357 +9787508395517 +9787508396583 +9787508396750 +9787508396767 +9787508396828 +9787508398761 +9787508399447 +9787508400396 +9787508400624 +9787508400952 +9787508401720 +9787508402048 +9787508402796 +9787508403458 +9787508404110 +9787508404134 +9787508404264 +9787508404295 +9787508404356 +9787508404394 +9787508404790 +9787508405308 +9787508405858 +9787508405940 +9787508406367 +9787508407463 +9787508407913 +9787508408620 +9787508408705 +9787508408774 +9787508409054 +9787508409085 +9787508409108 +9787508409238 +9787508409245 +9787508409450 +9787508409726 +9787508410197 +9787508410852 +9787508411231 +9787508412009 +9787508412948 +9787508412986 +9787508413419 +9787508413686 +9787508413754 +9787508413822 +9787508414195 +9787508414423 +9787508414898 +9787508415024 +9787508415604 +9787508415758 +9787508416113 +9787508416335 +9787508416540 +9787508416694 +9787508416885 +9787508416953 +9787508417011 +9787508417028 +9787508417042 +9787508417066 +9787508417219 +9787508417493 +9787508417660 +9787508417721 +9787508418223 +9787508418445 +9787508418476 +9787508418537 +9787508419084 +9787508419152 +9787508419268 +9787508419428 +9787508419749 +9787508419794 +9787508420264 +9787508420899 +9787508421049 +9787508422442 +9787508422459 +9787508422473 +9787508422503 +9787508422572 +9787508423012 +9787508423425 +9787508423814 +9787508424026 +9787508424163 +9787508425047 +9787508425306 +9787508425566 +9787508425627 +9787508425726 +9787508426235 +9787508426242 +9787508426389 +9787508426402 +9787508426648 +9787508426778 +9787508427195 +9787508427324 +9787508427386 +9787508427607 +9787508427676 +9787508427836 +9787508428345 +9787508429083 +9787508429502 +9787508429632 +9787508430126 +9787508430966 +9787508431093 +9787508431505 +9787508431901 +9787508432267 +9787508432335 +9787508432342 +9787508432373 +9787508432557 +9787508432571 +9787508432731 +9787508434100 +9787508434209 +9787508434254 +9787508434957 +9787508435114 +9787508435411 +9787508435459 +9787508435565 +9787508436043 +9787508436098 +9787508436968 +9787508437125 +9787508437415 +9787508437712 +9787508438825 +9787508439389 +9787508439785 +9787508440187 +9787508440255 +9787508440590 +9787508440934 +9787508441160 +9787508441603 +9787508441696 +9787508441917 +9787508442655 +9787508443126 +9787508443683 +9787508443805 +9787508444024 +9787508444871 +9787508444956 +9787508444994 +9787508445045 +9787508445076 +9787508445366 +9787508445373 +9787508445427 +9787508445564 +9787508446325 +9787508447421 +9787508448244 +9787508448510 +9787508448756 +9787508449562 +9787508449685 +9787508450018 +9787508450162 +9787508450179 +9787508450988 +9787508451411 +9787508451428 +9787508451626 +9787508451749 +9787508452500 +9787508453675 +9787508453729 +9787508454153 +9787508454177 +9787508454856 +9787508455815 +9787508455839 +9787508455914 +9787508456010 +9787508456096 +9787508456126 +9787508456263 +9787508456416 +9787508457246 +9787508457635 +9787508457673 +9787508457758 +9787508458472 +9787508458533 +9787508458571 +9787508459219 +9787508459530 +9787508459547 +9787508460499 +9787508460680 +9787508460697 +9787508461328 +9787508461526 +9787508461960 +9787508462493 +9787508462523 +9787508462585 +9787508463032 +9787508464176 +9787508464183 +9787508464619 +9787508465128 +9787508465555 +9787508466057 +9787508466187 +9787508466415 +9787508468365 +9787508468419 +9787508468464 +9787508469225 +9787508469768 +9787508470627 +9787508471013 +9787508471389 +9787508471433 +9787508471457 +9787508471600 +9787508471860 +9787508472003 +9787508472850 +9787508472874 +9787508473345 +9787508473543 +9787508473833 +9787508473932 +9787508474809 +9787508475561 +9787508475950 +9787508476209 +9787508476834 +9787508476841 +9787508477954 +9787508478517 +9787508479446 +9787508479866 +9787508480060 +9787508480992 +9787508481784 +9787508481876 +9787508481968 +9787508482019 +9787508483849 +9787508483900 +9787508484525 +9787508484655 +9787508484853 +9787508485423 +9787508486062 +9787508486239 +9787508488530 +9787508488707 +9787508488813 +9787508490724 +9787508491646 +9787508492742 +9787508492773 +9787508493732 +9787508493848 +9787508494272 +9787508494906 +9787508494920 +9787508495255 +9787508495279 +9787508495330 +9787508495651 +9787508495668 +9787508495903 +9787508497624 +9787508497631 +9787508497839 +9787508498942 +9787508499406 +9787508500263 +9787508500812 +9787508501215 +9787508501604 +9787508501611 +9787508501635 +9787508502199 +9787508502502 +9787508502526 +9787508502564 +9787508502908 +9787508502953 +9787508502991 +9787508503004 +9787508503097 +9787508503677 +9787508503745 +9787508503813 +9787508503820 +9787508503967 +9787508503981 +9787508504087 +9787508504216 +9787508504292 +9787508504407 +9787508504414 +9787508504490 +9787508504711 +9787508505084 +9787508505190 +9787508505282 +9787508505411 +9787508505428 +9787508505770 +9787508505862 +9787508505923 +9787508505978 +9787508505992 +9787508506111 +9787508506128 +9787508506289 +9787508506920 +9787508507002 +9787508507323 +9787508507392 +9787508507590 +9787508507934 +9787508508030 +9787508508061 +9787508508078 +9787508508139 +9787508508382 +9787508508399 +9787508508474 +9787508508481 +9787508508535 +9787508508610 +9787508508689 +9787508508740 +9787508508825 +9787508509426 +9787508509464 +9787508509471 +9787508509570 +9787508509624 +9787508509662 +9787508509938 +9787508509969 +9787508510200 +9787508510248 +9787508510262 +9787508510323 +9787508511047 +9787508511177 +9787508511474 +9787508511498 +9787508511528 +9787508511566 +9787508511658 +9787508511665 +9787508511672 +9787508511689 +9787508511917 +9787508512082 +9787508512792 +9787508512853 +9787508513188 +9787508513294 +9787508513362 +9787508513447 +9787508513621 +9787508513645 +9787508513706 +9787508513720 +9787508513737 +9787508513829 +9787508514109 +9787508514437 +9787508514536 +9787508514581 +9787508514994 +9787508515328 +9787508515441 +9787508515526 +9787508515540 +9787508515625 +9787508515632 +9787508515656 +9787508515854 +9787508516097 +9787508516103 +9787508516110 +9787508516127 +9787508516325 +9787508516332 +9787508516431 +9787508516707 +9787508516745 +9787508516820 +9787508516950 +9787508517025 +9787508517032 +9787508517339 +9787508517384 +9787508517643 +9787508517728 +9787508517766 +9787508517896 +9787508518237 +9787508518664 +9787508518732 +9787508518787 +9787508518831 +9787508518855 +9787508518985 +9787508519074 +9787508519081 +9787508519838 +9787508519913 +9787508519968 +9787508520261 +9787508520537 +9787508520551 +9787508520575 +9787508520698 +9787508520704 +9787508521350 +9787508521534 +9787508521626 +9787508521695 +9787508521732 +9787508521770 +9787508522067 +9787508522210 +9787508522432 +9787508522548 +9787508522609 +9787508522647 +9787508522937 +9787508522968 +9787508523231 +9787508523408 +9787508523613 +9787508523705 +9787508524054 +9787508524115 +9787508524207 +9787508524511 +9787508524573 +9787508524849 +9787508525037 +9787508526119 +9787508526379 +9787508526423 +9787508526508 +9787508526539 +9787508526843 +9787508526935 +9787508526980 +9787508527031 +9787508527147 +9787508527345 +9787508527420 +9787508527581 +9787508527642 +9787508527673 +9787508527789 +9787508527826 +9787508527857 +9787508527918 +9787508527925 +9787508527956 +9787508527963 +9787508528205 +9787508528977 +9787508529271 +9787508529400 +9787508529479 +9787508529509 +9787508530079 +9787508530505 +9787508530772 +9787508530796 +9787508531472 +9787508531519 +9787508531564 +9787508531977 +9787508532394 +9787508532516 +9787508532714 +9787508533018 +9787508533032 +9787508533087 +9787508533155 +9787508533889 +9787508534220 +9787508534428 +9787508534534 +9787508534633 +9787508534671 +9787508534800 +9787508534862 +9787508534893 +9787508535067 +9787508535159 +9787508535258 +9787508535500 +9787508535517 +9787508535739 +9787508535791 +9787508536002 +9787508536026 +9787508536118 +9787508536200 +9787508536217 +9787508536255 +9787508536521 +9787508536538 +9787508536606 +9787508536972 +9787508537412 +9787508537788 +9787508538402 +9787508538495 +9787508538853 +9787508538860 +9787508538877 +9787508538907 +9787508538945 +9787508538976 +9787508539355 +9787508539515 +9787508539805 +9787508539997 +9787508540054 +9787508540108 +9787508540139 +9787508540528 +9787508540559 +9787508541075 +9787508541365 +9787508541938 +9787508542294 +9787508543017 +9787508543321 +9787508543505 +9787508543628 +9787508543970 +9787508544441 +9787508544588 +9787508544670 +9787508545011 +9787508545165 +9787508545455 +9787508545691 +9787508545882 +9787508546353 +9787508546445 +9787508546452 +9787508546797 +9787508547084 +9787508547305 +9787508547985 +9787508548111 +9787508548517 +9787508549729 +9787508549880 +9787508550480 +9787508550497 +9787508550626 +9787508550831 +9787508550886 +9787508551005 +9787508551081 +9787508551197 +9787508551234 +9787508551258 +9787508551401 +9787508551500 +9787508551548 +9787508551593 +9787508551623 +9787508552033 +9787508552811 +9787508552903 +9787508552996 +9787508553153 +9787508553627 +9787508600123 +9787508600475 +9787508600819 +9787508600826 +9787508600901 +9787508600925 +9787508601113 +9787508601137 +9787508601311 +9787508601380 +9787508601472 +9787508601502 +9787508601557 +9787508601939 +9787508602004 +9787508602127 +9787508602202 +9787508602523 +9787508602622 +9787508602707 +9787508602868 +9787508602905 +9787508603001 +9787508603018 +9787508603056 +9787508603391 +9787508603414 +9787508603636 +9787508603834 +9787508603841 +9787508603896 +9787508604008 +9787508604077 +9787508604121 +9787508604305 +9787508604473 +9787508604640 +9787508604725 +9787508604770 +9787508604848 +9787508604879 +9787508604916 +9787508604961 +9787508605128 +9787508605197 +9787508605340 +9787508605500 +9787508605562 +9787508605630 +9787508605708 +9787508605746 +9787508605791 +9787508605906 +9787508605975 +9787508605982 +9787508606002 +9787508606026 +9787508606194 +9787508606255 +9787508606262 +9787508606491 +9787508606552 +9787508606859 +9787508606972 +9787508606989 +9787508607009 +9787508607047 +9787508607054 +9787508607160 +9787508607252 +9787508607313 +9787508607399 +9787508607474 +9787508607535 +9787508607580 +9787508607771 +9787508607825 +9787508607849 +9787508607955 +9787508608280 +9787508608327 +9787508608396 +9787508608730 +9787508608754 +9787508608761 +9787508608815 +9787508608921 +9787508608969 +9787508609157 +9787508609188 +9787508609270 +9787508609478 +9787508609652 +9787508609959 +9787508609997 +9787508610030 +9787508610313 +9787508610528 +9787508610566 +9787508610771 +9787508610917 +9787508610955 +9787508611150 +9787508611532 +9787508611549 +9787508611556 +9787508611662 +9787508611723 +9787508611747 +9787508612157 +9787508612850 +9787508612881 +9787508612911 +9787508613055 +9787508613109 +9787508613116 +9787508613161 +9787508613444 +9787508613512 +9787508613772 +9787508613970 +9787508613987 +9787508613994 +9787508614229 +9787508614236 +9787508614298 +9787508614472 +9787508614922 +9787508614939 +9787508614946 +9787508614960 +9787508615059 +9787508615233 +9787508615349 +9787508615424 +9787508615837 +9787508615943 +9787508616520 +9787508616773 +9787508616797 +9787508617008 +9787508617107 +9787508617404 +9787508617558 +9787508617657 +9787508618128 +9787508618135 +9787508618142 +9787508618159 +9787508618203 +9787508618210 +9787508618272 +9787508618937 +9787508619095 +9787508619101 +9787508619118 +9787508619200 +9787508619347 +9787508619385 +9787508619484 +9787508619682 +9787508619873 +9787508620398 +9787508620510 +9787508620626 +9787508620657 +9787508620718 +9787508620831 +9787508620916 +9787508621340 +9787508621418 +9787508621425 +9787508621654 +9787508621838 +9787508621890 +9787508622132 +9787508622200 +9787508622729 +9787508622743 +9787508622842 +9787508623016 +9787508623139 +9787508623283 +9787508623535 +9787508623559 +9787508623870 +9787508624068 +9787508624181 +9787508624198 +9787508624372 +9787508624396 +9787508624549 +9787508624655 +9787508624877 +9787508625188 +9787508625485 +9787508625492 +9787508625515 +9787508626642 +9787508627533 +9787508627670 +9787508627960 +9787508628004 +9787508628783 +9787508629445 +9787508629476 +9787508629575 +9787508629735 +9787508629926 +9787508630038 +9787508630311 +9787508630632 +9787508630793 +9787508630922 +9787508630960 +9787508631028 +9787508631530 +9787508632964 +9787508633169 +9787508633541 +9787508634401 +9787508635248 +9787508636115 +9787508636382 +9787508636467 +9787508636528 +9787508636849 +9787508636887 +9787508637020 +9787508637129 +9787508637600 +9787508639048 +9787508639642 +9787508639666 +9787508639697 +9787508639710 +9787508640242 +9787508640945 +9787508641577 +9787508643113 +9787508643380 +9787508643496 +9787508643922 +9787508645216 +9787508646220 +9787508646398 +9787508647494 +9787508647555 +9787508647890 +9787508647968 +9787508648354 +9787508650319 +9787508650340 +9787508650456 +9787508650944 +9787508651262 +9787508652320 +9787508652610 +9787508652702 +9787508653013 +9787508653099 +9787508653914 +9787508654492 +9787508654713 +9787508654737 +9787508655833 +9787508656113 +9787508656557 +9787508656670 +9787508656717 +9787508657967 +9787508658087 +9787508658285 +9787508658377 +9787508658421 +9787508658469 +9787508658728 +9787508658773 +9787508659305 +9787508659497 +9787508659534 +9787508659541 +9787508659688 +9787508659862 +9787508660394 +9787508660523 +9787508660653 +9787508660660 +9787508660677 +9787508660998 +9787508661070 +9787508661322 +9787508662060 +9787508663067 +9787508663364 +9787508663388 +9787508665917 +9787508666150 +9787508666174 +9787508666181 +9787508666426 +9787508666433 +9787508666440 +9787508666457 +9787508667263 +9787508667454 +9787508668611 +9787508668659 +9787508669199 +9787508669540 +9787508669625 +9787508669663 +9787508670072 +9787508670317 +9787508670539 +9787508670768 +9787508672120 +9787508672267 +9787508672595 +9787508672618 +9787508672625 +9787508672922 +9787508673462 +9787508673677 +9787508674339 +9787508675442 +9787508675626 +9787508675985 +9787508676043 +9787508676418 +9787508680262 +9787508680422 +9787508681351 +9787508681375 +9787508681764 +9787508681870 +9787508682235 +9787508682402 +9787508682419 +9787508683065 +9787508683072 +9787508683089 +9787508683317 +9787508684659 +9787508684680 +9787508684697 +9787508685564 +9787508686370 +9787508686875 +9787508687377 +9787508688237 +9787508688329 +9787508689876 +9787508691770 +9787508691824 +9787508691831 +9787508691848 +9787508691855 +9787508692296 +9787508692685 +9787508692937 +9787508693453 +9787508694108 +9787508694283 +9787508694467 +9787508694603 +9787508695150 +9787508695334 +9787508696140 +9787508696416 +9787508696577 +9787508696720 +9787508696799 +9787508697161 +9787508697321 +9787508697338 +9787508697451 +9787508697574 +9787508697703 +9787508698519 +9787508698595 +9787508698892 +9787508699035 +9787508699585 +9787508700229 +9787508700243 +9787508700403 +9787508700465 +9787508700472 +9787508700502 +9787508700557 +9787508700571 +9787508700588 +9787508700601 +9787508700670 +9787508700694 +9787508700731 +9787508700755 +9787508700847 +9787508700939 +9787508701028 +9787508701219 +9787508701318 +9787508701370 +9787508701486 +9787508701509 +9787508701776 +9787508701820 +9787508701905 +9787508701912 +9787508702056 +9787508702131 +9787508702230 +9787508702476 +9787508702506 +9787508702650 +9787508702681 +9787508702742 +9787508702896 +9787508702988 +9787508703022 +9787508703176 +9787508703183 +9787508703190 +9787508703220 +9787508703237 +9787508703268 +9787508703312 +9787508703336 +9787508703626 +9787508703657 +9787508703787 +9787508703800 +9787508703909 +9787508703916 +9787508703923 +9787508703930 +9787508703954 +9787508703961 +9787508704029 +9787508704043 +9787508704579 +9787508704937 +9787508705002 +9787508705064 +9787508705088 +9787508705132 +9787508705354 +9787508705361 +9787508705408 +9787508705477 +9787508705491 +9787508705507 +9787508705521 +9787508705668 +9787508705699 +9787508705781 +9787508705866 +9787508705934 +9787508705958 +9787508705972 +9787508705989 +9787508706047 +9787508706184 +9787508706214 +9787508706252 +9787508706269 +9787508706306 +9787508706313 +9787508706320 +9787508706337 +9787508706443 +9787508706542 +9787508706597 +9787508706610 +9787508706641 +9787508706658 +9787508706757 +9787508706764 +9787508706771 +9787508707020 +9787508707105 +9787508707167 +9787508707518 +9787508707556 +9787508707600 +9787508707679 +9787508707693 +9787508707785 +9787508707808 +9787508708119 +9787508708201 +9787508708348 +9787508708379 +9787508708584 +9787508708836 +9787508708928 +9787508708942 +9787508709307 +9787508709444 +9787508709505 +9787508709659 +9787508709666 +9787508709710 +9787508709758 +9787508709765 +9787508709819 +9787508710037 +9787508710099 +9787508710112 +9787508710136 +9787508710150 +9787508710211 +9787508710228 +9787508710266 +9787508710280 +9787508710303 +9787508710372 +9787508710419 +9787508710426 +9787508710488 +9787508710730 +9787508711027 +9787508711034 +9787508711102 +9787508711195 +9787508711225 +9787508711256 +9787508711348 +9787508711478 +9787508711577 +9787508711645 +9787508711935 +9787508712123 +9787508712246 +9787508712277 +9787508712338 +9787508712420 +9787508712482 +9787508712499 +9787508712512 +9787508712529 +9787508712550 +9787508712567 +9787508712581 +9787508712611 +9787508712635 +9787508712857 +9787508712949 +9787508712956 +9787508712970 +9787508713120 +9787508713199 +9787508713335 +9787508713359 +9787508713397 +9787508713496 +9787508713663 +9787508713861 +9787508713946 +9787508714066 +9787508714141 +9787508714219 +9787508714684 +9787508714790 +9787508714813 +9787508714875 +9787508715179 +9787508715261 +9787508715322 +9787508715445 +9787508715513 +9787508715520 +9787508715544 +9787508715636 +9787508715704 +9787508716107 +9787508716121 +9787508716176 +9787508716206 +9787508716473 +9787508716619 +9787508716893 +9787508716909 +9787508717012 +9787508717036 +9787508717227 +9787508717623 +9787508717630 +9787508717890 +9787508718156 +9787508718170 +9787508718187 +9787508718347 +9787508718415 +9787508718439 +9787508718613 +9787508718835 +9787508718903 +9787508719078 +9787508719092 +9787508719153 +9787508719160 +9787508719238 +9787508719320 +9787508719412 +9787508719863 +9787508720005 +9787508720067 +9787508720111 +9787508720265 +9787508720272 +9787508720289 +9787508720302 +9787508720364 +9787508720371 +9787508720395 +9787508720456 +9787508720579 +9787508720654 +9787508720661 +9787508720685 +9787508720722 +9787508720807 +9787508721118 +9787508721576 +9787508721767 +9787508722030 +9787508722399 +9787508722405 +9787508722504 +9787508722719 +9787508722726 +9787508723082 +9787508723136 +9787508723334 +9787508723853 +9787508723877 +9787508723938 +9787508724003 +9787508724232 +9787508724324 +9787508724423 +9787508724447 +9787508724539 +9787508724584 +9787508724591 +9787508724744 +9787508724843 +9787508724850 +9787508724911 +9787508724959 +9787508725154 +9787508725192 +9787508725437 +9787508725604 +9787508725833 +9787508725840 +9787508725994 +9787508726007 +9787508726168 +9787508726199 +9787508726205 +9787508726687 +9787508726779 +9787508726786 +9787508726960 +9787508727103 +9787508727158 +9787508727165 +9787508727226 +9787508727394 +9787508727424 +9787508727820 +9787508727950 +9787508728049 +9787508728087 +9787508728131 +9787508728155 +9787508728186 +9787508728193 +9787508728582 +9787508728681 +9787508728735 +9787508728803 +9787508728858 +9787508728971 +9787508728988 +9787508729015 +9787508729282 +9787508729374 +9787508729381 +9787508729503 +9787508729565 +9787508729596 +9787508729626 +9787508729763 +9787508729954 +9787508730325 +9787508730356 +9787508730417 +9787508730752 +9787508731094 +9787508731155 +9787508731414 +9787508731766 +9787508731773 +9787508731797 +9787508731803 +9787508731810 +9787508732091 +9787508732237 +9787508732534 +9787508732664 +9787508732831 +9787508732862 +9787508732978 +9787508733098 +9787508733111 +9787508733135 +9787508733241 +9787508733258 +9787508733326 +9787508733487 +9787508733579 +9787508733623 +9787508733722 +9787508733746 +9787508733890 +9787508733906 +9787508734101 +9787508734330 +9787508734804 +9787508735047 +9787508735078 +9787508735139 +9787508735276 +9787508735856 +9787508735887 +9787508736013 +9787508736211 +9787508736310 +9787508737027 +9787508737454 +9787508737744 +9787508737843 +9787508737850 +9787508738383 +9787508738543 +9787508738666 +9787508738758 +9787508738888 +9787508739618 +9787508739694 +9787508739724 +9787508739915 +9787508739946 +9787508740003 +9787508740027 +9787508740058 +9787508740096 +9787508740232 +9787508740973 +9787508741062 +9787508741086 +9787508741147 +9787508741246 +9787508741826 +9787508742205 +9787508742403 +9787508742410 +9787508742427 +9787508742540 +9787508742663 +9787508743196 +9787508743240 +9787508743929 +9787508744032 +9787508744131 +9787508744544 +9787508744674 +9787508744926 +9787508745602 +9787508745619 +9787508745763 +9787508745824 +9787508745831 +9787508745985 +9787508745992 +9787508746029 +9787508746135 +9787508746173 +9787508746579 +9787508746661 +9787508746678 +9787508747378 +9787508748290 +9787508748320 +9787508748382 +9787508748504 +9787508749068 +9787508749280 +9787508749570 +9787508750217 +9787508750828 +9787508751153 +9787508751429 +9787508751443 +9787508751764 +9787508751795 +9787508752037 +9787508752297 +9787508752341 +9787508753089 +9787508753331 +9787508753461 +9787508753591 +9787508753713 +9787508754222 +9787508754406 +9787508754499 +9787508754628 +9787508754871 +9787508755205 +9787508755502 +9787508755823 +9787508755915 +9787508756165 +9787508756592 +9787508756790 +9787508756967 +9787508757469 +9787508758954 +9787508759562 +9787508760445 +9787508760568 +9787508760728 +9787508761039 +9787508761145 +9787508761398 +9787508761718 +9787508762128 +9787508762692 +9787508762814 +9787508763071 +9787508763132 +9787508763149 +9787508763231 +9787508763439 +9787508763453 +9787508763491 +9787508763545 +9787508763583 +9787508763910 +9787508763927 +9787508763958 +9787508764030 +9787508764177 +9787508764184 +9787508764351 +9787508764559 +9787508764627 +9787508764696 +9787508764702 +9787508764726 +9787508765198 +9787508765228 +9787508765402 +9787508765464 +9787508765471 +9787508765709 +9787508765921 +9787508766072 +9787508766089 +9787508766249 +9787508766287 +9787508766416 +9787508766911 +9787508767062 +9787508767161 +9787508767826 +9787508767925 +9787508768120 +9787508768182 +9787508768373 +9787508768564 +9787508768625 +9787508768816 +9787508769127 +9787508769172 +9787508769202 +9787508769349 +9787508769394 +9787508769448 +9787508769530 +9787508769646 +9787508769769 +9787508770017 +9787508770024 +9787508770031 +9787508770048 +9787508770055 +9787508770123 +9787508770154 +9787508770345 +9787508770413 +9787508770550 +9787508770932 +9787508771182 +9787508771533 +9787508771540 +9787508771557 +9787508771564 +9787508771687 +9787508801025 +9787508802671 +9787508804422 +9787508804453 +9787508804460 +9787508804484 +9787508804514 +9787508804569 +9787508804651 +9787508804927 +9787508804965 +9787508807614 +9787508809397 +9787508809410 +9787508811598 +9787508811604 +9787508812557 +9787508812786 +9787508813516 +9787508813776 +9787508814254 +9787508814285 +9787508814322 +9787508814599 +9787508815046 +9787508815060 +9787508815077 +9787508815305 +9787508815855 +9787508816814 +9787508816821 +9787508816838 +9787508816869 +9787508816883 +9787508817019 +9787508818887 +9787508819457 +9787508819532 +9787508819563 +9787508819600 +9787508819648 +9787508820743 +9787508821443 +9787508821450 +9787508821467 +9787508821474 +9787508821498 +9787508821597 +9787508821993 +9787508822013 +9787508822235 +9787508822266 +9787508822310 +9787508824451 +9787508825069 +9787508825083 +9787508825106 +9787508825120 +9787508825205 +9787508825212 +9787508825373 +9787508825427 +9787508825601 +9787508825618 +9787508825663 +9787508825670 +9787508825700 +9787508825779 +9787508825786 +9787508825823 +9787508825830 +9787508825922 +9787508827537 +9787508828824 +9787508828831 +9787508829371 +9787508829708 +9787508829746 +9787508829869 +9787508831114 +9787508832180 +9787508832623 +9787508832777 +9787508832784 +9787508832883 +9787508835068 +9787508835228 +9787508835235 +9787508835327 +9787508835921 +9787508836164 +9787508836225 +9787508836492 +9787508836935 +9787508837529 +9787508837666 +9787508837680 +9787508837703 +9787508837734 +9787508838755 +9787508839875 +9787508839905 +9787508839912 +9787508840031 +9787508840055 +9787508840222 +9787508840987 +9787508840994 +9787508841007 +9787508841021 +9787508841038 +9787508841069 +9787508841076 +9787508841175 +9787508841182 +9787508841199 +9787508841229 +9787508841236 +9787508841250 +9787508841267 +9787508841892 +9787508842073 +9787508842301 +9787508842349 +9787508842653 +9787508842684 +9787508842691 +9787508842707 +9787508842851 +9787508842882 +9787508842936 +9787508842943 +9787508842950 +9787508842967 +9787508843032 +9787508843070 +9787508843087 +9787508843117 +9787508843124 +9787508843131 +9787508843148 +9787508843179 +9787508843278 +9787508843322 +9787508843339 +9787508843353 +9787508843360 +9787508843919 +9787508843933 +9787508843971 +9787508844039 +9787508844046 +9787508844220 +9787508845265 +9787508845272 +9787508845982 +9787508846002 +9787508846088 +9787508846613 +9787508847306 +9787508848822 +9787508851341 +9787508852478 +9787508853765 +9787508856773 +9787508856797 +9787508857411 +9787508857503 +9787508858739 +9787508858753 +9787508858791 +9787508859118 +9787508859125 +9787508859132 +9787508860480 +9787508860503 +9787508861586 +9787508861944 +9787508861951 +9787508861968 +9787508861975 +9787508861982 +9787508862057 +9787508862118 +9787508862125 +9787508862149 +9787508862156 +9787508862163 +9787508862170 +9787508862422 +9787508862903 +9787508863245 +9787508863269 +9787508863450 +9787508863474 +9787508863641 +9787508863719 +9787508864372 +9787509000014 +9787509000021 +9787509000038 +9787509000175 +9787509000182 +9787509000250 +9787509000366 +9787509000465 +9787509000625 +9787509000632 +9787509000694 +9787509000700 +9787509000755 +9787509000908 +9787509000984 +9787509001141 +9787509001448 +9787509001523 +9787509001677 +9787509001790 +9787509001806 +9787509001813 +9787509001837 +9787509001905 +9787509001950 +9787509001974 +9787509002032 +9787509002056 +9787509002117 +9787509002155 +9787509002254 +9787509002292 +9787509002339 +9787509002513 +9787509002599 +9787509002612 +9787509002650 +9787509002735 +9787509002810 +9787509002872 +9787509002902 +9787509002926 +9787509003039 +9787509003046 +9787509003176 +9787509003251 +9787509003398 +9787509003459 +9787509003497 +9787509003534 +9787509003633 +9787509003718 +9787509003732 +9787509003787 +9787509004135 +9787509004159 +9787509004258 +9787509004371 +9787509004401 +9787509004418 +9787509004500 +9787509004609 +9787509004616 +9787509004647 +9787509004692 +9787509004807 +9787509004876 +9787509005248 +9787509005330 +9787509005415 +9787509005507 +9787509005521 +9787509005538 +9787509005545 +9787509005644 +9787509005743 +9787509006054 +9787509006139 +9787509006306 +9787509006467 +9787509006535 +9787509006801 +9787509007013 +9787509007105 +9787509007389 +9787509007457 +9787509007679 +9787509007860 +9787509008232 +9787509008249 +9787509008287 +9787509008355 +9787509008461 +9787509008577 +9787509009154 +9787509009185 +9787509009284 +9787509009291 +9787509009536 +9787509009703 +9787509009857 +9787509010143 +9787509010259 +9787509010419 +9787509010501 +9787509010563 +9787509010594 +9787509010655 +9787509011270 +9787509011324 +9787509011379 +9787509011829 +9787509012758 +9787509012802 +9787509013007 +9787509013083 +9787509013724 +9787509013748 +9787509014394 +9787509014769 +9787509014844 +9787509014998 +9787509015216 +9787509015384 +9787509015926 +9787509016008 +9787509016084 +9787509016145 +9787509016299 +9787509016626 +9787509016688 +9787509017005 +9787509017111 +9787509017210 +9787509017227 +9787509017234 +9787509017241 +9787509017319 +9787509017418 +9787509017616 +9787509017623 +9787509017630 +9787509017715 +9787509017814 +9787509017845 +9787509017906 +9787509017913 +9787509017920 +9787509017937 +9787509017975 +9787509018361 +9787509018415 +9787509018477 +9787509018507 +9787509100011 +9787509100073 +9787509100134 +9787509100165 +9787509100264 +9787509100325 +9787509100424 +9787509100523 +9787509100608 +9787509100875 +9787509100899 +9787509100905 +9787509101278 +9787509101292 +9787509101315 +9787509101667 +9787509102206 +9787509102329 +9787509102381 +9787509102473 +9787509102534 +9787509102596 +9787509102602 +9787509102732 +9787509102763 +9787509102862 +9787509103012 +9787509103043 +9787509103074 +9787509103265 +9787509103647 +9787509103838 +9787509104118 +9787509104279 +9787509104415 +9787509104729 +9787509104859 +9787509104873 +9787509104958 +9787509105214 +9787509105337 +9787509105351 +9787509105405 +9787509105702 +9787509105917 +9787509106051 +9787509106099 +9787509106129 +9787509106211 +9787509106327 +9787509106525 +9787509106570 +9787509106587 +9787509106631 +9787509106648 +9787509106822 +9787509106853 +9787509106860 +9787509107201 +9787509107324 +9787509107379 +9787509107409 +9787509107485 +9787509107638 +9787509107706 +9787509107843 +9787509107942 +9787509108017 +9787509108208 +9787509108215 +9787509108512 +9787509108550 +9787509108567 +9787509109113 +9787509109250 +9787509110171 +9787509110607 +9787509110683 +9787509110690 +9787509110898 +9787509111116 +9787509111178 +9787509111444 +9787509111482 +9787509111567 +9787509111581 +9787509111598 +9787509111703 +9787509111727 +9787509111895 +9787509112120 +9787509112304 +9787509112625 +9787509112632 +9787509112663 +9787509112687 +9787509112946 +9787509113028 +9787509113059 +9787509113288 +9787509113516 +9787509113592 +9787509113813 +9787509113851 +9787509113868 +9787509113981 +9787509114018 +9787509114131 +9787509114148 +9787509114292 +9787509114735 +9787509114742 +9787509115510 +9787509115800 +9787509115831 +9787509115855 +9787509115909 +9787509115923 +9787509115947 +9787509116104 +9787509116111 +9787509116272 +9787509116463 +9787509116609 +9787509116692 +9787509116708 +9787509116760 +9787509116869 +9787509117095 +9787509117170 +9787509117491 +9787509117538 +9787509117651 +9787509117699 +9787509117705 +9787509117910 +9787509117927 +9787509118030 +9787509118054 +9787509118078 +9787509118122 +9787509118146 +9787509118160 +9787509118276 +9787509118474 +9787509118689 +9787509118696 +9787509118771 +9787509118917 +9787509119099 +9787509119136 +9787509119228 +9787509119396 +9787509119433 +9787509119495 +9787509119549 +9787509119600 +9787509119907 +9787509119976 +9787509120064 +9787509120927 +9787509120958 +9787509121139 +9787509121337 +9787509121344 +9787509121351 +9787509121658 +9787509121726 +9787509121757 +9787509121948 +9787509122594 +9787509122617 +9787509122648 +9787509122815 +9787509122891 +9787509122907 +9787509123010 +9787509123096 +9787509123218 +9787509123225 +9787509123560 +9787509123706 +9787509123799 +9787509124529 +9787509124956 +9787509125403 +9787509125441 +9787509126110 +9787509126387 +9787509126783 +9787509126806 +9787509126998 +9787509127018 +9787509127032 +9787509127063 +9787509127247 +9787509127742 +9787509127964 +9787509128381 +9787509128541 +9787509128589 +9787509128602 +9787509128954 +9787509128961 +9787509129029 +9787509129364 +9787509129388 +9787509129395 +9787509129418 +9787509129449 +9787509130643 +9787509130803 +9787509131077 +9787509131190 +9787509131404 +9787509131428 +9787509132128 +9787509132210 +9787509132265 +9787509132913 +9787509133422 +9787509133484 +9787509133903 +9787509133934 +9787509133965 +9787509134184 +9787509134207 +9787509134481 +9787509134948 +9787509134979 +9787509135037 +9787509135105 +9787509135990 +9787509136492 +9787509136706 +9787509136737 +9787509137017 +9787509137123 +9787509137383 +9787509137482 +9787509137567 +9787509137833 +9787509138137 +9787509138168 +9787509138434 +9787509138557 +9787509138564 +9787509138601 +9787509138755 +9787509138885 +9787509139189 +9787509139554 +9787509139707 +9787509139714 +9787509140062 +9787509140574 +9787509140703 +9787509140864 +9787509140987 +9787509141496 +9787509141724 +9787509141977 +9787509142073 +9787509142080 +9787509142707 +9787509142714 +9787509142721 +9787509142875 +9787509142899 +9787509142943 +9787509142974 +9787509143551 +9787509144046 +9787509144213 +9787509144640 +9787509145678 +9787509145685 +9787509145692 +9787509145869 +9787509146439 +9787509146507 +9787509146705 +9787509146750 +9787509146781 +9787509146804 +9787509146903 +9787509147085 +9787509147429 +9787509147580 +9787509147863 +9787509148099 +9787509148303 +9787509148471 +9787509148501 +9787509148853 +9787509149294 +9787509149966 +9787509150146 +9787509150450 +9787509150481 +9787509150573 +9787509150733 +9787509150986 +9787509151013 +9787509151051 +9787509151785 +9787509152232 +9787509152973 +9787509152980 +9787509153345 +9787509153468 +9787509153482 +9787509154274 +9787509154465 +9787509155103 +9787509155158 +9787509155202 +9787509155592 +9787509155851 +9787509156001 +9787509156049 +9787509156292 +9787509156315 +9787509156537 +9787509157046 +9787509157169 +9787509157435 +9787509157725 +9787509157992 +9787509158050 +9787509158067 +9787509158135 +9787509158227 +9787509158289 +9787509158388 +9787509158470 +9787509158685 +9787509158913 +9787509158944 +9787509159019 +9787509159194 +9787509160206 +9787509160442 +9787509160572 +9787509160732 +9787509160763 +9787509161289 +9787509161364 +9787509161432 +9787509162453 +9787509162927 +9787509162941 +9787509162965 +9787509163047 +9787509163283 +9787509163429 +9787509163597 +9787509163788 +9787509164358 +9787509164488 +9787509164600 +9787509165461 +9787509165492 +9787509165508 +9787509165522 +9787509165843 +9787509165911 +9787509165928 +9787509165980 +9787509165997 +9787509166000 +9787509166079 +9787509166130 +9787509166291 +9787509166505 +9787509166604 +9787509166697 +9787509166970 +9787509167380 +9787509167595 +9787509168080 +9787509168097 +9787509168288 +9787509168479 +9787509169001 +9787509169018 +9787509169124 +9787509169131 +9787509169414 +9787509169544 +9787509169568 +9787509169896 +9787509170434 +9787509170519 +9787509171349 +9787509171400 +9787509171905 +9787509172018 +9787509172353 +9787509172414 +9787509172711 +9787509172957 +9787509173060 +9787509173077 +9787509173251 +9787509173992 +9787509174104 +9787509174135 +9787509174166 +9787509174326 +9787509174333 +9787509174654 +9787509174890 +9787509175026 +9787509175422 +9787509175569 +9787509175583 +9787509175620 +9787509175811 +9787509175828 +9787509175941 +9787509176009 +9787509176092 +9787509176115 +9787509176139 +9787509176191 +9787509176290 +9787509176306 +9787509176368 +9787509176436 +9787509176467 +9787509176535 +9787509176566 +9787509176580 +9787509176856 +9787509176917 +9787509177099 +9787509178089 +9787509178096 +9787509178331 +9787509178645 +9787509178799 +9787509178867 +9787509180259 +9787509180488 +9787509180518 +9787509181928 +9787509182116 +9787509182253 +9787509182437 +9787509182680 +9787509182802 +9787509183014 +9787509183113 +9787509183144 +9787509183151 +9787509183168 +9787509183311 +9787509183335 +9787509183342 +9787509183380 +9787509183458 +9787509183816 +9787509184097 +9787509184103 +9787509184127 +9787509184158 +9787509184219 +9787509184332 +9787509184394 +9787509184639 +9787509185315 +9787509185339 +9787509185353 +9787509185414 +9787509185445 +9787509185544 +9787509185636 +9787509185872 +9787509185933 +9787509185957 +9787509186138 +9787509186152 +9787509186176 +9787509186275 +9787509186282 +9787509186336 +9787509186404 +9787509186589 +9787509186763 +9787509186978 +9787509187128 +9787509187487 +9787509187586 +9787509187593 +9787509188095 +9787509188200 +9787509188286 +9787509188385 +9787509189177 +9787509189221 +9787509189290 +9787509189528 +9787509189542 +9787509189733 +9787509190210 +9787509190456 +9787509190463 +9787509192054 +9787509192412 +9787509192702 +9787509192740 +9787509192757 +9787509192894 +9787509192917 +9787509193488 +9787509200070 +9787509200087 +9787509200216 +9787509200391 +9787509200490 +9787509200537 +9787509200766 +9787509200841 +9787509200865 +9787509200919 +9787509201329 +9787509201374 +9787509201442 +9787509201466 +9787509201503 +9787509201534 +9787509201749 +9787509201787 +9787509202036 +9787509202081 +9787509202166 +9787509202999 +9787509203088 +9787509203262 +9787509203415 +9787509203477 +9787509204047 +9787509204214 +9787509204474 +9787509204511 +9787509204542 +9787509205112 +9787509205150 +9787509205167 +9787509205181 +9787509205242 +9787509205259 +9787509205266 +9787509205280 +9787509205389 +9787509205433 +9787509205549 +9787509205662 +9787509205792 +9787509206058 +9787509206065 +9787509206225 +9787509206232 +9787509206263 +9787509206294 +9787509206362 +9787509206386 +9787509206416 +9787509206492 +9787509206584 +9787509206942 +9787509206966 +9787509207185 +9787509207369 +9787509207383 +9787509207659 +9787509207710 +9787509207802 +9787509208182 +9787509208229 +9787509208236 +9787509208403 +9787509208601 +9787509208625 +9787509208724 +9787509209257 +9787509209370 +9787509209394 +9787509209479 +9787509209554 +9787509209615 +9787509209677 +9787509209912 +9787509210062 +9787509210598 +9787509210727 +9787509210956 +9787509211137 +9787509211328 +9787509211526 +9787509211588 +9787509211656 +9787509211762 +9787509211847 +9787509211939 +9787509212110 +9787509212127 +9787509212141 +9787509213056 +9787509214053 +9787509214077 +9787509214336 +9787509214367 +9787509214817 +9787509215074 +9787509216859 +9787509217320 +9787509217429 +9787509218938 +9787509219416 +9787509219638 +9787509219645 +9787509219652 +9787509219812 +9787509219843 +9787509219942 +9787509219966 +9787509220023 +9787509220153 +9787509220405 +9787509220627 +9787509220634 +9787509220641 +9787509220757 +9787509220771 +9787509220887 +9787509220924 +9787509221204 +9787509221525 +9787509222201 +9787509222218 +9787509222324 +9787509222676 +9787509222706 +9787509222751 +9787509222775 +9787509223222 +9787509224021 +9787509224038 +9787509224045 +9787509224052 +9787509224175 +9787509224335 +9787509224342 +9787509224588 +9787509224649 +9787509224724 +9787509225073 +9787509225370 +9787509225448 +9787509225684 +9787509226506 +9787509227206 +9787509300459 +9787509300725 +9787509300992 +9787509303566 +9787509303573 +9787509304495 +9787509305461 +9787509305683 +9787509305959 +9787509306437 +9787509307472 +9787509307588 +9787509307731 +9787509307861 +9787509307922 +9787509309506 +9787509309728 +9787509310281 +9787509314203 +9787509315170 +9787509316856 +9787509317037 +9787509318379 +9787509318911 +9787509319017 +9787509319482 +9787509319628 +9787509320082 +9787509320471 +9787509321164 +9787509321249 +9787509321546 +9787509321768 +9787509321805 +9787509322239 +9787509322666 +9787509322864 +9787509324455 +9787509326329 +9787509326527 +9787509327227 +9787509327319 +9787509327906 +9787509328415 +9787509328545 +9787509329337 +9787509329382 +9787509330302 +9787509331071 +9787509331101 +9787509331606 +9787509331613 +9787509331637 +9787509332672 +9787509334034 +9787509334195 +9787509334652 +9787509335710 +9787509336090 +9787509336946 +9787509337233 +9787509337417 +9787509338094 +9787509338308 +9787509339077 +9787509339091 +9787509339107 +9787509339114 +9787509340097 +9787509340523 +9787509340943 +9787509343104 +9787509343517 +9787509343586 +9787509343951 +9787509344187 +9787509347461 +9787509348550 +9787509349526 +9787509350430 +9787509350508 +9787509354278 +9787509355213 +9787509356265 +9787509357767 +9787509358177 +9787509362037 +9787509363508 +9787509363591 +9787509363614 +9787509365076 +9787509365618 +9787509365946 +9787509366561 +9787509366882 +9787509367391 +9787509367414 +9787509368480 +9787509368497 +9787509370261 +9787509374498 +9787509379165 +9787509379189 +9787509381847 +9787509382837 +9787509383162 +9787509383506 +9787509383964 +9787509385524 +9787509387252 +9787509387566 +9787509387962 +9787509388167 +9787509388761 +9787509389409 +9787509389874 +9787509391983 +9787509393260 +9787509395714 +9787509396155 +9787509396254 +9787509396896 +9787509397169 +9787509397589 +9787509398685 +9787509399040 +9787509400005 +9787509400104 +9787509400135 +9787509400371 +9787509400388 +9787509400470 +9787509400517 +9787509400609 +9787509400616 +9787509400654 +9787509400692 +9787509400708 +9787509400715 +9787509400760 +9787509401019 +9787509401125 +9787509401149 +9787509401170 +9787509401392 +9787509401446 +9787509401491 +9787509401781 +9787509401798 +9787509401811 +9787509401941 +9787509401958 +9787509401972 +9787509402153 +9787509402474 +9787509402481 +9787509402627 +9787509402993 +9787509403037 +9787509403198 +9787509403730 +9787509403884 +9787509404003 +9787509404140 +9787509404157 +9787509404188 +9787509404232 +9787509404256 +9787509404287 +9787509404317 +9787509404348 +9787509404423 +9787509404508 +9787509404645 +9787509404751 +9787509404904 +9787509405215 +9787509405253 +9787509405260 +9787509405277 +9787509405291 +9787509405345 +9787509405352 +9787509405390 +9787509405475 +9787509405543 +9787509405567 +9787509405581 +9787509405802 +9787509405819 +9787509406120 +9787509406144 +9787509406588 +9787509406601 +9787509406786 +9787509406823 +9787509406847 +9787509406960 +9787509407066 +9787509407127 +9787509407264 +9787509407547 +9787509407684 +9787509407707 +9787509407714 +9787509407882 +9787509408018 +9787509408131 +9787509408155 +9787509408223 +9787509408315 +9787509408322 +9787509408339 +9787509408360 +9787509408438 +9787509408483 +9787509408506 +9787509408520 +9787509408643 +9787509408896 +9787509408988 +9787509409046 +9787509409152 +9787509409169 +9787509409299 +9787509409305 +9787509409336 +9787509409534 +9787509409787 +9787509409879 +9787509409978 +9787509409985 +9787509409992 +9787509410004 +9787509410141 +9787509410158 +9787509410165 +9787509410172 +9787509410202 +9787509410226 +9787509410288 +9787509410349 +9787509410455 +9787509410592 +9787509410608 +9787509410622 +9787509410653 +9787509410776 +9787509410813 +9787509410844 +9787509410868 +9787509410974 +9787509411414 +9787509411452 +9787509411483 +9787509411629 +9787509411742 +9787509411797 +9787509411810 +9787509411827 +9787509411919 +9787509411964 +9787509411995 +9787509412176 +9787509412237 +9787509412244 +9787509412442 +9787509412558 +9787509412626 +9787509412633 +9787509412657 +9787509412671 +9787509412725 +9787509412756 +9787509412800 +9787509412817 +9787509412831 +9787509412893 +9787509413005 +9787509413173 +9787509413180 +9787509413210 +9787509413296 +9787509413692 +9787509414019 +9787509414064 +9787509414309 +9787509414514 +9787509414583 +9787509414934 +9787509415399 +9787509415696 +9787509415740 +9787509415818 +9787509500255 +9787509500880 +9787509502129 +9787509502761 +9787509502792 +9787509503386 +9787509503409 +9787509503621 +9787509503836 +9787509504451 +9787509504499 +9787509504635 +9787509504697 +9787509504857 +9787509506028 +9787509506035 +9787509507117 +9787509507810 +9787509508022 +9787509508749 +9787509508763 +9787509509906 +9787509509920 +9787509510131 +9787509510322 +9787509510445 +9787509510490 +9787509510599 +9787509511626 +9787509512388 +9787509512395 +9787509512548 +9787509512661 +9787509513231 +9787509513729 +9787509514146 +9787509514320 +9787509514405 +9787509514764 +9787509515099 +9787509517581 +9787509517611 +9787509518632 +9787509519004 +9787509519301 +9787509519646 +9787509519714 +9787509519943 +9787509520130 +9787509520291 +9787509520451 +9787509521014 +9787509522486 +9787509522837 +9787509522905 +9787509523018 +9787509523377 +9787509523476 +9787509523575 +9787509523582 +9787509524299 +9787509525241 +9787509525265 +9787509525289 +9787509527047 +9787509527351 +9787509528105 +9787509528716 +9787509528907 +9787509529010 +9787509529423 +9787509529812 +9787509529928 +9787509530573 +9787509531778 +9787509532478 +9787509533420 +9787509534175 +9787509534243 +9787509535110 +9787509535172 +9787509535295 +9787509536599 +9787509536650 +9787509537107 +9787509537664 +9787509537701 +9787509538074 +9787509538692 +9787509539033 +9787509539187 +9787509539545 +9787509539620 +9787509540381 +9787509540435 +9787509541425 +9787509541432 +9787509543023 +9787509543078 +9787509543436 +9787509544488 +9787509544563 +9787509545096 +9787509546390 +9787509546673 +9787509546727 +9787509547328 +9787509548080 +9787509548318 +9787509548332 +9787509548363 +9787509548479 +9787509549353 +9787509549698 +9787509549797 +9787509550076 +9787509550281 +9787509550328 +9787509550533 +9787509550632 +9787509550649 +9787509550779 +9787509550977 +9787509551004 +9787509551080 +9787509551097 +9787509552636 +9787509552667 +9787509553039 +9787509553244 +9787509553404 +9787509555453 +9787509555675 +9787509555828 +9787509555941 +9787509555958 +9787509556979 +9787509557297 +9787509558317 +9787509558508 +9787509558959 +9787509559017 +9787509559048 +9787509559208 +9787509560433 +9787509560853 +9787509561492 +9787509562048 +9787509562413 +9787509562840 +9787509563410 +9787509563571 +9787509563809 +9787509563960 +9787509564400 +9787509564738 +9787509565803 +9787509566336 +9787509566558 +9787509567517 +9787509567524 +9787509567999 +9787509568446 +9787509569511 +9787509569887 +9787509569917 +9787509570876 +9787509570944 +9787509571071 +9787509571620 +9787509572436 +9787509572474 +9787509572955 +9787509573020 +9787509574126 +9787509574324 +9787509574713 +9787509574867 +9787509575239 +9787509576182 +9787509576403 +9787509576472 +9787509577707 +9787509580295 +9787509580714 +9787509581759 +9787509581865 +9787509583548 +9787509583609 +9787509583760 +9787509583777 +9787509584149 +9787509585467 +9787509585757 +9787509587263 +9787509588031 +9787509588055 +9787509588475 +9787509588796 +9787509589342 +9787509589748 +9787509589892 +9787509589908 +9787509589946 +9787509590126 +9787509590232 +9787509590591 +9787509590805 +9787509590812 +9787509591154 +9787509591581 +9787509592144 +9787509592373 +9787509592397 +9787509592557 +9787509592564 +9787509592861 +9787509593141 +9787509593226 +9787509593301 +9787509593318 +9787509594827 +9787509595114 +9787509595169 +9787509595688 +9787509595947 +9787509596012 +9787509596029 +9787509596289 +9787509596531 +9787509596647 +9787509596715 +9787509596906 +9787509597231 +9787509597507 +9787509597637 +9787509598214 +9787509598238 +9787509598382 +9787509598399 +9787509599402 +9787509599426 +9787509600108 +9787509600252 +9787509600634 +9787509600801 +9787509600832 +9787509601051 +9787509602218 +9787509602324 +9787509602843 +9787509603383 +9787509603536 +9787509604045 +9787509604229 +9787509604427 +9787509604557 +9787509604809 +9787509604823 +9787509605103 +9787509605370 +9787509605417 +9787509607152 +9787509607848 +9787509608340 +9787509608784 +9787509610107 +9787509610503 +9787509611500 +9787509611708 +9787509611821 +9787509612415 +9787509612651 +9787509613610 +9787509614259 +9787509614396 +9787509614747 +9787509615331 +9787509615522 +9787509616161 +9787509616475 +9787509617021 +9787509618448 +9787509618592 +9787509618653 +9787509619834 +9787509619964 +9787509620205 +9787509620311 +9787509621073 +9787509622186 +9787509623343 +9787509624487 +9787509624944 +9787509626627 +9787509628232 +9787509629109 +9787509629260 +9787509630570 +9787509630761 +9787509631997 +9787509632512 +9787509632970 +9787509633595 +9787509633786 +9787509633823 +9787509634165 +9787509634516 +9787509634820 +9787509634899 +9787509636596 +9787509636824 +9787509636954 +9787509637647 +9787509638705 +9787509638927 +9787509640609 +9787509641309 +9787509641620 +9787509643600 +9787509643716 +9787509644423 +9787509644799 +9787509645581 +9787509645840 +9787509646960 +9787509647691 +9787509648094 +9787509648278 +9787509648377 +9787509649565 +9787509650097 +9787509651407 +9787509651476 +9787509651537 +9787509652015 +9787509652435 +9787509653357 +9787509655030 +9787509656396 +9787509656464 +9787509656754 +9787509657195 +9787509657249 +9787509658765 +9787509658789 +9787509659038 +9787509659328 +9787509660195 +9787509660287 +9787509660553 +9787509660577 +9787509660744 +9787509661147 +9787509661796 +9787509662991 +9787509663448 +9787509664568 +9787509664728 +9787509665268 +9787509666258 +9787509667187 +9787509667323 +9787509667569 +9787509670354 +9787509670811 +9787509670996 +9787509671009 +9787509671566 +9787509672808 +9787509672907 +9787509673164 +9787509673232 +9787509673454 +9787509673478 +9787509673607 +9787509674086 +9787509674161 +9787509674208 +9787509674390 +9787509674680 +9787509675373 +9787509675397 +9787509675465 +9787509676066 +9787509676271 +9787509676301 +9787509676462 +9787509676967 +9787509677513 +9787509678077 +9787509678169 +9787509678558 +9787509679876 +9787509680049 +9787509680186 +9787509681008 +9787509681039 +9787509681480 +9787509681497 +9787509682142 +9787509682388 +9787509682883 +9787509683002 +9787509683460 +9787509683576 +9787509683897 +9787509683958 +9787509684108 +9787509684177 +9787509685105 +9787509686140 +9787509687727 +9787509687789 +9787509688014 +9787509688137 +9787509688182 +9787509688380 +9787509688533 +9787509689059 +9787509689141 +9787509689752 +9787509689981 +9787509690017 +9787509690130 +9787509690505 +9787509690529 +9787509690826 +9787509690925 +9787509691380 +9787509691915 +9787509691922 +9787509692554 +9787509692981 +9787509693339 +9787509693513 +9787509693605 +9787509693889 +9787509694251 +9787509694893 +9787509694909 +9787509695524 +9787509695531 +9787509695548 +9787509695555 +9787509695609 +9787509695838 +9787509695852 +9787509695906 +9787509696385 +9787509696873 +9787509696934 +9787509697276 +9787509697382 +9787509697528 +9787509698273 +9787509698358 +9787509699034 +9787509699379 +9787509699690 +9787509700150 +9787509700198 +9787509700556 +9787509700679 +9787509700860 +9787509700976 +9787509701034 +9787509701546 +9787509701560 +9787509701676 +9787509701720 +9787509701775 +9787509701911 +9787509701935 +9787509701973 +9787509702161 +9787509702765 +9787509702796 +9787509702864 +9787509703175 +9787509703625 +9787509703670 +9787509703717 +9787509703977 +9787509703984 +9787509704172 +9787509704318 +9787509704806 +9787509705162 +9787509705254 +9787509705285 +9787509705391 +9787509705438 +9787509705483 +9787509705643 +9787509706114 +9787509706138 +9787509706770 +9787509706855 +9787509706879 +9787509707418 +9787509707425 +9787509707449 +9787509707517 +9787509707524 +9787509708095 +9787509708132 +9787509708569 +9787509708774 +9787509708910 +9787509709818 +9787509709863 +9787509710340 +9787509710531 +9787509710555 +9787509711354 +9787509711941 +9787509712160 +9787509712252 +9787509712344 +9787509712580 +9787509712849 +9787509712979 +9787509713624 +9787509713648 +9787509713679 +9787509713907 +9787509714003 +9787509714492 +9787509714515 +9787509714539 +9787509714829 +9787509715031 +9787509715185 +9787509715444 +9787509715819 +9787509716519 +9787509716854 +9787509716922 +9787509717288 +9787509717462 +9787509717806 +9787509717882 +9787509718117 +9787509718124 +9787509718148 +9787509718254 +9787509718940 +9787509718971 +9787509719411 +9787509720202 +9787509720219 +9787509720684 +9787509720783 +9787509720790 +9787509720929 +9787509721391 +9787509721490 +9787509721834 +9787509721889 +9787509721940 +9787509722084 +9787509722169 +9787509722343 +9787509722497 +9787509723517 +9787509723937 +9787509724873 +9787509725030 +9787509725160 +9787509725436 +9787509725665 +9787509725955 +9787509726211 +9787509726372 +9787509726587 +9787509726662 +9787509726914 +9787509727423 +9787509727812 +9787509728338 +9787509728383 +9787509728567 +9787509728697 +9787509729359 +9787509729595 +9787509729670 +9787509730225 +9787509730287 +9787509730553 +9787509730577 +9787509730676 +9787509730690 +9787509731680 +9787509731758 +9787509732106 +9787509732267 +9787509732274 +9787509733097 +9787509733134 +9787509733387 +9787509733776 +9787509734018 +9787509734292 +9787509734452 +9787509734490 +9787509736296 +9787509737507 +9787509738030 +9787509739457 +9787509739471 +9787509739518 +9787509739600 +9787509739792 +9787509739808 +9787509739822 +9787509740194 +9787509741146 +9787509741269 +9787509741344 +9787509741405 +9787509741412 +9787509741443 +9787509741689 +9787509741924 +9787509742068 +9787509742600 +9787509743218 +9787509743355 +9787509743546 +9787509743928 +9787509744796 +9787509744963 +9787509745526 +9787509745854 +9787509746349 +9787509748022 +9787509748633 +9787509748923 +9787509748954 +9787509749616 +9787509750070 +9787509750391 +9787509750896 +9787509750919 +9787509751145 +9787509751619 +9787509751954 +9787509752340 +9787509752906 +9787509753293 +9787509753736 +9787509753767 +9787509754153 +9787509754290 +9787509754511 +9787509754818 +9787509755099 +9787509755204 +9787509755280 +9787509755723 +9787509755969 +9787509756027 +9787509756720 +9787509756829 +9787509756911 +9787509757406 +9787509757864 +9787509758663 +9787509758694 +9787509758847 +9787509759387 +9787509760017 +9787509760482 +9787509760789 +9787509760840 +9787509762103 +9787509762394 +9787509762707 +9787509763056 +9787509763124 +9787509763315 +9787509764305 +9787509764404 +9787509764510 +9787509764695 +9787509764831 +9787509764909 +9787509765760 +9787509765968 +9787509766088 +9787509766095 +9787509766217 +9787509766231 +9787509766453 +9787509767184 +9787509767504 +9787509767689 +9787509767740 +9787509768051 +9787509768105 +9787509768112 +9787509768938 +9787509769201 +9787509770153 +9787509770382 +9787509771464 +9787509771518 +9787509771631 +9787509771648 +9787509771662 +9787509772645 +9787509772683 +9787509772836 +9787509772881 +9787509773703 +9787509774120 +9787509774199 +9787509774281 +9787509774311 +9787509774410 +9787509774809 +9787509775424 +9787509775523 +9787509775967 +9787509776001 +9787509776506 +9787509776735 +9787509776742 +9787509777220 +9787509777480 +9787509777848 +9787509778104 +9787509779460 +9787509779637 +9787509780084 +9787509780237 +9787509780299 +9787509781012 +9787509781395 +9787509781494 +9787509782392 +9787509782651 +9787509782699 +9787509782842 +9787509783573 +9787509783740 +9787509784020 +9787509784297 +9787509786154 +9787509786659 +9787509786840 +9787509786956 +9787509787052 +9787509787090 +9787509787113 +9787509787274 +9787509787762 +9787509788127 +9787509788271 +9787509788561 +9787509788936 +9787509789056 +9787509789094 +9787509789186 +9787509789261 +9787509789377 +9787509790038 +9787509790151 +9787509790182 +9787509790373 +9787509790380 +9787509790960 +9787509791974 +9787509792254 +9787509792933 +9787509793084 +9787509793237 +9787509793947 +9787509794104 +9787509794722 +9787509795316 +9787509795613 +9787509795767 +9787509795828 +9787509796047 +9787509797082 +9787509797457 +9787509797914 +9787509798119 +9787509798614 +9787509798690 +9787509798911 +9787509798928 +9787509799581 +9787509800102 +9787509800263 +9787509800270 +9787509800386 +9787509800485 +9787509800591 +9787509800607 +9787509800997 +9787509801239 +9787509801413 +9787509801529 +9787509801765 +9787509801772 +9787509801789 +9787509801819 +9787509802243 +9787509802328 +9787509802441 +9787509802489 +9787509802595 +9787509803004 +9787509803141 +9787509803158 +9787509803271 +9787509803318 +9787509803363 +9787509803417 +9787509803547 +9787509803622 +9787509803684 +9787509803851 +9787509804032 +9787509804391 +9787509804667 +9787509804834 +9787509805015 +9787509805190 +9787509805305 +9787509805770 +9787509806173 +9787509806241 +9787509806470 +9787509806500 +9787509806609 +9787509806623 +9787509806760 +9787509807040 +9787509807231 +9787509807651 +9787509807705 +9787509807712 +9787509808016 +9787509808283 +9787509808542 +9787509808559 +9787509808580 +9787509808672 +9787509809174 +9787509809280 +9787509809341 +9787509809365 +9787509809563 +9787509809631 +9787509810965 +9787509811610 +9787509811696 +9787509812556 +9787509813430 +9787509813898 +9787509814680 +9787509814871 +9787509814987 +9787509815069 +9787509815410 +9787509815564 +9787509815809 +9787509816479 +9787509816615 +9787509816646 +9787509816738 +9787509816981 +9787509817278 +9787509817629 +9787509817698 +9787509817728 +9787509817865 +9787509817995 +9787509818022 +9787509818053 +9787509818121 +9787509818336 +9787509818541 +9787509819173 +9787509819326 +9787509819371 +9787509819647 +9787509819821 +9787509819869 +9787509820001 +9787509820018 +9787509820193 +9787509820230 +9787509820322 +9787509820674 +9787509820773 +9787509820834 +9787509820865 +9787509821404 +9787509821480 +9787509821534 +9787509822104 +9787509822531 +9787509822838 +9787509822845 +9787509823217 +9787509823309 +9787509823408 +9787509823460 +9787509823576 +9787509823613 +9787509823675 +9787509823897 +9787509823941 +9787509823989 +9787509824337 +9787509824344 +9787509824672 +9787509824733 +9787509824849 +9787509824870 +9787509824887 +9787509825075 +9787509825099 +9787509825181 +9787509825242 +9787509825631 +9787509825716 +9787509825778 +9787509826638 +9787509826799 +9787509826898 +9787509826935 +9787509826942 +9787509827017 +9787509827635 +9787509827680 +9787509827758 +9787509827888 +9787509828021 +9787509828113 +9787509828465 +9787509828755 +9787509828861 +9787509829011 +9787509829127 +9787509829271 +9787509829332 +9787509829646 +9787509829738 +9787509829998 +9787509830253 +9787509830673 +9787509831298 +9787509831366 +9787509831380 +9787509831519 +9787509831861 +9787509832028 +9787509832400 +9787509833599 +9787509833759 +9787509834688 +9787509834695 +9787509834701 +9787509834718 +9787509834749 +9787509834787 +9787509835203 +9787509835784 +9787509835845 +9787509836057 +9787509836156 +9787509836613 +9787509837429 +9787509837856 +9787509838020 +9787509838037 +9787509838242 +9787509838273 +9787509838396 +9787509838884 +9787509839751 +9787509841136 +9787509841389 +9787509841778 +9787509842744 +9787509844441 +9787509844830 +9787509845493 +9787509845646 +9787509846049 +9787509846247 +9787509846421 +9787509846858 +9787509846933 +9787509846940 +9787509846957 +9787509846964 +9787509847008 +9787509847121 +9787509848357 +9787509848753 +9787509848784 +9787509849538 +9787509849842 +9787509849927 +9787509849934 +9787509849996 +9787509850008 +9787509850411 +9787509850435 +9787509850442 +9787509850466 +9787509850565 +9787509850695 +9787509850824 +9787509850831 +9787509850916 +9787509850985 +9787509851098 +9787509851104 +9787509851128 +9787509851746 +9787509852989 +9787509853665 +9787509853870 +9787509853955 +9787509854372 +9787509854389 +9787509854396 +9787509854563 +9787509854709 +9787509854860 +9787509854877 +9787509854884 +9787509854891 +9787509854914 +9787509854938 +9787509855300 +9787509855430 +9787509855584 +9787509855676 +9787509855942 +9787509855980 +9787509856109 +9787509857243 +9787509857250 +9787509857274 +9787509857304 +9787509857328 +9787509857335 +9787509857342 +9787509857359 +9787509857366 +9787509857380 +9787509857427 +9787509857434 +9787509857458 +9787509857496 +9787509857595 +9787509857694 +9787509857724 +9787509857922 +9787509858004 +9787509858011 +9787509858028 +9787509858165 +9787509858264 +9787509858660 +9787509858943 +9787509859308 +9787509859391 +9787509859452 +9787509859742 +9787509859827 +9787509859926 +9787509859957 +9787509860052 +9787509860304 +9787509860366 +9787509860434 +9787509860472 +9787509860564 +9787509860649 +9787509860922 +9787509861011 +9787509861080 +9787509861332 +9787509861363 +9787509861462 +9787509861660 +9787509861677 +9787509861820 +9787509861950 +9787509862308 +9787509862544 +9787509862582 +9787509862599 +9787509863046 +9787509863169 +9787509863220 +9787509863596 +9787509864043 +9787509864111 +9787509864159 +9787509864203 +9787509864258 +9787509864265 +9787509864395 +9787509864401 +9787509864418 +9787509864487 +9787509864524 +9787509864555 +9787509864579 +9787509864708 +9787509864715 +9787509864791 +9787509864807 +9787509864814 +9787509865132 +9787509865248 +9787509865552 +9787509865569 +9787509865576 +9787509865606 +9787509865675 +9787509865866 +9787509865996 +9787509866009 +9787509866085 +9787509866092 +9787509866535 +9787509866689 +9787509867617 +9787509867778 +9787509867785 +9787509867914 +9787509900185 +9787509900826 +9787509900987 +9787509901021 +9787509901052 +9787509901236 +9787509901465 +9787509901809 +9787509901878 +9787509901922 +9787509901939 +9787509902035 +9787509902714 +9787509903360 +9787509903599 +9787509903773 +9787509904015 +9787509904152 +9787509904169 +9787509904343 +9787509904640 +9787509904800 +9787509905012 +9787509905364 +9787509905500 +9787509905883 +9787509906088 +9787509906194 +9787509906224 +9787509906231 +9787509906293 +9787509906316 +9787509906507 +9787509906521 +9787509906569 +9787509906576 +9787509906590 +9787509906675 +9787509906682 +9787509906781 +9787509907023 +9787509907078 +9787509907115 +9787509907221 +9787509907375 +9787509907429 +9787509907528 +9787509907542 +9787509907559 +9787509907566 +9787509907610 +9787509907641 +9787509907689 +9787509907757 +9787509907818 +9787509907962 +9787509908037 +9787509908273 +9787509908587 +9787509908648 +9787509908709 +9787509909003 +9787509909119 +9787509909157 +9787509909362 +9787509909430 +9787509909669 +9787509910047 +9787509910221 +9787509910306 +9787509910313 +9787509910320 +9787509910412 +9787509910450 +9787509910511 +9787509910566 +9787509910641 +9787509910658 +9787509910665 +9787509910689 +9787509910702 +9787509910740 +9787509910757 +9787509910832 +9787509910849 +9787509910863 +9787509911228 +9787509911365 +9787509911426 +9787509911471 +9787509911662 +9787509911693 +9787509911754 +9787509911785 +9787509911921 +9787509911945 +9787509911952 +9787509911969 +9787509911976 +9787509911983 +9787509911990 +9787509912157 +9787509912218 +9787509912256 +9787509912263 +9787509912355 +9787509912386 +9787509912430 +9787509912478 +9787509912492 +9787509912515 +9787509912522 +9787509912560 +9787509912577 +9787509912584 +9787509912591 +9787509912645 +9787509912799 +9787509912850 +9787509913031 +9787509913086 +9787509913130 +9787509913338 +9787509913437 +9787509913451 +9787509913574 +9787509913581 +9787509913604 +9787509913635 +9787509913642 +9787509913659 +9787509913680 +9787509913697 +9787509913703 +9787509913710 +9787509913789 +9787509913932 +9787509913970 +9787509913987 +9787509913994 +9787509914038 +9787509914106 +9787509914113 +9787509914182 +9787509914199 +9787509914267 +9787509914403 +9787509914410 +9787509914434 +9787509914441 +9787509914458 +9787509914519 +9787509914601 +9787509914649 +9787509914694 +9787509914939 +9787509914984 +9787509915035 +9787509915059 +9787509915189 +9787509915202 +9787509915219 +9787509915264 +9787509915271 +9787509915332 +9787509915356 +9787509915363 +9787509915387 +9787509915400 +9787509915431 +9787509915462 +9787509915516 +9787509915523 +9787509915530 +9787509915547 +9787509915554 +9787509915561 +9787509915578 +9787509915592 +9787509915608 +9787509915615 +9787509915639 +9787509915646 +9787509915653 +9787509915677 +9787509915684 +9787509915745 +9787509915752 +9787509915813 +9787509915875 +9787509915905 +9787509915967 +9787509915998 +9787509916032 +9787510000416 +9787510003196 +9787510003387 +9787510004971 +9787510005510 +9787510005596 +9787510005671 +9787510005817 +9787510005848 +9787510005879 +9787510005947 +9787510006005 +9787510006029 +9787510006111 +9787510006128 +9787510006159 +9787510006203 +9787510006227 +9787510006241 +9787510006340 +9787510006418 +9787510006500 +9787510006555 +9787510006623 +9787510006630 +9787510006654 +9787510006661 +9787510006692 +9787510006791 +9787510006890 +9787510006937 +9787510006999 +9787510007026 +9787510007033 +9787510007057 +9787510007118 +9787510007125 +9787510007132 +9787510007224 +9787510007866 +9787510007934 +9787510008030 +9787510008085 +9787510008122 +9787510008139 +9787510008399 +9787510008429 +9787510008450 +9787510008559 +9787510008887 +9787510009136 +9787510009143 +9787510009150 +9787510009167 +9787510009792 +9787510009808 +9787510009969 +9787510010354 +9787510010439 +9787510010484 +9787510010507 +9787510010545 +9787510010576 +9787510010583 +9787510011467 +9787510011481 +9787510011696 +9787510011894 +9787510011955 +9787510011993 +9787510012037 +9787510012044 +9787510012051 +9787510012068 +9787510012228 +9787510012501 +9787510012617 +9787510012754 +9787510012846 +9787510012853 +9787510012969 +9787510013683 +9787510013737 +9787510013775 +9787510013836 +9787510013959 +9787510013980 +9787510014017 +9787510014284 +9787510014291 +9787510014321 +9787510014369 +9787510014406 +9787510014420 +9787510014451 +9787510014932 +9787510015229 +9787510015427 +9787510015434 +9787510015588 +9787510015618 +9787510015670 +9787510015687 +9787510015717 +9787510015724 +9787510015779 +9787510015809 +9787510015830 +9787510015861 +9787510015915 +9787510016035 +9787510016103 +9787510016127 +9787510016202 +9787510016219 +9787510016226 +9787510016233 +9787510016264 +9787510016318 +9787510016325 +9787510016349 +9787510016356 +9787510016387 +9787510016400 +9787510017360 +9787510017469 +9787510017650 +9787510017780 +9787510017827 +9787510017889 +9787510018275 +9787510018282 +9787510018503 +9787510018695 +9787510018794 +9787510018954 +9787510019029 +9787510019111 +9787510019180 +9787510019685 +9787510019937 +9787510019944 +9787510020070 +9787510020117 +9787510020278 +9787510020292 +9787510020315 +9787510020322 +9787510020346 +9787510020391 +9787510020490 +9787510020735 +9787510021169 +9787510021244 +9787510021848 +9787510021855 +9787510022111 +9787510022142 +9787510022210 +9787510022296 +9787510022388 +9787510023392 +9787510023620 +9787510023705 +9787510023729 +9787510023866 +9787510024146 +9787510024184 +9787510024269 +9787510024306 +9787510024474 +9787510024559 +9787510024627 +9787510024764 +9787510024917 +9787510024924 +9787510024948 +9787510024962 +9787510025006 +9787510025013 +9787510025075 +9787510025211 +9787510025303 +9787510025570 +9787510025846 +9787510025877 +9787510025891 +9787510025907 +9787510026096 +9787510026287 +9787510026461 +9787510026478 +9787510027048 +9787510027239 +9787510027314 +9787510027376 +9787510027499 +9787510027529 +9787510027741 +9787510027758 +9787510027901 +9787510028465 +9787510028533 +9787510028540 +9787510028564 +9787510028571 +9787510028588 +9787510028786 +9787510028830 +9787510028915 +9787510029417 +9787510029776 +9787510029783 +9787510029929 +9787510029943 +9787510029974 +9787510030017 +9787510030123 +9787510030208 +9787510030307 +9787510030888 +9787510031137 +9787510031168 +9787510031212 +9787510031465 +9787510031588 +9787510031779 +9787510031854 +9787510031885 +9787510032080 +9787510032103 +9787510032356 +9787510032431 +9787510032486 +9787510032493 +9787510033230 +9787510033445 +9787510033490 +9787510033575 +9787510033582 +9787510034190 +9787510034312 +9787510034329 +9787510034459 +9787510034626 +9787510035197 +9787510035791 +9787510036613 +9787510036668 +9787510036736 +9787510036743 +9787510036774 +9787510036781 +9787510036934 +9787510037160 +9787510037405 +9787510037702 +9787510038013 +9787510038624 +9787510038945 +9787510039331 +9787510039386 +9787510039492 +9787510039508 +9787510039676 +9787510039713 +9787510039843 +9787510039850 +9787510040030 +9787510040047 +9787510040474 +9787510040733 +9787510041174 +9787510041242 +9787510041280 +9787510041471 +9787510041495 +9787510041563 +9787510041570 +9787510041679 +9787510041716 +9787510041969 +9787510042195 +9787510043253 +9787510044984 +9787510045011 +9787510045141 +9787510045172 +9787510045370 +9787510045684 +9787510045769 +9787510046087 +9787510046254 +9787510046476 +9787510046964 +9787510047077 +9787510047299 +9787510047398 +9787510047466 +9787510047480 +9787510047824 +9787510048173 +9787510048609 +9787510048647 +9787510049170 +9787510049194 +9787510049378 +9787510049392 +9787510049521 +9787510049576 +9787510049767 +9787510049927 +9787510050039 +9787510050374 +9787510050534 +9787510050770 +9787510051494 +9787510051760 +9787510051913 +9787510052583 +9787510052606 +9787510053375 +9787510053382 +9787510053962 +9787510054082 +9787510054556 +9787510054860 +9787510054884 +9787510054945 +9787510054969 +9787510054976 +9787510054983 +9787510055034 +9787510055041 +9787510055607 +9787510055843 +9787510056246 +9787510056253 +9787510056864 +9787510057168 +9787510057700 +9787510057809 +9787510057816 +9787510058233 +9787510058509 +9787510058738 +9787510058998 +9787510059506 +9787510059551 +9787510059933 +9787510060045 +9787510060243 +9787510060502 +9787510060519 +9787510060564 +9787510060595 +9787510061271 +9787510061493 +9787510061578 +9787510061585 +9787510061783 +9787510061813 +9787510062421 +9787510062643 +9787510063190 +9787510063411 +9787510063749 +9787510063756 +9787510063794 +9787510063855 +9787510063992 +9787510065965 +9787510066313 +9787510066887 +9787510067143 +9787510067532 +9787510067600 +9787510068058 +9787510068430 +9787510068959 +9787510069086 +9787510069185 +9787510069468 +9787510069499 +9787510069628 +9787510070068 +9787510070167 +9787510070204 +9787510070372 +9787510071232 +9787510071287 +9787510071621 +9787510071690 +9787510072345 +9787510072796 +9787510072802 +9787510072871 +9787510074431 +9787510074554 +9787510076503 +9787510077135 +9787510077975 +9787510078347 +9787510078439 +9787510079139 +9787510079351 +9787510079726 +9787510079993 +9787510080241 +9787510081392 +9787510081415 +9787510081514 +9787510081606 +9787510081736 +9787510082122 +9787510082511 +9787510083068 +9787510084904 +9787510085840 +9787510086427 +9787510086663 +9787510086816 +9787510087318 +9787510087349 +9787510087363 +9787510087578 +9787510087691 +9787510088384 +9787510088391 +9787510088759 +9787510088766 +9787510088834 +9787510089138 +9787510091025 +9787510091919 +9787510092138 +9787510092855 +9787510093999 +9787510094392 +9787510094545 +9787510096389 +9787510096891 +9787510097584 +9787510097706 +9787510098468 +9787510099137 +9787510099168 +9787510099519 +9787510099595 +9787510100130 +9787510100284 +9787510102189 +9787510102332 +9787510102738 +9787510103001 +9787510103049 +9787510103209 +9787510103773 +9787510104312 +9787510104367 +9787510105302 +9787510105470 +9787510106293 +9787510106712 +9787510106958 +9787510107436 +9787510107467 +9787510108242 +9787510108563 +9787510109041 +9787510109058 +9787510109119 +9787510109225 +9787510109539 +9787510109614 +9787510109966 +9787510110023 +9787510110245 +9787510110269 +9787510110467 +9787510110504 +9787510110627 +9787510110801 +9787510111280 +9787510111396 +9787510111679 +9787510111723 +9787510113055 +9787510113192 +9787510113727 +9787510114175 +9787510114656 +9787510114922 +9787510114953 +9787510115011 +9787510115141 +9787510115165 +9787510115189 +9787510115226 +9787510115325 +9787510115387 +9787510115394 +9787510115448 +9787510115486 +9787510115745 +9787510115752 +9787510116070 +9787510116087 +9787510116094 +9787510116247 +9787510116599 +9787510117213 +9787510117251 +9787510117336 +9787510117404 +9787510117695 +9787510117916 +9787510117992 +9787510118012 +9787510118265 +9787510118296 +9787510118616 +9787510118722 +9787510119590 +9787510120350 +9787510120916 +9787510121371 +9787510121388 +9787510122132 +9787510122170 +9787510122194 +9787510122255 +9787510122378 +9787510124662 +9787510124884 +9787510124969 +9787510125072 +9787510125157 +9787510125324 +9787510125355 +9787510125621 +9787510125683 +9787510126239 +9787510126710 +9787510126864 +9787510127502 +9787510127540 +9787510127953 +9787510128097 +9787510128240 +9787510129216 +9787510129834 +9787510130069 +9787510130502 +9787510130519 +9787510131431 +9787510131561 +9787510131882 +9787510132414 +9787510132421 +9787510132438 +9787510132544 +9787510132551 +9787510133084 +9787510133114 +9787510133138 +9787510133589 +9787510133961 +9787510134128 +9787510134593 +9787510134692 +9787510134777 +9787510134807 +9787510134937 +9787510135019 +9787510135026 +9787510135576 +9787510135668 +9787510135842 +9787510135866 +9787510136894 +9787510137358 +9787510138546 +9787510139185 +9787510139703 +9787510139765 +9787510139925 +9787510140662 +9787510140808 +9787510141300 +9787510141331 +9787510143205 +9787510143663 +9787510143908 +9787510144936 +9787510144943 +9787510144950 +9787510144974 +9787510144981 +9787510145001 +9787510145018 +9787510145124 +9787510145186 +9787510145490 +9787510145513 +9787510145773 +9787510146244 +9787510146626 +9787510146992 +9787510147425 +9787510147432 +9787510147470 +9787510147708 +9787510150685 +9787510150708 +9787510151712 +9787510151729 +9787510151743 +9787510151897 +9787510152603 +9787510152689 +9787510152924 +9787510153068 +9787510153402 +9787510153693 +9787510154867 +9787510154904 +9787510155093 +9787510156793 +9787510156977 +9787510157639 +9787510157653 +9787510158117 +9787510158285 +9787510158957 +9787510160066 +9787510160592 +9787510160615 +9787510160646 +9787510160653 +9787510162039 +9787510162206 +9787510162220 +9787510162411 +9787510162770 +9787510162787 +9787510162794 +9787510162817 +9787510162862 +9787510163012 +9787510163029 +9787510163036 +9787510163043 +9787510163524 +9787510163586 +9787510164927 +9787510164958 +9787510165115 +9787510165337 +9787510165344 +9787510165382 +9787510165733 +9787510165856 +9787510165863 +9787510166105 +9787510166136 +9787510166662 +9787510166914 +9787510167348 +9787510167775 +9787510168086 +9787510168093 +9787510168130 +9787510169052 +9787510169311 +9787510169625 +9787510170065 +9787510171048 +9787510171512 +9787510173363 +9787510173387 +9787510173462 +9787510173868 +9787510174827 +9787510174834 +9787510175749 +9787510177514 +9787510177576 +9787510177743 +9787510177927 +9787510178047 +9787510179143 +9787510179389 +9787510179471 +9787510179631 +9787510180194 +9787510180460 +9787510180477 +9787510180798 +9787510181221 +9787510181375 +9787510181672 +9787510181955 +9787510182013 +9787510182068 +9787510184147 +9787510185687 +9787510185694 +9787510185700 +9787510185977 +9787510186738 +9787510186745 +9787510187599 +9787510187636 +9787510188077 +9787510188084 +9787510188268 +9787510188985 +9787510189883 +9787510191916 +9787510192173 +9787510193767 +9787510195563 +9787510195594 +9787510195624 +9787510196331 +9787510197352 +9787510199257 +9787510200007 +9787510200397 +9787510200663 +9787510200854 +9787510200908 +9787510201073 +9787510201189 +9787510201332 +9787510201448 +9787510201493 +9787510201745 +9787510201783 +9787510202858 +9787510203039 +9787510203046 +9787510204067 +9787510204111 +9787510204555 +9787510205309 +9787510205477 +9787510205958 +9787510206467 +9787510206559 +9787510206610 +9787510207020 +9787510207662 +9787510208416 +9787510209239 +9787510209499 +9787510209796 +9787510209857 +9787510210181 +9787510210792 +9787510210853 +9787510211027 +9787510211362 +9787510211492 +9787510211522 +9787510211706 +9787510211713 +9787510211850 +9787510211911 +9787510212239 +9787510212345 +9787510212376 +9787510212765 +9787510213168 +9787510213496 +9787510213830 +9787510213991 +9787510214189 +9787510214738 +9787510214806 +9787510215070 +9787510215100 +9787510215254 +9787510215681 +9787510216107 +9787510216121 +9787510216374 +9787510217074 +9787510217289 +9787510217487 +9787510217579 +9787510217715 +9787510218064 +9787510218071 +9787510218316 +9787510218828 +9787510218873 +9787510218903 +9787510219825 +9787510219900 +9787510220012 +9787510220081 +9787510220470 +9787510220692 +9787510220715 +9787510221163 +9787510221224 +9787510221651 +9787510221743 +9787510221811 +9787510221903 +9787510222078 +9787510222139 +9787510223075 +9787510223112 +9787510223303 +9787510223495 +9787510223556 +9787510223709 +9787510223716 +9787510223945 +9787510224072 +9787510224089 +9787510224096 +9787510224324 +9787510224362 +9787510224461 +9787510224867 +9787510225116 +9787510225338 +9787510225376 +9787510226168 +9787510226175 +9787510226281 +9787510226342 +9787510226472 +9787510226656 +9787510226663 +9787510226687 +9787510226892 +9787510227103 +9787510227158 +9787510227196 +9787510227363 +9787510227370 +9787510227394 +9787510227530 +9787510227561 +9787510227639 +9787510227660 +9787510227707 +9787510227752 +9787510227813 +9787510227820 +9787510228018 +9787510228124 +9787510228131 +9787510228254 +9787510228575 +9787510228612 +9787510228711 +9787510228742 +9787510228759 +9787510228797 +9787510228803 +9787510228834 +9787510228841 +9787510228889 +9787510228940 +9787510228988 +9787510229053 +9787510229114 +9787510229183 +9787510229299 +9787510229374 +9787510229435 +9787510229572 +9787510229596 +9787510229640 +9787510229664 +9787510229763 +9787510229985 +9787510230233 +9787510230417 +9787510230646 +9787510230691 +9787510230769 +9787510230844 +9787510231612 +9787510300370 +9787510301193 +9787510301681 +9787510302237 +9787510303999 +9787510304118 +9787510304279 +9787510304996 +9787510305184 +9787510305368 +9787510305511 +9787510305825 +9787510306495 +9787510307362 +9787510307447 +9787510308086 +9787510308192 +9787510309267 +9787510309328 +9787510309403 +9787510310041 +9787510310911 +9787510311253 +9787510312250 +9787510312304 +9787510312694 +9787510313134 +9787510313165 +9787510314056 +9787510315206 +9787510315367 +9787510315534 +9787510316029 +9787510316654 +9787510316760 +9787510316852 +9787510317811 +9787510317828 +9787510318092 +9787510319129 +9787510319297 +9787510319464 +9787510319471 +9787510320538 +9787510321887 +9787510321948 +9787510322532 +9787510323171 +9787510323539 +9787510324017 +9787510324079 +9787510324208 +9787510324215 +9787510324284 +9787510324475 +9787510326233 +9787510327285 +9787510327544 +9787510327827 +9787510328060 +9787510328077 +9787510328121 +9787510328527 +9787510328923 +9787510328985 +9787510329128 +9787510330360 +9787510331657 +9787510332111 +9787510332258 +9787510332340 +9787510332814 +9787510332890 +9787510334146 +9787510334221 +9787510334344 +9787510334368 +9787510334672 +9787510334696 +9787510334818 +9787510335273 +9787510335556 +9787510335822 +9787510335907 +9787510335938 +9787510336119 +9787510336232 +9787510336461 +9787510336645 +9787510336836 +9787510336942 +9787510337246 +9787510337284 +9787510337543 +9787510337628 +9787510337659 +9787510337727 +9787510337864 +9787510338106 +9787510338151 +9787510339066 +9787510339073 +9787510339646 +9787510340185 +9787510340253 +9787510340529 +9787510340635 +9787510341199 +9787510341588 +9787510342868 +9787510344107 +9787510344800 +9787510344909 +9787510344961 +9787510344985 +9787510346477 +9787510346538 +9787510346644 +9787510346743 +9787510347481 +9787510347535 +9787510347870 +9787510348204 +9787510348228 +9787510348501 +9787510349010 +9787510349126 +9787510351181 +9787510351785 +9787510352027 +9787510352553 +9787510352850 +9787510400025 +9787510400094 +9787510400209 +9787510400223 +9787510400254 +9787510400445 +9787510400483 +9787510400575 +9787510400650 +9787510400742 +9787510400773 +9787510400827 +9787510400902 +9787510400926 +9787510400957 +9787510401039 +9787510401077 +9787510401138 +9787510401152 +9787510401251 +9787510401305 +9787510401343 +9787510401398 +9787510401466 +9787510401503 +9787510401527 +9787510401664 +9787510401732 +9787510401862 +9787510402012 +9787510402036 +9787510402227 +9787510402319 +9787510402401 +9787510402432 +9787510402487 +9787510402616 +9787510402678 +9787510402692 +9787510402708 +9787510402722 +9787510402807 +9787510402821 +9787510402906 +9787510402913 +9787510402920 +9787510403279 +9787510403347 +9787510403439 +9787510403446 +9787510403514 +9787510403675 +9787510404030 +9787510404238 +9787510404399 +9787510404559 +9787510404924 +9787510404979 +9787510405044 +9787510405051 +9787510405129 +9787510405495 +9787510405501 +9787510405525 +9787510405532 +9787510405570 +9787510405617 +9787510405648 +9787510405747 +9787510405808 +9787510405846 +9787510406171 +9787510406379 +9787510406638 +9787510406652 +9787510406683 +9787510406867 +9787510406973 +9787510407109 +9787510407130 +9787510407147 +9787510407161 +9787510407413 +9787510407628 +9787510407918 +9787510407987 +9787510408069 +9787510408137 +9787510408274 +9787510408298 +9787510408373 +9787510408434 +9787510408496 +9787510408830 +9787510408984 +9787510409004 +9787510409073 +9787510409097 +9787510409134 +9787510409448 +9787510409578 +9787510409783 +9787510409875 +9787510409974 +9787510410086 +9787510410123 +9787510410192 +9787510410352 +9787510410505 +9787510410680 +9787510411106 +9787510411168 +9787510411175 +9787510411335 +9787510411786 +9787510411823 +9787510411854 +9787510411922 +9787510411946 +9787510412004 +9787510412066 +9787510412141 +9787510412264 +9787510412356 +9787510412455 +9787510412479 +9787510412509 +9787510412530 +9787510412783 +9787510412929 +9787510413049 +9787510413056 +9787510413100 +9787510413117 +9787510413124 +9787510413131 +9787510413278 +9787510413353 +9787510413636 +9787510413698 +9787510414060 +9787510414084 +9787510414183 +9787510414268 +9787510414312 +9787510414664 +9787510414749 +9787510415012 +9787510415517 +9787510415623 +9787510415760 +9787510415982 +9787510416132 +9787510416736 +9787510417030 +9787510417382 +9787510417474 +9787510418129 +9787510418143 +9787510418174 +9787510418198 +9787510418518 +9787510418617 +9787510418662 +9787510418679 +9787510418822 +9787510418846 +9787510418990 +9787510419027 +9787510419133 +9787510419140 +9787510419294 +9787510419355 +9787510419621 +9787510419799 +9787510419836 +9787510419867 +9787510420108 +9787510420146 +9787510420191 +9787510420221 +9787510420344 +9787510420801 +9787510421068 +9787510421136 +9787510421396 +9787510421730 +9787510421754 +9787510421785 +9787510421884 +9787510422027 +9787510422409 +9787510422591 +9787510422706 +9787510422911 +9787510423154 +9787510423321 +9787510423543 +9787510423581 +9787510423741 +9787510423895 +9787510424595 +9787510424762 +9787510425011 +9787510425042 +9787510425080 +9787510425516 +9787510426308 +9787510426483 +9787510426513 +9787510426711 +9787510426735 +9787510426827 +9787510426919 +9787510426971 +9787510427008 +9787510427107 +9787510427138 +9787510427145 +9787510427411 +9787510427565 +9787510427725 +9787510428647 +9787510428708 +9787510428791 +9787510429002 +9787510429279 +9787510429385 +9787510429460 +9787510430497 +9787510430527 +9787510430831 +9787510431319 +9787510431470 +9787510431913 +9787510431937 +9787510431999 +9787510432088 +9787510432101 +9787510432248 +9787510432552 +9787510432644 +9787510432668 +9787510432781 +9787510433269 +9787510433399 +9787510433658 +9787510433856 +9787510433894 +9787510433986 +9787510434013 +9787510434617 +9787510434853 +9787510435157 +9787510435218 +9787510435331 +9787510435737 +9787510435799 +9787510435966 +9787510436154 +9787510436376 +9787510436680 +9787510437243 +9787510437366 +9787510437564 +9787510437854 +9787510438196 +9787510438202 +9787510438561 +9787510438899 +9787510438950 +9787510440564 +9787510440830 +9787510440861 +9787510441035 +9787510441172 +9787510441882 +9787510441967 +9787510442001 +9787510442230 +9787510442438 +9787510442469 +9787510442759 +9787510443473 +9787510443534 +9787510443770 +9787510444043 +9787510444746 +9787510444937 +9787510445774 +9787510445798 +9787510445903 +9787510445972 +9787510446252 +9787510446702 +9787510446979 +9787510447228 +9787510448027 +9787510448355 +9787510448430 +9787510448638 +9787510448676 +9787510448942 +9787510449055 +9787510449086 +9787510449284 +9787510449314 +9787510449383 +9787510449505 +9787510449871 +9787510450426 +9787510450709 +9787510450969 +9787510451232 +9787510451249 +9787510451256 +9787510451263 +9787510451591 +9787510451836 +9787510451928 +9787510452307 +9787510452444 +9787510452536 +9787510452550 +9787510452901 +9787510453052 +9787510454080 +9787510454578 +9787510454653 +9787510454837 +9787510454981 +9787510454998 +9787510455407 +9787510455520 +9787510455759 +9787510456480 +9787510457760 +9787510457852 +9787510458019 +9787510458781 +9787510458910 +9787510459054 +9787510459597 +9787510460548 +9787510462337 +9787510465178 +9787510467264 +9787510467448 +9787510467486 +9787510468261 +9787510468285 +9787510468735 +9787510469008 +9787510469541 +9787510470264 +9787510470349 +9787510470462 +9787510470578 +9787510470639 +9787510470745 +9787510471223 +9787510472039 +9787510472473 +9787510472503 +9787510472800 +9787510472954 +9787510473029 +9787510473050 +9787510474354 +9787510474453 +9787510474989 +9787510475245 +9787510475580 +9787510475719 +9787510475726 +9787510476303 +9787510476365 +9787510476433 +9787510476440 +9787510476617 +9787510476624 +9787510476631 +9787510476679 +9787510476884 +9787510477010 +9787510477157 +9787510477287 +9787510477362 +9787510477812 +9787510477942 +9787510477980 +9787510478000 +9787510478017 +9787510478154 +9787510478161 +9787510478178 +9787510478376 +9787510478512 +9787510478628 +9787510478802 +9787510478833 +9787510479076 +9787510479106 +9787510479113 +9787510479175 +9787510479342 +9787510479359 +9787510479373 +9787510479397 +9787510479403 +9787510479434 +9787510479441 +9787510479502 +9787510479519 +9787510479557 +9787510479595 +9787510479632 +9787510479854 +9787510480560 +9787510480584 +9787510480928 +9787510480980 +9787510481024 +9787510481208 +9787510481314 +9787510481444 +9787510500138 +9787510500374 +9787510500381 +9787510500589 +9787510500664 +9787510500695 +9787510500800 +9787510500930 +9787510500947 +9787510500954 +9787510500961 +9787510501098 +9787510501104 +9787510501364 +9787510501371 +9787510501463 +9787510501494 +9787510501517 +9787510501555 +9787510501562 +9787510501753 +9787510501784 +9787510600111 +9787510600227 +9787510600838 +9787510601774 +9787510601859 +9787510601903 +9787510602825 +9787510603051 +9787510603075 +9787510603112 +9787510603129 +9787510603198 +9787510603303 +9787510603815 +9787510603891 +9787510603907 +9787510603914 +9787510603921 +9787510603945 +9787510603952 +9787510603990 +9787510604027 +9787510604089 +9787510604102 +9787510604126 +9787510604140 +9787510604157 +9787510604195 +9787510604201 +9787510604560 +9787510604584 +9787510604829 +9787510604928 +9787510604980 +9787510605918 +9787510606267 +9787510607165 +9787510607301 +9787510608421 +9787510608537 +9787510608759 +9787510608827 +9787510610561 +9787510612138 +9787510612350 +9787510613265 +9787510614101 +9787510615146 +9787510615252 +9787510615832 +9787510615887 +9787510615993 +9787510616181 +9787510616334 +9787510616440 +9787510617560 +9787510618284 +9787510618291 +9787510618321 +9787510619618 +9787510619922 +9787510622465 +9787510622991 +9787510623530 +9787510623561 +9787510623585 +9787510623653 +9787510623684 +9787510623745 +9787510623752 +9787510623837 +9787510624995 +9787510625312 +9787510626142 +9787510626197 +9787510628054 +9787510628252 +9787510629181 +9787510630248 +9787510630439 +9787510631658 +9787510631665 +9787510632839 +9787510633003 +9787510634581 +9787510636011 +9787510637179 +9787510637209 +9787510645228 +9787510647246 +9787510647260 +9787510647307 +9787510647420 +9787510647437 +9787510647444 +9787510647499 +9787510647536 +9787510647543 +9787510647574 +9787510647598 +9787510647628 +9787510647642 +9787510647666 +9787510647680 +9787510647697 +9787510647703 +9787510647727 +9787510647734 +9787510647758 +9787510647796 +9787510647918 +9787510648830 +9787510649363 +9787510649370 +9787510649974 +9787510650321 +9787510650338 +9787510650345 +9787510650352 +9787510650666 +9787510650680 +9787510651854 +9787510651953 +9787510651977 +9787510652202 +9787510652219 +9787510652400 +9787510652530 +9787510652578 +9787510652714 +9787510653100 +9787510653148 +9787510653186 +9787510653193 +9787510654435 +9787510655180 +9787510655289 +9787510655494 +9787510655531 +9787510656194 +9787510656590 +9787510656699 +9787510656712 +9787510656743 +9787510656811 +9787510656866 +9787510657887 +9787510658563 +9787510658914 +9787510659140 +9787510659348 +9787510659430 +9787510659447 +9787510659805 +9787510659898 +9787510660009 +9787510660016 +9787510660030 +9787510660139 +9787510660832 +9787510660962 +9787510661204 +9787510661228 +9787510661242 +9787510661273 +9787510661549 +9787510661556 +9787510661587 +9787510661594 +9787510661686 +9787510661693 +9787510661716 +9787510661839 +9787510663055 +9787510663062 +9787510663505 +9787510663666 +9787510664151 +9787510665837 +9787510665936 +9787510665967 +9787510665974 +9787510666025 +9787510666032 +9787510666247 +9787510666384 +9787510666445 +9787510666780 +9787510666797 +9787510667466 +9787510667664 +9787510667961 +9787510668098 +9787510668111 +9787510668128 +9787510668135 +9787510668142 +9787510668159 +9787510668166 +9787510668173 +9787510668289 +9787510668302 +9787510668340 +9787510668357 +9787510668371 +9787510668401 +9787510668470 +9787510668531 +9787510668562 +9787510668579 +9787510668630 +9787510669132 +9787510669446 +9787510669545 +9787510669620 +9787510669958 +9787510670343 +9787510670367 +9787510671593 +9787510671609 +9787510671616 +9787510671692 +9787510671722 +9787510671944 +9787510672002 +9787510672552 +9787510673085 +9787510673139 +9787510673221 +9787510673238 +9787510673344 +9787510673405 +9787510673634 +9787510673993 +9787510674112 +9787510674150 +9787510674167 +9787510674174 +9787510674198 +9787510674280 +9787510674426 +9787510674433 +9787510674549 +9787510674693 +9787510674723 +9787510674822 +9787510675027 +9787510675126 +9787510675195 +9787510675225 +9787510675232 +9787510675249 +9787510675539 +9787510675560 +9787510675577 +9787510675843 +9787510675966 +9787510676000 +9787510676031 +9787510676130 +9787510676147 +9787510676222 +9787510676840 +9787510676895 +9787510677427 +9787510677618 +9787510677649 +9787510677762 +9787510677779 +9787510677892 +9787510678257 +9787510678264 +9787510678271 +9787510678325 +9787510678486 +9787510678608 +9787510679117 +9787510679353 +9787510679377 +9787510679469 +9787510679537 +9787510679544 +9787510679827 +9787510679872 +9787510680007 +9787510680014 +9787510680083 +9787510680090 +9787510680113 +9787510680137 +9787510680144 +9787510680151 +9787510680212 +9787510680328 +9787510680571 +9787510680588 +9787510680601 +9787510680618 +9787510680656 +9787510680663 +9787510680694 +9787510680724 +9787510680762 +9787510680786 +9787510680854 +9787510680878 +9787510681059 +9787510681103 +9787510681417 +9787510681431 +9787510681592 +9787510681684 +9787510681691 +9787510681912 +9787510682230 +9787510682308 +9787510682322 +9787510682339 +9787510682483 +9787510682957 +9787510683244 +9787510683251 +9787510683527 +9787510683596 +9787510683671 +9787510684043 +9787510684050 +9787510684067 +9787510684081 +9787510684104 +9787510684111 +9787510684180 +9787510684203 +9787510684241 +9787510684807 +9787510685002 +9787510685019 +9787510685026 +9787510685033 +9787510685040 +9787510685057 +9787510685064 +9787510685071 +9787510685088 +9787510685095 +9787510685101 +9787510685149 +9787510685156 +9787510685163 +9787510685248 +9787510686085 +9787510686092 +9787510686108 +9787510686139 +9787510686146 +9787510686153 +9787510686160 +9787510686177 +9787510686191 +9787510686207 +9787510686214 +9787510686221 +9787510686245 +9787510686412 +9787510686429 +9787510686474 +9787510686511 +9787510686528 +9787510686535 +9787510686542 +9787510686566 +9787510686573 +9787510686597 +9787510686603 +9787510686610 +9787510686627 +9787510686634 +9787510686641 +9787510686658 +9787510686672 +9787510686771 +9787510686832 +9787510686924 +9787510687020 +9787510687129 +9787510687150 +9787510687198 +9787510687242 +9787510687259 +9787510687266 +9787510687273 +9787510687297 +9787510687310 +9787510687327 +9787510687334 +9787510687341 +9787510687358 +9787510687365 +9787510687372 +9787510687389 +9787510687396 +9787510687402 +9787510687419 +9787510687655 +9787510687662 +9787510687952 +9787510688010 +9787510688034 +9787510688041 +9787510688072 +9787510688133 +9787510688157 +9787510688195 +9787510688201 +9787510688218 +9787510688225 +9787510688263 +9787510688270 +9787510688287 +9787510688294 +9787510688386 +9787510688638 +9787510688652 +9787510688669 +9787510688676 +9787510688805 +9787510688812 +9787510688829 +9787510688843 +9787510688850 +9787510688874 +9787510688928 +9787510689185 +9787510689260 +9787510689277 +9787510689598 +9787510689796 +9787510689802 +9787510689857 +9787510690044 +9787510690051 +9787510690167 +9787510690235 +9787510690396 +9787510690433 +9787510690761 +9787510690815 +9787510691126 +9787510691324 +9787510691331 +9787510691393 +9787510691409 +9787510691416 +9787510691492 +9787510691539 +9787510691560 +9787510691584 +9787510691683 +9787510691690 +9787510691799 +9787510691911 +9787510691942 +9787510692000 +9787510692437 +9787510692468 +9787510692673 +9787510692680 +9787510692697 +9787510692956 +9787510692994 +9787510693007 +9787510693045 +9787510693052 +9787510693212 +9787510693649 +9787510693656 +9787510694158 +9787510694424 +9787510694547 +9787510694561 +9787510694585 +9787510694615 +9787510694677 +9787510694882 +9787510694899 +9787510694950 +9787510694967 +9787510695001 +9787510695025 +9787510695353 +9787510695407 +9787510697678 +9787510700095 +9787510700279 +9787510700514 +9787510700538 +9787510700644 +9787510700651 +9787510700699 +9787510700927 +9787510700941 +9787510700965 +9787510700972 +9787510700989 +9787510701023 +9787510701245 +9787510701283 +9787510701467 +9787510701504 +9787510701559 +9787510701948 +9787510701962 +9787510702020 +9787510702099 +9787510702303 +9787510702471 +9787510702556 +9787510702648 +9787510703003 +9787510703041 +9787510703188 +9787510703201 +9787510703218 +9787510703249 +9787510703317 +9787510703331 +9787510703645 +9787510703652 +9787510703713 +9787510703744 +9787510703959 +9787510704154 +9787510704192 +9787510704239 +9787510704307 +9787510704413 +9787510704512 +9787510704697 +9787510704864 +9787510705113 +9787510705199 +9787510705441 +9787510705489 +9787510706592 +9787510706608 +9787510707148 +9787510707193 +9787510707230 +9787510707445 +9787510707469 +9787510707568 +9787510707896 +9787510708084 +9787510708534 +9787510708800 +9787510709111 +9787510709821 +9787510709906 +9787510709920 +9787510710209 +9787510710216 +9787510710230 +9787510710377 +9787510710629 +9787510710698 +9787510710711 +9787510710742 +9787510710926 +9787510710988 +9787510710995 +9787510711008 +9787510711046 +9787510711138 +9787510711213 +9787510711220 +9787510711640 +9787510711688 +9787510711725 +9787510711732 +9787510800016 +9787510800085 +9787510800115 +9787510800146 +9787510800177 +9787510800290 +9787510800511 +9787510800924 +9787510801402 +9787510801518 +9787510801532 +9787510801747 +9787510801754 +9787510801921 +9787510802102 +9787510802171 +9787510802812 +9787510802935 +9787510802959 +9787510802966 +9787510802973 +9787510802997 +9787510803185 +9787510803215 +9787510803284 +9787510803291 +9787510803352 +9787510803499 +9787510803604 +9787510803628 +9787510803734 +9787510803970 +9787510803987 +9787510804038 +9787510804182 +9787510804557 +9787510804595 +9787510804618 +9787510804663 +9787510804717 +9787510804809 +9787510804885 +9787510804991 +9787510805110 +9787510805158 +9787510805240 +9787510805332 +9787510805554 +9787510805684 +9787510805943 +9787510806056 +9787510806780 +9787510807404 +9787510807435 +9787510807534 +9787510807633 +9787510807800 +9787510807831 +9787510807886 +9787510807930 +9787510807961 +9787510807978 +9787510808081 +9787510808395 +9787510808531 +9787510808562 +9787510808616 +9787510808746 +9787510808784 +9787510808883 +9787510809101 +9787510809118 +9787510809149 +9787510809453 +9787510809699 +9787510809866 +9787510810398 +9787510810787 +9787510811319 +9787510811418 +9787510811784 +9787510811807 +9787510811890 +9787510811999 +9787510812422 +9787510813344 +9787510814112 +9787510814273 +9787510814365 +9787510814853 +9787510815379 +9787510815393 +9787510815416 +9787510815447 +9787510815508 +9787510817243 +9787510817298 +9787510817519 +9787510817878 +9787510818578 +9787510818745 +9787510819124 +9787510819148 +9787510819452 +9787510819667 +9787510819674 +9787510819773 +9787510820731 +9787510820861 +9787510820892 +9787510821233 +9787510821240 +9787510821356 +9787510821417 +9787510821820 +9787510822063 +9787510822162 +9787510822223 +9787510822278 +9787510822421 +9787510822803 +9787510822834 +9787510822926 +9787510823978 +9787510824050 +9787510824081 +9787510824128 +9787510824159 +9787510824166 +9787510824562 +9787510824586 +9787510824753 +9787510824777 +9787510825712 +9787510825774 +9787510826351 +9787510826405 +9787510826870 +9787510827709 +9787510827785 +9787510828829 +9787510828850 +9787510828911 +9787510828935 +9787510829055 +9787510829543 +9787510829697 +9787510830242 +9787510830709 +9787510830846 +9787510830877 +9787510831478 +9787510831867 +9787510831911 +9787510831997 +9787510832161 +9787510832635 +9787510832734 +9787510832758 +9787510833182 +9787510833311 +9787510833601 +9787510833748 +9787510833946 +9787510834622 +9787510834653 +9787510834660 +9787510835018 +9787510835179 +9787510835223 +9787510835650 +9787510835681 +9787510836756 +9787510837159 +9787510837470 +9787510838026 +9787510838293 +9787510839504 +9787510841446 +9787510841453 +9787510841811 +9787510842313 +9787510842481 +9787510844287 +9787510844683 +9787510844959 +9787510845697 +9787510846465 +9787510846533 +9787510847455 +9787510847806 +9787510847912 +9787510849930 +9787510850547 +9787510851612 +9787510852886 +9787510852978 +9787510855092 +9787510855436 +9787510855528 +9787510855627 +9787510856020 +9787510856471 +9787510859281 +9787510859540 +9787510860393 +9787510860737 +9787510861765 +9787510862861 +9787510863066 +9787510863530 +9787510864933 +9787510865305 +9787510866739 +9787510866791 +9787510866845 +9787510868009 +9787510868603 +9787510870361 +9787510870972 +9787510871023 +9787510871559 +9787510872549 +9787510875755 +9787510876219 +9787510876684 +9787510877261 +9787510877780 +9787510878015 +9787510878176 +9787510878893 +9787510879234 +9787510879319 +9787510879913 +9787510880438 +9787510881299 +9787510881756 +9787510882111 +9787510882555 +9787510883354 +9787510883385 +9787510883491 +9787510883507 +9787510884306 +9787510884634 +9787510884757 +9787510885518 +9787510885990 +9787510886768 +9787510887314 +9787510887840 +9787510888144 +9787510888205 +9787510888496 +9787510889769 +9787510890529 +9787510890901 +9787510891793 +9787510892547 +9787510893131 +9787510893391 +9787510893469 +9787510893810 +9787510893988 +9787510895517 +9787510895678 +9787510897566 +9787510898068 +9787510898518 +9787510899119 +9787510899348 +9787510899409 +9787510899775 +9787510900143 +9787510900433 +9787510900815 +9787510900853 +9787510901294 +9787510901409 +9787510901720 +9787510902581 +9787510902765 +9787510903267 +9787510903465 +9787510903601 +9787510904059 +9787510904608 +9787510904790 +9787510905438 +9787510905605 +9787510905797 +9787510906053 +9787510906404 +9787510906428 +9787510906527 +9787510907074 +9787510907234 +9787510907241 +9787510907517 +9787510907623 +9787510907821 +9787510908125 +9787510908262 +9787510908477 +9787510908583 +9787510908910 +9787510909238 +9787510909498 +9787510909658 +9787510909665 +9787510910043 +9787510910487 +9787510910524 +9787510910746 +9787510910906 +9787510911323 +9787510911644 +9787510911651 +9787510912016 +9787510912313 +9787510912634 +9787510912689 +9787510913075 +9787510913471 +9787510915574 +9787510916533 +9787510917578 +9787510917875 +9787510919213 +9787510919480 +9787510919596 +9787510919657 +9787510919886 +9787510919909 +9787510920318 +9787510921971 +9787510922954 +9787510924309 +9787510924576 +9787510924873 +9787510925047 +9787510925115 +9787510925139 +9787510925252 +9787510925788 +9787510925849 +9787510925856 +9787510925948 +9787510926051 +9787510926464 +9787510926600 +9787510926853 +9787510927140 +9787510927171 +9787510927195 +9787510927324 +9787510927867 +9787510928079 +9787510928123 +9787510928284 +9787510928468 +9787510928604 +9787510928635 +9787510928680 +9787510928710 +9787510928734 +9787510928765 +9787510928789 +9787510928826 +9787510928918 +9787510928994 +9787510929052 +9787510929120 +9787510929205 +9787510929236 +9787510929250 +9787510929328 +9787510929342 +9787510929533 +9787510929618 +9787510929625 +9787510929632 +9787510929663 +9787510929885 +9787510929892 +9787510929977 +9787510930256 +9787510930270 +9787510930379 +9787510930416 +9787510930492 +9787510930539 +9787510930553 +9787510930584 +9787510930638 +9787510930706 +9787510930713 +9787510930720 +9787510930744 +9787510930829 +9787510930904 +9787510930935 +9787510931086 +9787510931130 +9787510931161 +9787510931239 +9787510931260 +9787510931284 +9787510931437 +9787510931451 +9787510931710 +9787510931741 +9787510931772 +9787510931864 +9787510931871 +9787510931925 +9787510931994 +9787510932090 +9787510932120 +9787510932243 +9787510932472 +9787510932540 +9787510932755 +9787510932885 +9787510933066 +9787510933103 +9787510933158 +9787510933325 +9787510933479 +9787510933769 +9787510933813 +9787510934056 +9787510934124 +9787510934148 +9787510934254 +9787510934285 +9787510934292 +9787510934315 +9787510934384 +9787510934438 +9787510934506 +9787510934629 +9787510934735 +9787510934865 +9787510935169 +9787510935176 +9787510935190 +9787510935220 +9787510935305 +9787510935329 +9787510935381 +9787510935398 +9787510935404 +9787510935541 +9787510935640 +9787510935671 +9787510935701 +9787510935923 +9787510936234 +9787510936258 +9787510936272 +9787510936333 +9787510936388 +9787510936432 +9787510936517 +9787510936555 +9787510936579 +9787510936630 +9787510936647 +9787510936661 +9787510936784 +9787510936807 +9787510936845 +9787510936883 +9787510937057 +9787510937071 +9787510937118 +9787510937248 +9787510937255 +9787510937262 +9787510937460 +9787510937545 +9787510937569 +9787510937576 +9787510937583 +9787510937613 +9787510937712 +9787510937743 +9787510937767 +9787510937804 +9787510937811 +9787510937835 +9787510937842 +9787510937859 +9787510937873 +9787510937880 +9787510937910 +9787510937958 +9787510937972 +9787510938047 +9787510938054 +9787510938078 +9787510938085 +9787510938092 +9787510938160 +9787510938184 +9787510938191 +9787510938214 +9787510938221 +9787510938238 +9787510938269 +9787510938313 +9787510938344 +9787510938375 +9787510938412 +9787510938443 +9787510938450 +9787510938467 +9787510938498 +9787510938504 +9787510938511 +9787510938597 +9787510938627 +9787510938665 +9787510938757 +9787510938764 +9787510938771 +9787510938818 +9787510938849 +9787510938900 +9787510938917 +9787510938924 +9787510938931 +9787510938962 +9787510938993 +9787510939006 +9787510939044 +9787510939051 +9787510939068 +9787510939082 +9787510939105 +9787510939143 +9787510939204 +9787510939228 +9787510939259 +9787510939266 +9787510939303 +9787510939327 +9787510939334 +9787510939365 +9787510939389 +9787510939549 +9787510939587 +9787510939617 +9787510939631 +9787510939648 +9787510939679 +9787510939716 +9787510939723 +9787510939792 +9787510939891 +9787510939914 +9787510939990 +9787510940002 +9787510940064 +9787510940088 +9787510940095 +9787510940132 +9787510940149 +9787510940163 +9787510940187 +9787510940224 +9787510940231 +9787510940279 +9787510940293 +9787510940323 +9787510940354 +9787510940446 +9787510940453 +9787510940460 +9787510940477 +9787510940569 +9787510940712 +9787510940767 +9787510940781 +9787510940835 +9787510941078 +9787510941092 +9787510941108 +9787510941122 +9787510941139 +9787510941153 +9787510941177 +9787510941191 +9787510941207 +9787510941252 +9787510941269 +9787510941290 +9787510941306 +9787510941313 +9787510941320 +9787510941337 +9787510941405 +9787510941474 +9787510941542 +9787510941573 +9787510941597 +9787510941818 +9787510941825 +9787510941832 +9787510941856 +9787510941870 +9787510941887 +9787510942006 +9787510942051 +9787510942099 +9787510942167 +9787510942259 +9787510942280 +9787510942303 +9787510942365 +9787510942389 +9787510942440 +9787510942457 +9787510942594 +9787510942617 +9787510942624 +9787510942631 +9787510942648 +9787510942655 +9787510942679 +9787510942747 +9787510942822 +9787510942860 +9787510942990 +9787510943041 +9787510943065 +9787510943072 +9787510943270 +9787510943287 +9787510943461 +9787510943478 +9787510943553 +9787510943676 +9787510943706 +9787510943805 +9787510943836 +9787510943980 +9787510943997 +9787510944062 +9787510944093 +9787510944154 +9787510944208 +9787510944215 +9787510944239 +9787510944253 +9787510944383 +9787510944475 +9787510944529 +9787510944611 +9787510944727 +9787510944765 +9787510944833 +9787510944895 +9787510945106 +9787511000019 +9787511000101 +9787511000897 +9787511000958 +9787511001009 +9787511001078 +9787511001504 +9787511001528 +9787511001733 +9787511001764 +9787511001863 +9787511001917 +9787511002112 +9787511002242 +9787511002259 +9787511002266 +9787511002495 +9787511002549 +9787511002556 +9787511002686 +9787511002778 +9787511003928 +9787511003935 +9787511004055 +9787511004062 +9787511004079 +9787511004116 +9787511004154 +9787511004284 +9787511004505 +9787511004673 +9787511004680 +9787511004697 +9787511004772 +9787511004796 +9787511004956 +9787511005076 +9787511005168 +9787511005267 +9787511005281 +9787511005526 +9787511005694 +9787511005724 +9787511005915 +9787511006004 +9787511006028 +9787511006035 +9787511006059 +9787511006134 +9787511006141 +9787511006257 +9787511006271 +9787511006288 +9787511006486 +9787511006493 +9787511006554 +9787511006561 +9787511006592 +9787511006646 +9787511006653 +9787511006660 +9787511006684 +9787511006776 +9787511006950 +9787511007100 +9787511007131 +9787511007155 +9787511007230 +9787511007261 +9787511007285 +9787511007360 +9787511007407 +9787511007414 +9787511007469 +9787511007537 +9787511007568 +9787511007667 +9787511007674 +9787511007681 +9787511007759 +9787511007797 +9787511007827 +9787511008114 +9787511008169 +9787511008411 +9787511008633 +9787511009104 +9787511009456 +9787511009616 +9787511009708 +9787511009784 +9787511009982 +9787511010353 +9787511010377 +9787511010780 +9787511010810 +9787511010919 +9787511010926 +9787511010940 +9787511010957 +9787511011008 +9787511011015 +9787511011046 +9787511011145 +9787511011176 +9787511011275 +9787511011299 +9787511011411 +9787511011503 +9787511011534 +9787511011565 +9787511011657 +9787511011688 +9787511011978 +9787511011992 +9787511012074 +9787511012203 +9787511012340 +9787511012630 +9787511012708 +9787511012715 +9787511012814 +9787511012821 +9787511012845 +9787511012883 +9787511012890 +9787511012951 +9787511012975 +9787511013019 +9787511013040 +9787511013071 +9787511013095 +9787511013132 +9787511013194 +9787511013309 +9787511013422 +9787511013439 +9787511013521 +9787511013538 +9787511013569 +9787511013590 +9787511013637 +9787511013712 +9787511013729 +9787511013750 +9787511013941 +9787511013989 +9787511014009 +9787511014047 +9787511014092 +9787511014122 +9787511014368 +9787511014405 +9787511014429 +9787511014474 +9787511015068 +9787511015136 +9787511015495 +9787511015716 +9787511015846 +9787511015921 +9787511015976 +9787511015983 +9787511015990 +9787511016003 +9787511016454 +9787511016515 +9787511016775 +9787511016799 +9787511016898 +9787511017307 +9787511017338 +9787511017345 +9787511017697 +9787511017994 +9787511018007 +9787511018014 +9787511018021 +9787511018069 +9787511018137 +9787511018144 +9787511018328 +9787511018410 +9787511018571 +9787511018595 +9787511018984 +9787511019028 +9787511019035 +9787511019042 +9787511019059 +9787511019417 +9787511019455 +9787511019707 +9787511019806 +9787511019844 +9787511019905 +9787511020499 +9787511020529 +9787511020536 +9787511020697 +9787511020819 +9787511020833 +9787511020888 +9787511020895 +9787511021380 +9787511021595 +9787511021687 +9787511021755 +9787511021762 +9787511022295 +9787511022608 +9787511022707 +9787511022714 +9787511022929 +9787511022974 +9787511022981 +9787511023032 +9787511023803 +9787511023865 +9787511024404 +9787511024459 +9787511024541 +9787511024558 +9787511024602 +9787511024879 +9787511024886 +9787511024923 +9787511024961 +9787511025357 +9787511025937 +9787511026125 +9787511026132 +9787511026149 +9787511026316 +9787511027054 +9787511027160 +9787511027641 +9787511027771 +9787511028556 +9787511028563 +9787511028570 +9787511028778 +9787511028792 +9787511028808 +9787511028860 +9787511029126 +9787511029263 +9787511029317 +9787511029393 +9787511029409 +9787511029805 +9787511029898 +9787511029966 +9787511029973 +9787511030023 +9787511030689 +9787511030733 +9787511031525 +9787511031877 +9787511032263 +9787511032270 +9787511032294 +9787511032362 +9787511032379 +9787511032423 +9787511032454 +9787511032645 +9787511032737 +9787511032782 +9787511033192 +9787511033208 +9787511033215 +9787511033338 +9787511033635 +9787511033840 +9787511033857 +9787511033871 +9787511034168 +9787511034199 +9787511034243 +9787511034472 +9787511034762 +9787511035257 +9787511035332 +9787511035349 +9787511035356 +9787511037244 +9787511038678 +9787511039040 +9787511039088 +9787511039521 +9787511039552 +9787511039880 +9787511039897 +9787511040008 +9787511040046 +9787511040091 +9787511040152 +9787511040213 +9787511040398 +9787511040404 +9787511040411 +9787511040428 +9787511040442 +9787511040831 +9787511040893 +9787511041203 +9787511041562 +9787511041876 +9787511042187 +9787511042200 +9787511042354 +9787511042361 +9787511042378 +9787511044570 +9787511044785 +9787511045249 +9787511045256 +9787511045683 +9787511045706 +9787511045713 +9787511045768 +9787511046154 +9787511046468 +9787511046567 +9787511046642 +9787511047144 +9787511047380 +9787511047441 +9787511047748 +9787511047779 +9787511048400 +9787511048783 +9787511049841 +9787511050182 +9787511050465 +9787511050656 +9787511051349 +9787511051448 +9787511051455 +9787511051462 +9787511052025 +9787511052186 +9787511052223 +9787511052254 +9787511052438 +9787511052582 +9787511053107 +9787511053251 +9787511053305 +9787511053312 +9787511053459 +9787511053565 +9787511053640 +9787511053695 +9787511053824 +9787511054517 +9787511054531 +9787511054692 +9787511054999 +9787511055033 +9787511055040 +9787511055057 +9787511055064 +9787511055071 +9787511055095 +9787511056450 +9787511057266 +9787511057273 +9787511057365 +9787511057372 +9787511057549 +9787511057617 +9787511057709 +9787511057785 +9787511057839 +9787511057860 +9787511058126 +9787511058294 +9787511058669 +9787511058683 +9787511058713 +9787511059123 +9787511059307 +9787511059345 +9787511059383 +9787511059680 +9787511059697 +9787511060020 +9787511060075 +9787511060297 +9787511060464 +9787511061027 +9787511061706 +9787511061829 +9787511062260 +9787511062284 +9787511062345 +9787511062475 +9787511062482 +9787511062499 +9787511062642 +9787511062758 +9787511062994 +9787511063434 +9787511063489 +9787511063694 +9787511063830 +9787511064035 +9787511064097 +9787511064479 +9787511064561 +9787511064684 +9787511064714 +9787511064783 +9787511064851 +9787511065230 +9787511065247 +9787511065292 +9787511065315 +9787511065339 +9787511065506 +9787511065520 +9787511065810 +9787511065841 +9787511065889 +9787511065933 +9787511066152 +9787511066619 +9787511066626 +9787511066633 +9787511066671 +9787511066701 +9787511067005 +9787511067142 +9787511067241 +9787511067289 +9787511067449 +9787511067456 +9787511067692 +9787511067746 +9787511067791 +9787511067944 +9787511068095 +9787511068156 +9787511068163 +9787511068194 +9787511068200 +9787511068422 +9787511068439 +9787511068842 +9787511069023 +9787511069153 +9787511069245 +9787511069269 +9787511069283 +9787511069351 +9787511069511 +9787511069528 +9787511069696 +9787511069740 +9787511069801 +9787511069818 +9787511069825 +9787511069917 +9787511069924 +9787511069948 +9787511069962 +9787511070258 +9787511070401 +9787511070630 +9787511070883 +9787511070968 +9787511070975 +9787511071323 +9787511071439 +9787511071569 +9787511071941 +9787511072221 +9787511072269 +9787511072276 +9787511072382 +9787511072429 +9787511072528 +9787511072849 +9787511072894 +9787511073136 +9787511073716 +9787511074980 +9787511100238 +9787511100344 +9787511100498 +9787511100535 +9787511100764 +9787511100832 +9787511101181 +9787511101204 +9787511101709 +9787511101723 +9787511101785 +9787511102591 +9787511102881 +9787511103352 +9787511103604 +9787511104045 +9787511104090 +9787511104137 +9787511104625 +9787511105486 +9787511105585 +9787511105929 +9787511106117 +9787511106230 +9787511106667 +9787511107190 +9787511107497 +9787511107541 +9787511107596 +9787511107664 +9787511107688 +9787511107770 +9787511107787 +9787511107930 +9787511108449 +9787511108524 +9787511108838 +9787511108968 +9787511109361 +9787511109637 +9787511110305 +9787511110541 +9787511110596 +9787511110633 +9787511111142 +9787511111203 +9787511111340 +9787511111425 +9787511111500 +9787511111814 +9787511112316 +9787511112897 +9787511113375 +9787511113467 +9787511113580 +9787511113757 +9787511114044 +9787511114600 +9787511114624 +9787511114655 +9787511114761 +9787511114891 +9787511114938 +9787511115089 +9787511116314 +9787511116413 +9787511117212 +9787511117373 +9787511117526 +9787511118288 +9787511118325 +9787511118424 +9787511118431 +9787511118462 +9787511118479 +9787511118523 +9787511118783 +9787511119292 +9787511120311 +9787511120410 +9787511120823 +9787511121189 +9787511121509 +9787511121837 +9787511122193 +9787511123121 +9787511123138 +9787511123169 +9787511123183 +9787511123817 +9787511124081 +9787511124326 +9787511124661 +9787511125019 +9787511125040 +9787511125316 +9787511126429 +9787511126474 +9787511126627 +9787511126634 +9787511127457 +9787511127549 +9787511127563 +9787511127617 +9787511127709 +9787511127716 +9787511127761 +9787511127792 +9787511128287 +9787511128423 +9787511128454 +9787511128607 +9787511128638 +9787511128782 +9787511128805 +9787511129468 +9787511129758 +9787511130136 +9787511130204 +9787511130310 +9787511130969 +9787511130976 +9787511131478 +9787511131928 +9787511132260 +9787511132550 +9787511132598 +9787511132932 +9787511133052 +9787511133236 +9787511133373 +9787511133397 +9787511133939 +9787511133946 +9787511134608 +9787511135698 +9787511135773 +9787511135995 +9787511136275 +9787511136336 +9787511136701 +9787511137296 +9787511137432 +9787511137951 +9787511137982 +9787511138033 +9787511138385 +9787511138477 +9787511139306 +9787511139504 +9787511139542 +9787511139566 +9787511139696 +9787511139870 +9787511139900 +9787511140135 +9787511140166 +9787511140197 +9787511140562 +9787511140722 +9787511140739 +9787511140883 +9787511141019 +9787511141187 +9787511141613 +9787511141811 +9787511141897 +9787511142078 +9787511142108 +9787511142207 +9787511142832 +9787511142962 +9787511143099 +9787511143167 +9787511143181 +9787511143273 +9787511143310 +9787511143471 +9787511143655 +9787511143792 +9787511143808 +9787511144096 +9787511144263 +9787511144317 +9787511144980 +9787511145222 +9787511145291 +9787511145697 +9787511145765 +9787511145802 +9787511146083 +9787511146311 +9787511146717 +9787511146861 +9787511147226 +9787511147561 +9787511147615 +9787511147790 +9787511147929 +9787511148032 +9787511148070 +9787511149350 +9787511149985 +9787511150288 +9787511150516 +9787511150585 +9787511151438 +9787511151483 +9787511151506 +9787511151902 +9787511151971 +9787511152008 +9787511152169 +9787511152350 +9787511152664 +9787511152671 +9787511152831 +9787511153142 +9787511153449 +9787511153715 +9787511153739 +9787511153753 +9787511154125 +9787511154231 +9787511154484 +9787511154675 +9787511154750 +9787511154767 +9787511154798 +9787511155016 +9787511155085 +9787511155351 +9787511156457 +9787511156648 +9787511156976 +9787511157300 +9787511158062 +9787511158086 +9787511158406 +9787511158710 +9787511158871 +9787511159069 +9787511159694 +9787511159885 +9787511160133 +9787511160263 +9787511201805 +9787511203595 +9787511203670 +9787511203762 +9787511203885 +9787511203946 +9787511203991 +9787511204394 +9787511204820 +9787511205100 +9787511205179 +9787511205452 +9787511205476 +9787511205582 +9787511205643 +9787511205780 +9787511206145 +9787511206169 +9787511206220 +9787511206312 +9787511206466 +9787511206497 +9787511206558 +9787511207258 +9787511207272 +9787511207401 +9787511207685 +9787511207722 +9787511207760 +9787511207777 +9787511207814 +9787511207845 +9787511208286 +9787511208354 +9787511208378 +9787511208675 +9787511208699 +9787511209795 +9787511209924 +9787511209931 +9787511210005 +9787511210173 +9787511210180 +9787511210203 +9787511210739 +9787511211002 +9787511211101 +9787511211187 +9787511211378 +9787511211491 +9787511211705 +9787511211736 +9787511212733 +9787511212818 +9787511212993 +9787511213051 +9787511213105 +9787511213242 +9787511213440 +9787511213532 +9787511213570 +9787511213785 +9787511213990 +9787511214393 +9787511214409 +9787511214423 +9787511214430 +9787511214652 +9787511215109 +9787511215192 +9787511215994 +9787511216601 +9787511216670 +9787511217080 +9787511217141 +9787511217226 +9787511217332 +9787511217363 +9787511217417 +9787511217578 +9787511217745 +9787511217851 +9787511217882 +9787511218278 +9787511218377 +9787511218384 +9787511218469 +9787511218759 +9787511219251 +9787511219695 +9787511219701 +9787511219855 +9787511220134 +9787511220363 +9787511220660 +9787511221100 +9787511221117 +9787511221322 +9787511221346 +9787511221544 +9787511221759 +9787511222046 +9787511222411 +9787511222473 +9787511222534 +9787511223005 +9787511223104 +9787511223142 +9787511223326 +9787511223364 +9787511223807 +9787511224064 +9787511224910 +9787511226402 +9787511226419 +9787511226501 +9787511226532 +9787511226549 +9787511226624 +9787511226631 +9787511226839 +9787511226877 +9787511226938 +9787511227218 +9787511227935 +9787511228093 +9787511228109 +9787511228703 +9787511228772 +9787511229342 +9787511229366 +9787511230003 +9787511230010 +9787511230065 +9787511230072 +9787511230225 +9787511230300 +9787511230522 +9787511231628 +9787511231888 +9787511232410 +9787511232519 +9787511233028 +9787511233783 +9787511235077 +9787511235084 +9787511235145 +9787511235350 +9787511235640 +9787511235909 +9787511235985 +9787511236180 +9787511237316 +9787511237521 +9787511237668 +9787511238429 +9787511238443 +9787511238917 +9787511238993 +9787511239020 +9787511239112 +9787511239143 +9787511239167 +9787511239372 +9787511239471 +9787511239488 +9787511239785 +9787511240392 +9787511240538 +9787511241139 +9787511241191 +9787511241498 +9787511241603 +9787511241733 +9787511241986 +9787511242006 +9787511242143 +9787511243652 +9787511244000 +9787511244093 +9787511244314 +9787511244406 +9787511245120 +9787511245151 +9787511245229 +9787511245250 +9787511245465 +9787511245670 +9787511246158 +9787511246448 +9787511246844 +9787511246899 +9787511247001 +9787511247223 +9787511247230 +9787511247247 +9787511247261 +9787511247292 +9787511247346 +9787511247377 +9787511247391 +9787511248312 +9787511248442 +9787511248770 +9787511249333 +9787511250100 +9787511250353 +9787511250650 +9787511250704 +9787511250735 +9787511250803 +9787511250964 +9787511251268 +9787511251329 +9787511251428 +9787511251589 +9787511252432 +9787511252579 +9787511252654 +9787511253637 +9787511254399 +9787511254429 +9787511254504 +9787511254511 +9787511254887 +9787511255495 +9787511255839 +9787511256454 +9787511256843 +9787511256898 +9787511257307 +9787511257796 +9787511257987 +9787511258571 +9787511259240 +9787511259257 +9787511259271 +9787511259288 +9787511259349 +9787511259844 +9787511260079 +9787511260086 +9787511260123 +9787511260468 +9787511260505 +9787511260574 +9787511261472 +9787511261717 +9787511262103 +9787511262172 +9787511262325 +9787511262370 +9787511262585 +9787511262615 +9787511262653 +9787511262660 +9787511262844 +9787511262851 +9787511262868 +9787511262875 +9787511262882 +9787511262899 +9787511262929 +9787511262936 +9787511262950 +9787511262967 +9787511262974 +9787511262998 +9787511263018 +9787511263087 +9787511263100 +9787511263131 +9787511263179 +9787511263230 +9787511263247 +9787511263254 +9787511263261 +9787511263315 +9787511263346 +9787511263360 +9787511263667 +9787511264053 +9787511264442 +9787511264596 +9787511264817 +9787511265203 +9787511265340 +9787511266132 +9787511266248 +9787511266323 +9787511266330 +9787511266361 +9787511266378 +9787511266521 +9787511266729 +9787511266897 +9787511266934 +9787511267061 +9787511267344 +9787511268341 +9787511268358 +9787511268433 +9787511269539 +9787511269836 +9787511270979 +9787511270986 +9787511271082 +9787511271334 +9787511271341 +9787511271419 +9787511271617 +9787511271877 +9787511272041 +9787511272379 +9787511272409 +9787511272416 +9787511272454 +9787511272461 +9787511272973 +9787511273215 +9787511273826 +9787511274106 +9787511274700 +9787511274731 +9787511276155 +9787511276322 +9787511276346 +9787511276544 +9787511276704 +9787511276834 +9787511277015 +9787511277220 +9787511277732 +9787511277862 +9787511277978 +9787511279095 +9787511279675 +9787511280473 +9787511280602 +9787511281241 +9787511281593 +9787511281654 +9787511282224 +9787511282354 +9787511282460 +9787511282552 +9787511282798 +9787511283962 +9787511284495 +9787511284501 +9787511285157 +9787511285171 +9787511285416 +9787511285447 +9787511285942 +9787511286529 +9787511287984 +9787511287991 +9787511288325 +9787511289162 +9787511289285 +9787511289391 +9787511289650 +9787511289957 +9787511290663 +9787511291370 +9787511291578 +9787511291981 +9787511292254 +9787511294586 +9787511294951 +9787511295330 +9787511295453 +9787511295477 +9787511295484 +9787511296054 +9787511298010 +9787511298027 +9787511298065 +9787511299635 +9787511300003 +9787511300058 +9787511300232 +9787511300393 +9787511300676 +9787511300782 +9787511301055 +9787511301345 +9787511301451 +9787511301468 +9787511301666 +9787511301819 +9787511301956 +9787511302083 +9787511302151 +9787511302496 +9787511302717 +9787511302847 +9787511302939 +9787511302977 +9787511303059 +9787511303295 +9787511303363 +9787511303479 +9787511303516 +9787511303554 +9787511303653 +9787511303691 +9787511303943 +9787511304070 +9787511304285 +9787511304483 +9787511304490 +9787511304544 +9787511304629 +9787511304674 +9787511304759 +9787511304780 +9787511304995 +9787511305312 +9787511306173 +9787511306357 +9787511306647 +9787511306807 +9787511306852 +9787511306920 +9787511306975 +9787511307187 +9787511307446 +9787511307484 +9787511307507 +9787511307934 +9787511308214 +9787511308399 +9787511308450 +9787511308528 +9787511308559 +9787511308702 +9787511308801 +9787511308894 +9787511308962 +9787511309082 +9787511309129 +9787511309426 +9787511309761 +9787511310019 +9787511310347 +9787511310361 +9787511310392 +9787511310606 +9787511310620 +9787511310736 +9787511310972 +9787511311351 +9787511311368 +9787511311610 +9787511312082 +9787511312136 +9787511312402 +9787511312488 +9787511312761 +9787511312846 +9787511312877 +9787511312884 +9787511313157 +9787511313263 +9787511313355 +9787511313461 +9787511313812 +9787511314338 +9787511314734 +9787511314826 +9787511315229 +9787511315267 +9787511317360 +9787511317438 +9787511317445 +9787511318053 +9787511318220 +9787511318329 +9787511318916 +9787511319678 +9787511320032 +9787511320124 +9787511320476 +9787511321541 +9787511321640 +9787511321718 +9787511321800 +9787511322012 +9787511322241 +9787511322364 +9787511322449 +9787511322531 +9787511322654 +9787511322661 +9787511322760 +9787511322821 +9787511322968 +9787511323323 +9787511323699 +9787511323781 +9787511323798 +9787511324177 +9787511324313 +9787511324450 +9787511324832 +9787511325624 +9787511325730 +9787511325907 +9787511326515 +9787511326591 +9787511326621 +9787511326812 +9787511326829 +9787511327154 +9787511327192 +9787511327338 +9787511327703 +9787511327758 +9787511327895 +9787511328175 +9787511328212 +9787511328243 +9787511328540 +9787511328571 +9787511328656 +9787511328724 +9787511329547 +9787511329776 +9787511329790 +9787511329806 +9787511329875 +9787511330055 +9787511330383 +9787511331069 +9787511331182 +9787511331205 +9787511331397 +9787511331854 +9787511331878 +9787511331960 +9787511331991 +9787511332097 +9787511332196 +9787511332264 +9787511332301 +9787511332318 +9787511332585 +9787511332943 +9787511333032 +9787511333520 +9787511333711 +9787511333728 +9787511333780 +9787511333940 +9787511334138 +9787511334237 +9787511334343 +9787511335203 +9787511335975 +9787511336026 +9787511336156 +9787511336361 +9787511336460 +9787511336712 +9787511336958 +9787511337351 +9787511337450 +9787511337580 +9787511337689 +9787511337757 +9787511337771 +9787511337863 +9787511338167 +9787511338426 +9787511338686 +9787511339225 +9787511339287 +9787511339539 +9787511339690 +9787511340054 +9787511340344 +9787511340610 +9787511341020 +9787511341280 +9787511341976 +9787511342270 +9787511342331 +9787511342362 +9787511342546 +9787511342997 +9787511343093 +9787511343840 +9787511344076 +9787511344427 +9787511344588 +9787511344663 +9787511344694 +9787511344885 +9787511345233 +9787511345325 +9787511345332 +9787511345820 +9787511346254 +9787511346308 +9787511347046 +9787511347541 +9787511348074 +9787511348821 +9787511349248 +9787511349279 +9787511349545 +9787511351715 +9787511352071 +9787511352576 +9787511352743 +9787511352811 +9787511353443 +9787511353498 +9787511353801 +9787511353887 +9787511354112 +9787511354129 +9787511354402 +9787511354433 +9787511354440 +9787511354617 +9787511354655 +9787511354730 +9787511355119 +9787511356116 +9787511356321 +9787511356680 +9787511356727 +9787511356765 +9787511357267 +9787511357366 +9787511357373 +9787511357403 +9787511357656 +9787511357960 +9787511358004 +9787511358028 +9787511358165 +9787511358189 +9787511358561 +9787511358592 +9787511359148 +9787511359230 +9787511359247 +9787511359582 +9787511359612 +9787511359780 +9787511359797 +9787511360069 +9787511360472 +9787511361080 +9787511361349 +9787511361585 +9787511361653 +9787511361660 +9787511361769 +9787511361844 +9787511361981 +9787511362148 +9787511362315 +9787511362728 +9787511363169 +9787511363473 +9787511363527 +9787511363947 +9787511364456 +9787511364876 +9787511365279 +9787511365477 +9787511365507 +9787511365897 +9787511366382 +9787511366689 +9787511367082 +9787511367303 +9787511367396 +9787511367709 +9787511368010 +9787511368430 +9787511368478 +9787511369055 +9787511369345 +9787511369420 +9787511369475 +9787511369482 +9787511369949 +9787511370006 +9787511370181 +9787511370280 +9787511370327 +9787511370600 +9787511370624 +9787511370716 +9787511370839 +9787511371232 +9787511371270 +9787511371416 +9787511371423 +9787511371812 +9787511371874 +9787511372154 +9787511372567 +9787511372703 +9787511372901 +9787511373137 +9787511373984 +9787511374189 +9787511374202 +9787511374547 +9787511375308 +9787511375872 +9787511376015 +9787511376428 +9787511376497 +9787511376787 +9787511377418 +9787511378422 +9787511378590 +9787511378767 +9787511378965 +9787511379085 +9787511379108 +9787511379290 +9787511379306 +9787511380203 +9787511380241 +9787511380616 +9787511380814 +9787511380982 +9787511381422 +9787511381507 +9787511381729 +9787511381767 +9787511381903 +9787511382580 +9787511382658 +9787511382856 +9787511382887 +9787511382948 +9787511383341 +9787511383679 +9787511383693 +9787511383754 +9787511383853 +9787511384393 +9787511385109 +9787511385185 +9787511386076 +9787511386250 +9787511386298 +9787511386335 +9787511386588 +9787511387196 +9787511387240 +9787511387271 +9787511387301 +9787511387349 +9787511387950 +9787511388568 +9787511388773 +9787511388803 +9787511389053 +9787511389244 +9787511389596 +9787511389633 +9787511389879 +9787511389961 +9787511389992 +9787511390110 +9787511390400 +9787511390646 +9787511390745 +9787511391230 +9787511391735 +9787511392213 +9787511392220 +9787511392237 +9787511392244 +9787511392459 +9787511393197 +9787511393951 +9787511394613 +9787511395450 +9787511400703 +9787511401502 +9787511401786 +9787511402318 +9787511402882 +9787511403988 +9787511404763 +9787511406187 +9787511407115 +9787511407986 +9787511409454 +9787511410450 +9787511411259 +9787511412362 +9787511412607 +9787511412836 +9787511413116 +9787511413406 +9787511413772 +9787511415394 +9787511416063 +9787511416322 +9787511416360 +9787511417350 +9787511420039 +9787511420879 +9787511421227 +9787511421388 +9787511421791 +9787511421913 +9787511422194 +9787511422231 +9787511422835 +9787511423177 +9787511423269 +9787511423382 +9787511424136 +9787511424600 +9787511424747 +9787511425065 +9787511425836 +9787511426765 +9787511427243 +9787511427908 +9787511428875 +9787511429223 +9787511431363 +9787511431479 +9787511431578 +9787511431608 +9787511433473 +9787511433909 +9787511434050 +9787511434067 +9787511434364 +9787511435361 +9787511436269 +9787511436276 +9787511436498 +9787511437419 +9787511438157 +9787511438249 +9787511438836 +9787511439024 +9787511439925 +9787511439949 +9787511440365 +9787511440419 +9787511440631 +9787511440952 +9787511441102 +9787511442017 +9787511442574 +9787511442673 +9787511442888 +9787511444356 +9787511445407 +9787511445827 +9787511445872 +9787511446046 +9787511447012 +9787511447166 +9787511447647 +9787511447838 +9787511448002 +9787511448019 +9787511448781 +9787511448804 +9787511448989 +9787511449153 +9787511449368 +9787511449610 +9787511450791 +9787511450913 +9787511450951 +9787511451354 +9787511452696 +9787511453464 +9787511453532 +9787511454379 +9787511454997 +9787511455369 +9787511456007 +9787511456175 +9787511458001 +9787511458056 +9787511458155 +9787511458162 +9787511458285 +9787511458582 +9787511458810 +9787511459039 +9787511459152 +9787511459183 +9787511459374 +9787511459862 +9787511459954 +9787511460172 +9787511460332 +9787511460455 +9787511460813 +9787511461025 +9787511461889 +9787511461957 +9787511461964 +9787511461971 +9787511461988 +9787511462107 +9787511462442 +9787511462787 +9787511463234 +9787511463623 +9787511463722 +9787511463876 +9787511463968 +9787511464095 +9787511464132 +9787511464156 +9787511464163 +9787511464231 +9787511464347 +9787511464378 +9787511464415 +9787511464446 +9787511464613 +9787511464637 +9787511464668 +9787511464699 +9787511464835 +9787511464866 +9787511464873 +9787511464927 +9787511464941 +9787511465009 +9787511465207 +9787511465412 +9787511465481 +9787511465535 +9787511465740 +9787511466051 +9787511466235 +9787511466938 +9787511466983 +9787511467058 +9787511467072 +9787511467171 +9787511467256 +9787511467263 +9787511467287 +9787511467386 +9787511467461 +9787511467478 +9787511467492 +9787511467522 +9787511467669 +9787511467706 +9787511467812 +9787511467836 +9787511467843 +9787511467867 +9787511468048 +9787511468123 +9787511468475 +9787511468499 +9787511468505 +9787511468512 +9787511468529 +9787511468536 +9787511468550 +9787511468673 +9787511468819 +9787511468970 +9787511469090 +9787511469304 +9787511469458 +9787511469502 +9787511469519 +9787511469557 +9787511469649 +9787511469786 +9787511469908 +9787511469984 +9787511470003 +9787511470287 +9787511470393 +9787511470447 +9787511470454 +9787511470461 +9787511470560 +9787511470645 +9787511470652 +9787511470676 +9787511470829 +9787511470935 +9787511470942 +9787511470959 +9787511470980 +9787511471024 +9787511471116 +9787511471215 +9787511471239 +9787511471444 +9787511471512 +9787511471581 +9787511471628 +9787511471635 +9787511471642 +9787511471659 +9787511471666 +9787511471680 +9787511471802 +9787511471857 +9787511471864 +9787511471888 +9787511471932 +9787511471956 +9787511471994 +9787511472052 +9787511472199 +9787511472250 +9787511472441 +9787511472489 +9787511472519 +9787511472526 +9787511472533 +9787511472557 +9787511472564 +9787511472588 +9787511472663 +9787511472694 +9787511472885 +9787511473288 +9787511473325 +9787511473448 +9787511473462 +9787511473516 +9787511473547 +9787511473554 +9787511473622 +9787511473714 +9787511473851 +9787511473882 +9787511473899 +9787511473905 +9787511473912 +9787511474162 +9787511474230 +9787511474339 +9787511474629 +9787511474803 +9787511474827 +9787511475114 +9787511475121 +9787511475145 +9787511475213 +9787511475275 +9787511475497 +9787511475510 +9787511475541 +9787511475558 +9787511475565 +9787511475640 +9787511475657 +9787511475725 +9787511475879 +9787511476289 +9787511476517 +9787511476524 +9787511476531 +9787511476548 +9787511476555 +9787511476562 +9787511476579 +9787511476791 +9787511477279 +9787511477293 +9787511477347 +9787511477446 +9787511477842 +9787511478368 +9787511478900 +9787511479433 +9787511479860 +9787511500106 +9787511500175 +9787511500472 +9787511500502 +9787511500533 +9787511500649 +9787511500663 +9787511500847 +9787511501202 +9787511501219 +9787511501318 +9787511501523 +9787511501592 +9787511501622 +9787511501677 +9787511501738 +9787511501882 +9787511501943 +9787511501950 +9787511502001 +9787511502476 +9787511502520 +9787511503015 +9787511503831 +9787511504265 +9787511504340 +9787511505088 +9787511505101 +9787511505156 +9787511505293 +9787511505606 +9787511506443 +9787511506566 +9787511506627 +9787511506733 +9787511506818 +9787511506993 +9787511507419 +9787511507501 +9787511507518 +9787511507532 +9787511507686 +9787511507792 +9787511507877 +9787511507990 +9787511508423 +9787511508447 +9787511508553 +9787511508898 +9787511509482 +9787511511959 +9787511512000 +9787511512062 +9787511512208 +9787511512222 +9787511512543 +9787511512734 +9787511514318 +9787511514691 +9787511514769 +9787511514868 +9787511514882 +9787511515209 +9787511516350 +9787511516411 +9787511517531 +9787511517968 +9787511518118 +9787511518125 +9787511518316 +9787511518545 +9787511519276 +9787511519559 +9787511519788 +9787511519986 +9787511520142 +9787511520524 +9787511521224 +9787511521897 +9787511522238 +9787511522252 +9787511522269 +9787511522405 +9787511522856 +9787511522894 +9787511523310 +9787511523327 +9787511523525 +9787511523563 +9787511523884 +9787511524096 +9787511524416 +9787511524508 +9787511524874 +9787511525284 +9787511525697 +9787511526410 +9787511526779 +9787511526960 +9787511526991 +9787511527004 +9787511527608 +9787511528056 +9787511528483 +9787511529381 +9787511529503 +9787511529671 +9787511529695 +9787511529770 +9787511529794 +9787511530271 +9787511530585 +9787511530783 +9787511530998 +9787511531247 +9787511531261 +9787511531735 +9787511532060 +9787511532237 +9787511532848 +9787511532909 +9787511532947 +9787511533241 +9787511533340 +9787511533838 +9787511534071 +9787511534293 +9787511534750 +9787511535177 +9787511536723 +9787511536983 +9787511537492 +9787511537850 +9787511538383 +9787511538420 +9787511539533 +9787511539601 +9787511539861 +9787511540744 +9787511540768 +9787511540775 +9787511541079 +9787511541307 +9787511542434 +9787511542465 +9787511542601 +9787511543271 +9787511543288 +9787511543950 +9787511545039 +9787511545046 +9787511545664 +9787511545718 +9787511546029 +9787511546593 +9787511547323 +9787511547842 +9787511547958 +9787511548351 +9787511548740 +9787511548757 +9787511549587 +9787511549785 +9787511550545 +9787511550897 +9787511551757 +9787511551863 +9787511551887 +9787511552600 +9787511552679 +9787511553034 +9787511553294 +9787511553454 +9787511553874 +9787511554253 +9787511554345 +9787511554673 +9787511554680 +9787511554758 +9787511555151 +9787511555298 +9787511555854 +9787511555960 +9787511556387 +9787511556837 +9787511557063 +9787511557193 +9787511557261 +9787511557278 +9787511557933 +9787511557940 +9787511558183 +9787511558589 +9787511558879 +9787511559456 +9787511559616 +9787511559661 +9787511559685 +9787511559708 +9787511559821 +9787511559869 +9787511560131 +9787511560155 +9787511560193 +9787511560247 +9787511560261 +9787511560278 +9787511560414 +9787511560445 +9787511560452 +9787511560551 +9787511560735 +9787511561343 +9787511561350 +9787511561626 +9787511561831 +9787511562357 +9787511562463 +9787511563071 +9787511563088 +9787511563132 +9787511563279 +9787511563477 +9787511563507 +9787511563651 +9787511563750 +9787511563873 +9787511564207 +9787511564368 +9787511564450 +9787511564504 +9787511564535 +9787511564627 +9787511564702 +9787511564733 +9787511564948 +9787511564955 +9787511565037 +9787511565068 +9787511565150 +9787511565181 +9787511565204 +9787511565211 +9787511565303 +9787511565310 +9787511565525 +9787511565594 +9787511565785 +9787511565792 +9787511565877 +9787511565945 +9787511565952 +9787511565976 +9787511566027 +9787511566041 +9787511566409 +9787511566454 +9787511566478 +9787511566669 +9787511566812 +9787511566836 +9787511567017 +9787511567147 +9787511567208 +9787511567376 +9787511567802 +9787511568069 +9787511568137 +9787511568243 +9787511568328 +9787511568403 +9787511568410 +9787511568564 +9787511568779 +9787511569127 +9787511569202 +9787511569240 +9787511569370 +9787511569448 +9787511569455 +9787511569516 +9787511569578 +9787511569677 +9787511569721 +9787511569837 +9787511570185 +9787511570215 +9787511570390 +9787511570543 +9787511570628 +9787511570666 +9787511571120 +9787511571410 +9787511571472 +9787511571588 +9787511571663 +9787511571847 +9787511571854 +9787511571984 +9787511572103 +9787511572158 +9787511572264 +9787511572271 +9787511572363 +9787511572448 +9787511572462 +9787511572486 +9787511572592 +9787511572622 +9787511572684 +9787511572714 +9787511572769 +9787511572851 +9787511572912 +9787511573032 +9787511573070 +9787511573247 +9787511573605 +9787511573940 +9787511574015 +9787511574039 +9787511574282 +9787511574343 +9787511574404 +9787511574503 +9787511574510 +9787511574534 +9787511574619 +9787511574640 +9787511574671 +9787511574688 +9787511574725 +9787511574893 +9787511575036 +9787511575043 +9787511575074 +9787511575081 +9787511575159 +9787511575166 +9787511575173 +9787511575197 +9787511575210 +9787511575289 +9787511575302 +9787511575319 +9787511575326 +9787511575333 +9787511575340 +9787511575357 +9787511575395 +9787511575715 +9787511575753 +9787511575838 +9787511575869 +9787511575913 +9787511575951 +9787511575982 +9787511576026 +9787511576071 +9787511576170 +9787511576316 +9787511576408 +9787511576620 +9787511576637 +9787511576644 +9787511576651 +9787511576743 +9787511576750 +9787511576811 +9787511576910 +9787511577115 +9787511577160 +9787511577184 +9787511577399 +9787511577405 +9787511577412 +9787511577429 +9787511577436 +9787511577764 +9787511577771 +9787511577924 +9787511578051 +9787511578075 +9787511578204 +9787511578235 +9787511578303 +9787511578365 +9787511578457 +9787511578471 +9787511578549 +9787511578563 +9787511578662 +9787511578693 +9787511578808 +9787511578921 +9787511578938 +9787511578976 +9787511578983 +9787511579157 +9787511579164 +9787511579218 +9787511579522 +9787511579546 +9787511580061 +9787511580115 +9787511580146 +9787511580177 +9787511580184 +9787511580207 +9787511580214 +9787511580221 +9787511580306 +9787511580450 +9787511580467 +9787511580887 +9787511580948 +9787511580955 +9787511580962 +9787511580986 +9787511581020 +9787511581068 +9787511581112 +9787511581266 +9787511581327 +9787511581334 +9787511581501 +9787511581549 +9787511581600 +9787511581624 +9787511581648 +9787511581655 +9787511581679 +9787511581693 +9787511581709 +9787511581808 +9787511581914 +9787511581983 +9787511582003 +9787511582010 +9787511582065 +9787511582096 +9787511582157 +9787511582249 +9787511582270 +9787511582485 +9787511582508 +9787511582553 +9787511582584 +9787511582614 +9787511582669 +9787511582676 +9787511582836 +9787511582904 +9787511582942 +9787511582980 +9787511583031 +9787511583055 +9787511583062 +9787511583161 +9787511583192 +9787511583277 +9787511583291 +9787511583468 +9787511583550 +9787511583680 +9787511583918 +9787511583949 +9787511584496 +9787511584755 +9787511584762 +9787511584847 +9787511584984 +9787511585059 +9787511585196 +9787511585257 +9787511585479 +9787511585486 +9787511585493 +9787511585509 +9787511585516 +9787511585530 +9787511585813 +9787511585837 +9787511585844 +9787511585943 +9787511586346 +9787511586476 +9787511586681 +9787511586728 +9787511586841 +9787511587626 +9787511588586 +9787511600165 +9787511600455 +9787511600691 +9787511601100 +9787511601971 +9787511602107 +9787511602398 +9787511602718 +9787511602909 +9787511603364 +9787511603838 +9787511604415 +9787511604705 +9787511604712 +9787511605481 +9787511605979 +9787511606105 +9787511606150 +9787511606839 +9787511606938 +9787511606990 +9787511607034 +9787511607362 +9787511607584 +9787511607706 +9787511608222 +9787511609052 +9787511609083 +9787511609601 +9787511609700 +9787511610010 +9787511610294 +9787511610515 +9787511610843 +9787511611048 +9787511611253 +9787511611482 +9787511612038 +9787511612144 +9787511612663 +9787511613042 +9787511613394 +9787511613424 +9787511613431 +9787511613509 +9787511613554 +9787511613592 +9787511613714 +9787511614032 +9787511614162 +9787511614315 +9787511614582 +9787511614742 +9787511615534 +9787511615701 +9787511616104 +9787511616326 +9787511616692 +9787511616807 +9787511618115 +9787511618658 +9787511618894 +9787511619044 +9787511619426 +9787511619440 +9787511619457 +9787511619488 +9787511619884 +9787511620422 +9787511620590 +9787511620682 +9787511621252 +9787511621412 +9787511623171 +9787511623201 +9787511623218 +9787511623379 +9787511623867 +9787511623942 +9787511623997 +9787511624017 +9787511624543 +9787511624789 +9787511624918 +9787511625045 +9787511625090 +9787511625434 +9787511626219 +9787511626318 +9787511626363 +9787511626967 +9787511627162 +9787511627650 +9787511627896 +9787511628015 +9787511628039 +9787511628350 +9787511628572 +9787511628695 +9787511628855 +9787511629265 +9787511629319 +9787511629364 +9787511629838 +9787511630230 +9787511630278 +9787511630766 +9787511630995 +9787511631183 +9787511631657 +9787511631824 +9787511631855 +9787511632067 +9787511632791 +9787511632982 +9787511633088 +9787511633187 +9787511633279 +9787511633590 +9787511635839 +9787511636188 +9787511636270 +9787511636898 +9787511637079 +9787511637253 +9787511637802 +9787511639318 +9787511639493 +9787511639738 +9787511640079 +9787511640444 +9787511640598 +9787511640741 +9787511640833 +9787511641519 +9787511641687 +9787511641847 +9787511642561 +9787511642578 +9787511642851 +9787511643018 +9787511643117 +9787511643537 +9787511644213 +9787511644619 +9787511645012 +9787511645531 +9787511645661 +9787511646064 +9787511646255 +9787511646262 +9787511646422 +9787511646545 +9787511647061 +9787511647290 +9787511647511 +9787511649461 +9787511650191 +9787511650573 +9787511650702 +9787511651457 +9787511651648 +9787511652454 +9787511652492 +9787511652591 +9787511652966 +9787511653543 +9787511653604 +9787511653758 +9787511654359 +9787511654878 +9787511656315 +9787511656384 +9787511656421 +9787511656544 +9787511657534 +9787511658036 +9787511658173 +9787511658296 +9787511659378 +9787511659828 +9787511660268 +9787511660404 +9787511660428 +9787511660480 +9787511660831 +9787511660930 +9787511661135 +9787511661715 +9787511661999 +9787511662194 +9787511662217 +9787511662255 +9787511662477 +9787511663108 +9787511663160 +9787511663610 +9787511663870 +9787511664099 +9787511664150 +9787511664204 +9787511664655 +9787511664761 +9787511664839 +9787511665270 +9787511665355 +9787511666482 +9787511667144 +9787511667441 +9787511667892 +9787511668042 +9787511668325 +9787511668615 +9787511669018 +9787511669285 +9787511669292 +9787511669780 +9787511670540 +9787511670793 +9787511671011 +9787511671509 +9787511700056 +9787511700193 +9787511700216 +9787511700292 +9787511700391 +9787511700506 +9787511700520 +9787511700803 +9787511701091 +9787511701145 +9787511701367 +9787511701374 +9787511701527 +9787511701558 +9787511701589 +9787511701701 +9787511701725 +9787511701794 +9787511701824 +9787511702197 +9787511702241 +9787511702319 +9787511702333 +9787511702340 +9787511702449 +9787511702470 +9787511702647 +9787511702784 +9787511702975 +9787511703224 +9787511703378 +9787511703507 +9787511703521 +9787511704344 +9787511704450 +9787511704474 +9787511704610 +9787511704764 +9787511705082 +9787511705181 +9787511705358 +9787511705365 +9787511705426 +9787511705921 +9787511706188 +9787511706270 +9787511706355 +9787511706584 +9787511706737 +9787511706768 +9787511706775 +9787511706966 +9787511707031 +9787511707123 +9787511707345 +9787511707529 +9787511707710 +9787511707741 +9787511708168 +9787511708175 +9787511708236 +9787511708359 +9787511708502 +9787511708564 +9787511708663 +9787511708892 +9787511709172 +9787511709196 +9787511709202 +9787511709363 +9787511709448 +9787511709479 +9787511709967 +9787511710109 +9787511710376 +9787511710499 +9787511710505 +9787511710581 +9787511710765 +9787511711007 +9787511711151 +9787511711182 +9787511711199 +9787511711380 +9787511711724 +9787511711861 +9787511711892 +9787511711991 +9787511712493 +9787511712776 +9787511712783 +9787511712875 +9787511713070 +9787511713131 +9787511713407 +9787511713919 +9787511714299 +9787511714435 +9787511714657 +9787511714718 +9787511714732 +9787511715166 +9787511715753 +9787511715760 +9787511715852 +9787511715869 +9787511716132 +9787511716194 +9787511716200 +9787511716217 +9787511716262 +9787511716279 +9787511716439 +9787511716491 +9787511716798 +9787511716842 +9787511717108 +9787511717122 +9787511717153 +9787511717238 +9787511717481 +9787511718198 +9787511718471 +9787511719270 +9787511719379 +9787511719942 +9787511720191 +9787511720399 +9787511720498 +9787511720573 +9787511720603 +9787511720658 +9787511720733 +9787511720795 +9787511720825 +9787511721013 +9787511721228 +9787511721259 +9787511721341 +9787511721426 +9787511721471 +9787511721549 +9787511721778 +9787511722409 +9787511722485 +9787511722751 +9787511722966 +9787511723062 +9787511723277 +9787511723291 +9787511723345 +9787511723635 +9787511723703 +9787511723833 +9787511724434 +9787511724465 +9787511724496 +9787511724533 +9787511724984 +9787511725271 +9787511725622 +9787511725653 +9787511725660 +9787511725677 +9787511725998 +9787511726001 +9787511726025 +9787511726117 +9787511726469 +9787511726568 +9787511726896 +9787511727343 +9787511727534 +9787511727602 +9787511727619 +9787511727763 +9787511727923 +9787511727978 +9787511728043 +9787511728074 +9787511728333 +9787511728401 +9787511728418 +9787511728463 +9787511728470 +9787511728517 +9787511728562 +9787511728586 +9787511728609 +9787511728623 +9787511729002 +9787511729187 +9787511729538 +9787511730800 +9787511731340 +9787511731395 +9787511731494 +9787511731555 +9787511731838 +9787511732026 +9787511732064 +9787511732132 +9787511732460 +9787511732705 +9787511732736 +9787511732798 +9787511732873 +9787511732958 +9787511733092 +9787511733320 +9787511733504 +9787511733641 +9787511733702 +9787511734006 +9787511734075 +9787511734228 +9787511735072 +9787511735393 +9787511735539 +9787511735683 +9787511735744 +9787511735980 +9787511736406 +9787511736932 +9787511738189 +9787511738561 +9787511739469 +9787511740083 +9787511740113 +9787511740304 +9787511740397 +9787511740595 +9787511740601 +9787511740717 +9787511740915 +9787511741196 +9787511741691 +9787511741783 +9787511741837 +9787511742360 +9787511742384 +9787511742537 +9787511742551 +9787511742704 +9787511742759 +9787511743343 +9787511743541 +9787511743589 +9787511743671 +9787511743831 +9787511743855 +9787511743862 +9787511743961 +9787511743985 +9787511744159 +9787511744166 +9787511744180 +9787511744203 +9787511744234 +9787511744302 +9787511744395 +9787511744401 +9787511744456 +9787511744487 +9787511744562 +9787511744678 +9787511744685 +9787511744708 +9787511744814 +9787511744821 +9787511744869 +9787511744876 +9787511744890 +9787511744913 +9787511745033 +9787511745040 +9787511745088 +9787511745095 +9787511745217 +9787511745415 +9787511745590 +9787511745729 +9787511745866 +9787511745897 +9787511746252 +9787511746276 +9787511746283 +9787511746337 +9787511746375 +9787511746399 +9787511746429 +9787511746504 +9787511746931 +9787511746962 +9787511747082 +9787511747099 +9787511747129 +9787511747136 +9787511747228 +9787511747303 +9787511747372 +9787511747419 +9787511747426 +9787511747440 +9787511747624 +9787511747648 +9787511747655 +9787511747860 +9787511748027 +9787511748119 +9787511748195 +9787511748225 +9787511748362 +9787511748492 +9787511748928 +9787511749031 +9787511749161 +9787511800091 +9787511801029 +9787511801081 +9787511801326 +9787511801807 +9787511802385 +9787511802538 +9787511802620 +9787511802637 +9787511803009 +9787511803610 +9787511803733 +9787511804594 +9787511804846 +9787511804921 +9787511805157 +9787511805423 +9787511805638 +9787511805775 +9787511806529 +9787511806536 +9787511806727 +9787511806758 +9787511806994 +9787511807830 +9787511808004 +9787511808271 +9787511808660 +9787511809070 +9787511809247 +9787511809698 +9787511809797 +9787511810427 +9787511810540 +9787511810748 +9787511811028 +9787511811325 +9787511811738 +9787511812070 +9787511812117 +9787511812889 +9787511813084 +9787511813312 +9787511813770 +9787511814050 +9787511814784 +9787511815385 +9787511816368 +9787511817877 +9787511817884 +9787511817945 +9787511818355 +9787511818379 +9787511819734 +9787511819741 +9787511819918 +9787511820426 +9787511821539 +9787511822093 +9787511822598 +9787511822727 +9787511823038 +9787511823182 +9787511824790 +9787511825063 +9787511825353 +9787511825834 +9787511826114 +9787511826503 +9787511827586 +9787511827593 +9787511828477 +9787511828866 +9787511829238 +9787511829283 +9787511829825 +9787511830067 +9787511830340 +9787511830685 +9787511831033 +9787511831941 +9787511832948 +9787511833693 +9787511834232 +9787511834324 +9787511835239 +9787511836533 +9787511837424 +9787511837783 +9787511837943 +9787511838124 +9787511839121 +9787511839244 +9787511840875 +9787511841858 +9787511842534 +9787511842978 +9787511843043 +9787511843234 +9787511843326 +9787511843593 +9787511843906 +9787511845412 +9787511845504 +9787511845771 +9787511846051 +9787511846778 +9787511847072 +9787511847386 +9787511847942 +9787511848314 +9787511849090 +9787511849182 +9787511849953 +9787511850430 +9787511850515 +9787511851598 +9787511851840 +9787511851932 +9787511852601 +9787511852809 +9787511853912 +9787511854322 +9787511855138 +9787511855695 +9787511856319 +9787511857217 +9787511857668 +9787511857910 +9787511859938 +9787511860491 +9787511861092 +9787511861740 +9787511861818 +9787511861924 +9787511862099 +9787511862693 +9787511863065 +9787511863171 +9787511863454 +9787511864772 +9787511865205 +9787511865281 +9787511865519 +9787511865663 +9787511866073 +9787511866905 +9787511867322 +9787511867629 +9787511867933 +9787511868299 +9787511868770 +9787511869739 +9787511869944 +9787511870452 +9787511871268 +9787511871923 +9787511873002 +9787511874580 +9787511874603 +9787511875570 +9787511876270 +9787511876294 +9787511876355 +9787511877666 +9787511877864 +9787511879097 +9787511880505 +9787511880536 +9787511880864 +9787511881236 +9787511882196 +9787511882240 +9787511882493 +9787511882745 +9787511882820 +9787511883032 +9787511883780 +9787511884091 +9787511884244 +9787511884268 +9787511884787 +9787511885623 +9787511886170 +9787511886941 +9787511887665 +9787511887733 +9787511888822 +9787511888952 +9787511892331 +9787511892522 +9787511892690 +9787511892751 +9787511893260 +9787511893765 +9787511894007 +9787511895516 +9787511895981 +9787511896315 +9787511896384 +9787511896476 +9787511897862 +9787511898456 +9787511898500 +9787511898685 +9787511899972 +9787511900180 +9787511900203 +9787511900456 +9787511900845 +9787511901118 +9787511901194 +9787511901224 +9787511901439 +9787511901583 +9787511901729 +9787511902238 +9787511902283 +9787511902344 +9787511902399 +9787511902405 +9787511902429 +9787511902870 +9787511902894 +9787511903006 +9787511903044 +9787511903624 +9787511903747 +9787511903815 +9787511903945 +9787511904003 +9787511904065 +9787511904249 +9787511904263 +9787511904454 +9787511904560 +9787511904645 +9787511904829 +9787511904850 +9787511904935 +9787511905123 +9787511905246 +9787511905314 +9787511905406 +9787511905451 +9787511905789 +9787511905826 +9787511906212 +9787511906434 +9787511906441 +9787511906502 +9787511907400 +9787511907691 +9787511907899 +9787511908063 +9787511908315 +9787511908377 +9787511908490 +9787511908582 +9787511908803 +9787511908889 +9787511908957 +9787511908964 +9787511909121 +9787511909282 +9787511909787 +9787511909992 +9787511910233 +9787511910301 +9787511910479 +9787511910639 +9787511910912 +9787511911131 +9787511911568 +9787511912411 +9787511913432 +9787511914101 +9787511914224 +9787511915092 +9787511915474 +9787511915689 +9787511916044 +9787511916242 +9787511916259 +9787511916389 +9787511916532 +9787511918284 +9787511918642 +9787511919779 +9787511920652 +9787511922595 +9787511922878 +9787511923103 +9787511923370 +9787511923394 +9787511924704 +9787511925268 +9787511925312 +9787511925350 +9787511925398 +9787511925664 +9787511925701 +9787511925749 +9787511925756 +9787511925770 +9787511925985 +9787511926333 +9787511926395 +9787511926418 +9787511926494 +9787511926623 +9787511926913 +9787511926920 +9787511926999 +9787511927620 +9787511927736 +9787511927767 +9787511927774 +9787511927804 +9787511927811 +9787511927859 +9787511927873 +9787511928061 +9787511928412 +9787511928689 +9787511928702 +9787511928726 +9787511928801 +9787511928818 +9787511928931 +9787511929075 +9787511929082 +9787511929099 +9787511929228 +9787511929259 +9787511929266 +9787511929327 +9787511929433 +9787511929464 +9787511929501 +9787511929518 +9787511929716 +9787511929754 +9787511930002 +9787511930101 +9787511930217 +9787511930248 +9787511930286 +9787511930477 +9787511930828 +9787511930835 +9787511930989 +9787511931146 +9787511931276 +9787511931559 +9787511931597 +9787511932211 +9787511932433 +9787511932501 +9787511932655 +9787511932891 +9787512000360 +9787512000377 +9787512000681 +9787512000728 +9787512000834 +9787512001114 +9787512001718 +9787512001985 +9787512002050 +9787512002142 +9787512002241 +9787512002876 +9787512003507 +9787512003613 +9787512003958 +9787512004269 +9787512004498 +9787512004931 +9787512005051 +9787512005105 +9787512005327 +9787512005419 +9787512005594 +9787512005716 +9787512006102 +9787512006584 +9787512006867 +9787512007017 +9787512007031 +9787512008090 +9787512008342 +9787512008465 +9787512008823 +9787512009080 +9787512009554 +9787512010192 +9787512010550 +9787512011373 +9787512011717 +9787512011823 +9787512012103 +9787512012189 +9787512012226 +9787512012257 +9787512012363 +9787512012585 +9787512012653 +9787512012899 +9787512013247 +9787512014374 +9787512014404 +9787512014602 +9787512015135 +9787512015418 +9787512015586 +9787512015937 +9787512016118 +9787512016262 +9787512016736 +9787512017344 +9787512017818 +9787512017986 +9787512018389 +9787512018761 +9787512018792 +9787512019485 +9787512019980 +9787512020146 +9787512020177 +9787512020214 +9787512020238 +9787512020252 +9787512020962 +9787512021112 +9787512021143 +9787512021204 +9787512021235 +9787512023192 +9787512023215 +9787512023321 +9787512023925 +9787512024120 +9787512026230 +9787512026490 +9787512026612 +9787512026896 +9787512027398 +9787512027855 +9787512029675 +9787512031036 +9787512032170 +9787512032606 +9787512033252 +9787512034372 +9787512035355 +9787512035744 +9787512036383 +9787512036727 +9787512039513 +9787512040007 +9787512040434 +9787512043619 +9787512043770 +9787512043848 +9787512044067 +9787512044333 +9787512044852 +9787512044975 +9787512045262 +9787512045439 +9787512046252 +9787512046320 +9787512046597 +9787512046771 +9787512047853 +9787512049185 +9787512049451 +9787512049727 +9787512050020 +9787512050600 +9787512050808 +9787512052079 +9787512052338 +9787512053335 +9787512053656 +9787512054530 +9787512054561 +9787512054691 +9787512054820 +9787512054981 +9787512055308 +9787512055391 +9787512055445 +9787512055452 +9787512055636 +9787512056114 +9787512056220 +9787512057968 +9787512058378 +9787512058576 +9787512058682 +9787512059054 +9787512059481 +9787512059504 +9787512060623 +9787512060906 +9787512061545 +9787512063723 +9787512100329 +9787512100473 +9787512103269 +9787512104846 +9787512105263 +9787512106239 +9787512106864 +9787512108257 +9787512108783 +9787512109995 +9787512110137 +9787512110151 +9787512111554 +9787512112193 +9787512114708 +9787512115941 +9787512118232 +9787512119543 +9787512119994 +9787512120396 +9787512120440 +9787512121102 +9787512122321 +9787512122888 +9787512123533 +9787512123861 +9787512126299 +9787512126954 +9787512127166 +9787512128989 +9787512130319 +9787512130579 +9787512130593 +9787512130708 +9787512131408 +9787512131590 +9787512133389 +9787512134034 +9787512134249 +9787512135314 +9787512136007 +9787512136038 +9787512136380 +9787512136823 +9787512136878 +9787512136977 +9787512137356 +9787512138469 +9787512138742 +9787512138780 +9787512139145 +9787512139466 +9787512140073 +9787512140639 +9787512140783 +9787512141070 +9787512142817 +9787512142985 +9787512143142 +9787512143890 +9787512144408 +9787512144675 +9787512144934 +9787512145085 +9787512145382 +9787512145405 +9787512145696 +9787512146907 +9787512147522 +9787512148024 +9787512148284 +9787512148307 +9787512148505 +9787512148567 +9787512148666 +9787512148963 +9787512149328 +9787512149779 +9787512149786 +9787512149885 +9787512150379 +9787512150386 +9787512150393 +9787512150454 +9787512150577 +9787512150942 +9787512151321 +9787512151628 +9787512151673 +9787512152595 +9787512152618 +9787512153172 +9787512153356 +9787512153646 +9787512153738 +9787512154285 +9787512200395 +9787512200586 +9787512200593 +9787512200784 +9787512200982 +9787512201231 +9787512201354 +9787512201422 +9787512201453 +9787512201545 +9787512201552 +9787512201842 +9787512201934 +9787512202177 +9787512202337 +9787512202375 +9787512202382 +9787512202399 +9787512202559 +9787512203013 +9787512203020 +9787512203037 +9787512203099 +9787512203129 +9787512203624 +9787512203877 +9787512204072 +9787512204157 +9787512204256 +9787512204294 +9787512204560 +9787512204652 +9787512204836 +9787512205147 +9787512205390 +9787512206366 +9787512206519 +9787512206533 +9787512206755 +9787512207042 +9787512207752 +9787512207769 +9787512208186 +9787512208827 +9787512208988 +9787512208995 +9787512209008 +9787512209022 +9787512209039 +9787512209329 +9787512209336 +9787512209664 +9787512210189 +9787512210462 +9787512210660 +9787512210707 +9787512210820 +9787512211377 +9787512211582 +9787512211643 +9787512211902 +9787512212145 +9787512212220 +9787512212268 +9787512212282 +9787512212381 +9787512212435 +9787512212442 +9787512212633 +9787512212909 +9787512213043 +9787512213623 +9787512213869 +9787512213937 +9787512214200 +9787512214231 +9787512214620 +9787512214705 +9787512214750 +9787512214866 +9787512215238 +9787512215290 +9787512215399 +9787512215665 +9787512215672 +9787512215962 +9787512216037 +9787512216129 +9787512216648 +9787512216709 +9787512216778 +9787512216815 +9787512217386 +9787512217645 +9787512217744 +9787512218048 +9787512218529 +9787512218550 +9787512219243 +9787512219335 +9787512219359 +9787512219373 +9787512219403 +9787512219601 +9787512301214 +9787512302624 +9787512302723 +9787512303799 +9787512303881 +9787512304390 +9787512305007 +9787512305120 +9787512305380 +9787512307148 +9787512307155 +9787512307810 +9787512307841 +9787512307995 +9787512308374 +9787512309814 +9787512310131 +9787512310339 +9787512310612 +9787512310704 +9787512311626 +9787512311978 +9787512313194 +9787512313347 +9787512313491 +9787512314399 +9787512314986 +9787512315389 +9787512315433 +9787512315990 +9787512316164 +9787512316331 +9787512316706 +9787512316997 +9787512317017 +9787512317321 +9787512317390 +9787512317642 +9787512318281 +9787512318441 +9787512318724 +9787512319165 +9787512319837 +9787512320239 +9787512320529 +9787512320864 +9787512321021 +9787512321304 +9787512321458 +9787512321625 +9787512321847 +9787512322219 +9787512322295 +9787512322455 +9787512322721 +9787512324091 +9787512324725 +9787512325869 +9787512325951 +9787512326941 +9787512327504 +9787512327573 +9787512327726 +9787512327757 +9787512327955 +9787512327979 +9787512328433 +9787512328853 +9787512328914 +9787512329133 +9787512329935 +9787512330795 +9787512331983 +9787512332010 +9787512332348 +9787512332935 +9787512333437 +9787512333581 +9787512334250 +9787512334465 +9787512335271 +9787512335462 +9787512335783 +9787512336391 +9787512336803 +9787512336971 +9787512337053 +9787512337275 +9787512337848 +9787512337879 +9787512338364 +9787512338562 +9787512338807 +9787512338890 +9787512339200 +9787512339217 +9787512339354 +9787512339484 +9787512339798 +9787512339972 +9787512340237 +9787512340664 +9787512340725 +9787512341463 +9787512341487 +9787512341968 +9787512342095 +9787512342101 +9787512342125 +9787512342811 +9787512343269 +9787512343573 +9787512344464 +9787512344723 +9787512344747 +9787512345522 +9787512345669 +9787512345676 +9787512345683 +9787512345720 +9787512345850 +9787512345904 +9787512346468 +9787512346765 +9787512347144 +9787512347434 +9787512347984 +9787512348516 +9787512349179 +9787512349667 +9787512349773 +9787512349797 +9787512350106 +9787512350519 +9787512350816 +9787512350892 +9787512351233 +9787512352216 +9787512352476 +9787512352551 +9787512352650 +9787512352919 +9787512354067 +9787512354302 +9787512354500 +9787512354760 +9787512354821 +9787512355453 +9787512355477 +9787512355941 +9787512356146 +9787512356276 +9787512356917 +9787512356986 +9787512357112 +9787512357273 +9787512357761 +9787512358119 +9787512358263 +9787512358515 +9787512358737 +9787512358768 +9787512358775 +9787512358973 +9787512359017 +9787512359185 +9787512359222 +9787512359420 +9787512359598 +9787512359659 +9787512359734 +9787512359741 +9787512360099 +9787512360167 +9787512360921 +9787512361263 +9787512362277 +9787512362635 +9787512362833 +9787512364998 +9787512365483 +9787512365520 +9787512365582 +9787512365667 +9787512365780 +9787512366114 +9787512366459 +9787512367029 +9787512367036 +9787512367043 +9787512367357 +9787512367470 +9787512367548 +9787512367708 +9787512367760 +9787512368019 +9787512368811 +9787512369603 +9787512369931 +9787512370029 +9787512370333 +9787512370463 +9787512370593 +9787512371187 +9787512371323 +9787512372214 +9787512373082 +9787512373501 +9787512373839 +9787512373853 +9787512374492 +9787512374539 +9787512374584 +9787512375574 +9787512376243 +9787512376670 +9787512376991 +9787512377394 +9787512377509 +9787512377523 +9787512378117 +9787512378315 +9787512378377 +9787512378407 +9787512378506 +9787512379336 +9787512379763 +9787512380523 +9787512380837 +9787512380905 +9787512381155 +9787512381308 +9787512381537 +9787512381551 +9787512381704 +9787512382664 +9787512382800 +9787512382893 +9787512383081 +9787512383128 +9787512383210 +9787512383258 +9787512383272 +9787512383456 +9787512383500 +9787512384095 +9787512384187 +9787512385207 +9787512385368 +9787512386112 +9787512386631 +9787512386655 +9787512387522 +9787512388017 +9787512388512 +9787512389212 +9787512389533 +9787512389564 +9787512390287 +9787512390386 +9787512390423 +9787512390621 +9787512390690 +9787512391499 +9787512391628 +9787512391758 +9787512392175 +9787512392724 +9787512392991 +9787512393110 +9787512393530 +9787512393936 +9787512394216 +9787512394353 +9787512395329 +9787512395404 +9787512396456 +9787512396616 +9787512397088 +9787512397293 +9787512397668 +9787512397835 +9787512397859 +9787512398511 +9787512398832 +9787512398894 +9787512400276 +9787512400399 +9787512401051 +9787512401129 +9787512401532 +9787512402201 +9787512402423 +9787512402904 +9787512404922 +9787512405141 +9787512405196 +9787512405301 +9787512405325 +9787512405356 +9787512406308 +9787512406513 +9787512407121 +9787512407640 +9787512407749 +9787512408630 +9787512409033 +9787512409224 +9787512410428 +9787512410527 +9787512410954 +9787512411388 +9787512411456 +9787512412392 +9787512412422 +9787512412477 +9787512412637 +9787512413238 +9787512413474 +9787512414464 +9787512415034 +9787512415911 +9787512417526 +9787512418509 +9787512419001 +9787512419247 +9787512420106 +9787512420342 +9787512420762 +9787512421660 +9787512422384 +9787512425118 +9787512426108 +9787512426405 +9787512427068 +9787512427587 +9787512428232 +9787512428942 +9787512429482 +9787512429741 +9787512429802 +9787512431065 +9787512431706 +9787512431904 +9787512432444 +9787512433397 +9787512433489 +9787512433847 +9787512433960 +9787512434646 +9787512435049 +9787512435087 +9787512435414 +9787512435513 +9787512435544 +9787512435629 +9787512435667 +9787512435742 +9787512436121 +9787512436206 +9787512436312 +9787512436350 +9787512436503 +9787512436510 +9787512436688 +9787512436701 +9787512436756 +9787512436954 +9787512437128 +9787512437289 +9787512437296 +9787512437821 +9787512438842 +9787512439023 +9787512439092 +9787512439474 +9787512439481 +9787512439566 +9787512439597 +9787512439726 +9787512439870 +9787512439931 +9787512439948 +9787512440197 +9787512440203 +9787512440371 +9787512440401 +9787512440616 +9787512440678 +9787512440777 +9787512440975 +9787512441156 +9787512441293 +9787512441583 +9787512441668 +9787512441705 +9787512441712 +9787512441736 +9787512441767 +9787512441781 +9787512441798 +9787512441804 +9787512441811 +9787512441835 +9787512441842 +9787512441859 +9787512441866 +9787512441873 +9787512441958 +9787512441972 +9787512442085 +9787512442108 +9787512442122 +9787512442160 +9787512442252 +9787512442351 +9787512442368 +9787512442498 +9787512442566 +9787512442658 +9787512442771 +9787512442931 +9787512443044 +9787512443105 +9787512443143 +9787512443174 +9787512443488 +9787512443525 +9787512443549 +9787512443556 +9787512443563 +9787512443570 +9787512443587 +9787512443822 +9787512444065 +9787512444164 +9787512444171 +9787512444249 +9787512444409 +9787512444461 +9787512445383 +9787512445680 +9787512446229 +9787512446243 +9787512446250 +9787512446618 +9787512446786 +9787512447066 +9787512447141 +9787512447622 +9787512500051 +9787512500075 +9787512500129 +9787512500174 +9787512500211 +9787512500334 +9787512500723 +9787512500877 +9787512500907 +9787512501034 +9787512501058 +9787512501225 +9787512501409 +9787512501461 +9787512501508 +9787512501621 +9787512501652 +9787512501706 +9787512501805 +9787512501850 +9787512501881 +9787512502208 +9787512502321 +9787512502345 +9787512502406 +9787512502499 +9787512502628 +9787512502659 +9787512502789 +9787512502857 +9787512502864 +9787512502987 +9787512503007 +9787512503038 +9787512503120 +9787512503168 +9787512503366 +9787512503380 +9787512503410 +9787512503571 +9787512503588 +9787512503748 +9787512503960 +9787512504059 +9787512504097 +9787512504172 +9787512504271 +9787512504356 +9787512504448 +9787512504509 +9787512504660 +9787512504752 +9787512504813 +9787512504851 +9787512504936 +9787512505711 +9787512505841 +9787512505902 +9787512505926 +9787512505933 +9787512505964 +9787512505971 +9787512506299 +9787512506329 +9787512506343 +9787512506398 +9787512506480 +9787512506589 +9787512506602 +9787512506619 +9787512506633 +9787512506640 +9787512506800 +9787512506909 +9787512506978 +9787512507036 +9787512507050 +9787512507067 +9787512507074 +9787512507081 +9787512507258 +9787512507425 +9787512507432 +9787512507487 +9787512507999 +9787512508002 +9787512508200 +9787512508255 +9787512508293 +9787512508316 +9787512508330 +9787512508347 +9787512508415 +9787512508477 +9787512508552 +9787512508675 +9787512508842 +9787512508897 +9787512509160 +9787512509191 +9787512509276 +9787512509535 +9787512509580 +9787512509764 +9787512509825 +9787512510043 +9787512510067 +9787512510821 +9787512510906 +9787512510920 +9787512511095 +9787512511606 +9787512511743 +9787512511835 +9787512511927 +9787512512153 +9787512512177 +9787512512214 +9787512512252 +9787512512382 +9787512512443 +9787512512689 +9787512512696 +9787512512702 +9787512512757 +9787512512764 +9787512512771 +9787512513518 +9787512513938 +9787512513945 +9787512514171 +9787512514317 +9787512514324 +9787512514720 +9787512514829 +9787512514843 +9787512514911 +9787512515000 +9787512515055 +9787512515123 +9787512515161 +9787512515208 +9787512515277 +9787512515284 +9787512515376 +9787512515444 +9787512515468 +9787512515529 +9787512515574 +9787512515611 +9787512515635 +9787512515642 +9787512515673 +9787512515710 +9787512515789 +9787512515819 +9787512515826 +9787512515864 +9787512515871 +9787512515970 +9787512515994 +9787512516021 +9787512516045 +9787512516052 +9787512516137 +9787512516144 +9787512516151 +9787512516168 +9787512516175 +9787512516236 +9787512516243 +9787512516250 +9787512516267 +9787512516274 +9787512516335 +9787512516373 +9787512516458 +9787512516472 +9787512516915 +9787512517165 +9787512517219 +9787512517400 +9787512517448 +9787512517455 +9787512517608 +9787512517615 +9787512517875 +9787512518100 +9787512518216 +9787512518377 +9787512518407 +9787512518728 +9787512519275 +9787512519336 +9787512520912 +9787512600058 +9787512600102 +9787512600119 +9787512600485 +9787512600515 +9787512600584 +9787512600676 +9787512600683 +9787512600690 +9787512600706 +9787512600737 +9787512601031 +9787512601093 +9787512601178 +9787512601208 +9787512601352 +9787512601451 +9787512601635 +9787512601697 +9787512601956 +9787512601987 +9787512602328 +9787512602373 +9787512602526 +9787512602861 +9787512603288 +9787512603394 +9787512603493 +9787512604094 +9787512604155 +9787512604261 +9787512605350 +9787512605404 +9787512605787 +9787512605916 +9787512606142 +9787512606159 +9787512606418 +9787512606609 +9787512606630 +9787512606906 +9787512606999 +9787512607125 +9787512607415 +9787512607439 +9787512607446 +9787512607699 +9787512608306 +9787512611078 +9787512611283 +9787512611313 +9787512611320 +9787512611375 +9787512611771 +9787512611795 +9787512612358 +9787512612877 +9787512612914 +9787512613195 +9787512613911 +9787512614413 +9787512614574 +9787512614628 +9787512614642 +9787512614864 +9787512614956 +9787512615229 +9787512615236 +9787512615243 +9787512615328 +9787512615632 +9787512615694 +9787512616127 +9787512616202 +9787512616264 +9787512616288 +9787512616462 +9787512616790 +9787512617537 +9787512617735 +9787512617841 +9787512617865 +9787512617902 +9787512617919 +9787512617926 +9787512617971 +9787512618084 +9787512618176 +9787512618244 +9787512618398 +9787512618480 +9787512619791 +9787512619852 +9787512620360 +9787512620582 +9787512620636 +9787512620674 +9787512620704 +9787512621039 +9787512621053 +9787512621077 +9787512622159 +9787512622630 +9787512622647 +9787512622654 +9787512622692 +9787512622746 +9787512623071 +9787512623125 +9787512623224 +9787512623248 +9787512623286 +9787512623330 +9787512623392 +9787512623446 +9787512623668 +9787512623699 +9787512624290 +9787512625075 +9787512625563 +9787512625952 +9787512626096 +9787512626201 +9787512627376 +9787512627567 +9787512627857 +9787512627864 +9787512628199 +9787512628397 +9787512628533 +9787512628892 +9787512629943 +9787512630246 +9787512630376 +9787512630482 +9787512630567 +9787512630789 +9787512630796 +9787512630833 +9787512631007 +9787512631335 +9787512631342 +9787512632066 +9787512632288 +9787512632608 +9787512633070 +9787512633162 +9787512633247 +9787512633636 +9787512633704 +9787512633896 +9787512633995 +9787512634015 +9787512634503 +9787512634718 +9787512634923 +9787512634961 +9787512634978 +9787512634992 +9787512635272 +9787512635340 +9787512635371 +9787512635401 +9787512635470 +9787512635524 +9787512636668 +9787512636965 +9787512637160 +9787512638327 +9787512638358 +9787512638518 +9787512638525 +9787512639492 +9787512640238 +9787512640894 +9787512641389 +9787512642027 +9787512642041 +9787512642485 +9787512643611 +9787512643642 +9787512643871 +9787512644403 +9787512644410 +9787512644472 +9787512644755 +9787512644762 +9787512644809 +9787512645110 +9787512645806 +9787512646179 +9787512646629 +9787512646711 +9787512646995 +9787512647008 +9787512649453 +9787512649965 +9787512651111 +9787512651302 +9787512651333 +9787512651371 +9787512651869 +9787512651968 +9787512652118 +9787512652255 +9787512652736 +9787512652750 +9787512652880 +9787512652941 +9787512653214 +9787512653412 +9787512654112 +9787512654600 +9787512654693 +9787512655294 +9787512655393 +9787512655508 +9787512655522 +9787512655591 +9787512655614 +9787512655652 +9787512655713 +9787512655959 +9787512656314 +9787512656512 +9787512657571 +9787512657656 +9787512659452 +9787512659469 +9787512659773 +9787512659865 +9787512659872 +9787512660038 +9787512660632 +9787512660847 +9787512660885 +9787512660946 +9787512660984 +9787512661004 +9787512662018 +9787512662292 +9787512662759 +9787512662766 +9787512663077 +9787512664227 +9787512665224 +9787512665606 +9787512665798 +9787512666023 +9787512666825 +9787512667013 +9787512667068 +9787512667389 +9787512667624 +9787512667747 +9787512668164 +9787512668683 +9787512668690 +9787512668874 +9787512668881 +9787512668898 +9787512669734 +9787512669741 +9787512670365 +9787512670488 +9787512670594 +9787512670754 +9787512670853 +9787512670907 +9787512670914 +9787512671171 +9787512671188 +9787512672499 +9787512672611 +9787512672772 +9787512672819 +9787512672826 +9787512672857 +9787512672888 +9787512672987 +9787512673144 +9787512674288 +9787512675483 +9787512675940 +9787512676343 +9787512676725 +9787512676909 +9787512677098 +9787512677197 +9787512677203 +9787512677739 +9787512677746 +9787512677784 +9787512678231 +9787512678774 +9787512679443 +9787512679474 +9787512680036 +9787512680401 +9787512680487 +9787512680562 +9787512680593 +9787512680869 +9787512680876 +9787512681071 +9787512681392 +9787512681705 +9787512681873 +9787512681972 +9787512683013 +9787512683440 +9787512683549 +9787512684089 +9787512684416 +9787512684782 +9787512685116 +9787512685475 +9787512686458 +9787512687356 +9787512687707 +9787512687714 +9787512687806 +9787512688148 +9787512688810 +9787512689114 +9787512689121 +9787512689169 +9787512689909 +9787512689923 +9787512690387 +9787512690592 +9787512690684 +9787512691131 +9787512691322 +9787512691797 +9787512691841 +9787512691858 +9787512692299 +9787512692893 +9787512692947 +9787512692954 +9787512693036 +9787512693203 +9787512693739 +9787512694057 +9787512694163 +9787512694606 +9787512694705 +9787512694712 +9787512694736 +9787512694811 +9787512695269 +9787512695474 +9787512695559 +9787512695573 +9787512695580 +9787512695597 +9787512695603 +9787512695665 +9787512695672 +9787512695689 +9787512695696 +9787512695702 +9787512695856 +9787512695948 +9787512696013 +9787512696334 +9787512696389 +9787512696402 +9787512696495 +9787512696884 +9787512698093 +9787512698222 +9787512698246 +9787512698352 +9787512698574 +9787512698635 +9787512699045 +9787512699052 +9787512699427 +9787512699557 +9787512700055 +9787512700185 +9787512700383 +9787512700611 +9787512700659 +9787512701045 +9787512701205 +9787512701502 +9787512701625 +9787512701717 +9787512701878 +9787512701922 +9787512701953 +9787512702004 +9787512702073 +9787512702400 +9787512702554 +9787512702585 +9787512702950 +9787512703391 +9787512703698 +9787512703742 +9787512703957 +9787512704107 +9787512704114 +9787512704619 +9787512704787 +9787512704824 +9787512704862 +9787512704909 +9787512705036 +9787512705067 +9787512705234 +9787512705463 +9787512705517 +9787512706057 +9787512706293 +9787512706330 +9787512706446 +9787512706569 +9787512706675 +9787512707313 +9787512707344 +9787512707450 +9787512707559 +9787512708204 +9787512708730 +9787512708792 +9787512708839 +9787512708983 +9787512709355 +9787512709430 +9787512709577 +9787512709706 +9787512709904 +9787512709911 +9787512709997 +9787512710429 +9787512710504 +9787512710573 +9787512710689 +9787512710726 +9787512711075 +9787512711693 +9787512711907 +9787512713024 +9787512713413 +9787512714106 +9787512714274 +9787512714281 +9787512715165 +9787512715820 +9787512716025 +9787512716414 +9787512717190 +9787512717442 +9787512717466 +9787512717862 +9787512718197 +9787512718463 +9787512718630 +9787512718708 +9787512719262 +9787512719392 +9787512719736 +9787512719996 +9787512720152 +9787512720213 +9787512720299 +9787512720770 +9787512720909 +9787512721876 +9787512721883 +9787512722125 +9787512722156 +9787512722262 +9787512722293 +9787512722590 +9787512722682 +9787512722729 +9787512722781 +9787512722804 +9787512723122 +9787512723214 +9787512723238 +9787512723245 +9787512723313 +9787512723320 +9787512723351 +9787512723382 +9787512723412 +9787512723535 +9787512723627 +9787512723665 +9787512723733 +9787512723924 +9787512723931 +9787512723955 +9787512723962 +9787512724242 +9787512724464 +9787512800335 +9787512800489 +9787512800748 +9787512800847 +9787512800854 +9787512801196 +9787512801479 +9787512801509 +9787512801516 +9787512801684 +9787512802018 +9787512802070 +9787512802094 +9787512802155 +9787512802322 +9787512802452 +9787512802513 +9787512803107 +9787512803312 +9787512803411 +9787512803435 +9787512803503 +9787512803510 +9787512803565 +9787512803756 +9787512804029 +9787512804265 +9787512804333 +9787512804432 +9787512804463 +9787512804760 +9787512804791 +9787512804869 +9787512804937 +9787512805361 +9787512805590 +9787512805613 +9787512805705 +9787512805712 +9787512805743 +9787512805842 +9787512806481 +9787512806573 +9787512806740 +9787512806900 +9787512807228 +9787512807389 +9787512807402 +9787512807549 +9787512807877 +9787512807921 +9787512808140 +9787512808157 +9787512808225 +9787512808409 +9787512808546 +9787512808577 +9787512808621 +9787512808683 +9787512809208 +9787512809222 +9787512809314 +9787512809512 +9787512809581 +9787512809758 +9787512809802 +9787512809833 +9787512809918 +9787512811317 +9787512811744 +9787512812178 +9787512812321 +9787512812642 +9787512813595 +9787512813601 +9787512900974 +9787512901056 +9787512901063 +9787512901278 +9787512902695 +9787512902824 +9787512902831 +9787512902848 +9787512903678 +9787512903753 +9787512906600 +9787512906631 +9787512907928 +9787512908284 +9787512909533 +9787512911215 +9787512912205 +9787512912427 +9787512913233 +9787512913516 +9787512913523 +9787512913615 +9787512913622 +9787512913967 +9787512913981 +9787512914599 +9787512914636 +9787512914889 +9787512914957 +9787512915282 +9787512915428 +9787512915688 +9787512915763 +9787512915794 +9787512915978 +9787512916067 +9787512916081 +9787512916241 +9787512916449 +9787512916630 +9787512916906 +9787512917309 +9787512917408 +9787512917736 +9787512917781 +9787512917903 +9787512917910 +9787512917996 +9787512918474 +9787512918511 +9787512918719 +9787512918726 +9787512918887 +9787512919341 +9787512919389 +9787512919464 +9787512919754 +9787512919822 +9787512920071 +9787512920101 +9787512920125 +9787512920170 +9787512920224 +9787512920248 +9787512920262 +9787512920309 +9787512920446 +9787512920583 +9787512920682 +9787512920729 +9787512921146 +9787513000680 +9787513001083 +9787513001571 +9787513001878 +9787513002493 +9787513002547 +9787513002950 +9787513003674 +9787513003841 +9787513004381 +9787513004503 +9787513006552 +9787513006880 +9787513007153 +9787513007337 +9787513007399 +9787513007788 +9787513009140 +9787513009393 +9787513009935 +9787513011037 +9787513011808 +9787513012157 +9787513012218 +9787513013581 +9787513013826 +9787513013871 +9787513014458 +9787513014878 +9787513015059 +9787513015066 +9787513015165 +9787513015530 +9787513015875 +9787513016018 +9787513016407 +9787513016513 +9787513017565 +9787513018319 +9787513018715 +9787513018746 +9787513018814 +9787513018913 +9787513019392 +9787513019590 +9787513019927 +9787513020336 +9787513020459 +9787513020527 +9787513020589 +9787513021647 +9787513022385 +9787513022927 +9787513023603 +9787513023801 +9787513023979 +9787513024112 +9787513024181 +9787513024679 +9787513024815 +9787513025348 +9787513025768 +9787513025898 +9787513026130 +9787513026659 +9787513027069 +9787513027854 +9787513028424 +9787513028691 +9787513029100 +9787513029841 +9787513029889 +9787513030151 +9787513030298 +9787513030359 +9787513030434 +9787513031103 +9787513031141 +9787513032001 +9787513033640 +9787513033664 +9787513033732 +9787513033909 +9787513033954 +9787513034067 +9787513034258 +9787513034357 +9787513034494 +9787513036283 +9787513036290 +9787513036733 +9787513036924 +9787513037921 +9787513038058 +9787513038317 +9787513038867 +9787513038942 +9787513039055 +9787513039147 +9787513039642 +9787513039925 +9787513041126 +9787513041287 +9787513041669 +9787513042253 +9787513042857 +9787513043359 +9787513043410 +9787513043908 +9787513044141 +9787513044851 +9787513044981 +9787513045322 +9787513046404 +9787513046879 +9787513047319 +9787513047449 +9787513047548 +9787513047678 +9787513048699 +9787513049115 +9787513049580 +9787513049795 +9787513049863 +9787513050388 +9787513050777 +9787513050999 +9787513051002 +9787513051156 +9787513051774 +9787513052054 +9787513052108 +9787513052245 +9787513052320 +9787513052368 +9787513052399 +9787513053846 +9787513054232 +9787513055086 +9787513055444 +9787513055888 +9787513056809 +9787513057790 +9787513058216 +9787513059527 +9787513060790 +9787513060974 +9787513061490 +9787513062176 +9787513062510 +9787513062633 +9787513063111 +9787513063463 +9787513064262 +9787513065078 +9787513065269 +9787513066426 +9787513066587 +9787513066662 +9787513066983 +9787513067508 +9787513067652 +9787513067836 +9787513067904 +9787513067997 +9787513068000 +9787513068246 +9787513068338 +9787513068406 +9787513068666 +9787513068697 +9787513069274 +9787513070041 +9787513070065 +9787513070126 +9787513070232 +9787513070331 +9787513070515 +9787513070706 +9787513070867 +9787513070935 +9787513071109 +9787513071123 +9787513071284 +9787513071536 +9787513072397 +9787513072403 +9787513072458 +9787513072984 +9787513073875 +9787513074117 +9787513074254 +9787513074407 +9787513074537 +9787513074827 +9787513075077 +9787513075749 +9787513075800 +9787513075978 +9787513076418 +9787513077378 +9787513078245 +9787513078542 +9787513078948 +9787513079334 +9787513079808 +9787513079815 +9787513080170 +9787513080217 +9787513080224 +9787513080545 +9787513080552 +9787513080651 +9787513081030 +9787513081528 +9787513081559 +9787513081580 +9787513081924 +9787513081979 +9787513082143 +9787513082389 +9787513082433 +9787513082808 +9787513082976 +9787513083218 +9787513083799 +9787513084048 +9787513084086 +9787513084291 +9787513084307 +9787513084482 +9787513085366 +9787513085380 +9787513085403 +9787513085526 +9787513085656 +9787513085830 +9787513085960 +9787513086059 +9787513086103 +9787513086295 +9787513087148 +9787513087407 +9787513087490 +9787513087728 +9787513087780 +9787513087827 +9787513088015 +9787513088053 +9787513088183 +9787513088404 +9787513088411 +9787513088671 +9787513088749 +9787513089012 +9787513089166 +9787513089197 +9787513089302 +9787513089494 +9787513089586 +9787513089647 +9787513089722 +9787513089869 +9787513089975 +9787513089999 +9787513090032 +9787513090339 +9787513090582 +9787513090865 +9787513091114 +9787513091428 +9787513091435 +9787513091527 +9787513092067 +9787513092678 +9787513092708 +9787513093491 +9787513093675 +9787513094191 +9787513095259 +9787513095952 +9787513096713 +9787513096805 +9787513097031 +9787513097598 +9787513098724 +9787513098908 +9787513099981 +9787513100038 +9787513100298 +9787513100977 +9787513101479 +9787513101486 +9787513101493 +9787513101509 +9787513101516 +9787513101912 +9787513101950 +9787513102124 +9787513103350 +9787513103473 +9787513104579 +9787513105224 +9787513105521 +9787513105903 +9787513105996 +9787513106917 +9787513107365 +9787513107372 +9787513107501 +9787513107655 +9787513108799 +9787513108836 +9787513109055 +9787513109949 +9787513110020 +9787513110617 +9787513110662 +9787513111027 +9787513111119 +9787513111461 +9787513115643 +9787513115674 +9787513115681 +9787513115759 +9787513116350 +9787513117371 +9787513117708 +9787513117944 +9787513117968 +9787513118347 +9787513119689 +9787513120432 +9787513121156 +9787513121163 +9787513122337 +9787513124973 +9787513125772 +9787513126472 +9787513126496 +9787513126861 +9787513127295 +9787513129633 +9787513129688 +9787513130103 +9787513130288 +9787513130547 +9787513130707 +9787513131377 +9787513131452 +9787513131780 +9787513131803 +9787513131872 +9787513131889 +9787513132305 +9787513132916 +9787513132985 +9787513133043 +9787513133203 +9787513133791 +9787513134101 +9787513134408 +9787513134415 +9787513134439 +9787513134446 +9787513134453 +9787513134460 +9787513134477 +9787513134484 +9787513134491 +9787513136013 +9787513136303 +9787513136365 +9787513136440 +9787513136488 +9787513136648 +9787513136938 +9787513136945 +9787513137232 +9787513138468 +9787513138482 +9787513138499 +9787513138604 +9787513138697 +9787513138956 +9787513139359 +9787513139830 +9787513139847 +9787513139854 +9787513140362 +9787513140515 +9787513140546 +9787513140591 +9787513140812 +9787513140850 +9787513140867 +9787513141093 +9787513141413 +9787513141437 +9787513141482 +9787513141628 +9787513142243 +9787513142625 +9787513142953 +9787513143110 +9787513144513 +9787513144711 +9787513144759 +9787513144827 +9787513144834 +9787513144896 +9787513144957 +9787513144964 +9787513145008 +9787513145039 +9787513145077 +9787513145152 +9787513145831 +9787513145947 +9787513145992 +9787513146159 +9787513146760 +9787513146784 +9787513146807 +9787513146890 +9787513146951 +9787513147033 +9787513147071 +9787513147095 +9787513147354 +9787513147378 +9787513147682 +9787513148016 +9787513148245 +9787513148269 +9787513148610 +9787513149280 +9787513149310 +9787513149327 +9787513149402 +9787513149549 +9787513149709 +9787513149716 +9787513149822 +9787513149846 +9787513149853 +9787513149860 +9787513149877 +9787513149891 +9787513149914 +9787513149938 +9787513149945 +9787513150002 +9787513150019 +9787513150026 +9787513150033 +9787513150637 +9787513150712 +9787513150736 +9787513150767 +9787513151115 +9787513151320 +9787513151696 +9787513151702 +9787513151719 +9787513151917 +9787513152181 +9787513152211 +9787513152358 +9787513153034 +9787513153317 +9787513153430 +9787513154567 +9787513154581 +9787513154598 +9787513154604 +9787513154680 +9787513154727 +9787513154802 +9787513154819 +9787513154826 +9787513154833 +9787513154840 +9787513154857 +9787513155052 +9787513155274 +9787513156325 +9787513156509 +9787513156516 +9787513156868 +9787513156882 +9787513157315 +9787513157322 +9787513157414 +9787513157476 +9787513157513 +9787513157537 +9787513157551 +9787513157599 +9787513157605 +9787513157841 +9787513157919 +9787513158015 +9787513158121 +9787513158152 +9787513158169 +9787513158176 +9787513158206 +9787513158251 +9787513158268 +9787513158312 +9787513158343 +9787513158350 +9787513158381 +9787513158411 +9787513158435 +9787513158701 +9787513158749 +9787513159180 +9787513159272 +9787513159463 +9787513159562 +9787513159616 +9787513159722 +9787513159845 +9787513159944 +9787513160032 +9787513160827 +9787513161022 +9787513161121 +9787513161428 +9787513161459 +9787513161848 +9787513161923 +9787513161930 +9787513161947 +9787513162050 +9787513162104 +9787513162418 +9787513162524 +9787513162579 +9787513163262 +9787513163347 +9787513163378 +9787513163408 +9787513164191 +9787513164771 +9787513164832 +9787513166003 +9787513166362 +9787513166393 +9787513166409 +9787513166454 +9787513166515 +9787513166522 +9787513167468 +9787513167581 +9787513167673 +9787513167680 +9787513167703 +9787513167710 +9787513167734 +9787513167901 +9787513168038 +9787513168090 +9787513168120 +9787513168151 +9787513168168 +9787513168175 +9787513168205 +9787513168359 +9787513168854 +9787513169134 +9787513170185 +9787513170239 +9787513170321 +9787513170697 +9787513170703 +9787513170758 +9787513170833 +9787513170840 +9787513170864 +9787513171007 +9787513171113 +9787513171144 +9787513171151 +9787513171168 +9787513171496 +9787513171526 +9787513171939 +9787513173261 +9787513173315 +9787513173339 +9787513173377 +9787513173407 +9787513173469 +9787513173513 +9787513173537 +9787513173551 +9787513173643 +9787513173650 +9787513173667 +9787513173698 +9787513173711 +9787513173735 +9787513173742 +9787513174312 +9787513174329 +9787513174763 +9787513174787 +9787513174794 +9787513174916 +9787513174930 +9787513175111 +9787513175197 +9787513175210 +9787513175845 +9787513175852 +9787513176149 +9787513176668 +9787513176705 +9787513176729 +9787513177252 +9787513177481 +9787513177535 +9787513177719 +9787513177856 +9787513178754 +9787513178808 +9787513179164 +9787513179201 +9787513179287 +9787513179584 +9787513179591 +9787513180085 +9787513180092 +9787513180122 +9787513180436 +9787513180450 +9787513180948 +9787513181075 +9787513181754 +9787513181761 +9787513181778 +9787513181891 +9787513181914 +9787513181945 +9787513182034 +9787513182041 +9787513182058 +9787513182065 +9787513182157 +9787513182256 +9787513182522 +9787513182850 +9787513182935 +9787513183055 +9787513183390 +9787513183413 +9787513183567 +9787513183604 +9787513183734 +9787513184120 +9787513185615 +9787513186773 +9787513187268 +9787513187428 +9787513189385 +9787513189484 +9787513190619 +9787513190671 +9787513190954 +9787513191043 +9787513191050 +9787513191418 +9787513191425 +9787513192392 +9787513193009 +9787513193016 +9787513196093 +9787513199193 +9787513200226 +9787513200646 +9787513200769 +9787513201254 +9787513201261 +9787513201315 +9787513201445 +9787513202084 +9787513202800 +9787513203142 +9787513203371 +9787513203388 +9787513203807 +9787513203883 +9787513204392 +9787513205184 +9787513205504 +9787513205856 +9787513205931 +9787513205948 +9787513206181 +9787513206204 +9787513206228 +9787513206242 +9787513206754 +9787513207225 +9787513207256 +9787513207485 +9787513207812 +9787513208734 +9787513208772 +9787513208901 +9787513209076 +9787513209106 +9787513209229 +9787513209489 +9787513210515 +9787513210928 +9787513210942 +9787513211017 +9787513211123 +9787513211154 +9787513212052 +9787513213882 +9787513215770 +9787513215855 +9787513216555 +9787513218801 +9787513218856 +9787513219624 +9787513219747 +9787513223539 +9787513224390 +9787513224741 +9787513226578 +9787513226615 +9787513226639 +9787513226646 +9787513226660 +9787513226707 +9787513227193 +9787513228534 +9787513232906 +9787513234856 +9787513235525 +9787513236652 +9787513236775 +9787513237857 +9787513237963 +9787513238359 +9787513241083 +9787513241311 +9787513243131 +9787513243476 +9787513244169 +9787513245135 +9787513246149 +9787513247184 +9787513247993 +9787513248013 +9787513248167 +9787513248204 +9787513248518 +9787513248716 +9787513248938 +9787513250085 +9787513250801 +9787513252430 +9787513253697 +9787513255011 +9787513255479 +9787513255615 +9787513255783 +9787513256407 +9787513256568 +9787513256919 +9787513257404 +9787513258739 +9787513260176 +9787513260473 +9787513261937 +9787513263085 +9787513263399 +9787513264396 +9787513264662 +9787513264884 +9787513266642 +9787513267335 +9787513270090 +9787513271974 +9787513272162 +9787513274265 +9787513274272 +9787513276351 +9787513277129 +9787513278270 +9787513278515 +9787513278553 +9787513279550 +9787513279574 +9787513279581 +9787513279765 +9787513280068 +9787513280082 +9787513280167 +9787513280440 +9787513280495 +9787513280501 +9787513280587 +9787513280594 +9787513280662 +9787513280754 +9787513280792 +9787513280808 +9787513280938 +9787513280983 +9787513281249 +9787513281362 +9787513281423 +9787513281508 +9787513281621 +9787513281850 +9787513281928 +9787513282178 +9787513282253 +9787513282277 +9787513282468 +9787513282673 +9787513282789 +9787513282963 +9787513283014 +9787513283144 +9787513283199 +9787513283212 +9787513283236 +9787513283267 +9787513283281 +9787513283397 +9787513283557 +9787513283564 +9787513283663 +9787513283670 +9787513283939 +9787513283953 +9787513283977 +9787513284066 +9787513284196 +9787513284202 +9787513284219 +9787513284349 +9787513284356 +9787513284363 +9787513284387 +9787513284660 +9787513284738 +9787513284745 +9787513284837 +9787513284936 +9787513284981 +9787513285001 +9787513285018 +9787513285056 +9787513285254 +9787513285339 +9787513285377 +9787513285391 +9787513285469 +9787513285506 +9787513285636 +9787513285704 +9787513285735 +9787513285773 +9787513285803 +9787513285988 +9787513285995 +9787513286015 +9787513286039 +9787513286060 +9787513286114 +9787513286190 +9787513286213 +9787513286220 +9787513286244 +9787513286275 +9787513286282 +9787513286336 +9787513286428 +9787513286435 +9787513286572 +9787513286589 +9787513286756 +9787513286770 +9787513286787 +9787513286879 +9787513286886 +9787513286916 +9787513286978 +9787513286985 +9787513286992 +9787513287005 +9787513287067 +9787513287074 +9787513287098 +9787513287142 +9787513287234 +9787513287388 +9787513287494 +9787513287500 +9787513287524 +9787513287531 +9787513287562 +9787513287593 +9787513287623 +9787513287630 +9787513287920 +9787513288002 +9787513288170 +9787513288224 +9787513288408 +9787513288491 +9787513288507 +9787513288538 +9787513288545 +9787513288613 +9787513288644 +9787513288668 +9787513288682 +9787513288699 +9787513288750 +9787513288767 +9787513288859 +9787513288873 +9787513288903 +9787513288927 +9787513288934 +9787513288996 +9787513289016 +9787513289092 +9787513289115 +9787513289177 +9787513289191 +9787513289214 +9787513289276 +9787513289368 +9787513289412 +9787513289429 +9787513289542 +9787513289689 +9787513289788 +9787513289801 +9787513289962 +9787513290012 +9787513290111 +9787513290272 +9787513290289 +9787513290395 +9787513290623 +9787513290760 +9787513290821 +9787513290838 +9787513290883 +9787513290890 +9787513290937 +9787513290944 +9787513290975 +9787513291620 +9787513291811 +9787513291842 +9787513292054 +9787513292160 +9787513292191 +9787513292276 +9787513292429 +9787513292450 +9787513292757 +9787513292795 +9787513292887 +9787513292917 +9787513293044 +9787513293198 +9787513293341 +9787513293358 +9787513293433 +9787513293471 +9787513294249 +9787513295406 +9787513300261 +9787513300346 +9787513300353 +9787513300391 +9787513300407 +9787513300421 +9787513300445 +9787513300483 +9787513300506 +9787513300513 +9787513300582 +9787513300605 +9787513300858 +9787513300995 +9787513301336 +9787513301565 +9787513301602 +9787513301701 +9787513302289 +9787513302548 +9787513303002 +9787513303019 +9787513303026 +9787513303064 +9787513303132 +9787513303460 +9787513303484 +9787513303545 +9787513303552 +9787513303590 +9787513303712 +9787513303903 +9787513303927 +9787513303934 +9787513303965 +9787513304009 +9787513304061 +9787513304078 +9787513304085 +9787513304436 +9787513304467 +9787513304474 +9787513304535 +9787513304542 +9787513304580 +9787513304597 +9787513304603 +9787513304610 +9787513304696 +9787513304757 +9787513304764 +9787513304771 +9787513304788 +9787513304825 +9787513304832 +9787513304849 +9787513305006 +9787513305242 +9787513305310 +9787513305716 +9787513305754 +9787513306034 +9787513306065 +9787513306232 +9787513306249 +9787513306324 +9787513306416 +9787513306461 +9787513306737 +9787513306898 +9787513306942 +9787513306959 +9787513306966 +9787513306997 +9787513307024 +9787513307185 +9787513307314 +9787513307512 +9787513307628 +9787513307635 +9787513307680 +9787513307710 +9787513307987 +9787513308168 +9787513308281 +9787513308649 +9787513308656 +9787513308694 +9787513308717 +9787513308724 +9787513308830 +9787513309233 +9787513309875 +9787513309905 +9787513310123 +9787513310215 +9787513310284 +9787513310468 +9787513310536 +9787513310628 +9787513310789 +9787513311526 +9787513311984 +9787513312035 +9787513312868 +9787513313070 +9787513313292 +9787513313490 +9787513313520 +9787513313650 +9787513313698 +9787513314046 +9787513314114 +9787513314169 +9787513314732 +9787513314893 +9787513315203 +9787513315531 +9787513315609 +9787513315616 +9787513315623 +9787513315630 +9787513315661 +9787513315845 +9787513315937 +9787513316019 +9787513316033 +9787513316231 +9787513316460 +9787513316552 +9787513316750 +9787513317290 +9787513317320 +9787513317467 +9787513317887 +9787513318044 +9787513318051 +9787513318310 +9787513318334 +9787513318341 +9787513318389 +9787513318433 +9787513318563 +9787513318778 +9787513318853 +9787513319003 +9787513319089 +9787513319096 +9787513319164 +9787513319270 +9787513319348 +9787513319560 +9787513319591 +9787513319904 +9787513319911 +9787513320054 +9787513320160 +9787513320177 +9787513320184 +9787513320337 +9787513320351 +9787513320474 +9787513320566 +9787513321006 +9787513321037 +9787513321150 +9787513321167 +9787513321174 +9787513321266 +9787513321488 +9787513321518 +9787513321778 +9787513321785 +9787513321891 +9787513321952 +9787513322058 +9787513322102 +9787513322188 +9787513322355 +9787513322478 +9787513322485 +9787513322492 +9787513322515 +9787513322522 +9787513322560 +9787513322577 +9787513322584 +9787513322676 +9787513322706 +9787513322768 +9787513322775 +9787513322805 +9787513322881 +9787513322898 +9787513322911 +9787513322928 +9787513322966 +9787513322973 +9787513323017 +9787513323048 +9787513323147 +9787513323420 +9787513323598 +9787513324199 +9787513324250 +9787513324311 +9787513324489 +9787513324809 +9787513324953 +9787513324960 +9787513325042 +9787513325059 +9787513325097 +9787513325394 +9787513325424 +9787513325431 +9787513325509 +9787513325547 +9787513325561 +9787513325578 +9787513325608 +9787513325660 +9787513325707 +9787513325752 +9787513325806 +9787513326780 +9787513327091 +9787513327107 +9787513327138 +9787513327169 +9787513327176 +9787513327206 +9787513327282 +9787513327312 +9787513327343 +9787513327350 +9787513327404 +9787513327435 +9787513327442 +9787513327480 +9787513327565 +9787513327589 +9787513327596 +9787513327787 +9787513328760 +9787513328975 +9787513329040 +9787513329095 +9787513329729 +9787513329873 +9787513330244 +9787513330251 +9787513330268 +9787513330282 +9787513330305 +9787513330633 +9787513330657 +9787513330671 +9787513330725 +9787513330961 +9787513330978 +9787513331463 +9787513331487 +9787513331494 +9787513331692 +9787513331760 +9787513331784 +9787513331852 +9787513331944 +9787513331968 +9787513332026 +9787513332132 +9787513332408 +9787513332453 +9787513332712 +9787513332798 +9787513333085 +9787513333252 +9787513333290 +9787513333337 +9787513333344 +9787513333351 +9787513333382 +9787513333399 +9787513333405 +9787513333412 +9787513333450 +9787513333467 +9787513333474 +9787513333566 +9787513333573 +9787513333580 +9787513333832 +9787513333894 +9787513334075 +9787513334082 +9787513334099 +9787513334143 +9787513334594 +9787513334631 +9787513334648 +9787513334693 +9787513334945 +9787513335300 +9787513335430 +9787513335508 +9787513335560 +9787513335577 +9787513335591 +9787513335836 +9787513335843 +9787513335942 +9787513336246 +9787513336758 +9787513336796 +9787513336857 +9787513336864 +9787513336871 +9787513337397 +9787513337410 +9787513337427 +9787513337472 +9787513337489 +9787513337496 +9787513337502 +9787513337847 +9787513337885 +9787513337953 +9787513338752 +9787513338769 +9787513338783 +9787513339070 +9787513339865 +9787513339933 +9787513340168 +9787513340175 +9787513340472 +9787513340496 +9787513340922 +9787513341059 +9787513341066 +9787513341073 +9787513341141 +9787513341172 +9787513341455 +9787513341493 +9787513341509 +9787513341554 +9787513342216 +9787513342223 +9787513342384 +9787513342506 +9787513343152 +9787513343206 +9787513343374 +9787513343381 +9787513343398 +9787513343640 +9787513343725 +9787513343817 +9787513343824 +9787513343855 +9787513344005 +9787513344029 +9787513344036 +9787513344197 +9787513344517 +9787513344623 +9787513344814 +9787513345330 +9787513345620 +9787513345729 +9787513345743 +9787513345798 +9787513345811 +9787513346177 +9787513346337 +9787513346757 +9787513347365 +9787513347372 +9787513347396 +9787513348393 +9787513348409 +9787513348485 +9787513348614 +9787513348751 +9787513349079 +9787513349086 +9787513349147 +9787513349314 +9787513349390 +9787513349406 +9787513349963 +9787513349994 +9787513350075 +9787513350471 +9787513350549 +9787513350556 +9787513350938 +9787513351065 +9787513351096 +9787513351126 +9787513351140 +9787513351423 +9787513351478 +9787513351775 +9787513351881 +9787513352031 +9787513352055 +9787513352222 +9787513352239 +9787513352376 +9787513352451 +9787513352505 +9787513352543 +9787513352604 +9787513352697 +9787513352741 +9787513352758 +9787513352970 +9787513352987 +9787513352994 +9787513353014 +9787513353052 +9787513353069 +9787513353151 +9787513353199 +9787513353205 +9787513353212 +9787513353236 +9787513353250 +9787513353267 +9787513353380 +9787513353403 +9787513353410 +9787513353441 +9787513353458 +9787513353465 +9787513353519 +9787513353526 +9787513353533 +9787513353564 +9787513353601 +9787513353618 +9787513353632 +9787513353649 +9787513353663 +9787513353724 +9787513353731 +9787513353748 +9787513353793 +9787513353816 +9787513353939 +9787513353960 +9787513353991 +9787513354011 +9787513354875 +9787513354882 +9787513355285 +9787513355391 +9787513355438 +9787513355681 +9787513355698 +9787513355704 +9787513355735 +9787513355742 +9787513355797 +9787513355803 +9787513355865 +9787513355872 +9787513355889 +9787513355896 +9787513355919 +9787513355926 +9787513355933 +9787513355940 +9787513355964 +9787513355995 +9787513356015 +9787513356084 +9787513356091 +9787513356107 +9787513356114 +9787513356121 +9787513356183 +9787513356213 +9787513356237 +9787513356251 +9787513356282 +9787513356299 +9787513356367 +9787513356442 +9787513356459 +9787513356473 +9787513356480 +9787513356503 +9787513356558 +9787513356602 +9787513356619 +9787513356640 +9787513356695 +9787513356718 +9787513356725 +9787513356756 +9787513356787 +9787513356794 +9787513356800 +9787513356817 +9787513356824 +9787513356855 +9787513356862 +9787513356893 +9787513356923 +9787513356954 +9787513356985 +9787513356992 +9787513357128 +9787513357142 +9787513357159 +9787513357173 +9787513357203 +9787513357227 +9787513357234 +9787513357241 +9787513357265 +9787513357289 +9787513357296 +9787513357302 +9787513357357 +9787513357364 +9787513357425 +9787513357456 +9787513357524 +9787513357548 +9787513357586 +9787513357593 +9787513357616 +9787513357692 +9787513357777 +9787513357791 +9787513357814 +9787513357821 +9787513357838 +9787513357845 +9787513357883 +9787513357890 +9787513357913 +9787513357920 +9787513357982 +9787513358101 +9787513358132 +9787513358149 +9787513358156 +9787513358217 +9787513358231 +9787513358248 +9787513358279 +9787513358316 +9787513358392 +9787513358521 +9787513358576 +9787513358811 +9787513358828 +9787513359085 +9787513359382 +9787513359535 +9787513359719 +9787513359764 +9787513359894 +9787513359955 +9787513359993 +9787513360012 +9787513360128 +9787513360364 +9787513360500 +9787513360616 +9787513360777 +9787513360913 +9787513361415 +9787513361491 +9787513361606 +9787513400190 +9787513400244 +9787513400343 +9787513400350 +9787513400398 +9787513400541 +9787513400633 +9787513400671 +9787513400732 +9787513400893 +9787513400961 +9787513400978 +9787513400985 +9787513400992 +9787513401005 +9787513401050 +9787513401081 +9787513401104 +9787513401111 +9787513401135 +9787513401166 +9787513401173 +9787513401197 +9787513401210 +9787513401487 +9787513401494 +9787513401616 +9787513401630 +9787513401692 +9787513401739 +9787513401791 +9787513401814 +9787513401838 +9787513402125 +9787513402132 +9787513402170 +9787513402262 +9787513402309 +9787513402323 +9787513402460 +9787513402491 +9787513402507 +9787513402606 +9787513402811 +9787513402859 +9787513402880 +9787513402934 +9787513402965 +9787513403009 +9787513403054 +9787513403078 +9787513403115 +9787513403139 +9787513403153 +9787513403160 +9787513403184 +9787513403221 +9787513403238 +9787513403313 +9787513403344 +9787513403375 +9787513403382 +9787513403696 +9787513403702 +9787513403818 +9787513403955 +9787513404006 +9787513404044 +9787513404099 +9787513404143 +9787513404341 +9787513404358 +9787513404389 +9787513404440 +9787513404488 +9787513404693 +9787513404709 +9787513404716 +9787513404761 +9787513404839 +9787513404891 +9787513404969 +9787513405027 +9787513405065 +9787513405119 +9787513405157 +9787513405164 +9787513405195 +9787513405218 +9787513405225 +9787513405263 +9787513405287 +9787513405348 +9787513405386 +9787513405522 +9787513405577 +9787513405607 +9787513405966 +9787513406116 +9787513406161 +9787513406253 +9787513406291 +9787513406529 +9787513406642 +9787513406680 +9787513406963 +9787513406970 +9787513407038 +9787513407069 +9787513407199 +9787513407274 +9787513407571 +9787513407847 +9787513407953 +9787513408424 +9787513408523 +9787513408929 +9787513408981 +9787513409155 +9787513409278 +9787513409346 +9787513409353 +9787513409421 +9787513409810 +9787513410304 +9787513410564 +9787513410571 +9787513410595 +9787513410816 +9787513410892 +9787513411370 +9787513411387 +9787513412384 +9787513412445 +9787513412483 +9787513413077 +9787513413268 +9787513413428 +9787513413497 +9787513413770 +9787513414258 +9787513414272 +9787513414760 +9787513414777 +9787513414869 +9787513414883 +9787513414944 +9787513414951 +9787513414982 +9787513415002 +9787513415019 +9787513415316 +9787513415354 +9787513415699 +9787513415743 +9787513415811 +9787513415828 +9787513415859 +9787513415910 +9787513415941 +9787513416016 +9787513416023 +9787513416146 +9787513416269 +9787513416276 +9787513416504 +9787513416535 +9787513416627 +9787513416634 +9787513416641 +9787513416658 +9787513416771 +9787513416795 +9787513416801 +9787513416887 +9787513417235 +9787513500272 +9787513500517 +9787513500746 +9787513500920 +9787513500937 +9787513501002 +9787513501019 +9787513501026 +9787513501323 +9787513501606 +9787513501767 +9787513502122 +9787513502160 +9787513502238 +9787513503136 +9787513504188 +9787513504669 +9787513504812 +9787513504904 +9787513504911 +9787513504928 +9787513504935 +9787513505529 +9787513505581 +9787513505628 +9787513505673 +9787513505888 +9787513506373 +9787513506946 +9787513506977 +9787513507134 +9787513507738 +9787513508858 +9787513508919 +9787513509343 +9787513511445 +9787513511452 +9787513511469 +9787513512169 +9787513513333 +9787513513784 +9787513513913 +9787513513999 +9787513514385 +9787513514675 +9787513514699 +9787513514705 +9787513514972 +9787513515153 +9787513515696 +9787513516136 +9787513516402 +9787513516600 +9787513517027 +9787513517034 +9787513517041 +9787513517058 +9787513517065 +9787513517416 +9787513517751 +9787513517850 +9787513518529 +9787513518536 +9787513518543 +9787513518598 +9787513518604 +9787513518680 +9787513518888 +9787513518895 +9787513518963 +9787513519670 +9787513519908 +9787513519939 +9787513519946 +9787513519984 +9787513520218 +9787513520300 +9787513520348 +9787513520942 +9787513521048 +9787513521413 +9787513521574 +9787513521901 +9787513521987 +9787513522656 +9787513522755 +9787513523639 +9787513524155 +9787513524582 +9787513525275 +9787513525336 +9787513525527 +9787513525626 +9787513525916 +9787513525923 +9787513526241 +9787513526319 +9787513526333 +9787513526760 +9787513526784 +9787513526814 +9787513526852 +9787513526890 +9787513526906 +9787513526920 +9787513526951 +9787513527149 +9787513527385 +9787513527828 +9787513527835 +9787513528177 +9787513528290 +9787513528313 +9787513528405 +9787513528511 +9787513528702 +9787513528849 +9787513528924 +9787513528931 +9787513529167 +9787513529631 +9787513529648 +9787513530187 +9787513530491 +9787513530552 +9787513530644 +9787513531085 +9787513531108 +9787513531412 +9787513531610 +9787513531719 +9787513531948 +9787513531993 +9787513532013 +9787513532167 +9787513532549 +9787513532662 +9787513532952 +9787513532969 +9787513533027 +9787513533034 +9787513533096 +9787513533140 +9787513533270 +9787513533348 +9787513533362 +9787513533850 +9787513534123 +9787513534338 +9787513534635 +9787513535113 +9787513535199 +9787513535380 +9787513535502 +9787513535915 +9787513536387 +9787513536400 +9787513536424 +9787513536783 +9787513537421 +9787513538503 +9787513538671 +9787513539319 +9787513539777 +9787513540452 +9787513540926 +9787513541350 +9787513541589 +9787513541916 +9787513541978 +9787513542159 +9787513542173 +9787513543637 +9787513543651 +9787513544306 +9787513544627 +9787513545020 +9787513545037 +9787513545068 +9787513545082 +9787513545099 +9787513545112 +9787513545976 +9787513545983 +9787513546119 +9787513546133 +9787513546867 +9787513546942 +9787513546973 +9787513547000 +9787513547079 +9787513547307 +9787513547321 +9787513547505 +9787513548403 +9787513548618 +9787513548991 +9787513549264 +9787513549271 +9787513549387 +9787513549486 +9787513549493 +9787513549509 +9787513549516 +9787513550154 +9787513550420 +9787513550437 +9787513550550 +9787513550888 +9787513550895 +9787513551618 +9787513551632 +9787513551786 +9787513551977 +9787513552165 +9787513552189 +9787513552486 +9787513552660 +9787513552677 +9787513552684 +9787513552714 +9787513552721 +9787513553032 +9787513553131 +9787513553155 +9787513553209 +9787513553339 +9787513553421 +9787513553759 +9787513554190 +9787513554206 +9787513554992 +9787513556958 +9787513556989 +9787513557009 +9787513557245 +9787513558334 +9787513558372 +9787513558952 +9787513560221 +9787513561570 +9787513562003 +9787513562553 +9787513562881 +9787513562898 +9787513563079 +9787513563123 +9787513564250 +9787513564366 +9787513564458 +9787513564588 +9787513564663 +9787513564830 +9787513565066 +9787513565790 +9787513565806 +9787513565813 +9787513568210 +9787513568326 +9787513568371 +9787513568524 +9787513569224 +9787513569927 +9787513570565 +9787513570978 +9787513571326 +9787513572101 +9787513572316 +9787513572347 +9787513572583 +9787513572958 +9787513573023 +9787513573290 +9787513573443 +9787513573474 +9787513573511 +9787513574341 +9787513574785 +9787513574792 +9787513575058 +9787513575164 +9787513575515 +9787513575584 +9787513575959 +9787513576000 +9787513576024 +9787513576642 +9787513577571 +9787513577861 +9787513577885 +9787513578202 +9787513578301 +9787513579957 +9787513580045 +9787513580625 +9787513580878 +9787513580915 +9787513580922 +9787513580977 +9787513581608 +9787513582292 +9787513582308 +9787513583657 +9787513584739 +9787513584920 +9787513585866 +9787513586122 +9787513586139 +9787513586146 +9787513586153 +9787513586269 +9787513587051 +9787513587082 +9787513587105 +9787513587112 +9787513587143 +9787513587228 +9787513587686 +9787513587693 +9787513588041 +9787513588164 +9787513588188 +9787513588195 +9787513588331 +9787513588812 +9787513590105 +9787513590341 +9787513590402 +9787513590662 +9787513590686 +9787513591362 +9787513591430 +9787513591461 +9787513591607 +9787513592871 +9787513593380 +9787513593557 +9787513594400 +9787513594882 +9787513595124 +9787513595469 +9787513595674 +9787513595681 +9787513595742 +9787513595766 +9787513595797 +9787513595865 +9787513595919 +9787513595926 +9787513595964 +9787513596176 +9787513596213 +9787513596442 +9787513597548 +9787513597746 +9787513597869 +9787513598187 +9787513598613 +9787513599108 +9787513599177 +9787513599511 +9787513600460 +9787513600583 +9787513600682 +9787513600927 +9787513600958 +9787513601498 +9787513602877 +9787513602945 +9787513603645 +9787513603867 +9787513604284 +9787513604994 +9787513606059 +9787513606745 +9787513607056 +9787513607827 +9787513609487 +9787513609821 +9787513609920 +9787513610032 +9787513610322 +9787513610797 +9787513611725 +9787513612067 +9787513612142 +9787513613255 +9787513614429 +9787513614504 +9787513614856 +9787513615525 +9787513615587 +9787513615785 +9787513616003 +9787513617024 +9787513619042 +9787513619059 +9787513619066 +9787513619165 +9787513619172 +9787513619301 +9787513619318 +9787513619622 +9787513619899 +9787513619912 +9787513620109 +9787513620314 +9787513621830 +9787513622936 +9787513623032 +9787513624671 +9787513625326 +9787513625449 +9787513625609 +9787513626521 +9787513627115 +9787513630467 +9787513630559 +9787513631235 +9787513631501 +9787513631822 +9787513631877 +9787513632317 +9787513633215 +9787513633765 +9787513634120 +9787513634182 +9787513635042 +9787513635356 +9787513635424 +9787513635813 +9787513635929 +9787513636155 +9787513636322 +9787513636414 +9787513636469 +9787513637671 +9787513638203 +9787513638753 +9787513638760 +9787513639279 +9787513639293 +9787513639309 +9787513639422 +9787513641746 +9787513642453 +9787513642941 +9787513643221 +9787513643924 +9787513644181 +9787513645256 +9787513646130 +9787513647212 +9787513648097 +9787513648196 +9787513648516 +9787513648769 +9787513648998 +9787513650083 +9787513652469 +9787513654777 +9787513655309 +9787513655347 +9787513656337 +9787513656672 +9787513657495 +9787513658676 +9787513659390 +9787513659413 +9787513659567 +9787513659864 +9787513660648 +9787513660716 +9787513661171 +9787513661188 +9787513661447 +9787513661577 +9787513661775 +9787513662475 +9787513662499 +9787513662512 +9787513662895 +9787513663090 +9787513663151 +9787513663434 +9787513663489 +9787513663502 +9787513663557 +9787513663762 +9787513663854 +9787513664073 +9787513664189 +9787513665070 +9787513665247 +9787513665483 +9787513665872 +9787513666084 +9787513666558 +9787513666589 +9787513666626 +9787513666879 +9787513667036 +9787513667197 +9787513667517 +9787513668033 +9787513668132 +9787513668156 +9787513668460 +9787513668484 +9787513668569 +9787513669313 +9787513669597 +9787513669757 +9787513669924 +9787513670135 +9787513670388 +9787513670449 +9787513670487 +9787513670548 +9787513670586 +9787513670722 +9787513670784 +9787513670944 +9787513671095 +9787513671385 +9787513671439 +9787513671569 +9787513671583 +9787513671590 +9787513671675 +9787513671729 +9787513671989 +9787513672467 +9787513672641 +9787513672733 +9787513672825 +9787513672931 +9787513673006 +9787513673228 +9787513673341 +9787513673372 +9787513673464 +9787513673693 +9787513673785 +9787513673792 +9787513673969 +9787513674294 +9787513674331 +9787513674348 +9787513674393 +9787513674430 +9787513674447 +9787513674454 +9787513674690 +9787513674706 +9787513674713 +9787513674720 +9787513674805 +9787513674843 +9787513674874 +9787513674881 +9787513674973 +9787513675017 +9787513675086 +9787513675123 +9787513675147 +9787513675185 +9787513675208 +9787513675222 +9787513675376 +9787513675741 +9787513675758 +9787513675765 +9787513676090 +9787513676205 +9787513676311 +9787513676366 +9787513676434 +9787513676601 +9787513676656 +9787513676663 +9787513676670 +9787513676717 +9787513676816 +9787513676861 +9787513676892 +9787513676960 +9787513677097 +9787513677134 +9787513677226 +9787513677240 +9787513677325 +9787513677370 +9787513677400 +9787513677509 +9787513677646 +9787513677691 +9787513677769 +9787513677820 +9787513677912 +9787513678162 +9787513678643 +9787513678650 +9787513678704 +9787513678766 +9787513678896 +9787513678926 +9787513679145 +9787513679220 +9787513679237 +9787513679275 +9787513679282 +9787513679343 +9787513679367 +9787513679473 +9787513679480 +9787513679510 +9787513679541 +9787513679589 +9787513679657 +9787513679848 +9787513679961 +9787513679992 +9787513680066 +9787513680196 +9787513680264 +9787513680820 +9787513680905 +9787513680936 +9787513681094 +9787513681155 +9787513681629 +9787513681636 +9787513681643 +9787513681841 +9787513700139 +9787513701082 +9787513701150 +9787513701167 +9787513701174 +9787513701181 +9787513701198 +9787513701204 +9787513701914 +9787513702010 +9787513702058 +9787513702157 +9787513702393 +9787513702447 +9787513702553 +9787513703246 +9787513704250 +9787513704564 +9787513704632 +9787513705882 +9787513706322 +9787513706612 +9787513706728 +9787513706896 +9787513706940 +9787513706988 +9787513706995 +9787513707268 +9787513707299 +9787513707305 +9787513707398 +9787513707589 +9787513707664 +9787513707695 +9787513707718 +9787513707862 +9787513707886 +9787513707909 +9787513708340 +9787513708357 +9787513708401 +9787513708449 +9787513708517 +9787513708623 +9787513708708 +9787513708753 +9787513708807 +9787513708814 +9787513708821 +9787513708852 +9787513708920 +9787513708982 +9787513709026 +9787513709569 +9787513710220 +9787513710237 +9787513710275 +9787513711128 +9787513711579 +9787513712330 +9787513712347 +9787513712361 +9787513712743 +9787513712897 +9787513713214 +9787513713863 +9787513713887 +9787513714037 +9787513714655 +9787513714686 +9787513714709 +9787513714716 +9787513714723 +9787513714945 +9787513715096 +9787513715249 +9787513715256 +9787513715515 +9787513715560 +9787513716116 +9787513716123 +9787513716864 +9787513716888 +9787513717007 +9787513717120 +9787513717779 +9787513718059 +9787513719087 +9787513719100 +9787513719278 +9787513719285 +9787513719292 +9787513719391 +9787513719445 +9787513719612 +9787513719681 +9787513719728 +9787513720199 +9787513720465 +9787513720656 +9787513720953 +9787513721011 +9787513721257 +9787513721424 +9787513721431 +9787513721769 +9787513721776 +9787513721783 +9787513721790 +9787513721974 +9787513721981 +9787513722001 +9787513722063 +9787513722100 +9787513722117 +9787513722124 +9787513722131 +9787513722179 +9787513722292 +9787513722476 +9787513722513 +9787513722711 +9787513722971 +9787513723107 +9787513723138 +9787513723206 +9787513723213 +9787513723220 +9787513723244 +9787513723268 +9787513723275 +9787513723329 +9787513723640 +9787513723657 +9787513723664 +9787513723862 +9787513724111 +9787513724135 +9787513724463 +9787513724791 +9787513725408 +9787513725415 +9787513725644 +9787513725941 +9787513726252 +9787513726771 +9787513726955 +9787513726962 +9787513726979 +9787513727402 +9787513727433 +9787513727730 +9787513728799 +9787513729079 +9787513729093 +9787513729604 +9787513729611 +9787513729949 +9787513730235 +9787513731126 +9787513731270 +9787513731812 +9787513732079 +9787513800075 +9787513800501 +9787513800723 +9787513800815 +9787513800846 +9787513801072 +9787513801201 +9787513801775 +9787513802260 +9787513802376 +9787513802390 +9787513802413 +9787513802468 +9787513802888 +9787513803151 +9787513803380 +9787513803458 +9787513803731 +9787513803779 +9787513803908 +9787513804080 +9787513804646 +9787513804752 +9787513804783 +9787513804981 +9787513805285 +9787513805452 +9787513805490 +9787513805551 +9787513805674 +9787513805698 +9787513805711 +9787513805872 +9787513805926 +9787513805957 +9787513806206 +9787513806565 +9787513806596 +9787513806633 +9787513806657 +9787513807302 +9787513807524 +9787513807753 +9787513807920 +9787513808026 +9787513808781 +9787513809238 +9787513809399 +9787513809665 +9787513809672 +9787513810395 +9787513810739 +9787513810753 +9787513810777 +9787513810791 +9787513810982 +9787513811071 +9787513811118 +9787513811613 +9787513811651 +9787513811699 +9787513812368 +9787513812399 +9787513812528 +9787513814805 +9787513814904 +9787513814942 +9787513815178 +9787513816830 +9787513817158 +9787513817233 +9787513817295 +9787513818414 +9787513818483 +9787513818544 +9787513818803 +9787513818841 +9787513818865 +9787513818940 +9787513819268 +9787513819275 +9787513819282 +9787513819299 +9787513819305 +9787513819572 +9787513819633 +9787513819664 +9787513819749 +9787513819756 +9787513819879 +9787513819886 +9787513820004 +9787513820059 +9787513820141 +9787513820332 +9787513820691 +9787513820745 +9787513820981 +9787513821551 +9787513821735 +9787513821742 +9787513821759 +9787513821766 +9787513821773 +9787513821902 +9787513822046 +9787513822251 +9787513822268 +9787513822305 +9787513822893 +9787513822909 +9787513822916 +9787513822923 +9787513822954 +9787513822978 +9787513822985 +9787513823210 +9787513823296 +9787513823302 +9787513823593 +9787513823678 +9787513824439 +9787513824613 +9787513824729 +9787513824828 +9787513825931 +9787513826044 +9787513900072 +9787513900171 +9787513900409 +9787513900492 +9787513900546 +9787513900560 +9787513900577 +9787513900614 +9787513900621 +9787513901079 +9787513901185 +9787513901321 +9787513901352 +9787513901383 +9787513901413 +9787513901574 +9787513901659 +9787513901840 +9787513901864 +9787513901901 +9787513902014 +9787513902229 +9787513902427 +9787513902458 +9787513902588 +9787513902779 +9787513902809 +9787513902847 +9787513903448 +9787513903523 +9787513903806 +9787513904902 +9787513904933 +9787513905138 +9787513905312 +9787513905466 +9787513905480 +9787513905671 +9787513906685 +9787513906968 +9787513907088 +9787513907118 +9787513907200 +9787513907491 +9787513907583 +9787513908801 +9787513909464 +9787513909501 +9787513910019 +9787513910224 +9787513910637 +9787513911269 +9787513911689 +9787513911740 +9787513911856 +9787513913775 +9787513913911 +9787513914581 +9787513915052 +9787513915144 +9787513915229 +9787513916943 +9787513917100 +9787513917148 +9787513917179 +9787513917186 +9787513917230 +9787513917292 +9787513917346 +9787513917353 +9787513917506 +9787513917803 +9787513918053 +9787513918114 +9787513918145 +9787513919005 +9787513919821 +9787513920445 +9787513920544 +9787513921381 +9787513922005 +9787513922128 +9787513922418 +9787513922654 +9787513923125 +9787513923316 +9787513923378 +9787513923385 +9787513923538 +9787513923781 +9787513924009 +9787513924054 +9787513924061 +9787513924306 +9787513924405 +9787513924498 +9787513924504 +9787513924658 +9787513924665 +9787513924689 +9787513924702 +9787513924863 +9787513925136 +9787513925211 +9787513925402 +9787513925426 +9787513925488 +9787513925518 +9787513925525 +9787513925563 +9787513926126 +9787513926492 +9787513926577 +9787513926652 +9787513926768 +9787513926782 +9787513927178 +9787513927413 +9787513927642 +9787513927871 +9787513927963 +9787513927970 +9787513927987 +9787513928014 +9787513928168 +9787513928175 +9787513928182 +9787513928205 +9787513928243 +9787513928267 +9787513928540 +9787513929011 +9787513929035 +9787513929042 +9787513929240 +9787513929462 +9787513929639 +9787513929646 +9787513929776 +9787513929790 +9787513929820 +9787513929875 +9787513929950 +9787513929998 +9787513930048 +9787513930178 +9787513930369 +9787513930727 +9787513930901 +9787513930932 +9787513930949 +9787513931175 +9787513931274 +9787513931298 +9787513931380 +9787513931571 +9787513932004 +9787513932011 +9787513932097 +9787513932240 +9787513932257 +9787513932325 +9787513932479 +9787513932660 +9787513932714 +9787513932790 +9787513932851 +9787513932998 +9787513933070 +9787513933124 +9787513933148 +9787513933162 +9787513933186 +9787513933216 +9787513933391 +9787513933414 +9787513933421 +9787513933612 +9787513933728 +9787513933926 +9787513933940 +9787513934060 +9787513934084 +9787513934398 +9787513934411 +9787513934466 +9787513934473 +9787513934633 +9787513934695 +9787513934800 +9787513934817 +9787513935067 +9787513935074 +9787513935111 +9787513935203 +9787513935210 +9787513935340 +9787513935395 +9787513935432 +9787513935623 +9787513935807 +9787513935821 +9787513935838 +9787513935845 +9787513935852 +9787513935890 +9787513935982 +9787513936194 +9787513936255 +9787513936514 +9787513936873 +9787513937177 +9787513937740 +9787513937863 +9787513938310 +9787513938471 +9787513938662 +9787513938907 +9787513939119 +9787513939652 +9787513939744 +9787513940252 +9787513940269 +9787513940351 +9787513940467 +9787513940573 +9787513940740 +9787513940825 +9787513940849 +9787513940856 +9787513940948 +9787513940955 +9787513941112 +9787513941167 +9787513941297 +9787513941341 +9787513941426 +9787513941570 +9787513941587 +9787513941686 +9787513941723 +9787513941754 +9787513941785 +9787513941792 +9787513941822 +9787513941853 +9787513941884 +9787513941938 +9787513941983 +9787513942065 +9787513942089 +9787513942126 +9787513942140 +9787513942188 +9787513942324 +9787513942485 +9787513942492 +9787513942539 +9787513942607 +9787513942775 +9787513942874 +9787513942966 +9787513943017 +9787513943079 +9787513943154 +9787513943192 +9787513943246 +9787513943291 +9787513943406 +9787513943451 +9787513943468 +9787513943505 +9787513943512 +9787513943574 +9787513943598 +9787513943611 +9787513943628 +9787513943635 +9787513943642 +9787513943666 +9787513943710 +9787513943727 +9787513943895 +9787513943918 +9787513944007 +9787513944014 +9787513944021 +9787513944090 +9787513944229 +9787513944267 +9787513944274 +9787513944304 +9787513944328 +9787513944359 +9787513944410 +9787513944533 +9787513944571 +9787513944588 +9787513944755 +9787513944762 +9787513944793 +9787513944809 +9787513944830 +9787513944885 +9787513944915 +9787513945011 +9787513945103 +9787513945110 +9787513945134 +9787513945158 +9787513945165 +9787513945202 +9787513945226 +9787513945332 +9787513945349 +9787513945356 +9787513945363 +9787513945394 +9787513945400 +9787513945424 +9787513945448 +9787513945455 +9787513945462 +9787513945493 +9787513945509 +9787513945547 +9787513945554 +9787513945653 +9787513945660 +9787513945707 +9787513945714 +9787513945721 +9787513945745 +9787513945813 +9787513945820 +9787513945875 +9787513945882 +9787513945943 +9787513945950 +9787513945967 +9787513946049 +9787513946117 +9787513946131 +9787513946186 +9787513946216 +9787513946223 +9787513946308 +9787513946315 +9787513946322 +9787513946346 +9787513946360 +9787513946384 +9787513946391 +9787513946407 +9787513946438 +9787513946445 +9787513946469 +9787513946506 +9787513946513 +9787513946605 +9787513946629 +9787513946636 +9787513946681 +9787513946766 +9787513946841 +9787513946865 +9787513946896 +9787513946902 +9787513946926 +9787513946933 +9787513947084 +9787513947091 +9787513947176 +9787513947220 +9787513947268 +9787513947275 +9787513947312 +9787513947374 +9787513947411 +9787513947442 +9787513947466 +9787513947480 +9787513947497 +9787513947510 +9787513947626 +9787513947657 +9787513947701 +9787513947732 +9787513947756 +9787513947763 +9787513947862 +9787513947886 +9787513947909 +9787513947985 +9787513948012 +9787513948029 +9787513948111 +9787513948142 +9787513948241 +9787513948258 +9787513948265 +9787513948326 +9787513948401 +9787513948494 +9787513948500 +9787513948524 +9787513948555 +9787513948579 +9787513948593 +9787513948623 +9787513948883 +9787513948944 +9787513948975 +9787513948982 +9787513948999 +9787513949033 +9787513949040 +9787513949118 +9787513949163 +9787513949170 +9787513949316 +9787513949514 +9787513950220 +9787513950275 +9787514000009 +9787514000078 +9787514000153 +9787514000245 +9787514000276 +9787514000313 +9787514000337 +9787514000375 +9787514000481 +9787514000498 +9787514000504 +9787514000566 +9787514000610 +9787514000641 +9787514000689 +9787514000764 +9787514000788 +9787514000849 +9787514000894 +9787514000917 +9787514001075 +9787514001082 +9787514001143 +9787514001198 +9787514001211 +9787514001235 +9787514001242 +9787514001266 +9787514001273 +9787514001327 +9787514001440 +9787514001501 +9787514001624 +9787514001686 +9787514001723 +9787514001761 +9787514001853 +9787514001860 +9787514001884 +9787514001952 +9787514001990 +9787514002003 +9787514002096 +9787514002133 +9787514002195 +9787514002294 +9787514002485 +9787514002515 +9787514002577 +9787514002638 +9787514002652 +9787514002669 +9787514002683 +9787514002799 +9787514002812 +9787514002829 +9787514002904 +9787514003062 +9787514003093 +9787514003369 +9787514003406 +9787514003659 +9787514003666 +9787514003741 +9787514003871 +9787514003901 +9787514003932 +9787514004069 +9787514004083 +9787514004144 +9787514004229 +9787514004267 +9787514004359 +9787514004427 +9787514004564 +9787514004663 +9787514004700 +9787514004731 +9787514004748 +9787514004793 +9787514004809 +9787514005004 +9787514005035 +9787514005110 +9787514005219 +9787514005271 +9787514005295 +9787514005349 +9787514005356 +9787514005363 +9787514005431 +9787514005462 +9787514005486 +9787514005509 +9787514005578 +9787514005622 +9787514005813 +9787514005820 +9787514005851 +9787514005974 +9787514006094 +9787514006315 +9787514006322 +9787514006339 +9787514006476 +9787514006711 +9787514006872 +9787514006926 +9787514006957 +9787514006995 +9787514007008 +9787514007084 +9787514007145 +9787514007176 +9787514007381 +9787514007442 +9787514007558 +9787514007596 +9787514007770 +9787514008111 +9787514008142 +9787514008296 +9787514008319 +9787514008708 +9787514008753 +9787514009132 +9787514009255 +9787514009347 +9787514009637 +9787514009941 +9787514010053 +9787514010060 +9787514010114 +9787514010213 +9787514010275 +9787514010312 +9787514010602 +9787514010619 +9787514011043 +9787514011227 +9787514011326 +9787514011777 +9787514012873 +9787514012897 +9787514012910 +9787514012965 +9787514013115 +9787514013382 +9787514013658 +9787514013702 +9787514013740 +9787514013825 +9787514013832 +9787514013924 +9787514013948 +9787514015126 +9787514015133 +9787514015331 +9787514015348 +9787514015379 +9787514015591 +9787514015874 +9787514016314 +9787514016642 +9787514016871 +9787514017243 +9787514017250 +9787514017274 +9787514017403 +9787514018059 +9787514018097 +9787514018103 +9787514018134 +9787514018325 +9787514018448 +9787514018646 +9787514019926 +9787514020144 +9787514020274 +9787514020557 +9787514020960 +9787514021653 +9787514021844 +9787514021868 +9787514022322 +9787514022728 +9787514022926 +9787514022995 +9787514023145 +9787514023367 +9787514023565 +9787514023572 +9787514023695 +9787514023701 +9787514023718 +9787514023923 +9787514024579 +9787514024968 +9787514024975 +9787514024999 +9787514025057 +9787514025101 +9787514025651 +9787514025699 +9787514025804 +9787514025958 +9787514026214 +9787514026283 +9787514026474 +9787514026641 +9787514026726 +9787514026764 +9787514026924 +9787514026979 +9787514027211 +9787514027259 +9787514027389 +9787514027440 +9787514027556 +9787514028102 +9787514028157 +9787514028164 +9787514028539 +9787514028584 +9787514029130 +9787514100624 +9787514101249 +9787514101546 +9787514102130 +9787514104776 +9787514107005 +9787514107364 +9787514107838 +9787514108842 +9787514109320 +9787514109863 +9787514110081 +9787514111040 +9787514112511 +9787514114553 +9787514115628 +9787514115765 +9787514116083 +9787514116618 +9787514117691 +9787514118056 +9787514118469 +9787514118681 +9787514119817 +9787514120271 +9787514120608 +9787514120653 +9787514120738 +9787514121728 +9787514122817 +9787514122961 +9787514124101 +9787514124347 +9787514124613 +9787514124996 +9787514125665 +9787514126044 +9787514126563 +9787514126648 +9787514126679 +9787514126686 +9787514126693 +9787514126945 +9787514127324 +9787514127478 +9787514127614 +9787514127966 +9787514128093 +9787514129151 +9787514129250 +9787514129700 +9787514130546 +9787514131482 +9787514132397 +9787514132564 +9787514133158 +9787514135084 +9787514135091 +9787514136975 +9787514137279 +9787514137705 +9787514137941 +9787514139679 +9787514140682 +9787514140903 +9787514142860 +9787514144154 +9787514144376 +9787514144772 +9787514145137 +9787514147643 +9787514147735 +9787514147759 +9787514148763 +9787514150377 +9787514151855 +9787514153767 +9787514153866 +9787514155983 +9787514158212 +9787514159028 +9787514159455 +9787514159622 +9787514160000 +9787514161632 +9787514163445 +9787514163698 +9787514164046 +9787514164053 +9787514164824 +9787514164978 +9787514165289 +9787514165913 +9787514166330 +9787514167498 +9787514169362 +9787514169515 +9787514170160 +9787514170320 +9787514170436 +9787514170443 +9787514170450 +9787514170467 +9787514170597 +9787514170788 +9787514171815 +9787514172249 +9787514172485 +9787514174052 +9787514175493 +9787514175875 +9787514177336 +9787514177909 +9787514181432 +9787514183191 +9787514184242 +9787514184655 +9787514185683 +9787514191622 +9787514192803 +9787514193343 +9787514194012 +9787514197044 +9787514197983 +9787514198485 +9787514198676 +9787514199413 +9787514200270 +9787514200331 +9787514200430 +9787514200508 +9787514200591 +9787514200607 +9787514201222 +9787514201369 +9787514201475 +9787514202564 +9787514202724 +9787514202922 +9787514202984 +9787514203196 +9787514203424 +9787514203585 +9787514203769 +9787514204346 +9787514204360 +9787514204698 +9787514204704 +9787514204711 +9787514204759 +9787514205404 +9787514205459 +9787514205602 +9787514205978 +9787514206098 +9787514206272 +9787514206500 +9787514208146 +9787514208276 +9787514208535 +9787514208658 +9787514208962 +9787514209440 +9787514209471 +9787514209822 +9787514210453 +9787514210804 +9787514211122 +9787514211139 +9787514211566 +9787514211900 +9787514212068 +9787514212389 +9787514212686 +9787514213324 +9787514213393 +9787514213423 +9787514213430 +9787514213447 +9787514213737 +9787514213744 +9787514213751 +9787514213768 +9787514213799 +9787514213805 +9787514213812 +9787514214130 +9787514214215 +9787514214789 +9787514214963 +9787514215014 +9787514215229 +9787514215274 +9787514215717 +9787514216295 +9787514216301 +9787514216370 +9787514216424 +9787514216721 +9787514217056 +9787514217100 +9787514217117 +9787514217407 +9787514217506 +9787514217520 +9787514217551 +9787514217599 +9787514217612 +9787514217667 +9787514217827 +9787514218497 +9787514219470 +9787514219524 +9787514219562 +9787514219579 +9787514221381 +9787514221534 +9787514221572 +9787514222258 +9787514222364 +9787514222463 +9787514222869 +9787514223439 +9787514223644 +9787514224214 +9787514224269 +9787514224771 +9787514225204 +9787514225266 +9787514225280 +9787514225617 +9787514225785 +9787514226003 +9787514227246 +9787514227369 +9787514227482 +9787514227505 +9787514227529 +9787514227543 +9787514227574 +9787514227635 +9787514228205 +9787514228564 +9787514229141 +9787514229288 +9787514229646 +9787514229783 +9787514230154 +9787514230161 +9787514230291 +9787514230406 +9787514230505 +9787514230833 +9787514230895 +9787514231953 +9787514232110 +9787514232240 +9787514232301 +9787514232400 +9787514232417 +9787514233056 +9787514233063 +9787514233087 +9787514233094 +9787514233247 +9787514233261 +9787514233278 +9787514233308 +9787514233704 +9787514233711 +9787514233728 +9787514233865 +9787514234572 +9787514234978 +9787514235210 +9787514235265 +9787514235272 +9787514236477 +9787514236682 +9787514236811 +9787514236842 +9787514237092 +9787514237252 +9787514237504 +9787514237870 +9787514238303 +9787514239133 +9787514239218 +9787514239416 +9787514239423 +9787514239553 +9787514239812 +9787514239874 +9787514239928 +9787514239935 +9787514240016 +9787514240214 +9787514240320 +9787514240368 +9787514240450 +9787514240535 +9787514240542 +9787514240559 +9787514240689 +9787514240696 +9787514240740 +9787514240887 +9787514241099 +9787514241648 +9787514241778 +9787514241785 +9787514241792 +9787514241839 +9787514241907 +9787514242003 +9787514242041 +9787514242263 +9787514242287 +9787514242515 +9787514242898 +9787514242904 +9787514243161 +9787514243192 +9787514243253 +9787514243260 +9787514243291 +9787514243390 +9787514243406 +9787514243505 +9787514243512 +9787514243680 +9787514243697 +9787514243819 +9787514244083 +9787514244243 +9787514244298 +9787514244359 +9787514244465 +9787514244472 +9787514244571 +9787514244656 +9787514244892 +9787514245066 +9787514245134 +9787514245219 +9787514245714 +9787514245820 +9787514245967 +9787514246261 +9787514246681 +9787514247213 +9787514247510 +9787514300574 +9787514300659 +9787514301168 +9787514301922 +9787514302080 +9787514302103 +9787514302110 +9787514302189 +9787514302196 +9787514302448 +9787514302615 +9787514302974 +9787514303025 +9787514303247 +9787514303629 +9787514303803 +9787514304015 +9787514304091 +9787514304985 +9787514305005 +9787514305340 +9787514305791 +9787514306187 +9787514306361 +9787514306392 +9787514306576 +9787514306699 +9787514307078 +9787514307115 +9787514307207 +9787514307405 +9787514307443 +9787514308945 +9787514308969 +9787514308976 +9787514308990 +9787514309010 +9787514309164 +9787514309188 +9787514309195 +9787514309416 +9787514309539 +9787514309669 +9787514309676 +9787514309737 +9787514309850 +9787514309881 +9787514310085 +9787514310153 +9787514310252 +9787514310269 +9787514310306 +9787514310368 +9787514310573 +9787514310788 +9787514310948 +9787514311013 +9787514311181 +9787514311334 +9787514311556 +9787514311709 +9787514311747 +9787514312010 +9787514312676 +9787514312867 +9787514312911 +9787514312959 +9787514312980 +9787514313017 +9787514313130 +9787514313314 +9787514313376 +9787514313505 +9787514313802 +9787514313949 +9787514313956 +9787514313963 +9787514314830 +9787514315356 +9787514315479 +9787514315554 +9787514316001 +9787514316117 +9787514316261 +9787514316407 +9787514316513 +9787514316773 +9787514317046 +9787514317084 +9787514317336 +9787514317732 +9787514317749 +9787514317756 +9787514317770 +9787514317923 +9787514318456 +9787514318494 +9787514318531 +9787514318562 +9787514318968 +9787514319118 +9787514319361 +9787514319460 +9787514319583 +9787514322019 +9787514322507 +9787514322651 +9787514323832 +9787514323856 +9787514324242 +9787514325317 +9787514325508 +9787514325669 +9787514325751 +9787514325867 +9787514326154 +9787514326581 +9787514326697 +9787514326796 +9787514327021 +9787514327045 +9787514327502 +9787514328264 +9787514328554 +9787514328943 +9787514329551 +9787514330281 +9787514330380 +9787514331226 +9787514331684 +9787514331837 +9787514332162 +9787514332209 +9787514332537 +9787514332551 +9787514332711 +9787514332834 +9787514333282 +9787514334074 +9787514334524 +9787514334579 +9787514334630 +9787514334647 +9787514334722 +9787514334784 +9787514334968 +9787514335323 +9787514335668 +9787514335736 +9787514335804 +9787514336269 +9787514336887 +9787514336979 +9787514337143 +9787514337426 +9787514337655 +9787514337938 +9787514338430 +9787514338997 +9787514339000 +9787514339222 +9787514339314 +9787514340273 +9787514340341 +9787514340815 +9787514341539 +9787514341652 +9787514342505 +9787514342918 +9787514343779 +9787514343786 +9787514344356 +9787514344493 +9787514345209 +9787514345247 +9787514345254 +9787514345353 +9787514345834 +9787514346046 +9787514346138 +9787514346688 +9787514346725 +9787514346831 +9787514347173 +9787514347883 +9787514348040 +9787514348279 +9787514349023 +9787514349054 +9787514349184 +9787514349245 +9787514349399 +9787514349603 +9787514350012 +9787514350111 +9787514350517 +9787514350524 +9787514350531 +9787514350548 +9787514351521 +9787514351811 +9787514352689 +9787514353259 +9787514353822 +9787514354195 +9787514354621 +9787514356328 +9787514357318 +9787514358209 +9787514359343 +9787514361100 +9787514361704 +9787514361797 +9787514362992 +9787514363654 +9787514363692 +9787514364897 +9787514365023 +9787514367324 +9787514367881 +9787514369946 +9787514370423 +9787514370638 +9787514370645 +9787514370676 +9787514370720 +9787514370898 +9787514373806 +9787514373813 +9787514376128 +9787514376722 +9787514376791 +9787514376982 +9787514377873 +9787514378221 +9787514378344 +9787514378450 +9787514378467 +9787514378474 +9787514378498 +9787514379006 +9787514379273 +9787514380163 +9787514380200 +9787514380705 +9787514381269 +9787514382259 +9787514382549 +9787514382587 +9787514382631 +9787514382723 +9787514382808 +9787514383416 +9787514383782 +9787514384307 +9787514384437 +9787514384635 +9787514384642 +9787514385328 +9787514385427 +9787514385632 +9787514385861 +9787514385946 +9787514386226 +9787514387728 +9787514388138 +9787514388381 +9787514388411 +9787514388893 +9787514388947 +9787514389005 +9787514389159 +9787514389432 +9787514389760 +9787514390193 +9787514390674 +9787514390780 +9787514392555 +9787514393279 +9787514393316 +9787514393569 +9787514393729 +9787514393750 +9787514393811 +9787514394054 +9787514394290 +9787514394375 +9787514394412 +9787514396157 +9787514396447 +9787514396799 +9787514397024 +9787514397208 +9787514397314 +9787514397628 +9787514397758 +9787514399295 +9787514399301 +9787514399424 +9787514399462 +9787514399806 +9787514399929 +9787514399998 +9787514400120 +9787514400250 +9787514400274 +9787514400588 +9787514400854 +9787514401639 +9787514401882 +9787514404302 +9787514405323 +9787514405620 +9787514406108 +9787514406337 +9787514406498 +9787514406818 +9787514407198 +9787514407228 +9787514407464 +9787514408645 +9787514408737 +9787514409062 +9787514409109 +9787514409703 +9787514411058 +9787514411874 +9787514412253 +9787514412390 +9787514412499 +9787514413731 +9787514414189 +9787514414387 +9787514414981 +9787514415247 +9787514415599 +9787514415872 +9787514416275 +9787514416398 +9787514416466 +9787514416473 +9787514416688 +9787514416770 +9787514416794 +9787514417715 +9787514417739 +9787514418620 +9787514419252 +9787514419290 +9787514419627 +9787514419856 +9787514419863 +9787514420234 +9787514420432 +9787514421088 +9787514421835 +9787514421934 +9787514422603 +9787514422740 +9787514423013 +9787514423037 +9787514423143 +9787514423488 +9787514424379 +9787514424485 +9787514424522 +9787514424737 +9787514424843 +9787514425499 +9787514425666 +9787514427844 +9787514427851 +9787514428193 +9787514428834 +9787514429299 +9787514429701 +9787514430035 +9787514430325 +9787514430349 +9787514431629 +9787514431995 +9787514432039 +9787514432435 +9787514432664 +9787514432800 +9787514433548 +9787514433579 +9787514433661 +9787514434453 +9787514435948 +9787514436051 +9787514436921 +9787514437072 +9787514437744 +9787514437959 +9787514438291 +9787514439403 +9787514440638 +9787514441901 +9787514442106 +9787514442144 +9787514442304 +9787514442342 +9787514442472 +9787514442700 +9787514442755 +9787514443363 +9787514443370 +9787514443387 +9787514443714 +9787514443721 +9787514444056 +9787514444278 +9787514444414 +9787514444780 +9787514445664 +9787514445978 +9787514446814 +9787514447736 +9787514447934 +9787514448047 +9787514448122 +9787514448313 +9787514448665 +9787514449242 +9787514449853 +9787514452372 +9787514453973 +9787514454437 +9787514456660 +9787514459258 +9787514459630 +9787514500066 +9787514500196 +9787514500356 +9787514500479 +9787514500721 +9787514500929 +9787514500943 +9787514500950 +9787514501056 +9787514501124 +9787514501322 +9787514501353 +9787514501414 +9787514501421 +9787514501438 +9787514501490 +9787514501544 +9787514501575 +9787514501605 +9787514501629 +9787514501636 +9787514501681 +9787514501704 +9787514501827 +9787514502060 +9787514502107 +9787514502152 +9787514502237 +9787514502305 +9787514502428 +9787514502763 +9787514502879 +9787514502992 +9787514503074 +9787514503081 +9787514503173 +9787514503227 +9787514503272 +9787514503296 +9787514503326 +9787514503357 +9787514503647 +9787514503685 +9787514503906 +9787514503951 +9787514503968 +9787514504255 +9787514504354 +9787514504446 +9787514504545 +9787514504781 +9787514504927 +9787514505030 +9787514505177 +9787514505306 +9787514505450 +9787514505467 +9787514505566 +9787514505580 +9787514505627 +9787514505665 +9787514505740 +9787514505764 +9787514505771 +9787514505788 +9787514505818 +9787514505825 +9787514505856 +9787514505931 +9787514505986 +9787514505993 +9787514506129 +9787514506136 +9787514506167 +9787514506174 +9787514506211 +9787514506365 +9787514506433 +9787514506532 +9787514506617 +9787514506631 +9787514506648 +9787514506655 +9787514507034 +9787514507331 +9787514507362 +9787514507478 +9787514507485 +9787514507492 +9787514507584 +9787514507676 +9787514507782 +9787514507836 +9787514507843 +9787514507874 +9787514508024 +9787514508062 +9787514508246 +9787514508383 +9787514508758 +9787514508765 +9787514508857 +9787514508932 +9787514509991 +9787514510836 +9787514511246 +9787514511406 +9787514511857 +9787514512304 +9787514512328 +9787514512922 +9787514513257 +9787514513530 +9787514513974 +9787514514001 +9787514514223 +9787514514308 +9787514514506 +9787514514681 +9787514514766 +9787514515077 +9787514516098 +9787514516586 +9787514516791 +9787514517217 +9787514517316 +9787514517897 +9787514518245 +9787514518412 +9787514518955 +9787514519310 +9787514519662 +9787514519716 +9787514519761 +9787514519839 +9787514519860 +9787514520033 +9787514520156 +9787514520194 +9787514520248 +9787514520620 +9787514520729 +9787514521108 +9787514521245 +9787514521283 +9787514521313 +9787514521405 +9787514521467 +9787514521559 +9787514521580 +9787514521597 +9787514521665 +9787514521702 +9787514521832 +9787514522136 +9787514522143 +9787514522181 +9787514522266 +9787514522440 +9787514522495 +9787514522532 +9787514522563 +9787514522570 +9787514522600 +9787514522617 +9787514522723 +9787514522730 +9787514522754 +9787514522846 +9787514522853 +9787514522884 +9787514522891 +9787514522969 +9787514522983 +9787514600001 +9787514600186 +9787514600322 +9787514600339 +9787514600384 +9787514600919 +9787514600940 +9787514601404 +9787514601459 +9787514601688 +9787514601848 +9787514601947 +9787514601954 +9787514601978 +9787514602029 +9787514602173 +9787514602340 +9787514602418 +9787514602425 +9787514602463 +9787514602470 +9787514602517 +9787514602654 +9787514602777 +9787514602838 +9787514603040 +9787514603156 +9787514603217 +9787514603507 +9787514603613 +9787514603699 +9787514603774 +9787514603842 +9787514603873 +9787514603972 +9787514604214 +9787514604344 +9787514604382 +9787514604498 +9787514604542 +9787514604610 +9787514604993 +9787514605006 +9787514605013 +9787514605037 +9787514605051 +9787514605082 +9787514605600 +9787514605761 +9787514605822 +9787514605846 +9787514605914 +9787514605921 +9787514606010 +9787514606041 +9787514606201 +9787514606218 +9787514606294 +9787514606560 +9787514606621 +9787514606638 +9787514606737 +9787514606942 +9787514606997 +9787514607031 +9787514607048 +9787514607079 +9787514607123 +9787514607345 +9787514607543 +9787514607604 +9787514607826 +9787514608410 +9787514608595 +9787514608625 +9787514608663 +9787514608779 +9787514608946 +9787514608960 +9787514608991 +9787514609523 +9787514609547 +9787514609561 +9787514609813 +9787514609998 +9787514610086 +9787514610147 +9787514610208 +9787514610383 +9787514610826 +9787514610963 +9787514610994 +9787514611625 +9787514612004 +9787514612448 +9787514612516 +9787514612530 +9787514612608 +9787514612905 +9787514612974 +9787514613230 +9787514613476 +9787514613797 +9787514613803 +9787514613810 +9787514613834 +9787514613858 +9787514613865 +9787514613872 +9787514614602 +9787514614619 +9787514615432 +9787514616521 +9787514616576 +9787514616781 +9787514617115 +9787514617221 +9787514617252 +9787514617351 +9787514617382 +9787514617764 +9787514617788 +9787514618051 +9787514618204 +9787514618235 +9787514618242 +9787514618693 +9787514618723 +9787514619355 +9787514619362 +9787514619423 +9787514619508 +9787514619645 +9787514619911 +9787514619935 +9787514620016 +9787514620221 +9787514620481 +9787514620634 +9787514620795 +9787514621334 +9787514621662 +9787514621921 +9787514621938 +9787514621952 +9787514621969 +9787514621983 +9787514622089 +9787514622133 +9787514622249 +9787514622584 +9787514622614 +9787514622690 +9787514622751 +9787514622799 +9787514622881 +9787514623017 +9787514623024 +9787514623062 +9787514623147 +9787514623154 +9787514623246 +9787514623291 +9787514623420 +9787514623857 +9787514623888 +9787514624106 +9787514624298 +9787514624410 +9787514624595 +9787514624625 +9787514624656 +9787514624748 +9787514624762 +9787514624786 +9787514625080 +9787514625158 +9787514625271 +9787514625509 +9787514625981 +9787514700237 +9787514700466 +9787514700503 +9787514700664 +9787514700732 +9787514700749 +9787514700831 +9787514701128 +9787514701272 +9787514701388 +9787514701555 +9787514701586 +9787514702064 +9787514702477 +9787514702484 +9787514702569 +9787514702637 +9787514703467 +9787514703474 +9787514703528 +9787514703993 +9787514704020 +9787514704105 +9787514704235 +9787514704242 +9787514704334 +9787514704457 +9787514704495 +9787514704716 +9787514704815 +9787514704846 +9787514705003 +9787514705164 +9787514705409 +9787514705416 +9787514705492 +9787514705539 +9787514705560 +9787514705577 +9787514705737 +9787514705744 +9787514706291 +9787514706345 +9787514706413 +9787514706420 +9787514706444 +9787514706499 +9787514706512 +9787514706550 +9787514706833 +9787514707540 +9787514707748 +9787514707960 +9787514708097 +9787514708165 +9787514708332 +9787514708462 +9787514708554 +9787514708578 +9787514708653 +9787514708769 +9787514708776 +9787514708967 +9787514709063 +9787514709070 +9787514709087 +9787514709100 +9787514709124 +9787514709148 +9787514709155 +9787514709520 +9787514709568 +9787514709810 +9787514710021 +9787514710212 +9787514710267 +9787514710335 +9787514710359 +9787514710441 +9787514710472 +9787514710526 +9787514710618 +9787514710724 +9787514710816 +9787514710847 +9787514711073 +9787514711080 +9787514711455 +9787514711646 +9787514711653 +9787514711660 +9787514711677 +9787514711738 +9787514711790 +9787514711806 +9787514711929 +9787514712049 +9787514712063 +9787514712070 +9787514712117 +9787514712148 +9787514712155 +9787514712186 +9787514712209 +9787514712216 +9787514712391 +9787514712520 +9787514712537 +9787514712599 +9787514712629 +9787514712674 +9787514712698 +9787514712773 +9787514712780 +9787514712858 +9787514712865 +9787514712872 +9787514712995 +9787514713015 +9787514713022 +9787514713046 +9787514713053 +9787514713121 +9787514800128 +9787514800135 +9787514800166 +9787514800197 +9787514800258 +9787514800272 +9787514800555 +9787514800609 +9787514800616 +9787514800623 +9787514800647 +9787514800661 +9787514800678 +9787514800685 +9787514801040 +9787514801217 +9787514801231 +9787514801385 +9787514801422 +9787514801590 +9787514801637 +9787514801811 +9787514801828 +9787514801958 +9787514801989 +9787514802092 +9787514802108 +9787514802177 +9787514802221 +9787514802238 +9787514802290 +9787514802306 +9787514802313 +9787514802757 +9787514802795 +9787514802870 +9787514802894 +9787514803082 +9787514803174 +9787514803228 +9787514803235 +9787514803259 +9787514803303 +9787514803327 +9787514803716 +9787514803723 +9787514804065 +9787514804072 +9787514804126 +9787514804157 +9787514804195 +9787514804393 +9787514804584 +9787514804607 +9787514804645 +9787514804669 +9787514804676 +9787514804683 +9787514804690 +9787514804843 +9787514804850 +9787514804867 +9787514804874 +9787514804881 +9787514805215 +9787514805253 +9787514805574 +9787514805604 +9787514805642 +9787514805758 +9787514805796 +9787514805802 +9787514805833 +9787514806052 +9787514806151 +9787514806212 +9787514806373 +9787514806410 +9787514806458 +9787514806571 +9787514806755 +9787514806762 +9787514806861 +9787514806878 +9787514807240 +9787514807370 +9787514807424 +9787514807516 +9787514807646 +9787514807691 +9787514807714 +9787514807813 +9787514807943 +9787514807950 +9787514808032 +9787514808056 +9787514808421 +9787514808599 +9787514808681 +9787514808964 +9787514808995 +9787514809008 +9787514809046 +9787514809084 +9787514809114 +9787514809152 +9787514809176 +9787514809312 +9787514809343 +9787514809350 +9787514809374 +9787514809411 +9787514809473 +9787514809503 +9787514809510 +9787514809589 +9787514809688 +9787514809749 +9787514809978 +9787514810080 +9787514810202 +9787514810486 +9787514810509 +9787514810691 +9787514810714 +9787514810981 +9787514811148 +9787514811193 +9787514811322 +9787514811353 +9787514811360 +9787514811452 +9787514811490 +9787514811513 +9787514811520 +9787514811537 +9787514811551 +9787514811568 +9787514811599 +9787514811667 +9787514811728 +9787514811773 +9787514811803 +9787514811810 +9787514811872 +9787514811889 +9787514811919 +9787514811933 +9787514812060 +9787514812374 +9787514812398 +9787514812428 +9787514812435 +9787514812442 +9787514812602 +9787514812749 +9787514812992 +9787514813043 +9787514813104 +9787514813258 +9787514813296 +9787514813319 +9787514813517 +9787514813524 +9787514813531 +9787514813692 +9787514813890 +9787514813975 +9787514813999 +9787514814019 +9787514814026 +9787514814224 +9787514814248 +9787514814255 +9787514814262 +9787514814354 +9787514814439 +9787514814484 +9787514814507 +9787514814569 +9787514814576 +9787514814583 +9787514814705 +9787514814729 +9787514814736 +9787514814842 +9787514814927 +9787514814941 +9787514814972 +9787514815016 +9787514815177 +9787514815191 +9787514815368 +9787514815399 +9787514815443 +9787514815481 +9787514815559 +9787514815627 +9787514815740 +9787514815757 +9787514815771 +9787514815832 +9787514816105 +9787514816174 +9787514816181 +9787514816259 +9787514816273 +9787514816365 +9787514816556 +9787514816563 +9787514816587 +9787514816723 +9787514816730 +9787514816747 +9787514816860 +9787514816877 +9787514817096 +9787514817447 +9787514817461 +9787514817560 +9787514817584 +9787514817591 +9787514817669 +9787514817911 +9787514817928 +9787514817935 +9787514817942 +9787514817966 +9787514818277 +9787514818420 +9787514818574 +9787514818581 +9787514818710 +9787514818758 +9787514818765 +9787514818802 +9787514818895 +9787514818963 +9787514819199 +9787514819212 +9787514819274 +9787514819380 +9787514819458 +9787514819588 +9787514819663 +9787514819724 +9787514819793 +9787514820263 +9787514820577 +9787514820812 +9787514820904 +9787514821260 +9787514821284 +9787514821390 +9787514821512 +9787514821529 +9787514821536 +9787514821970 +9787514821994 +9787514822007 +9787514822397 +9787514822496 +9787514822540 +9787514822557 +9787514822571 +9787514822601 +9787514822632 +9787514822786 +9787514822977 +9787514823141 +9787514823424 +9787514823592 +9787514823622 +9787514823752 +9787514823837 +9787514823967 +9787514824186 +9787514824544 +9787514824575 +9787514824599 +9787514824834 +9787514825091 +9787514825404 +9787514825954 +9787514825978 +9787514826029 +9787514826159 +9787514826258 +9787514826395 +9787514826593 +9787514826791 +9787514827200 +9787514827415 +9787514827422 +9787514827446 +9787514827859 +9787514827873 +9787514828160 +9787514828313 +9787514828320 +9787514828337 +9787514828894 +9787514828986 +9787514828993 +9787514829389 +9787514829433 +9787514829440 +9787514829532 +9787514830026 +9787514830125 +9787514830286 +9787514830347 +9787514830415 +9787514830736 +9787514830781 +9787514830811 +9787514831030 +9787514831061 +9787514831221 +9787514831344 +9787514831382 +9787514831436 +9787514831443 +9787514831603 +9787514831870 +9787514831900 +9787514831986 +9787514832020 +9787514832198 +9787514832341 +9787514832365 +9787514832723 +9787514832938 +9787514832969 +9787514833096 +9787514833140 +9787514833287 +9787514833294 +9787514833300 +9787514833348 +9787514833843 +9787514833867 +9787514833942 +9787514834062 +9787514834123 +9787514834888 +9787514834895 +9787514834925 +9787514835137 +9787514835199 +9787514835250 +9787514835304 +9787514835311 +9787514835472 +9787514835779 +9787514835960 +9787514836127 +9787514836202 +9787514836219 +9787514836226 +9787514836325 +9787514836387 +9787514836493 +9787514836691 +9787514836721 +9787514836745 +9787514837162 +9787514837179 +9787514837476 +9787514837483 +9787514837940 +9787514838275 +9787514838350 +9787514838558 +9787514838688 +9787514838800 +9787514838978 +9787514838992 +9787514839487 +9787514839579 +9787514839876 +9787514840087 +9787514840599 +9787514840742 +9787514840841 +9787514840858 +9787514841152 +9787514841268 +9787514841329 +9787514841565 +9787514841701 +9787514841725 +9787514841794 +9787514841800 +9787514841817 +9787514841824 +9787514841831 +9787514841862 +9787514841930 +9787514841947 +9787514841961 +9787514841985 +9787514842036 +9787514842142 +9787514842425 +9787514842463 +9787514842890 +9787514843033 +9787514843569 +9787514843774 +9787514843811 +9787514844092 +9787514844108 +9787514844375 +9787514844382 +9787514844474 +9787514844924 +9787514844979 +9787514845044 +9787514845075 +9787514845549 +9787514845648 +9787514845778 +9787514846027 +9787514846324 +9787514846997 +9787514847024 +9787514847192 +9787514847390 +9787514847536 +9787514847543 +9787514847741 +9787514847819 +9787514847840 +9787514848083 +9787514848199 +9787514848205 +9787514848274 +9787514848281 +9787514848649 +9787514849615 +9787514849653 +9787514849875 +9787514849929 +9787514849936 +9787514850239 +9787514850246 +9787514850284 +9787514850390 +9787514850406 +9787514850413 +9787514850543 +9787514850604 +9787514850697 +9787514851083 +9787514851106 +9787514851335 +9787514851373 +9787514851380 +9787514851465 +9787514851670 +9787514851755 +9787514851816 +9787514851984 +9787514852004 +9787514852011 +9787514852059 +9787514852127 +9787514852134 +9787514852165 +9787514852202 +9787514852424 +9787514852431 +9787514852462 +9787514852684 +9787514852806 +9787514852998 +9787514853025 +9787514853155 +9787514853469 +9787514853544 +9787514853926 +9787514853940 +9787514854237 +9787514854534 +9787514854725 +9787514854732 +9787514854817 +9787514854879 +9787514854886 +9787514854923 +9787514854947 +9787514854954 +9787514854961 +9787514854978 +9787514855036 +9787514855418 +9787514855586 +9787514855845 +9787514856194 +9787514856248 +9787514856293 +9787514856576 +9787514856637 +9787514856750 +9787514856859 +9787514856866 +9787514856880 +9787514857009 +9787514857191 +9787514857306 +9787514857313 +9787514857320 +9787514857368 +9787514857542 +9787514857658 +9787514857986 +9787514858297 +9787514858532 +9787514858570 +9787514858587 +9787514858808 +9787514858884 +9787514858921 +9787514859034 +9787514859058 +9787514859072 +9787514859195 +9787514859287 +9787514859294 +9787514859317 +9787514859324 +9787514859980 +9787514860092 +9787514860139 +9787514860177 +9787514860207 +9787514860429 +9787514860443 +9787514860818 +9787514861105 +9787514861433 +9787514861457 +9787514861464 +9787514861662 +9787514862027 +9787514862164 +9787514862362 +9787514862645 +9787514862935 +9787514862959 +9787514863000 +9787514863277 +9787514863390 +9787514863406 +9787514863512 +9787514864014 +9787514864090 +9787514864243 +9787514864663 +9787514864762 +9787514865677 +9787514866087 +9787514866384 +9787514866421 +9787514866674 +9787514866957 +9787514867442 +9787514867596 +9787514868517 +9787514868876 +9787514868883 +9787514868951 +9787514869279 +9787514869286 +9787514869293 +9787514869347 +9787514869484 +9787514869514 +9787514869569 +9787514869590 +9787514869637 +9787514870053 +9787514870275 +9787514870305 +9787514870329 +9787514870671 +9787514871074 +9787514871135 +9787514871203 +9787514871838 +9787514872286 +9787514872606 +9787514872903 +9787514873634 +9787514874181 +9787514874365 +9787514875270 +9787514875294 +9787514875362 +9787514875386 +9787514876055 +9787514876468 +9787514876475 +9787514876864 +9787514877045 +9787514877069 +9787514877090 +9787514877946 +9787514878059 +9787514879018 +9787514879582 +9787514879766 +9787514880144 +9787514880151 +9787514880359 +9787514880380 +9787514880397 +9787514880403 +9787514880410 +9787514880618 +9787514881127 +9787514881141 +9787514881165 +9787514881288 +9787514881431 +9787514881448 +9787514882063 +9787514882216 +9787514882537 +9787514882728 +9787514882735 +9787514882957 +9787514883343 +9787514883350 +9787514883411 +9787514883428 +9787514883435 +9787514883749 +9787514883800 +9787514884586 +9787514884920 +9787514885088 +9787514885101 +9787514885729 +9787514885972 +9787514886252 +9787514887105 +9787514887785 +9787514887822 +9787514887938 +9787514888058 +9787514888164 +9787514888515 +9787514888553 +9787514888867 +9787514888881 +9787514888904 +9787514888911 +9787514889178 +9787514889796 +9787514891027 +9787514892581 +9787514893533 +9787514893571 +9787514894172 +9787514894189 +9787514894202 +9787514896244 +9787514896435 +9787514896664 +9787514897456 +9787514900323 +9787514900330 +9787514900354 +9787514900460 +9787514900514 +9787514900521 +9787514900545 +9787514900620 +9787514900637 +9787514900644 +9787514900675 +9787514900682 +9787514900699 +9787514900736 +9787514900743 +9787514900774 +9787514900781 +9787514900804 +9787514900958 +9787514901023 +9787514901146 +9787514901207 +9787514901535 +9787514901559 +9787514901603 +9787514901627 +9787514901658 +9787514901672 +9787514901689 +9787514902068 +9787514902266 +9787514902273 +9787514902402 +9787514902464 +9787514902556 +9787514902747 +9787514902846 +9787514902891 +9787514902914 +9787514903058 +9787514903072 +9787514903164 +9787514903188 +9787514903218 +9787514903294 +9787514903300 +9787514903492 +9787514903539 +9787514903553 +9787514903669 +9787514903676 +9787514903737 +9787514903775 +9787514903850 +9787514903942 +9787514903966 +9787514904031 +9787514904109 +9787514904123 +9787514904154 +9787514904246 +9787514904451 +9787514904468 +9787514904475 +9787514904499 +9787514904697 +9787514904741 +9787514904871 +9787514905038 +9787514905052 +9787514905243 +9787514905274 +9787514905434 +9787514905441 +9787514905656 +9787514905670 +9787514905823 +9787514905847 +9787514905861 +9787514905878 +9787514905908 +9787514905915 +9787514905939 +9787514905946 +9787514905977 +9787514905984 +9787514905991 +9787514906240 +9787514906479 +9787514906844 +9787514907049 +9787514907353 +9787514907391 +9787514907445 +9787514907483 +9787514907544 +9787514907575 +9787514907650 +9787514907698 +9787514907735 +9787514907742 +9787514907759 +9787514907865 +9787514908152 +9787514908206 +9787514908282 +9787514908404 +9787514908756 +9787514908770 +9787514908824 +9787514908831 +9787514908855 +9787514908879 +9787514908886 +9787514908923 +9787514909012 +9787514909142 +9787514909227 +9787514909463 +9787514909470 +9787514909500 +9787514909685 +9787514909739 +9787514909807 +9787514909913 +9787514909944 +9787514910063 +9787514910131 +9787514910179 +9787514910193 +9787514910223 +9787514910650 +9787514910711 +9787514911053 +9787514911480 +9787514911510 +9787514911565 +9787514911732 +9787514911893 +9787514911961 +9787514911992 +9787514912005 +9787514912081 +9787514912180 +9787514912203 +9787514912227 +9787514912258 +9787514912357 +9787514912395 +9787514912449 +9787514912654 +9787514912845 +9787514913019 +9787514913118 +9787514913125 +9787514913224 +9787514913231 +9787514913255 +9787514913309 +9787514913651 +9787514913675 +9787514913699 +9787514913781 +9787514913897 +9787514913972 +9787514914054 +9787514914405 +9787514914641 +9787514914658 +9787514914849 +9787514914863 +9787514914887 +9787514914900 +9787514914917 +9787514914924 +9787514914931 +9787514914986 +9787514914993 +9787514915044 +9787514915082 +9787514915112 +9787514915242 +9787514915372 +9787514915419 +9787514915488 +9787514915563 +9787514915587 +9787514915884 +9787514916249 +9787514916256 +9787514916409 +9787514916508 +9787514916805 +9787514917833 +9787514917840 +9787514917963 +9787514918229 +9787514918274 +9787514918304 +9787514918632 +9787514918649 +9787514918656 +9787514918663 +9787514918748 +9787514918762 +9787514918779 +9787514918816 +9787514918830 +9787514918854 +9787514918892 +9787514918915 +9787514918922 +9787514918953 +9787514919103 +9787514919141 +9787514919196 +9787514919516 +9787514919530 +9787514919547 +9787514919554 +9787514919769 +9787514920192 +9787514920215 +9787514920239 +9787514920246 +9787514920277 +9787514920369 +9787514920376 +9787514920505 +9787514920536 +9787514920550 +9787514920574 +9787514920581 +9787514920604 +9787514920628 +9787514920659 +9787514920680 +9787514920710 +9787514920727 +9787514920772 +9787514920789 +9787514920819 +9787514920833 +9787514920840 +9787514920871 +9787514920888 +9787514920895 +9787514920901 +9787514920949 +9787514920987 +9787514921014 +9787514921052 +9787514921090 +9787514921182 +9787514921212 +9787514921502 +9787514921830 +9787514922226 +9787514922271 +9787514922363 +9787514922394 +9787514922417 +9787514922684 +9787514923070 +9787514923094 +9787514923582 +9787514923681 +9787514923858 +9787514923957 +9787514924176 +9787514924312 +9787514924329 +9787514924381 +9787514924749 +9787514925524 +9787514925623 +9787514925708 +9787514925715 +9787514925722 +9787514926071 +9787514927191 +9787514927450 +9787514927535 +9787514927917 +9787514927986 +9787514929706 +9787514930238 +9787514930573 +9787514930580 +9787514930757 +9787514930924 +9787514931426 +9787514933208 +9787514933291 +9787514933376 +9787514933482 +9787514933499 +9787514933536 +9787514933543 +9787514933550 +9787514933567 +9787514933574 +9787514933581 +9787514933901 +9787514934014 +9787514934168 +9787514934236 +9787514934328 +9787514934359 +9787514934434 +9787514934441 +9787514934496 +9787514935837 +9787514936148 +9787514936940 +9787514938388 +9787515000145 +9787515000398 +9787515000473 +9787515000800 +9787515000824 +9787515000978 +9787515000985 +9787515001135 +9787515001159 +9787515001562 +9787515002200 +9787515002224 +9787515002545 +9787515002712 +9787515002941 +9787515003405 +9787515003641 +9787515004297 +9787515004365 +9787515005072 +9787515005416 +9787515005614 +9787515006253 +9787515006352 +9787515006369 +9787515006741 +9787515006871 +9787515006949 +9787515007151 +9787515007168 +9787515007441 +9787515007465 +9787515007649 +9787515007687 +9787515007694 +9787515008196 +9787515008202 +9787515008233 +9787515008653 +9787515009308 +9787515009452 +9787515010250 +9787515010496 +9787515011271 +9787515011950 +9787515012551 +9787515012865 +9787515013138 +9787515013558 +9787515013602 +9787515013640 +9787515013770 +9787515013794 +9787515013893 +9787515014012 +9787515014050 +9787515014401 +9787515014524 +9787515014906 +9787515015118 +9787515015569 +9787515015804 +9787515016283 +9787515016504 +9787515017112 +9787515017778 +9787515017914 +9787515018669 +9787515018843 +9787515018904 +9787515019710 +9787515019741 +9787515020730 +9787515021010 +9787515021225 +9787515021584 +9787515022055 +9787515022284 +9787515022307 +9787515022505 +9787515022673 +9787515022765 +9787515022970 +9787515023809 +9787515024004 +9787515024264 +9787515024271 +9787515024349 +9787515024523 +9787515024684 +9787515024691 +9787515024868 +9787515024899 +9787515024943 +9787515024950 +9787515025063 +9787515025100 +9787515025148 +9787515025469 +9787515025575 +9787515025889 +9787515026084 +9787515026374 +9787515026381 +9787515026527 +9787515026541 +9787515026558 +9787515026589 +9787515026718 +9787515026831 +9787515026978 +9787515027029 +9787515027067 +9787515027074 +9787515027104 +9787515027128 +9787515027135 +9787515027166 +9787515027173 +9787515027180 +9787515027296 +9787515027326 +9787515027340 +9787515027456 +9787515027821 +9787515027838 +9787515027852 +9787515027869 +9787515027906 +9787515027944 +9787515028286 +9787515028378 +9787515028453 +9787515028668 +9787515028699 +9787515028743 +9787515028866 +9787515028965 +9787515029191 +9787515029283 +9787515029351 +9787515029443 +9787515029559 +9787515029580 +9787515029726 +9787515029894 +9787515030081 +9787515030159 +9787515100401 +9787515100418 +9787515100616 +9787515100906 +9787515100913 +9787515101309 +9787515101408 +9787515101415 +9787515102290 +9787515102689 +9787515102719 +9787515102733 +9787515102788 +9787515102887 +9787515102955 +9787515102979 +9787515103051 +9787515103402 +9787515103419 +9787515103686 +9787515103785 +9787515103853 +9787515103891 +9787515104164 +9787515104409 +9787515104430 +9787515104478 +9787515104959 +9787515106304 +9787515106472 +9787515106496 +9787515106526 +9787515106755 +9787515107011 +9787515107189 +9787515107714 +9787515108292 +9787515108582 +9787515108896 +9787515108919 +9787515109176 +9787515109329 +9787515109572 +9787515109848 +9787515110202 +9787515110325 +9787515110479 +9787515200026 +9787515200422 +9787515200507 +9787515200514 +9787515200804 +9787515200828 +9787515200859 +9787515201146 +9787515201160 +9787515201849 +9787515202082 +9787515202204 +9787515202440 +9787515202464 +9787515202525 +9787515202860 +9787515202969 +9787515203058 +9787515203133 +9787515203348 +9787515203492 +9787515203966 +9787515203980 +9787515204192 +9787515204840 +9787515205229 +9787515205328 +9787515205410 +9787515205502 +9787515205571 +9787515205748 +9787515205779 +9787515205854 +9787515206035 +9787515206295 +9787515206325 +9787515206608 +9787515206615 +9787515206622 +9787515206639 +9787515206660 +9787515206738 +9787515206790 +9787515206813 +9787515206844 +9787515207124 +9787515207261 +9787515207452 +9787515207544 +9787515207643 +9787515207827 +9787515207858 +9787515207957 +9787515207964 +9787515208312 +9787515208374 +9787515208671 +9787515208701 +9787515208718 +9787515208770 +9787515208817 +9787515208848 +9787515208886 +9787515208893 +9787515209296 +9787515209432 +9787515209463 +9787515209517 +9787515209654 +9787515209746 +9787515209784 +9787515209869 +9787515210681 +9787515210902 +9787515210919 +9787515211060 +9787515211527 +9787515211534 +9787515211572 +9787515211626 +9787515211787 +9787515211947 +9787515212036 +9787515212050 +9787515212104 +9787515212203 +9787515212289 +9787515212456 +9787515212814 +9787515212951 +9787515213071 +9787515213088 +9787515213866 +9787515213927 +9787515214009 +9787515214931 +9787515214948 +9787515214962 +9787515215037 +9787515215051 +9787515215099 +9787515215181 +9787515215211 +9787515215280 +9787515215976 +9787515216447 +9787515216492 +9787515216508 +9787515216911 +9787515218045 +9787515218168 +9787515218199 +9787515218359 +9787515218366 +9787515218809 +9787515219233 +9787515219301 +9787515219479 +9787515219608 +9787515219776 +9787515219950 +9787515220444 +9787515221465 +9787515221564 +9787515222240 +9787515222424 +9787515222592 +9787515222653 +9787515222905 +9787515223728 +9787515224213 +9787515224480 +9787515224855 +9787515225135 +9787515225722 +9787515225739 +9787515225913 +9787515226163 +9787515226255 +9787515226262 +9787515226453 +9787515226620 +9787515227290 +9787515227405 +9787515227429 +9787515227535 +9787515227610 +9787515227641 +9787515227726 +9787515227757 +9787515227795 +9787515228051 +9787515228143 +9787515228174 +9787515228310 +9787515228365 +9787515228457 +9787515228488 +9787515228495 +9787515228600 +9787515228693 +9787515229164 +9787515229461 +9787515229935 +9787515229942 +9787515230535 +9787515300771 +9787515301006 +9787515301136 +9787515301327 +9787515301334 +9787515301341 +9787515301358 +9787515302119 +9787515302126 +9787515302133 +9787515302164 +9787515302171 +9787515302188 +9787515302195 +9787515302416 +9787515302447 +9787515302621 +9787515302829 +9787515302904 +9787515302997 +9787515303314 +9787515303642 +9787515303659 +9787515303741 +9787515304205 +9787515304335 +9787515304342 +9787515304557 +9787515304670 +9787515305011 +9787515305240 +9787515305578 +9787515305844 +9787515305998 +9787515306230 +9787515306629 +9787515306797 +9787515307411 +9787515307428 +9787515308845 +9787515308920 +9787515309095 +9787515309330 +9787515309637 +9787515309781 +9787515309804 +9787515310060 +9787515310145 +9787515310954 +9787515311135 +9787515311265 +9787515311272 +9787515312057 +9787515312071 +9787515312088 +9787515312149 +9787515312156 +9787515312361 +9787515312781 +9787515313030 +9787515313092 +9787515313139 +9787515313931 +9787515314242 +9787515314266 +9787515314280 +9787515314297 +9787515314303 +9787515314310 +9787515314396 +9787515314402 +9787515314457 +9787515314495 +9787515314501 +9787515314945 +9787515315508 +9787515315713 +9787515315843 +9787515315935 +9787515315942 +9787515316154 +9787515316161 +9787515316208 +9787515316437 +9787515316895 +9787515316987 +9787515317380 +9787515317458 +9787515317809 +9787515318271 +9787515318493 +9787515318929 +9787515319100 +9787515319315 +9787515319476 +9787515320434 +9787515320441 +9787515320458 +9787515320472 +9787515320489 +9787515320526 +9787515320953 +9787515321097 +9787515321226 +9787515321332 +9787515321462 +9787515321509 +9787515321608 +9787515321684 +9787515321691 +9787515321714 +9787515321851 +9787515321974 +9787515322643 +9787515322698 +9787515322711 +9787515322728 +9787515323053 +9787515323657 +9787515323879 +9787515323992 +9787515324272 +9787515324289 +9787515324296 +9787515324357 +9787515324609 +9787515324746 +9787515325002 +9787515325415 +9787515325637 +9787515325682 +9787515325811 +9787515326078 +9787515326603 +9787515326726 +9787515326825 +9787515327754 +9787515327839 +9787515328072 +9787515328287 +9787515328324 +9787515328386 +9787515328430 +9787515328959 +9787515329505 +9787515329666 +9787515329888 +9787515330310 +9787515330327 +9787515330778 +9787515330891 +9787515331041 +9787515332161 +9787515333120 +9787515333137 +9787515333533 +9787515333557 +9787515334530 +9787515334691 +9787515334837 +9787515334998 +9787515336435 +9787515337975 +9787515338354 +9787515338712 +9787515339399 +9787515340241 +9787515340258 +9787515340920 +9787515340937 +9787515341453 +9787515341620 +9787515342276 +9787515342290 +9787515342320 +9787515342474 +9787515342948 +9787515343808 +9787515343846 +9787515343914 +9787515343938 +9787515344195 +9787515346830 +9787515346861 +9787515346953 +9787515347998 +9787515348148 +9787515348629 +9787515348704 +9787515348728 +9787515348742 +9787515349244 +9787515349558 +9787515349664 +9787515349718 +9787515349909 +9787515351605 +9787515352107 +9787515352817 +9787515352909 +9787515353166 +9787515353678 +9787515353685 +9787515353692 +9787515354316 +9787515354460 +9787515354477 +9787515354651 +9787515354743 +9787515354910 +9787515354972 +9787515355009 +9787515355313 +9787515355436 +9787515356099 +9787515356518 +9787515356525 +9787515356662 +9787515356785 +9787515356846 +9787515356877 +9787515357164 +9787515357270 +9787515357287 +9787515357300 +9787515357614 +9787515357805 +9787515357829 +9787515357836 +9787515358086 +9787515358680 +9787515359274 +9787515360379 +9787515360669 +9787515360973 +9787515361055 +9787515361079 +9787515361420 +9787515361826 +9787515362038 +9787515362052 +9787515362076 +9787515362083 +9787515362755 +9787515363233 +9787515363240 +9787515363257 +9787515363264 +9787515363271 +9787515363288 +9787515363899 +9787515363981 +9787515364308 +9787515364636 +9787515364803 +9787515365015 +9787515365435 +9787515365671 +9787515366289 +9787515366555 +9787515366562 +9787515366821 +9787515367026 +9787515367217 +9787515367453 +9787515367682 +9787515367798 +9787515368245 +9787515368269 +9787515368429 +9787515368634 +9787515368825 +9787515368849 +9787515369006 +9787515369037 +9787515369105 +9787515369228 +9787515369235 +9787515369266 +9787515369297 +9787515369389 +9787515369396 +9787515369488 +9787515369549 +9787515369563 +9787515369631 +9787515369839 +9787515369846 +9787515369976 +9787515370118 +9787515370125 +9787515370132 +9787515370149 +9787515370187 +9787515370217 +9787515370231 +9787515370309 +9787515370408 +9787515370415 +9787515370460 +9787515370545 +9787515370651 +9787515370798 +9787515370811 +9787515370828 +9787515370842 +9787515370859 +9787515370866 +9787515370897 +9787515370903 +9787515370941 +9787515371092 +9787515371245 +9787515371443 +9787515371467 +9787515371573 +9787515371696 +9787515371948 +9787515372105 +9787515372112 +9787515372174 +9787515372204 +9787515372259 +9787515372280 +9787515372372 +9787515372396 +9787515372419 +9787515372488 +9787515372495 +9787515372549 +9787515372594 +9787515372655 +9787515372679 +9787515372723 +9787515372860 +9787515372914 +9787515372976 +9787515373027 +9787515373058 +9787515373065 +9787515373171 +9787515373225 +9787515373287 +9787515373478 +9787515373737 +9787515373829 +9787515373850 +9787515374208 +9787515374291 +9787515374598 +9787515374604 +9787515374901 +9787515375199 +9787515375281 +9787515375335 +9787515375397 +9787515375670 +9787515375977 +9787515376325 +9787515400112 +9787515400143 +9787515400341 +9787515400358 +9787515400815 +9787515400839 +9787515401027 +9787515401065 +9787515401195 +9787515401287 +9787515401294 +9787515401324 +9787515401416 +9787515401492 +9787515401645 +9787515401836 +9787515401980 +9787515402222 +9787515402321 +9787515402611 +9787515402628 +9787515402659 +9787515402819 +9787515402857 +9787515403021 +9787515403052 +9787515403144 +9787515403267 +9787515403397 +9787515403458 +9787515403496 +9787515403595 +9787515403816 +9787515404165 +9787515404400 +9787515404844 +9787515405230 +9787515405247 +9787515405377 +9787515405643 +9787515405780 +9787515406015 +9787515406350 +9787515406374 +9787515406558 +9787515406572 +9787515406985 +9787515407173 +9787515407654 +9787515407814 +9787515408187 +9787515408552 +9787515408811 +9787515408866 +9787515409115 +9787515409153 +9787515409320 +9787515410036 +9787515410104 +9787515410142 +9787515410333 +9787515410548 +9787515410586 +9787515410739 +9787515410791 +9787515411019 +9787515411170 +9787515411286 +9787515411347 +9787515411354 +9787515411682 +9787515411699 +9787515412078 +9787515412122 +9787515412214 +9787515412245 +9787515412450 +9787515412559 +9787515412580 +9787515412641 +9787515412733 +9787515412818 +9787515412849 +9787515412924 +9787515412979 +9787515413068 +9787515413303 +9787515413358 +9787515413396 +9787515413426 +9787515413471 +9787515413518 +9787515413532 +9787515413549 +9787515413686 +9787515413716 +9787515413747 +9787515413808 +9787515413822 +9787515413969 +9787515414027 +9787515414072 +9787515414171 +9787515414492 +9787515414553 +9787515414669 +9787515414911 +9787515415017 +9787515415222 +9787515415277 +9787515415314 +9787515415376 +9787515415789 +9787515500102 +9787515500829 +9787515500935 +9787515501222 +9787515501246 +9787515501376 +9787515501468 +9787515501574 +9787515501611 +9787515501789 +9787515501802 +9787515502274 +9787515502335 +9787515502427 +9787515502502 +9787515502625 +9787515502649 +9787515502670 +9787515502922 +9787515502977 +9787515503295 +9787515503301 +9787515503325 +9787515503387 +9787515503394 +9787515503561 +9787515503783 +9787515503813 +9787515503844 +9787515503905 +9787515504025 +9787515504193 +9787515504278 +9787515504544 +9787515505015 +9787515505213 +9787515505244 +9787515505435 +9787515505480 +9787515505534 +9787515505589 +9787515505596 +9787515505619 +9787515505688 +9787515505947 +9787515506005 +9787515506340 +9787515506357 +9787515506364 +9787515506487 +9787515506685 +9787515506746 +9787515506753 +9787515506845 +9787515506876 +9787515506883 +9787515506920 +9787515507101 +9787515507217 +9787515507309 +9787515507521 +9787515507538 +9787515507545 +9787515507712 +9787515508016 +9787515508078 +9787515508306 +9787515508412 +9787515508450 +9787515508887 +9787515508924 +9787515508979 +9787515509006 +9787515509150 +9787515509167 +9787515509334 +9787515509396 +9787515509686 +9787515509693 +9787515509709 +9787515509716 +9787515509877 +9787515509907 +9787515509938 +9787515509952 +9787515509969 +9787515510217 +9787515510262 +9787515510316 +9787515510972 +9787515511054 +9787515511184 +9787515511290 +9787515511320 +9787515511597 +9787515511641 +9787515512143 +9787515512181 +9787515512310 +9787515512822 +9787515512853 +9787515512884 +9787515513010 +9787515513041 +9787515513249 +9787515513263 +9787515513515 +9787515513591 +9787515513607 +9787515514109 +9787515514116 +9787515514277 +9787515514635 +9787515514697 +9787515514963 +9787515515380 +9787515516288 +9787515516387 +9787515516448 +9787515516608 +9787515517179 +9787515517254 +9787515517261 +9787515517360 +9787515517407 +9787515517452 +9787515517551 +9787515517971 +9787515518305 +9787515518336 +9787515518367 +9787515518442 +9787515518459 +9787515518497 +9787515518589 +9787515518961 +9787515519593 +9787515519616 +9787515519777 +9787515519821 +9787515519845 +9787515519999 +9787515520131 +9787515520155 +9787515520162 +9787515520346 +9787515520391 +9787515520407 +9787515520582 +9787515520698 +9787515520797 +9787515520827 +9787515521091 +9787515521275 +9787515521312 +9787515521527 +9787515521619 +9787515521657 +9787515521695 +9787515522531 +9787515522562 +9787515522586 +9787515522647 +9787515522685 +9787515522821 +9787515522845 +9787515523026 +9787515523088 +9787515523101 +9787515523156 +9787515523187 +9787515523194 +9787515523460 +9787515523507 +9787515523699 +9787515523705 +9787515523736 +9787515523903 +9787515524108 +9787515524238 +9787515524290 +9787515524313 +9787515524429 +9787515524511 +9787515524634 +9787515524702 +9787515524795 +9787515524825 +9787515524832 +9787515524962 +9787515524979 +9787515524986 +9787515524993 +9787515525013 +9787515525082 +9787515525099 +9787515525105 +9787515525129 +9787515525150 +9787515525266 +9787515525297 +9787515525303 +9787515525341 +9787515525389 +9787515525433 +9787515525471 +9787515525488 +9787515525587 +9787515525594 +9787515525648 +9787515525709 +9787515525839 +9787515525853 +9787515525952 +9787515526065 +9787515526089 +9787515526263 +9787515526386 +9787515526409 +9787515526454 +9787515526461 +9787515526478 +9787515526485 +9787515526560 +9787515526577 +9787515526584 +9787515526737 +9787515527239 +9787515527673 +9787515700243 +9787515700281 +9787515700502 +9787515700571 +9787515700595 +9787515700601 +9787515700625 +9787515700724 +9787515701097 +9787515701233 +9787515701332 +9787515701417 +9787515702261 +9787515702292 +9787515702438 +9787515702551 +9787515702575 +9787515702599 +9787515702650 +9787515702681 +9787515702711 +9787515702940 +9787515703008 +9787515703015 +9787515703046 +9787515703367 +9787515703688 +9787515703701 +9787515703947 +9787515704340 +9787515704593 +9787515705293 +9787515705385 +9787515705668 +9787515705729 +9787515705736 +9787515705903 +9787515705910 +9787515706009 +9787515706115 +9787515706306 +9787515706320 +9787515706375 +9787515706429 +9787515706528 +9787515706559 +9787515706726 +9787515706993 +9787515707105 +9787515707112 +9787515707129 +9787515707280 +9787515707402 +9787515707648 +9787515707815 +9787515707822 +9787515708089 +9787515708157 +9787515708232 +9787515708621 +9787515708720 +9787515708942 +9787515709116 +9787515709130 +9787515709192 +9787515709208 +9787515800387 +9787515800776 +9787515800806 +9787515801056 +9787515801810 +9787515801865 +9787515802749 +9787515802909 +9787515803210 +9787515803746 +9787515803753 +9787515803807 +9787515804422 +9787515804514 +9787515804590 +9787515804750 +9787515804804 +9787515804972 +9787515805108 +9787515805269 +9787515805276 +9787515805528 +9787515805689 +9787515805849 +9787515805887 +9787515805931 +9787515806006 +9787515806013 +9787515806020 +9787515806068 +9787515806105 +9787515806129 +9787515806167 +9787515806181 +9787515806204 +9787515806228 +9787515806327 +9787515806792 +9787515807164 +9787515807423 +9787515807744 +9787515807867 +9787515807928 +9787515808024 +9787515808505 +9787515808536 +9787515808567 +9787515808574 +9787515808598 +9787515808895 +9787515809205 +9787515809212 +9787515809229 +9787515809281 +9787515809649 +9787515809700 +9787515810089 +9787515810515 +9787515810522 +9787515810591 +9787515810638 +9787515810775 +9787515810812 +9787515811710 +9787515811871 +9787515812540 +9787515812663 +9787515813059 +9787515814254 +9787515814278 +9787515814322 +9787515814360 +9787515814452 +9787515814513 +9787515814674 +9787515814728 +9787515814735 +9787515814759 +9787515814766 +9787515814797 +9787515814865 +9787515814919 +9787515814957 +9787515815060 +9787515815244 +9787515815312 +9787515815855 +9787515816289 +9787515816920 +9787515817910 +9787515818061 +9787515818214 +9787515818245 +9787515818276 +9787515818351 +9787515819037 +9787515819099 +9787515819273 +9787515819396 +9787515819860 +9787515820170 +9787515820187 +9787515820774 +9787515821078 +9787515821153 +9787515821436 +9787515821757 +9787515821849 +9787515821900 +9787515822693 +9787515822839 +9787515822846 +9787515822860 +9787515822884 +9787515822891 +9787515822976 +9787515823034 +9787515823058 +9787515823126 +9787515823157 +9787515823171 +9787515823560 +9787515823591 +9787515823638 +9787515823652 +9787515823676 +9787515823690 +9787515823935 +9787515824161 +9787515824383 +9787515824550 +9787515824710 +9787515824758 +9787515824772 +9787515824918 +9787515825083 +9787515825168 +9787515825205 +9787515825373 +9787515825458 +9787515825540 +9787515825625 +9787515825694 +9787515825946 +9787515826097 +9787515826257 +9787515826370 +9787515826448 +9787515826615 +9787515826653 +9787515826660 +9787515826783 +9787515826790 +9787515826868 +9787515826875 +9787515826899 +9787515827025 +9787515827032 +9787515827094 +9787515827155 +9787515827490 +9787515827506 +9787515827544 +9787515827674 +9787515827681 +9787515827803 +9787515827889 +9787515827940 +9787515828091 +9787515828121 +9787515828220 +9787515828282 +9787515828299 +9787515828350 +9787515828374 +9787515828480 +9787515828527 +9787515828688 +9787515829142 +9787515829340 +9787515829371 +9787515829555 +9787515829746 +9787515829869 +9787515830155 +9787515830780 +9787515831121 +9787515831145 +9787515831190 +9787515831213 +9787515831855 +9787515832661 +9787515832876 +9787515833477 +9787515833590 +9787515833729 +9787515834085 +9787515834221 +9787515834498 +9787515834504 +9787515834597 +9787515834818 +9787515835358 +9787515835402 +9787515836072 +9787515836188 +9787515836218 +9787515836379 +9787515836386 +9787515836393 +9787515836492 +9787515836751 +9787515836805 +9787515836812 +9787515836874 +9787515836881 +9787515836935 +9787515837093 +9787515837185 +9787515837192 +9787515837284 +9787515837802 +9787515837819 +9787515838168 +9787515838427 +9787515838472 +9787515838496 +9787515838533 +9787515838724 +9787515838823 +9787515838946 +9787515838991 +9787515839011 +9787515839158 +9787515839202 +9787515839233 +9787515839417 +9787515839462 +9787515839677 +9787515839776 +9787515839981 +9787515840024 +9787515840277 +9787515840284 +9787515840321 +9787515840482 +9787515840673 +9787515840994 +9787515841045 +9787515841182 +9787515841199 +9787515841267 +9787515841274 +9787515841298 +9787515841700 +9787515841984 +9787515842196 +9787515842295 +9787515842387 +9787515842486 +9787515842585 +9787515843100 +9787515843117 +9787515900018 +9787515900315 +9787515900322 +9787515900483 +9787515900735 +9787515901060 +9787515901077 +9787515901183 +9787515901435 +9787515901459 +9787515901466 +9787515901916 +9787515901923 +9787515901930 +9787515902050 +9787515902135 +9787515902944 +9787515903200 +9787515903392 +9787515903446 +9787515903729 +9787515903903 +9787515903927 +9787515904016 +9787515904375 +9787515904405 +9787515904412 +9787515904535 +9787515904566 +9787515904580 +9787515904603 +9787515904610 +9787515904658 +9787515904702 +9787515905051 +9787515905136 +9787515905167 +9787515905242 +9787515905280 +9787515905327 +9787515905426 +9787515905617 +9787515905631 +9787515905648 +9787515905655 +9787515905938 +9787515906355 +9787515906850 +9787515906867 +9787515907000 +9787515907062 +9787515907079 +9787515907086 +9787515907192 +9787515907314 +9787515907444 +9787515907574 +9787515907581 +9787515907604 +9787515907628 +9787515907697 +9787515907741 +9787515907789 +9787515907819 +9787515908076 +9787515908366 +9787515908571 +9787515909219 +9787515909622 +9787515909929 +9787515909967 +9787515910062 +9787515910451 +9787515910536 +9787515910598 +9787515910604 +9787515911014 +9787515911137 +9787515911403 +9787515911489 +9787515911496 +9787515911595 +9787515912684 +9787515914060 +9787515914343 +9787515914428 +9787515914558 +9787515915036 +9787515915364 +9787515915678 +9787515915869 +9787515916231 +9787515916446 +9787515916620 +9787515916781 +9787515916873 +9787515916941 +9787515917061 +9787515917085 +9787515917108 +9787515917122 +9787515917160 +9787515917221 +9787515917429 +9787515917443 +9787515917528 +9787515917825 +9787515917832 +9787515918075 +9787515918433 +9787515918563 +9787515918624 +9787515918730 +9787515918976 +9787515918990 +9787515919003 +9787515919133 +9787515919157 +9787515919164 +9787515919188 +9787515919836 +9787515919881 +9787515920153 +9787515920429 +9787515920528 +9787515920719 +9787515921754 +9787515921785 +9787515921907 +9787515922058 +9787515922065 +9787515922218 +9787515922447 +9787515922560 +9787515922607 +9787515922614 +9787515922621 +9787515922744 +9787515922751 +9787515922928 +9787515922942 +9787515923017 +9787515923215 +9787515923260 +9787515923307 +9787515923314 +9787515923321 +9787515923420 +9787515923444 +9787515923475 +9787515923482 +9787515923536 +9787515923635 +9787515923710 +9787515923765 +9787515923796 +9787515923871 +9787515923895 +9787515923918 +9787515924045 +9787515924083 +9787515924113 +9787515924120 +9787515924144 +9787515924182 +9787515924199 +9787515924205 +9787515924311 +9787515924373 +9787515924380 +9787515924410 +9787515924434 +9787515924441 +9787515924571 +9787515924601 +9787515924656 +9787515924755 +9787515924816 +9787515924823 +9787515925257 +9787515925479 +9787515925646 +9787516002087 +9787516003527 +9787516003879 +9787516004166 +9787516005156 +9787516006962 +9787516007242 +9787516007402 +9787516008003 +9787516008201 +9787516009734 +9787516010570 +9787516011560 +9787516012659 +9787516012871 +9787516013762 +9787516013908 +9787516013977 +9787516014103 +9787516014325 +9787516014790 +9787516015162 +9787516016206 +9787516017159 +9787516017456 +9787516018378 +9787516018866 +9787516019191 +9787516020197 +9787516020227 +9787516020623 +9787516022023 +9787516022108 +9787516022535 +9787516023020 +9787516024232 +9787516025390 +9787516025505 +9787516025673 +9787516025697 +9787516026182 +9787516026373 +9787516026809 +9787516026847 +9787516026922 +9787516027189 +9787516027608 +9787516027714 +9787516027806 +9787516028568 +9787516028681 +9787516028810 +9787516029008 +9787516029503 +9787516029787 +9787516029930 +9787516030417 +9787516030615 +9787516031612 +9787516032459 +9787516033081 +9787516033241 +9787516033715 +9787516033975 +9787516034132 +9787516034262 +9787516035580 +9787516035658 +9787516036099 +9787516036235 +9787516036266 +9787516036495 +9787516036662 +9787516037072 +9787516037522 +9787516037539 +9787516037577 +9787516037683 +9787516037690 +9787516037782 +9787516038376 +9787516038437 +9787516038772 +9787516040065 +9787516040300 +9787516040607 +9787516040706 +9787516043288 +9787516043646 +9787516043974 +9787516100127 +9787516100172 +9787516100226 +9787516100332 +9787516100516 +9787516100523 +9787516100639 +9787516100660 +9787516101278 +9787516101407 +9787516101551 +9787516101728 +9787516101803 +9787516102084 +9787516102176 +9787516102213 +9787516102268 +9787516102282 +9787516102343 +9787516102565 +9787516102688 +9787516102718 +9787516102893 +9787516102961 +9787516103159 +9787516103326 +9787516103371 +9787516103432 +9787516103500 +9787516103715 +9787516104002 +9787516104200 +9787516104279 +9787516104309 +9787516104415 +9787516104439 +9787516104514 +9787516104538 +9787516104675 +9787516104682 +9787516104903 +9787516104910 +9787516104958 +9787516105191 +9787516105306 +9787516105313 +9787516105351 +9787516105368 +9787516105726 +9787516105818 +9787516106228 +9787516106983 +9787516107263 +9787516107447 +9787516107454 +9787516107744 +9787516107799 +9787516107805 +9787516107874 +9787516108031 +9787516108116 +9787516108260 +9787516108482 +9787516108598 +9787516108741 +9787516109007 +9787516109038 +9787516109311 +9787516109564 +9787516110171 +9787516110188 +9787516110393 +9787516110508 +9787516110515 +9787516110669 +9787516110713 +9787516111475 +9787516111888 +9787516112120 +9787516112199 +9787516112267 +9787516112304 +9787516112397 +9787516112427 +9787516112441 +9787516112489 +9787516112496 +9787516112625 +9787516112724 +9787516112779 +9787516112892 +9787516113141 +9787516113257 +9787516113523 +9787516113974 +9787516114094 +9787516114155 +9787516114254 +9787516114407 +9787516114612 +9787516114759 +9787516114933 +9787516115350 +9787516115459 +9787516115480 +9787516115497 +9787516115541 +9787516115695 +9787516116104 +9787516116166 +9787516116272 +9787516116418 +9787516116425 +9787516116746 +9787516116845 +9787516116906 +9787516116951 +9787516116975 +9787516116982 +9787516117064 +9787516117262 +9787516117415 +9787516117491 +9787516117538 +9787516117552 +9787516117675 +9787516117743 +9787516117781 +9787516117941 +9787516117989 +9787516118221 +9787516118238 +9787516118405 +9787516118429 +9787516118436 +9787516118481 +9787516118573 +9787516118658 +9787516118788 +9787516119075 +9787516119105 +9787516119426 +9787516119440 +9787516119471 +9787516119488 +9787516119600 +9787516119839 +9787516119976 +9787516120194 +9787516120248 +9787516120361 +9787516120439 +9787516120545 +9787516120590 +9787516120767 +9787516120811 +9787516120859 +9787516120873 +9787516120989 +9787516121023 +9787516121030 +9787516121115 +9787516121351 +9787516121689 +9787516121771 +9787516121870 +9787516121955 +9787516122099 +9787516122105 +9787516122303 +9787516122365 +9787516122396 +9787516122464 +9787516122549 +9787516122815 +9787516122846 +9787516123065 +9787516123102 +9787516123157 +9787516123225 +9787516123300 +9787516123515 +9787516123546 +9787516123805 +9787516123836 +9787516123959 +9787516124246 +9787516124468 +9787516124604 +9787516125113 +9787516125243 +9787516125540 +9787516125595 +9787516125779 +9787516125878 +9787516126004 +9787516126059 +9787516126097 +9787516126462 +9787516126523 +9787516126608 +9787516127001 +9787516127063 +9787516127117 +9787516127421 +9787516127438 +9787516127650 +9787516127773 +9787516127964 +9787516128046 +9787516128367 +9787516128442 +9787516128527 +9787516128602 +9787516128725 +9787516128800 +9787516129098 +9787516129210 +9787516129241 +9787516129401 +9787516129463 +9787516129470 +9787516129586 +9787516129593 +9787516129616 +9787516129623 +9787516129630 +9787516129678 +9787516129692 +9787516129913 +9787516130070 +9787516130353 +9787516130704 +9787516130759 +9787516130919 +9787516131220 +9787516131251 +9787516131428 +9787516131725 +9787516131886 +9787516131916 +9787516131947 +9787516132098 +9787516132111 +9787516132609 +9787516132685 +9787516133040 +9787516133309 +9787516133354 +9787516133460 +9787516133576 +9787516133682 +9787516133804 +9787516133880 +9787516134009 +9787516134085 +9787516134092 +9787516134115 +9787516134306 +9787516134313 +9787516134474 +9787516134481 +9787516134559 +9787516134665 +9787516134696 +9787516134849 +9787516134962 +9787516135129 +9787516135341 +9787516135471 +9787516135495 +9787516135518 +9787516135815 +9787516136058 +9787516136133 +9787516136256 +9787516136270 +9787516136447 +9787516136911 +9787516136973 +9787516137222 +9787516137246 +9787516137307 +9787516137390 +9787516137499 +9787516137512 +9787516137574 +9787516137901 +9787516138014 +9787516138076 +9787516138083 +9787516138090 +9787516138106 +9787516138427 +9787516138434 +9787516138465 +9787516138731 +9787516138748 +9787516138762 +9787516138779 +9787516138960 +9787516139110 +9787516139226 +9787516139363 +9787516139431 +9787516139653 +9787516140017 +9787516140222 +9787516140505 +9787516140659 +9787516140697 +9787516140772 +9787516141083 +9787516141144 +9787516141199 +9787516141366 +9787516141403 +9787516141427 +9787516141441 +9787516141472 +9787516141557 +9787516141601 +9787516141694 +9787516141724 +9787516141748 +9787516141977 +9787516141984 +9787516142165 +9787516142240 +9787516142257 +9787516142295 +9787516142424 +9787516142530 +9787516142585 +9787516143032 +9787516143162 +9787516143308 +9787516143551 +9787516143629 +9787516143711 +9787516144107 +9787516144145 +9787516144305 +9787516144701 +9787516145081 +9787516145159 +9787516145203 +9787516145463 +9787516145487 +9787516145500 +9787516145579 +9787516145968 +9787516146255 +9787516146323 +9787516146330 +9787516146552 +9787516146620 +9787516146668 +9787516146699 +9787516146934 +9787516146941 +9787516147092 +9787516147108 +9787516147221 +9787516147245 +9787516147252 +9787516147825 +9787516147849 +9787516148136 +9787516148143 +9787516148273 +9787516148280 +9787516148457 +9787516149072 +9787516149140 +9787516149362 +9787516149423 +9787516149485 +9787516150023 +9787516150078 +9787516150092 +9787516150108 +9787516150214 +9787516150436 +9787516150504 +9787516150795 +9787516150801 +9787516151204 +9787516151273 +9787516151297 +9787516151358 +9787516151426 +9787516151457 +9787516151488 +9787516151921 +9787516151983 +9787516152003 +9787516152010 +9787516152072 +9787516152096 +9787516152133 +9787516152140 +9787516152249 +9787516152331 +9787516152447 +9787516152478 +9787516152812 +9787516152829 +9787516152843 +9787516152997 +9787516153062 +9787516153598 +9787516154052 +9787516154236 +9787516154472 +9787516154670 +9787516154748 +9787516154816 +9787516154885 +9787516155271 +9787516155448 +9787516155455 +9787516155592 +9787516155738 +9787516155875 +9787516155912 +9787516156018 +9787516156070 +9787516156308 +9787516156506 +9787516156513 +9787516156568 +9787516156735 +9787516156742 +9787516156797 +9787516156988 +9787516157039 +9787516157114 +9787516157169 +9787516157329 +9787516157817 +9787516157886 +9787516158012 +9787516158197 +9787516158524 +9787516158906 +9787516158982 +9787516159040 +9787516159293 +9787516159330 +9787516159361 +9787516159835 +9787516159842 +9787516160114 +9787516160145 +9787516160213 +9787516160381 +9787516160701 +9787516160848 +9787516161012 +9787516161319 +9787516161463 +9787516161586 +9787516161630 +9787516161791 +9787516161944 +9787516162071 +9787516162170 +9787516162620 +9787516162644 +9787516162682 +9787516162750 +9787516163115 +9787516163139 +9787516163474 +9787516163498 +9787516163702 +9787516163726 +9787516163757 +9787516163795 +9787516163924 +9787516164464 +9787516165058 +9787516165430 +9787516165447 +9787516165645 +9787516165805 +9787516165881 +9787516165928 +9787516165959 +9787516166154 +9787516166499 +9787516166550 +9787516166727 +9787516166741 +9787516166765 +9787516166932 +9787516167113 +9787516167496 +9787516167687 +9787516168783 +9787516168844 +9787516168974 +9787516169100 +9787516169353 +9787516169575 +9787516169629 +9787516169667 +9787516169735 +9787516169766 +9787516169780 +9787516170052 +9787516170083 +9787516170175 +9787516170328 +9787516170458 +9787516170793 +9787516170854 +9787516171066 +9787516171295 +9787516171547 +9787516171851 +9787516172018 +9787516172131 +9787516172278 +9787516172292 +9787516172674 +9787516172681 +9787516173114 +9787516173312 +9787516173343 +9787516173534 +9787516173633 +9787516173763 +9787516174111 +9787516174708 +9787516174852 +9787516175026 +9787516175316 +9787516175996 +9787516176092 +9787516176177 +9787516176221 +9787516176252 +9787516176313 +9787516176504 +9787516176726 +9787516176757 +9787516176795 +9787516176832 +9787516176849 +9787516177624 +9787516177860 +9787516177877 +9787516178041 +9787516178102 +9787516178287 +9787516178584 +9787516178676 +9787516178843 +9787516178911 +9787516179130 +9787516179376 +9787516179383 +9787516179680 +9787516179734 +9787516179925 +9787516179949 +9787516180334 +9787516180426 +9787516180624 +9787516180716 +9787516180952 +9787516181041 +9787516181348 +9787516181386 +9787516181614 +9787516182116 +9787516182345 +9787516182420 +9787516182895 +9787516182956 +9787516183380 +9787516183410 +9787516183434 +9787516183489 +9787516183564 +9787516183687 +9787516183847 +9787516183915 +9787516184028 +9787516184042 +9787516184240 +9787516184295 +9787516184585 +9787516185445 +9787516185636 +9787516185797 +9787516186022 +9787516186176 +9787516186428 +9787516186657 +9787516187371 +9787516187395 +9787516187784 +9787516187807 +9787516187906 +9787516187944 +9787516188064 +9787516188101 +9787516188262 +9787516188293 +9787516188316 +9787516188477 +9787516188699 +9787516188767 +9787516188965 +9787516189399 +9787516189474 +9787516189498 +9787516189597 +9787516189603 +9787516189702 +9787516189818 +9787516190081 +9787516190098 +9787516190203 +9787516190456 +9787516190470 +9787516190494 +9787516190616 +9787516191187 +9787516191705 +9787516191934 +9787516192016 +9787516192269 +9787516192719 +9787516192986 +9787516193273 +9787516193396 +9787516193556 +9787516194065 +9787516194164 +9787516194379 +9787516195024 +9787516195468 +9787516195611 +9787516195802 +9787516195833 +9787516195871 +9787516196243 +9787516196403 +9787516196809 +9787516197257 +9787516197523 +9787516197745 +9787516197820 +9787516198537 +9787516198742 +9787516198919 +9787516198964 +9787516199305 +9787516200001 +9787516200575 +9787516200582 +9787516200599 +9787516200711 +9787516201176 +9787516201190 +9787516201206 +9787516201695 +9787516201701 +9787516202036 +9787516202456 +9787516203040 +9787516203224 +9787516203293 +9787516203453 +9787516203484 +9787516203521 +9787516204108 +9787516204177 +9787516204757 +9787516204801 +9787516204986 +9787516205020 +9787516205211 +9787516205440 +9787516205860 +9787516206171 +9787516206225 +9787516207000 +9787516207758 +9787516207895 +9787516208182 +9787516208205 +9787516208212 +9787516208236 +9787516209394 +9787516209431 +9787516209516 +9787516209530 +9787516209783 +9787516209806 +9787516209882 +9787516210260 +9787516210482 +9787516210499 +9787516210710 +9787516210970 +9787516211038 +9787516211045 +9787516211519 +9787516211724 +9787516211816 +9787516212462 +9787516212530 +9787516212547 +9787516213032 +9787516213346 +9787516213391 +9787516213513 +9787516213599 +9787516214091 +9787516214206 +9787516214305 +9787516214374 +9787516214398 +9787516214787 +9787516214831 +9787516215005 +9787516215104 +9787516215432 +9787516215463 +9787516215739 +9787516215784 +9787516215913 +9787516216293 +9787516216347 +9787516216583 +9787516216972 +9787516217337 +9787516217863 +9787516218129 +9787516218303 +9787516218327 +9787516218907 +9787516219096 +9787516219621 +9787516219959 +9787516220030 +9787516220139 +9787516220252 +9787516220313 +9787516220542 +9787516220719 +9787516220764 +9787516221327 +9787516221389 +9787516221600 +9787516222058 +9787516222454 +9787516222591 +9787516222782 +9787516222980 +9787516223031 +9787516223079 +9787516223116 +9787516223246 +9787516223345 +9787516223727 +9787516223840 +9787516223864 +9787516223949 +9787516224236 +9787516224625 +9787516224786 +9787516224854 +9787516225035 +9787516225110 +9787516225516 +9787516225523 +9787516225530 +9787516225561 +9787516225592 +9787516225660 +9787516225677 +9787516225776 +9787516225868 +9787516225899 +9787516225950 +9787516225981 +9787516226049 +9787516226100 +9787516226537 +9787516226551 +9787516226599 +9787516226629 +9787516226636 +9787516226674 +9787516226827 +9787516226988 +9787516227039 +9787516227053 +9787516227084 +9787516227312 +9787516227794 +9787516227824 +9787516227886 +9787516227916 +9787516227930 +9787516227961 +9787516228067 +9787516228180 +9787516228418 +9787516228869 +9787516228944 +9787516229026 +9787516229286 +9787516229316 +9787516229361 +9787516229477 +9787516229484 +9787516229507 +9787516229569 +9787516229606 +9787516229644 +9787516229705 +9787516229743 +9787516229842 +9787516229873 +9787516230251 +9787516230312 +9787516230374 +9787516230404 +9787516230459 +9787516230497 +9787516230565 +9787516230787 +9787516230817 +9787516230862 +9787516230909 +9787516230916 +9787516231043 +9787516231463 +9787516231470 +9787516231609 +9787516231616 +9787516231722 +9787516231746 +9787516231937 +9787516231951 +9787516232149 +9787516232217 +9787516232286 +9787516232293 +9787516232323 +9787516232354 +9787516232361 +9787516232408 +9787516232569 +9787516232651 +9787516232675 +9787516232699 +9787516232705 +9787516232989 +9787516233016 +9787516233085 +9787516233092 +9787516233214 +9787516233238 +9787516233252 +9787516233290 +9787516233504 +9787516233511 +9787516233535 +9787516233580 +9787516233597 +9787516233603 +9787516233641 +9787516233658 +9787516233696 +9787516233757 +9787516233856 +9787516233894 +9787516234006 +9787516234013 +9787516234020 +9787516234051 +9787516234259 +9787516234396 +9787516234464 +9787516234525 +9787516234624 +9787516234662 +9787516234723 +9787516234792 +9787516234808 +9787516234846 +9787516234945 +9787516235263 +9787516235270 +9787516235331 +9787516235423 +9787516235539 +9787516235645 +9787516235713 +9787516235775 +9787516235829 +9787516235836 +9787516235898 +9787516235997 +9787516236024 +9787516236079 +9787516236338 +9787516236345 +9787516236352 +9787516236444 +9787516236468 +9787516236550 +9787516236598 +9787516236802 +9787516236987 +9787516237168 +9787516237229 +9787516237243 +9787516237311 +9787516237489 +9787516237496 +9787516237502 +9787516237519 +9787516237724 +9787516237748 +9787516238073 +9787516238172 +9787516238240 +9787516238370 +9787516238684 +9787516238905 +9787516239209 +9787516239261 +9787516239308 +9787516300701 +9787516301357 +9787516301425 +9787516301500 +9787516301616 +9787516301913 +9787516301968 +9787516301982 +9787516302040 +9787516302064 +9787516302088 +9787516302217 +9787516302354 +9787516302606 +9787516302736 +9787516302859 +9787516302866 +9787516303030 +9787516303412 +9787516303443 +9787516303627 +9787516303788 +9787516303948 +9787516304013 +9787516304365 +9787516304532 +9787516304655 +9787516304723 +9787516304730 +9787516304976 +9787516305034 +9787516305331 +9787516306024 +9787516306284 +9787516306390 +9787516306406 +9787516306543 +9787516306659 +9787516307571 +9787516308158 +9787516311547 +9787516400050 +9787516400074 +9787516400234 +9787516400319 +9787516400357 +9787516400869 +9787516400890 +9787516401118 +9787516401231 +9787516401538 +9787516402078 +9787516402146 +9787516402375 +9787516402757 +9787516402795 +9787516402931 +9787516402948 +9787516402955 +9787516403068 +9787516403075 +9787516403082 +9787516403150 +9787516403174 +9787516403235 +9787516403303 +9787516403761 +9787516404782 +9787516404980 +9787516405673 +9787516405901 +9787516405963 +9787516406199 +9787516407066 +9787516407202 +9787516407370 +9787516407905 +9787516408339 +9787516408506 +9787516408933 +9787516408957 +9787516408971 +9787516410080 +9787516410103 +9787516410400 +9787516410509 +9787516411018 +9787516411124 +9787516411285 +9787516411926 +9787516412237 +9787516412428 +9787516412930 +9787516415689 +9787516415702 +9787516416099 +9787516416563 +9787516417249 +9787516417676 +9787516417867 +9787516417935 +9787516418697 +9787516418758 +9787516418802 +9787516418888 +9787516418932 +9787516418987 +9787516419052 +9787516419175 +9787516419564 +9787516419618 +9787516420324 +9787516420355 +9787516420478 +9787516420683 +9787516420898 +9787516421048 +9787516421192 +9787516421208 +9787516421437 +9787516421482 +9787516421765 +9787516421963 +9787516421970 +9787516421987 +9787516422045 +9787516422144 +9787516422342 +9787516422731 +9787516422755 +9787516423356 +9787516423417 +9787516423554 +9787516423592 +9787516423608 +9787516423653 +9787516424049 +9787516424360 +9787516424919 +9787516425350 +9787516425459 +9787516425466 +9787516425909 +9787516425992 +9787516426203 +9787516427064 +9787516427118 +9787516427347 +9787516427361 +9787516427385 +9787516427514 +9787516427699 +9787516427705 +9787516427712 +9787516427729 +9787516428054 +9787516428061 +9787516428139 +9787516428146 +9787516428191 +9787516428320 +9787516428344 +9787516428382 +9787516428481 +9787516428542 +9787516428696 +9787516428740 +9787516428979 +9787516429181 +9787516429204 +9787516429426 +9787516429884 +9787516429907 +9787516430248 +9787516430347 +9787516430415 +9787516430484 +9787516430545 +9787516430668 +9787516430828 +9787516430873 +9787516431405 +9787516431955 +9787516432464 +9787516432471 +9787516500057 +9787516500217 +9787516500385 +9787516500521 +9787516500774 +9787516500866 +9787516501092 +9787516501146 +9787516501481 +9787516501610 +9787516501641 +9787516501726 +9787516501771 +9787516501795 +9787516501832 +9787516501863 +9787516501870 +9787516501887 +9787516501894 +9787516501900 +9787516501948 +9787516501979 +9787516501986 +9787516502006 +9787516502013 +9787516502044 +9787516502068 +9787516502075 +9787516502082 +9787516502099 +9787516502105 +9787516502136 +9787516502143 +9787516502150 +9787516502617 +9787516502662 +9787516502716 +9787516502723 +9787516502730 +9787516502747 +9787516502754 +9787516502761 +9787516502921 +9787516502945 +9787516503201 +9787516503218 +9787516503232 +9787516503249 +9787516503454 +9787516503492 +9787516503751 +9787516504192 +9787516504277 +9787516504437 +9787516504574 +9787516504611 +9787516504659 +9787516505144 +9787516505830 +9787516505878 +9787516505885 +9787516506158 +9787516506189 +9787516506400 +9787516506424 +9787516506455 +9787516506776 +9787516506875 +9787516506882 +9787516506905 +9787516506981 +9787516507131 +9787516507339 +9787516507735 +9787516507773 +9787516507858 +9787516507865 +9787516507872 +9787516508107 +9787516508145 +9787516508398 +9787516508640 +9787516508909 +9787516509050 +9787516509388 +9787516509463 +9787516509470 +9787516509661 +9787516509777 +9787516509869 +9787516509890 +9787516510070 +9787516510308 +9787516510551 +9787516510643 +9787516510674 +9787516510773 +9787516511169 +9787516511176 +9787516511206 +9787516511343 +9787516511404 +9787516511732 +9787516511756 +9787516511787 +9787516512036 +9787516512302 +9787516512388 +9787516512630 +9787516512692 +9787516512999 +9787516513019 +9787516513033 +9787516513125 +9787516513545 +9787516513873 +9787516513903 +9787516513910 +9787516514085 +9787516514290 +9787516514306 +9787516514634 +9787516514931 +9787516514962 +9787516515365 +9787516515440 +9787516515549 +9787516515556 +9787516515693 +9787516515747 +9787516515792 +9787516515808 +9787516515945 +9787516516201 +9787516516386 +9787516516454 +9787516516676 +9787516516737 +9787516516782 +9787516516942 +9787516516973 +9787516517017 +9787516517215 +9787516517239 +9787516517291 +9787516517321 +9787516517420 +9787516517567 +9787516517598 +9787516517765 +9787516517888 +9787516517970 +9787516518243 +9787516518250 +9787516518328 +9787516518397 +9787516518472 +9787516518533 +9787516518557 +9787516518588 +9787516518663 +9787516518854 +9787516519035 +9787516519080 +9787516519110 +9787516519301 +9787516519318 +9787516519400 +9787516519493 +9787516519523 +9787516519530 +9787516519707 +9787516519882 +9787516519936 +9787516519981 +9787516519998 +9787516520062 +9787516520116 +9787516520178 +9787516520376 +9787516520437 +9787516520444 +9787516520468 +9787516520536 +9787516520581 +9787516520628 +9787516520772 +9787516520840 +9787516521168 +9787516521199 +9787516521304 +9787516521311 +9787516521335 +9787516521557 +9787516521724 +9787516521786 +9787516521939 +9787516521953 +9787516522028 +9787516522103 +9787516522202 +9787516522226 +9787516522233 +9787516522257 +9787516522301 +9787516522349 +9787516522400 +9787516522691 +9787516522837 +9787516522868 +9787516522936 +9787516522943 +9787516522974 +9787516523018 +9787516523155 +9787516523230 +9787516523322 +9787516523353 +9787516523520 +9787516523605 +9787516523643 +9787516523681 +9787516524053 +9787516524077 +9787516524244 +9787516524299 +9787516524336 +9787516524435 +9787516524442 +9787516524527 +9787516524626 +9787516524664 +9787516524671 +9787516524688 +9787516524725 +9787516524749 +9787516524794 +9787516524800 +9787516524817 +9787516524909 +9787516524916 +9787516524947 +9787516524985 +9787516525043 +9787516525166 +9787516525210 +9787516525258 +9787516525265 +9787516525272 +9787516525289 +9787516525296 +9787516525319 +9787516525487 +9787516525531 +9787516525586 +9787516525661 +9787516525678 +9787516525746 +9787516525753 +9787516525777 +9787516525814 +9787516525821 +9787516525906 +9787516525975 +9787516526057 +9787516526156 +9787516526170 +9787516526217 +9787516526224 +9787516526231 +9787516526262 +9787516526323 +9787516526361 +9787516526484 +9787516526514 +9787516526569 +9787516526576 +9787516526729 +9787516526781 +9787516526798 +9787516526873 +9787516526903 +9787516526927 +9787516526996 +9787516527016 +9787516527047 +9787516527054 +9787516527085 +9787516527108 +9787516527115 +9787516527122 +9787516527146 +9787516527160 +9787516527184 +9787516527238 +9787516527351 +9787516527368 +9787516527535 +9787516527658 +9787516527665 +9787516527696 +9787516527719 +9787516527740 +9787516527795 +9787516527856 +9787516527863 +9787516527870 +9787516527900 +9787516527924 +9787516527948 +9787516527955 +9787516527962 +9787516527986 +9787516528129 +9787516528150 +9787516528181 +9787516528204 +9787516528310 +9787516528372 +9787516528747 +9787516528778 +9787516528808 +9787516528983 +9787516529010 +9787516529126 +9787516529164 +9787516529232 +9787516529249 +9787516529256 +9787516529270 +9787516529287 +9787516529324 +9787516529379 +9787516529454 +9787516529621 +9787516529997 +9787516530009 +9787516530016 +9787516530351 +9787516530603 +9787516530832 +9787516530894 +9787516530900 +9787516530962 +9787516531112 +9787516531143 +9787516531181 +9787516531389 +9787516531396 +9787516531556 +9787516531594 +9787516531617 +9787516531709 +9787516531846 +9787516531907 +9787516531952 +9787516532348 +9787516532614 +9787516532645 +9787516532669 +9787516532713 +9787516533000 +9787516533093 +9787516533130 +9787516533222 +9787516533246 +9787516533604 +9787516533628 +9787516533659 +9787516533703 +9787516533765 +9787516533772 +9787516534045 +9787516534052 +9787516534083 +9787516534274 +9787516534298 +9787516534304 +9787516534687 +9787516534748 +9787516534892 +9787516535264 +9787516535349 +9787516535394 +9787516535608 +9787516536032 +9787516536094 +9787516536131 +9787516536278 +9787516536414 +9787516536568 +9787516536711 +9787516536728 +9787516537107 +9787516537169 +9787516537275 +9787516537817 +9787516537886 +9787516537893 +9787516538548 +9787516538555 +9787516538722 +9787516538746 +9787516539675 +9787516540916 +9787516541180 +9787516600214 +9787516600221 +9787516600290 +9787516600474 +9787516600856 +9787516601280 +9787516601297 +9787516601303 +9787516601877 +9787516601976 +9787516602140 +9787516602478 +9787516602584 +9787516602607 +9787516602683 +9787516602737 +9787516602744 +9787516602935 +9787516602973 +9787516603055 +9787516603369 +9787516603420 +9787516603581 +9787516603697 +9787516603765 +9787516603857 +9787516603918 +9787516603956 +9787516604267 +9787516604724 +9787516604830 +9787516604977 +9787516605554 +9787516605677 +9787516605738 +9787516606063 +9787516606162 +9787516606209 +9787516606650 +9787516606735 +9787516606759 +9787516607060 +9787516607633 +9787516607770 +9787516607992 +9787516608227 +9787516608371 +9787516608388 +9787516608654 +9787516608968 +9787516609088 +9787516609156 +9787516609231 +9787516609354 +9787516609873 +9787516609934 +9787516610015 +9787516610152 +9787516610367 +9787516610381 +9787516610909 +9787516610916 +9787516611364 +9787516611678 +9787516612002 +9787516612071 +9787516612668 +9787516612934 +9787516612996 +9787516613016 +9787516613054 +9787516613061 +9787516613313 +9787516613566 +9787516613894 +9787516614020 +9787516614235 +9787516614501 +9787516615256 +9787516615430 +9787516615799 +9787516615805 +9787516615966 +9787516616796 +9787516616864 +9787516617052 +9787516617205 +9787516617557 +9787516617601 +9787516618288 +9787516618318 +9787516618738 +9787516619650 +9787516619773 +9787516620274 +9787516620687 +9787516620694 +9787516621998 +9787516622032 +9787516622476 +9787516622674 +9787516623787 +9787516624067 +9787516624081 +9787516625309 +9787516626160 +9787516626245 +9787516626740 +9787516626979 +9787516628867 +9787516629710 +9787516630167 +9787516630181 +9787516630631 +9787516630686 +9787516631614 +9787516632826 +9787516632833 +9787516632840 +9787516632857 +9787516632994 +9787516635889 +9787516635896 +9787516637722 +9787516638224 +9787516638897 +9787516639368 +9787516639405 +9787516640517 +9787516640524 +9787516640531 +9787516640807 +9787516640814 +9787516640982 +9787516641279 +9787516641286 +9787516641989 +9787516642733 +9787516643051 +9787516643242 +9787516643266 +9787516643686 +9787516644102 +9787516644188 +9787516644393 +9787516644447 +9787516644942 +9787516645192 +9787516646335 +9787516646953 +9787516647189 +9787516647387 +9787516647561 +9787516647592 +9787516647998 +9787516649909 +9787516650455 +9787516650639 +9787516651148 +9787516651582 +9787516651865 +9787516651889 +9787516652442 +9787516652725 +9787516652732 +9787516652787 +9787516652831 +9787516652879 +9787516653159 +9787516653548 +9787516653715 +9787516654057 +9787516654651 +9787516655009 +9787516655252 +9787516655443 +9787516656280 +9787516656389 +9787516656648 +9787516656853 +9787516656860 +9787516656914 +9787516656983 +9787516657140 +9787516657157 +9787516657799 +9787516658314 +9787516658482 +9787516658659 +9787516658871 +9787516658901 +9787516659403 +9787516659489 +9787516659588 +9787516659632 +9787516660218 +9787516660751 +9787516660874 +9787516661048 +9787516661130 +9787516661727 +9787516661796 +9787516661956 +9787516661970 +9787516662014 +9787516662212 +9787516663011 +9787516663134 +9787516663370 +9787516663523 +9787516663622 +9787516663639 +9787516663684 +9787516663851 +9787516664193 +9787516664254 +9787516664605 +9787516664940 +9787516665022 +9787516665039 +9787516665220 +9787516665305 +9787516665350 +9787516665589 +9787516666203 +9787516666296 +9787516666302 +9787516666630 +9787516666777 +9787516666814 +9787516667309 +9787516667354 +9787516667521 +9787516667538 +9787516667644 +9787516667675 +9787516668191 +9787516668214 +9787516668252 +9787516668269 +9787516668276 +9787516668320 +9787516668337 +9787516668399 +9787516668429 +9787516668450 +9787516668559 +9787516668818 +9787516668870 +9787516668900 +9787516668948 +9787516668962 +9787516669259 +9787516669303 +9787516669501 +9787516669556 +9787516670835 +9787516671023 +9787516671122 +9787516671139 +9787516671191 +9787516671214 +9787516671252 +9787516671306 +9787516671351 +9787516671566 +9787516671627 +9787516671658 +9787516671689 +9787516671757 +9787516671771 +9787516671979 +9787516672075 +9787516672303 +9787516672785 +9787516673003 +9787516673164 +9787516673218 +9787516673294 +9787516673430 +9787516673515 +9787516673522 +9787516673706 +9787516673737 +9787516673768 +9787516673805 +9787516673881 +9787516674406 +9787516674499 +9787516674574 +9787516674604 +9787516674796 +9787516674826 +9787516674925 +9787516674949 +9787516675298 +9787516675366 +9787516675373 +9787516675434 +9787516675441 +9787516675519 +9787516675625 +9787516676288 +9787516676707 +9787516677094 +9787516677162 +9787516677353 +9787516677407 +9787516678312 +9787516678671 +9787516679050 +9787516679487 +9787516680537 +9787516700372 +9787516701836 +9787516701959 +9787516702161 +9787516702307 +9787516702543 +9787516702888 +9787516703830 +9787516704035 +9787516705582 +9787516706060 +9787516708668 +9787516709290 +9787516709726 +9787516710449 +9787516712160 +9787516716007 +9787516716977 +9787516717080 +9787516717561 +9787516717837 +9787516718964 +9787516719121 +9787516719398 +9787516719442 +9787516720035 +9787516720660 +9787516721414 +9787516721650 +9787516722817 +9787516722930 +9787516723036 +9787516723319 +9787516723913 +9787516724118 +9787516724316 +9787516724378 +9787516725672 +9787516725719 +9787516727249 +9787516729229 +9787516729472 +9787516729717 +9787516730102 +9787516730720 +9787516731260 +9787516731611 +9787516732922 +9787516733356 +9787516733417 +9787516733646 +9787516734094 +9787516734896 +9787516735725 +9787516736036 +9787516736555 +9787516737330 +9787516737507 +9787516737941 +9787516738207 +9787516738221 +9787516738603 +9787516738887 +9787516739419 +9787516740071 +9787516740637 +9787516740767 +9787516740774 +9787516740804 +9787516741023 +9787516741221 +9787516741498 +9787516741528 +9787516741764 +9787516741900 +9787516742006 +9787516742297 +9787516742327 +9787516742402 +9787516742709 +9787516742761 +9787516743164 +9787516743706 +9787516743775 +9787516743836 +9787516743850 +9787516744062 +9787516744246 +9787516744260 +9787516744499 +9787516744567 +9787516744901 +9787516744970 +9787516745014 +9787516745045 +9787516745090 +9787516745373 +9787516745519 +9787516745533 +9787516745670 +9787516745830 +9787516745892 +9787516745939 +9787516745946 +9787516745960 +9787516746301 +9787516746400 +9787516746455 +9787516746486 +9787516746554 +9787516746639 +9787516746653 +9787516746691 +9787516746721 +9787516746912 +9787516746974 +9787516747117 +9787516747148 +9787516747360 +9787516747476 +9787516747551 +9787516747629 +9787516747711 +9787516747803 +9787516747841 +9787516747926 +9787516747940 +9787516748008 +9787516748039 +9787516748091 +9787516748299 +9787516748435 +9787516748510 +9787516748602 +9787516748633 +9787516748657 +9787516748718 +9787516748992 +9787516749036 +9787516749203 +9787516749302 +9787516749388 +9787516749401 +9787516749470 +9787516749531 +9787516749623 +9787516749791 +9787516749852 +9787516749951 +9787516749968 +9787516750018 +9787516750070 +9787516750148 +9787516750186 +9787516750247 +9787516750339 +9787516750391 +9787516750551 +9787516750810 +9787516750834 +9787516751015 +9787516751039 +9787516751176 +9787516751268 +9787516751473 +9787516751749 +9787516751756 +9787516751794 +9787516751831 +9787516751862 +9787516752135 +9787516752340 +9787516752364 +9787516752609 +9787516752647 +9787516752661 +9787516752715 +9787516752937 +9787516753002 +9787516753057 +9787516753248 +9787516753378 +9787516753446 +9787516753903 +9787516753972 +9787516753996 +9787516754009 +9787516754023 +9787516754276 +9787516754368 +9787516754672 +9787516754696 +9787516754740 +9787516754757 +9787516754771 +9787516754795 +9787516754825 +9787516754948 +9787516755129 +9787516755211 +9787516755242 +9787516755280 +9787516755310 +9787516755389 +9787516755396 +9787516755419 +9787516755488 +9787516755501 +9787516755563 +9787516755686 +9787516755754 +9787516755785 +9787516755839 +9787516756201 +9787516756270 +9787516756607 +9787516756676 +9787516756904 +9787516756935 +9787516757093 +9787516757116 +9787516757246 +9787516757321 +9787516757345 +9787516757352 +9787516757383 +9787516757406 +9787516757413 +9787516757505 +9787516757574 +9787516757741 +9787516757857 +9787516757949 +9787516758359 +9787516758540 +9787516758595 +9787516758632 +9787516758700 +9787516758786 +9787516759059 +9787516759134 +9787516759349 +9787516759479 +9787516759745 +9787516759769 +9787516759790 +9787516760123 +9787516760130 +9787516760178 +9787516760338 +9787516760451 +9787516760789 +9787516760819 +9787516760840 +9787516760925 +9787516761038 +9787516761113 +9787516761168 +9787516761502 +9787516762011 +9787516762110 +9787516762134 +9787516762325 +9787516762646 +9787516762752 +9787516762820 +9787516762967 +9787516763452 +9787516763711 +9787516763919 +9787516763926 +9787516764039 +9787516764206 +9787516764213 +9787516764220 +9787516764367 +9787516764442 +9787516764459 +9787516764534 +9787516764572 +9787516764589 +9787516764640 +9787516765050 +9787516765579 +9787516765654 +9787516766279 +9787516767078 +9787516767450 +9787516768235 +9787516768938 +9787516800096 +9787516800195 +9787516800447 +9787516800478 +9787516800485 +9787516800492 +9787516800652 +9787516800829 +9787516800867 +9787516800874 +9787516801055 +9787516801154 +9787516801178 +9787516801215 +9787516801246 +9787516801420 +9787516801499 +9787516801512 +9787516801550 +9787516801710 +9787516802328 +9787516802397 +9787516802403 +9787516802472 +9787516802687 +9787516802816 +9787516802908 +9787516803196 +9787516803271 +9787516803288 +9787516803349 +9787516803417 +9787516803455 +9787516803462 +9787516803493 +9787516803608 +9787516804001 +9787516804094 +9787516804209 +9787516804216 +9787516804414 +9787516804612 +9787516804629 +9787516804643 +9787516804650 +9787516804698 +9787516804704 +9787516804711 +9787516804841 +9787516804964 +9787516804971 +9787516805558 +9787516805572 +9787516805589 +9787516805596 +9787516805619 +9787516805954 +9787516806104 +9787516806326 +9787516806463 +9787516807156 +9787516807644 +9787516807897 +9787516808931 +9787516808993 +9787516809532 +9787516810057 +9787516810262 +9787516810293 +9787516811764 +9787516811955 +9787516812693 +9787516812723 +9787516813713 +9787516814437 +9787516814482 +9787516815472 +9787516815946 +9787516816615 +9787516817414 +9787516817964 +9787516818923 +9787516819463 +9787516821077 +9787516821572 +9787516821893 +9787516822654 +9787516823613 +9787516823750 +9787516823774 +9787516824078 +9787516824184 +9787516824214 +9787516824344 +9787516824566 +9787516824931 +9787516825211 +9787516825501 +9787516825594 +9787516825662 +9787516826447 +9787516826461 +9787516826584 +9787516826638 +9787516826720 +9787516826799 +9787516827550 +9787516827611 +9787516827734 +9787516827741 +9787516827758 +9787516827765 +9787516827772 +9787516827994 +9787516828076 +9787516828397 +9787516828410 +9787516828854 +9787516829059 +9787516829486 +9787516829738 +9787516829752 +9787516829905 +9787516830383 +9787516830390 +9787516830697 +9787516830895 +9787516831076 +9787516831403 +9787516831496 +9787516831854 +9787516832004 +9787516832240 +9787516832387 +9787516832486 +9787516832646 +9787516832677 +9787516832707 +9787516832738 +9787516833575 +9787516833803 +9787516833988 +9787516834251 +9787516834527 +9787516834565 +9787516834633 +9787516834770 +9787516834800 +9787516834992 +9787516835036 +9787516835203 +9787516835234 +9787516835333 +9787516835579 +9787516835647 +9787516835654 +9787516835685 +9787516835692 +9787516835784 +9787516835807 +9787516835869 +9787516836002 +9787516836019 +9787516836057 +9787516836064 +9787516836132 +9787516836149 +9787516836156 +9787516836170 +9787516836224 +9787516836279 +9787516836330 +9787516836378 +9787516836392 +9787516836408 +9787516836439 +9787516836491 +9787516836507 +9787516836521 +9787516836538 +9787516836545 +9787516836552 +9787516836576 +9787516836675 +9787516836699 +9787516836828 +9787516837078 +9787516837108 +9787516837184 +9787516837207 +9787516837252 +9787516837269 +9787516837306 +9787516837344 +9787516837368 +9787516837399 +9787516837443 +9787516837474 +9787516837498 +9787516837535 +9787516837634 +9787516837641 +9787516837689 +9787516837726 +9787516837832 +9787516837849 +9787516837917 +9787516837955 +9787516837993 +9787516838006 +9787516838013 +9787516838020 +9787516838037 +9787516838051 +9787516838068 +9787516838082 +9787516838105 +9787516838150 +9787516838174 +9787516838211 +9787516838242 +9787516838266 +9787516838327 +9787516838365 +9787516838372 +9787516838433 +9787516838440 +9787516838532 +9787516838549 +9787516838624 +9787516838631 +9787516838648 +9787516838662 +9787516838716 +9787516838792 +9787516838815 +9787516838846 +9787516838853 +9787516838877 +9787516838990 +9787516839058 +9787516839065 +9787516839133 +9787516839362 +9787516839393 +9787516839409 +9787516839423 +9787516839430 +9787516839508 +9787516839522 +9787516839539 +9787516839591 +9787516839614 +9787516839621 +9787516839669 +9787516839690 +9787516839713 +9787516839720 +9787516839799 +9787516839836 +9787516839867 +9787516840009 +9787516840054 +9787516840078 +9787516840092 +9787516840252 +9787516840269 +9787516840337 +9787516840405 +9787516840429 +9787516840566 +9787516840597 +9787516840603 +9787516840689 +9787516840702 +9787516840757 +9787516840801 +9787516840818 +9787516840948 +9787516840962 +9787516841099 +9787516841129 +9787516841150 +9787516841174 +9787516841235 +9787516841259 +9787516841266 +9787516841334 +9787516841341 +9787516841372 +9787516841389 +9787516841471 +9787516841563 +9787516841662 +9787516841686 +9787516841716 +9787516841778 +9787516841785 +9787516842065 +9787516842133 +9787516842140 +9787516842249 +9787516842355 +9787516842362 +9787516901793 +9787516901809 +9787516901861 +9787516902332 +9787516902547 +9787516902554 +9787516902561 +9787516902622 +9787516902738 +9787516902868 +9787516903438 +9787516903698 +9787516904107 +9787516904732 +9787516905081 +9787516905296 +9787516905302 +9787516905487 +9787516905586 +9787516905593 +9787516905784 +9787516906293 +9787516906309 +9787516906408 +9787516906637 +9787516907320 +9787516907337 +9787516907887 +9787516908105 +9787516908273 +9787516909027 +9787516909508 +9787516909614 +9787516910429 +9787516910443 +9787516910511 +9787516910528 +9787516910535 +9787516910610 +9787516911273 +9787516911402 +9787516912263 +9787516912508 +9787516912515 +9787516912744 +9787516912867 +9787516913000 +9787516913154 +9787516913161 +9787516913291 +9787516913420 +9787516913468 +9787516913482 +9787516913529 +9787516913543 +9787516913550 +9787516913956 +9787516914335 +9787516914342 +9787516914434 +9787516914489 +9787516914502 +9787516914779 +9787516914977 +9787516915097 +9787516915615 +9787516916315 +9787516916346 +9787516916353 +9787516916407 +9787516916438 +9787516916452 +9787516916513 +9787516916650 +9787516916728 +9787516916872 +9787516916964 +9787516917305 +9787516917435 +9787516917442 +9787516917558 +9787516917664 +9787516917688 +9787516918036 +9787516918043 +9787516918333 +9787516918722 +9787516918869 +9787516919002 +9787516919408 +9787516919668 +9787516919705 +9787516919729 +9787516919781 +9787516919828 +9787516919958 +9787516920169 +9787516920299 +9787516920381 +9787516920404 +9787516920428 +9787516920503 +9787516920763 +9787516920824 +9787516921029 +9787516921449 +9787516921784 +9787516921968 +9787516922187 +9787516922392 +9787516922408 +9787516922514 +9787516922729 +9787516922828 +9787516922958 +9787516923061 +9787516923085 +9787516923092 +9787516923313 +9787516923368 +9787516923375 +9787516923382 +9787516923436 +9787516923481 +9787516923641 +9787516923733 +9787516923740 +9787516923757 +9787516923849 +9787516923856 +9787516923887 +9787516924129 +9787516924211 +9787516924372 +9787516924419 +9787516924440 +9787516924457 +9787516924501 +9787516924563 +9787516924570 +9787516924594 +9787516924600 +9787516924716 +9787516924822 +9787516925058 +9787516925096 +9787516925140 +9787516925188 +9787516925195 +9787516925225 +9787516925287 +9787516925348 +9787516925379 +9787516925393 +9787516925409 +9787516925508 +9787516925539 +9787516925577 +9787516925584 +9787516925621 +9787516925645 +9787516925676 +9787516925690 +9787516925737 +9787516925775 +9787516925799 +9787516925805 +9787516925812 +9787516925867 +9787516925874 +9787516925980 +9787516926062 +9787516926116 +9787516926154 +9787516926246 +9787516926277 +9787516926284 +9787516926314 +9787516926345 +9787516926369 +9787516926376 +9787516926383 +9787516926390 +9787516926413 +9787516926536 +9787516926543 +9787516926628 +9787516926642 +9787516926666 +9787516926710 +9787516926772 +9787516926819 +9787516926864 +9787516926970 +9787516927090 +9787516927113 +9787516927120 +9787516927144 +9787516927175 +9787516927182 +9787516927212 +9787516927229 +9787516927236 +9787516927427 +9787516927465 +9787516927687 +9787516927694 +9787516927748 +9787516927762 +9787516927779 +9787516927847 +9787516927861 +9787516927885 +9787516927892 +9787516927908 +9787516927991 +9787516928073 +9787516928233 +9787516928240 +9787516928325 +9787516928332 +9787516928400 +9787516928424 +9787516928448 +9787516928608 +9787516928615 +9787516928646 +9787516928660 +9787516928806 +9787516928882 +9787516929025 +9787516929032 +9787516929063 +9787516929162 +9787516929230 +9787516929278 +9787516929285 +9787516929292 +9787516929339 +9787516929360 +9787516929377 +9787516929391 +9787516929414 +9787516929421 +9787516929452 +9787516929797 +9787516929810 +9787516929896 +9787516929964 +9787516929971 +9787516930021 +9787516930038 +9787516930229 +9787516930298 +9787516962435 +9787517001300 +9787517001607 +9787517002284 +9787517002468 +9787517002512 +9787517002529 +9787517002697 +9787517002970 +9787517003656 +9787517003991 +9787517004622 +9787517004738 +9787517004967 +9787517005063 +9787517005391 +9787517005957 +9787517006527 +9787517007005 +9787517007180 +9787517008279 +9787517008804 +9787517009214 +9787517009665 +9787517009696 +9787517010081 +9787517010401 +9787517010661 +9787517011156 +9787517011804 +9787517012368 +9787517013037 +9787517013211 +9787517013426 +9787517014461 +9787517015185 +9787517016526 +9787517017158 +9787517017271 +9787517018254 +9787517018780 +9787517019626 +9787517020127 +9787517020134 +9787517020172 +9787517021179 +9787517021339 +9787517021926 +9787517023487 +9787517023562 +9787517023838 +9787517024125 +9787517026303 +9787517027638 +9787517027812 +9787517029830 +9787517030034 +9787517030416 +9787517030775 +9787517030874 +9787517031383 +9787517031567 +9787517032601 +9787517033363 +9787517033714 +9787517034735 +9787517036500 +9787517037934 +9787517037941 +9787517038054 +9787517038290 +9787517038719 +9787517039082 +9787517039761 +9787517039938 +9787517041016 +9787517041528 +9787517041559 +9787517041580 +9787517041818 +9787517041863 +9787517042365 +9787517042372 +9787517042846 +9787517043102 +9787517043621 +9787517044307 +9787517045557 +9787517045922 +9787517047322 +9787517047919 +9787517047933 +9787517048633 +9787517049197 +9787517050780 +9787517053736 +9787517054139 +9787517054610 +9787517054757 +9787517055075 +9787517055853 +9787517056683 +9787517057154 +9787517057543 +9787517057581 +9787517058076 +9787517058946 +9787517059950 +9787517060925 +9787517061045 +9787517062066 +9787517062998 +9787517063896 +9787517065432 +9787517065555 +9787517065814 +9787517066330 +9787517066552 +9787517068341 +9787517068730 +9787517068853 +9787517070450 +9787517071020 +9787517071068 +9787517071549 +9787517072850 +9787517073291 +9787517075189 +9787517075493 +9787517075653 +9787517075981 +9787517077084 +9787517077282 +9787517077732 +9787517078319 +9787517078586 +9787517079132 +9787517079767 +9787517080008 +9787517080640 +9787517080879 +9787517081074 +9787517082026 +9787517082040 +9787517084792 +9787517086123 +9787517086642 +9787517087199 +9787517087465 +9787517087496 +9787517087809 +9787517088103 +9787517088417 +9787517090014 +9787517090571 +9787517090854 +9787517091080 +9787517091349 +9787517091370 +9787517091721 +9787517091790 +9787517092308 +9787517092599 +9787517093688 +9787517093879 +9787517093909 +9787517094357 +9787517094432 +9787517094463 +9787517095224 +9787517095712 +9787517096306 +9787517096313 +9787517096436 +9787517096962 +9787517097020 +9787517097686 +9787517097709 +9787517097761 +9787517098003 +9787517098041 +9787517098171 +9787517098430 +9787517098447 +9787517099819 +9787517099956 +9787517100065 +9787517100294 +9787517100546 +9787517100768 +9787517101505 +9787517101710 +9787517101819 +9787517102113 +9787517102809 +9787517102861 +9787517102991 +9787517103295 +9787517103301 +9787517103394 +9787517103707 +9787517103714 +9787517103769 +9787517103875 +9787517104186 +9787517104377 +9787517104414 +9787517104681 +9787517104735 +9787517104759 +9787517104810 +9787517104858 +9787517104964 +9787517105022 +9787517105503 +9787517105695 +9787517105817 +9787517105930 +9787517105947 +9787517106012 +9787517106050 +9787517106081 +9787517106135 +9787517106142 +9787517106258 +9787517106654 +9787517106685 +9787517107699 +9787517108092 +9787517108290 +9787517108313 +9787517108375 +9787517108405 +9787517109211 +9787517109242 +9787517109389 +9787517109471 +9787517109532 +9787517109549 +9787517109686 +9787517109884 +9787517110378 +9787517110422 +9787517110439 +9787517110675 +9787517110712 +9787517110941 +9787517110972 +9787517111023 +9787517111184 +9787517111306 +9787517111658 +9787517111795 +9787517111924 +9787517111986 +9787517112044 +9787517112068 +9787517112167 +9787517113027 +9787517113140 +9787517113157 +9787517113195 +9787517114147 +9787517115090 +9787517116073 +9787517116295 +9787517116325 +9787517116363 +9787517116400 +9787517116691 +9787517117070 +9787517117308 +9787517117445 +9787517117568 +9787517117759 +9787517117964 +9787517118596 +9787517118879 +9787517119272 +9787517119388 +9787517119418 +9787517119654 +9787517120797 +9787517121558 +9787517123200 +9787517124474 +9787517125624 +9787517125778 +9787517128144 +9787517128434 +9787517128694 +9787517129721 +9787517130345 +9787517131274 +9787517132097 +9787517132325 +9787517132875 +9787517132974 +9787517133001 +9787517133063 +9787517133070 +9787517133087 +9787517133285 +9787517133445 +9787517133599 +9787517133988 +9787517134268 +9787517134374 +9787517134435 +9787517134763 +9787517134930 +9787517134992 +9787517135234 +9787517135500 +9787517135807 +9787517136071 +9787517136088 +9787517136187 +9787517136668 +9787517136767 +9787517136859 +9787517137139 +9787517137276 +9787517137351 +9787517138013 +9787517138075 +9787517138433 +9787517139430 +9787517139539 +9787517139744 +9787517139881 +9787517139966 +9787517140030 +9787517140252 +9787517142225 +9787517142447 +9787517142607 +9787517142614 +9787517142744 +9787517142775 +9787517142966 +9787517143024 +9787517143253 +9787517143390 +9787517143444 +9787517144243 +9787517144670 +9787517144922 +9787517145097 +9787517145554 +9787517145646 +9787517145721 +9787517145929 +9787517146483 +9787517146551 +9787517146803 +9787517147008 +9787517147077 +9787517147213 +9787517147299 +9787517147824 +9787517147848 +9787517148357 +9787517148371 +9787517148517 +9787517200079 +9787517200109 +9787517200116 +9787517200178 +9787517200222 +9787517200239 +9787517200284 +9787517200345 +9787517200352 +9787517200383 +9787517200437 +9787517200796 +9787517201083 +9787517201113 +9787517201168 +9787517201564 +9787517201717 +9787517201748 +9787517201960 +9787517202042 +9787517202417 +9787517202448 +9787517202523 +9787517202554 +9787517202578 +9787517203155 +9787517203902 +9787517204510 +9787517206293 +9787517207115 +9787517300113 +9787517300366 +9787517300489 +9787517301134 +9787517400493 +9787517400752 +9787517401117 +9787517401339 +9787517401544 +9787517401650 +9787517401711 +9787517401735 +9787517402039 +9787517402107 +9787517402190 +9787517402237 +9787517402329 +9787517402442 +9787517402466 +9787517402541 +9787517402602 +9787517402640 +9787517402879 +9787517403067 +9787517403074 +9787517403432 +9787517403487 +9787517403524 +9787517403579 +9787517403586 +9787517403685 +9787517403760 +9787517403814 +9787517404255 +9787517404293 +9787517404309 +9787517404392 +9787517404415 +9787517404477 +9787517404514 +9787517404521 +9787517404538 +9787517404675 +9787517404804 +9787517404835 +9787517404842 +9787517404866 +9787517404897 +9787517404989 +9787517405047 +9787517405092 +9787517405184 +9787517405290 +9787517405320 +9787517405375 +9787517405382 +9787517405559 +9787517405573 +9787517405726 +9787517405733 +9787517405924 +9787517406006 +9787517406020 +9787517406112 +9787517406228 +9787517406235 +9787517406303 +9787517406310 +9787517406372 +9787517406471 +9787517406549 +9787517406570 +9787517406624 +9787517406631 +9787517406648 +9787517406655 +9787517406877 +9787517406907 +9787517406914 +9787517406921 +9787517406976 +9787517407003 +9787517407034 +9787517407065 +9787517407133 +9787517407157 +9787517407164 +9787517407171 +9787517407218 +9787517407263 +9787517407331 +9787517407386 +9787517407393 +9787517407423 +9787517407638 +9787517407645 +9787517407669 +9787517407720 +9787517407744 +9787517407782 +9787517407812 +9787517407829 +9787517407843 +9787517407867 +9787517407898 +9787517407935 +9787517408055 +9787517408161 +9787517408178 +9787517408284 +9787517408314 +9787517408369 +9787517408406 +9787517408468 +9787517408611 +9787517408642 +9787517408659 +9787517408703 +9787517408741 +9787517408864 +9787517408871 +9787517408901 +9787517408925 +9787517409229 +9787517409250 +9787517409427 +9787517409458 +9787517409557 +9787517409663 +9787517409687 +9787517409717 +9787517409779 +9787517409854 +9787517409861 +9787517409878 +9787517409908 +9787517409915 +9787517409922 +9787517409946 +9787517409953 +9787517409960 +9787517409991 +9787517410010 +9787517410027 +9787517410102 +9787517410140 +9787517410256 +9787517410379 +9787517410492 +9787517410515 +9787517410522 +9787517410539 +9787517410546 +9787517410560 +9787517410591 +9787517410676 +9787517410683 +9787517410706 +9787517410713 +9787517410744 +9787517410782 +9787517410850 +9787517410874 +9787517410911 +9787517410935 +9787517410997 +9787517411017 +9787517411031 +9787517411062 +9787517411093 +9787517411109 +9787517411215 +9787517411253 +9787517411284 +9787517411314 +9787517411376 +9787517411383 +9787517411390 +9787517411512 +9787517411581 +9787517411598 +9787517411635 +9787517411666 +9787517411673 +9787517411826 +9787517411840 +9787517411871 +9787517411895 +9787517411918 +9787517411949 +9787517412007 +9787517412045 +9787517412083 +9787517412106 +9787517412113 +9787517412229 +9787517412243 +9787517412250 +9787517412489 +9787517412533 +9787517412618 +9787517412700 +9787517412762 +9787517412786 +9787517412793 +9787517412854 +9787517412885 +9787517412892 +9787517412908 +9787517412939 +9787517412984 +9787517412991 +9787517413028 +9787517413073 +9787517413103 +9787517413127 +9787517413141 +9787517413158 +9787517413189 +9787517413196 +9787517413226 +9787517413233 +9787517413240 +9787517413264 +9787517413288 +9787517413318 +9787517413332 +9787517413356 +9787517413363 +9787517413387 +9787517413424 +9787517413462 +9787517413578 +9787517413592 +9787517413691 +9787517413806 +9787517414025 +9787517414131 +9787517414223 +9787517414230 +9787517414261 +9787517414353 +9787517414384 +9787517414414 +9787517414421 +9787517414445 +9787517414469 +9787517500124 +9787517500360 +9787517500629 +9787517501336 +9787517501619 +9787517501725 +9787517503521 +9787517504009 +9787517504016 +9787517504283 +9787517504429 +9787517504498 +9787517504559 +9787517504627 +9787517504641 +9787517504788 +9787517504931 +9787517505167 +9787517505303 +9787517505334 +9787517505495 +9787517505686 +9787517505761 +9787517505815 +9787517506102 +9787517506126 +9787517506300 +9787517506423 +9787517506874 +9787517507109 +9787517507208 +9787517507291 +9787517507321 +9787517507406 +9787517507413 +9787517507451 +9787517507475 +9787517507512 +9787517507536 +9787517507543 +9787517507598 +9787517507611 +9787517507659 +9787517507772 +9787517507789 +9787517507932 +9787517508441 +9787517508656 +9787517508717 +9787517600282 +9787517600435 +9787517600657 +9787517601401 +9787517601579 +9787517602286 +9787517602484 +9787517602712 +9787517604143 +9787517604150 +9787517604365 +9787517604563 +9787517604587 +9787517604945 +9787517605553 +9787517606123 +9787517606604 +9787517606703 +9787517606833 +9787517606888 +9787517606932 +9787517607380 +9787517607526 +9787517607946 +9787517608493 +9787517608691 +9787517608981 +9787517609544 +9787517609650 +9787517609704 +9787517609797 +9787517609995 +9787517610007 +9787517610106 +9787517610120 +9787517610137 +9787517610151 +9787517610205 +9787517610243 +9787517610311 +9787517610335 +9787517610342 +9787517610359 +9787517610366 +9787517610373 +9787517610397 +9787517610403 +9787517610410 +9787517610441 +9787517610496 +9787517610502 +9787517610649 +9787517610656 +9787517610663 +9787517610670 +9787517610687 +9787517610847 +9787517610861 +9787517611066 +9787517611073 +9787517611110 +9787517611196 +9787517611202 +9787517700043 +9787517700296 +9787517700418 +9787517700463 +9787517700678 +9787517700722 +9787517701064 +9787517701170 +9787517701309 +9787517701347 +9787517701453 +9787517701514 +9787517701552 +9787517701637 +9787517701644 +9787517701705 +9787517701743 +9787517702085 +9787517702375 +9787517703013 +9787517703037 +9787517703044 +9787517703075 +9787517703082 +9787517703099 +9787517703181 +9787517703303 +9787517703389 +9787517703501 +9787517703709 +9787517703839 +9787517704522 +9787517705062 +9787517705246 +9787517705260 +9787517706205 +9787517706243 +9787517706533 +9787517706540 +9787517706571 +9787517706649 +9787517707097 +9787517707301 +9787517707387 +9787517707417 +9787517707769 +9787517707806 +9787517708551 +9787517708834 +9787517708919 +9787517709244 +9787517709558 +9787517709589 +9787517709756 +9787517709985 +9787517710080 +9787517710165 +9787517710233 +9787517710240 +9787517710684 +9787517711018 +9787517711025 +9787517711285 +9787517711643 +9787517712039 +9787517712213 +9787517712466 +9787517712640 +9787517712701 +9787517713012 +9787517713043 +9787517713135 +9787517713265 +9787517713319 +9787517713340 +9787517713357 +9787517713456 +9787517713470 +9787517713517 +9787517713654 +9787517713739 +9787517713807 +9787517713814 +9787517713883 +9787517713913 +9787517713920 +9787517713968 +9787517714019 +9787517714040 +9787517714071 +9787517714101 +9787517714163 +9787517714200 +9787517714224 +9787517714316 +9787517714415 +9787517714477 +9787517715078 +9787517800002 +9787517802334 +9787517802358 +9787517803300 +9787517809456 +9787517810643 +9787517810667 +9787517812760 +9787517813811 +9787517814535 +9787517815914 +9787517815921 +9787517816362 +9787517817031 +9787517817185 +9787517817413 +9787517818137 +9787517818144 +9787517819042 +9787517819943 +9787517820499 +9787517820703 +9787517820772 +9787517821571 +9787517821793 +9787517822233 +9787517822967 +9787517822974 +9787517823155 +9787517823506 +9787517823971 +9787517824367 +9787517824381 +9787517824756 +9787517824763 +9787517825845 +9787517826125 +9787517826491 +9787517826613 +9787517826644 +9787517827467 +9787517827931 +9787517828020 +9787517828082 +9787517828457 +9787517828587 +9787517829058 +9787517829157 +9787517829409 +9787517830436 +9787517830504 +9787517830719 +9787517830801 +9787517830856 +9787517830924 +9787517831822 +9787517831907 +9787517831952 +9787517832102 +9787517832553 +9787517833338 +9787517833444 +9787517833833 +9787517834038 +9787517834045 +9787517834106 +9787517834663 +9787517834939 +9787517835127 +9787517835523 +9787517836230 +9787517836599 +9787517837305 +9787517837602 +9787517838135 +9787517838142 +9787517838708 +9787517838722 +9787517838739 +9787517838746 +9787517838784 +9787517839149 +9787517839187 +9787517839224 +9787517840206 +9787517840831 +9787517841197 +9787517841470 +9787517841500 +9787517842316 +9787517842972 +9787517843399 +9787517843955 +9787517844037 +9787517844280 +9787517844488 +9787517844631 +9787517844990 +9787517845119 +9787517845393 +9787517846116 +9787517846253 +9787517846352 +9787517846475 +9787517846499 +9787517846826 +9787517847236 +9787517847472 +9787517847502 +9787517847656 +9787517847946 +9787517847960 +9787517848332 +9787517848349 +9787517848943 +9787517849018 +9787517849490 +9787517849513 +9787517849520 +9787517849568 +9787517850496 +9787517850748 +9787517851387 +9787517851462 +9787517852247 +9787517852728 +9787517853152 +9787517854289 +9787517854401 +9787517854524 +9787517854562 +9787517854593 +9787517854777 +9787517854968 +9787517855002 +9787517855170 +9787517855187 +9787517855378 +9787517855460 +9787517855705 +9787517855927 +9787517856252 +9787517856924 +9787517856955 +9787517857396 +9787517857556 +9787517857648 +9787517857662 +9787517857990 +9787517858010 +9787517858102 +9787517858317 +9787517859253 +9787517859437 +9787517859529 +9787517859864 +9787517860044 +9787517860358 +9787517860402 +9787517860631 +9787517860655 +9787517861379 +9787517861713 +9787517861775 +9787517863786 +9787517864202 +9787517865032 +9787517900412 +9787517901037 +9787517901792 +9787517902065 +9787517902188 +9787517902263 +9787517903260 +9787517903628 +9787517906131 +9787517906650 +9787517907404 +9787517907749 +9787517908043 +9787517908234 +9787517908760 +9787517908821 +9787517908845 +9787517908883 +9787517909323 +9787517909347 +9787517910015 +9787517910183 +9787517910190 +9787517910619 +9787517911012 +9787517911104 +9787517911135 +9787517911319 +9787517911432 +9787517912361 +9787517912422 +9787517912453 +9787517912675 +9787517912866 +9787517912880 +9787517912996 +9787517913283 +9787517913658 +9787517913733 +9787517913740 +9787517913993 +9787517914754 +9787517915461 +9787517915669 +9787518000166 +9787518000210 +9787518000449 +9787518000791 +9787518000814 +9787518001163 +9787518001958 +9787518002009 +9787518002184 +9787518002269 +9787518002351 +9787518002412 +9787518002573 +9787518002795 +9787518003266 +9787518004164 +9787518004171 +9787518004331 +9787518004386 +9787518004430 +9787518004577 +9787518004775 +9787518004805 +9787518004973 +9787518005079 +9787518005208 +9787518005321 +9787518005697 +9787518005826 +9787518005857 +9787518006274 +9787518006373 +9787518007059 +9787518007547 +9787518007608 +9787518007752 +9787518008025 +9787518008186 +9787518008469 +9787518008827 +9787518009923 +9787518010059 +9787518010080 +9787518010189 +9787518010196 +9787518010349 +9787518010516 +9787518010646 +9787518010868 +9787518011018 +9787518011094 +9787518011124 +9787518011186 +9787518011483 +9787518011537 +9787518012015 +9787518012046 +9787518012220 +9787518013296 +9787518013678 +9787518013739 +9787518013883 +9787518014040 +9787518014064 +9787518014071 +9787518014163 +9787518015368 +9787518015429 +9787518017249 +9787518017393 +9787518017492 +9787518017997 +9787518018888 +9787518018987 +9787518019526 +9787518019656 +9787518020300 +9787518020690 +9787518021185 +9787518021451 +9787518021710 +9787518022083 +9787518022250 +9787518022922 +9787518023141 +9787518023325 +9787518023356 +9787518023394 +9787518023950 +9787518024001 +9787518024117 +9787518024810 +9787518024919 +9787518024988 +9787518025589 +9787518025886 +9787518026104 +9787518026562 +9787518027156 +9787518027217 +9787518027545 +9787518027613 +9787518028221 +9787518028559 +9787518029037 +9787518029068 +9787518029211 +9787518029525 +9787518029655 +9787518031283 +9787518031313 +9787518031740 +9787518037599 +9787518039319 +9787518039401 +9787518040735 +9787518040896 +9787518040995 +9787518041169 +9787518041336 +9787518042098 +9787518042524 +9787518043187 +9787518044801 +9787518045280 +9787518045396 +9787518046966 +9787518047475 +9787518047611 +9787518048526 +9787518049677 +9787518050260 +9787518050840 +9787518051465 +9787518051762 +9787518051991 +9787518053803 +9787518053858 +9787518054220 +9787518054978 +9787518055494 +9787518055876 +9787518056941 +9787518057139 +9787518057658 +9787518058730 +9787518058778 +9787518058839 +9787518058846 +9787518061068 +9787518061174 +9787518063918 +9787518064366 +9787518064380 +9787518065219 +9787518065707 +9787518066605 +9787518068258 +9787518071562 +9787518071630 +9787518071654 +9787518071715 +9787518071838 +9787518071913 +9787518073160 +9787518074471 +9787518074990 +9787518075799 +9787518076086 +9787518076741 +9787518077335 +9787518077687 +9787518078035 +9787518078677 +9787518080205 +9787518081059 +9787518081868 +9787518082285 +9787518082445 +9787518082766 +9787518082827 +9787518083305 +9787518083749 +9787518084029 +9787518084418 +9787518084531 +9787518085231 +9787518085385 +9787518085569 +9787518085880 +9787518086245 +9787518086313 +9787518086436 +9787518086955 +9787518087358 +9787518087549 +9787518087921 +9787518087983 +9787518088621 +9787518088683 +9787518089154 +9787518089420 +9787518089628 +9787518089642 +9787518090655 +9787518090778 +9787518090785 +9787518091522 +9787518092031 +9787518093090 +9787518094523 +9787518094943 +9787518095391 +9787518095513 +9787518095698 +9787518095971 +9787518096091 +9787518096329 +9787518096664 +9787518096688 +9787518096718 +9787518096770 +9787518097210 +9787518097524 +9787518098040 +9787518098095 +9787518098507 +9787518099313 +9787518099443 +9787518099856 +9787518100507 +9787518101320 +9787518101603 +9787518102891 +9787518103287 +9787518103737 +9787518103751 +9787518103782 +9787518104093 +9787518104178 +9787518104482 +9787518105007 +9787518105113 +9787518105120 +9787518105205 +9787518105632 +9787518105670 +9787518106943 +9787518107230 +9787518107704 +9787518108657 +9787518200030 +9787518200139 +9787518200337 +9787518200375 +9787518200412 +9787518200450 +9787518200481 +9787518200504 +9787518200559 +9787518200917 +9787518200924 +9787518200962 +9787518200993 +9787518201570 +9787518201846 +9787518202157 +9787518202379 +9787518203727 +9787518204359 +9787518204472 +9787518204618 +9787518204786 +9787518204816 +9787518204885 +9787518205028 +9787518205127 +9787518205196 +9787518205370 +9787518205523 +9787518205677 +9787518206001 +9787518206018 +9787518206865 +9787518206902 +9787518206940 +9787518206964 +9787518207220 +9787518207824 +9787518207848 +9787518209026 +9787518209132 +9787518209217 +9787518209408 +9787518209507 +9787518209682 +9787518209804 +9787518209897 +9787518210411 +9787518210534 +9787518211258 +9787518211494 +9787518211722 +9787518212156 +9787518212262 +9787518212347 +9787518212354 +9787518212576 +9787518213085 +9787518213405 +9787518213511 +9787518213801 +9787518213924 +9787518214112 +9787518214686 +9787518214730 +9787518214884 +9787518214983 +9787518215010 +9787518215027 +9787518215171 +9787518215188 +9787518215249 +9787518215638 +9787518215959 +9787518216383 +9787518216659 +9787518300174 +9787518300310 +9787518300679 +9787518300747 +9787518300846 +9787518300921 +9787518301119 +9787518301201 +9787518301263 +9787518301454 +9787518301461 +9787518301690 +9787518302291 +9787518302604 +9787518302833 +9787518302871 +9787518302918 +9787518302970 +9787518303687 +9787518303717 +9787518303946 +9787518304226 +9787518304554 +9787518304912 +9787518304929 +9787518304936 +9787518304967 +9787518304998 +9787518305025 +9787518305087 +9787518305322 +9787518305476 +9787518305551 +9787518306046 +9787518306367 +9787518307036 +9787518307432 +9787518307463 +9787518307661 +9787518307784 +9787518307982 +9787518308118 +9787518308279 +9787518308705 +9787518308873 +9787518309542 +9787518309702 +9787518310050 +9787518310661 +9787518310883 +9787518311231 +9787518311408 +9787518312191 +9787518312283 +9787518312290 +9787518312382 +9787518312443 +9787518312641 +9787518312795 +9787518312948 +9787518313662 +9787518313853 +9787518313969 +9787518314355 +9787518314522 +9787518315123 +9787518315420 +9787518316083 +9787518316571 +9787518317264 +9787518317288 +9787518317370 +9787518317806 +9787518318049 +9787518318056 +9787518318179 +9787518318186 +9787518318193 +9787518318353 +9787518318629 +9787518319787 +9787518319954 +9787518320066 +9787518320127 +9787518320134 +9787518320332 +9787518320653 +9787518320837 +9787518321704 +9787518322626 +9787518322657 +9787518323449 +9787518323517 +9787518323524 +9787518323593 +9787518323692 +9787518325054 +9787518325146 +9787518325641 +9787518325764 +9787518325863 +9787518326549 +9787518326747 +9787518326778 +9787518327119 +9787518327355 +9787518327539 +9787518328208 +9787518328246 +9787518328321 +9787518328529 +9787518328734 +9787518328857 +9787518329151 +9787518329205 +9787518329618 +9787518329939 +9787518330010 +9787518330089 +9787518330201 +9787518330294 +9787518330362 +9787518330485 +9787518330539 +9787518330669 +9787518331871 +9787518332038 +9787518332076 +9787518332236 +9787518332441 +9787518332564 +9787518332687 +9787518332755 +9787518333080 +9787518333110 +9787518333691 +9787518333714 +9787518333752 +9787518333790 +9787518333929 +9787518334001 +9787518334100 +9787518334308 +9787518334872 +9787518334957 +9787518334971 +9787518335091 +9787518335275 +9787518335404 +9787518335435 +9787518335442 +9787518335510 +9787518335640 +9787518335688 +9787518335732 +9787518335848 +9787518335855 +9787518335893 +9787518336029 +9787518336395 +9787518336456 +9787518336531 +9787518336708 +9787518336760 +9787518336784 +9787518336791 +9787518336890 +9787518337149 +9787518337170 +9787518337194 +9787518337323 +9787518337446 +9787518337484 +9787518337491 +9787518337996 +9787518338139 +9787518338207 +9787518338214 +9787518338283 +9787518338405 +9787518338443 +9787518338474 +9787518338481 +9787518338528 +9787518338689 +9787518338696 +9787518338702 +9787518338719 +9787518338726 +9787518338917 +9787518338955 +9787518339006 +9787518339150 +9787518339204 +9787518339549 +9787518339556 +9787518339563 +9787518340040 +9787518340347 +9787518340538 +9787518340552 +9787518340583 +9787518340866 +9787518340897 +9787518340910 +9787518340927 +9787518340934 +9787518340941 +9787518340965 +9787518341153 +9787518341351 +9787518341405 +9787518341603 +9787518342457 +9787518343485 +9787518343720 +9787518343775 +9787518343973 +9787518344055 +9787518344666 +9787518345243 +9787518345502 +9787518345854 +9787518346073 +9787518346349 +9787518346363 +9787518346561 +9787518346578 +9787518346653 +9787518346790 +9787518346813 +9787518346875 +9787518346943 +9787518347070 +9787518347186 +9787518347407 +9787518347483 +9787518347872 +9787518348084 +9787518348169 +9787518348312 +9787518348374 +9787518348800 +9787518349210 +9787518349302 +9787518349715 +9787518349722 +9787518349739 +9787518349753 +9787518349777 +9787518349784 +9787518349807 +9787518350957 +9787518351411 +9787518351442 +9787518351466 +9787518351664 +9787518351671 +9787518352142 +9787518352586 +9787518352937 +9787518353354 +9787518353477 +9787518353514 +9787518353606 +9787518353699 +9787518353774 +9787518353804 +9787518353873 +9787518354085 +9787518354221 +9787518354252 +9787518354443 +9787518355150 +9787518355471 +9787518355587 +9787518355914 +9787518356041 +9787518356201 +9787518356294 +9787518356379 +9787518357130 +9787518357222 +9787518357239 +9787518357826 +9787518358007 +9787518358359 +9787518358557 +9787518358670 +9787518358717 +9787518358861 +9787518359448 +9787518359608 +9787518359967 +9787518360192 +9787518360307 +9787518360406 +9787518361335 +9787518361427 +9787518361496 +9787518362622 +9787518364862 +9787518365241 +9787518370627 +9787518375189 +9787518400171 +9787518400843 +9787518401093 +9787518401161 +9787518401178 +9787518401185 +9787518401208 +9787518401239 +9787518401338 +9787518401345 +9787518401369 +9787518401376 +9787518401383 +9787518401406 +9787518401413 +9787518401420 +9787518401758 +9787518402007 +9787518402076 +9787518403196 +9787518403219 +9787518403523 +9787518403738 +9787518404537 +9787518405329 +9787518405640 +9787518405763 +9787518405961 +9787518406111 +9787518406456 +9787518406791 +9787518408467 +9787518409259 +9787518409440 +9787518409617 +9787518409662 +9787518409877 +9787518410330 +9787518411108 +9787518411610 +9787518414215 +9787518414239 +9787518414338 +9787518414987 +9787518415373 +9787518415489 +9787518415502 +9787518415649 +9787518416950 +9787518417650 +9787518418237 +9787518418893 +9787518420636 +9787518423118 +9787518423842 +9787518424061 +9787518424498 +9787518424795 +9787518424825 +9787518424986 +9787518425396 +9787518425624 +9787518425754 +9787518426140 +9787518426997 +9787518427475 +9787518427833 +9787518427871 +9787518428960 +9787518429738 +9787518430109 +9787518431335 +9787518432516 +9787518433377 +9787518433810 +9787518434244 +9787518434381 +9787518434770 +9787518434923 +9787518434992 +9787518435258 +9787518435302 +9787518435395 +9787518435562 +9787518435975 +9787518436088 +9787518436293 +9787518436521 +9787518436590 +9787518437627 +9787518437948 +9787518437993 +9787518438006 +9787518438020 +9787518438174 +9787518438327 +9787518438389 +9787518438440 +9787518438495 +9787518439102 +9787518439164 +9787518439379 +9787518439386 +9787518440207 +9787518440832 +9787518440917 +9787518440993 +9787518441419 +9787518441679 +9787518441884 +9787518441938 +9787518441952 +9787518442355 +9787518442362 +9787518443086 +9787518443222 +9787518443314 +9787518443369 +9787518443444 +9787518443505 +9787518443512 +9787518443581 +9787518443598 +9787518443765 +9787518443956 +9787518444069 +9787518444212 +9787518444243 +9787518444281 +9787518444687 +9787518444786 +9787518444922 +9787518444946 +9787518445035 +9787518445134 +9787518445172 +9787518445301 +9787518445370 +9787518445455 +9787518445578 +9787518445615 +9787518445752 +9787518445783 +9787518445813 +9787518445899 +9787518445912 +9787518445967 +9787518445974 +9787518445981 +9787518446018 +9787518446025 +9787518446070 +9787518446193 +9787518446216 +9787518446261 +9787518446353 +9787518446384 +9787518446421 +9787518446438 +9787518446551 +9787518446612 +9787518446636 +9787518446643 +9787518446728 +9787518446766 +9787518446810 +9787518446988 +9787518447039 +9787518447053 +9787518447091 +9787518447428 +9787518447770 +9787518447947 +9787518448159 +9787518448173 +9787518448302 +9787518448388 +9787518448463 +9787518448609 +9787518448654 +9787518448661 +9787518448739 +9787518448937 +9787518449033 +9787518449040 +9787518449095 +9787518449163 +9787518449231 +9787518449286 +9787518449590 +9787518449644 +9787518449729 +9787518449743 +9787518450077 +9787518450190 +9787518450275 +9787518450350 +9787518450466 +9787518450572 +9787518450596 +9787518450671 +9787518450725 +9787518450893 +9787518451272 +9787518451289 +9787518451500 +9787518451579 +9787518451616 +9787518451715 +9787518452392 +9787518452576 +9787518453443 +9787518454396 +9787518455010 +9787518500529 +9787518500772 +9787518600489 +9787518600601 +9787518600717 +9787518600991 +9787518601486 +9787518601677 +9787518601813 +9787518601837 +9787518601851 +9787518601943 +9787518602407 +9787518602650 +9787518602742 +9787518602803 +9787518602810 +9787518602865 +9787518602872 +9787518603923 +9787518604142 +9787518604227 +9787518604258 +9787518604302 +9787518604319 +9787518604678 +9787518604852 +9787518604968 +9787518605385 +9787518605521 +9787518605569 +9787518605620 +9787518605682 +9787518605835 +9787518605873 +9787518606160 +9787518606245 +9787518606276 +9787518606597 +9787518606719 +9787518606764 +9787518606788 +9787518606993 +9787518607198 +9787518607228 +9787518607396 +9787518607983 +9787518608157 +9787518608218 +9787518608317 +9787518608386 +9787518608447 +9787518609185 +9787518609512 +9787518609710 +9787518609994 +9787518610006 +9787518610143 +9787518610167 +9787518610174 +9787518610396 +9787518610679 +9787518610693 +9787518611065 +9787518611430 +9787518611539 +9787518611706 +9787518611935 +9787518612109 +9787518612154 +9787518612215 +9787518612260 +9787518613106 +9787518613120 +9787518613205 +9787518613267 +9787518613632 +9787518614479 +9787518614530 +9787518614660 +9787518614738 +9787518616183 +9787518616275 +9787518616381 +9787518616466 +9787518616534 +9787518616633 +9787518616640 +9787518616664 +9787518616671 +9787518616688 +9787518616749 +9787518616831 +9787518616848 +9787518618057 +9787518618385 +9787518700363 +9787518700523 +9787518700738 +9787518700943 +9787518701001 +9787518701049 +9787518701179 +9787518701780 +9787518702022 +9787518702428 +9787518702435 +9787518702800 +9787518702824 +9787518702831 +9787518703418 +9787518704613 +9787518704712 +9787518704729 +9787518704750 +9787518705160 +9787518705474 +9787518705863 +9787518705917 +9787518706594 +9787518706914 +9787518707195 +9787518707256 +9787518707416 +9787518707461 +9787518707577 +9787518709366 +9787518709687 +9787518710676 +9787518710881 +9787518711017 +9787518711185 +9787518711482 +9787518711819 +9787518712335 +9787518712588 +9787518712601 +9787518712656 +9787518712731 +9787518712748 +9787518712915 +9787518713103 +9787518713318 +9787518713554 +9787518714018 +9787518714278 +9787518714292 +9787518714476 +9787518714490 +9787518714742 +9787518714810 +9787518714834 +9787518715251 +9787518715404 +9787518715435 +9787518715473 +9787518715565 +9787518715862 +9787518716197 +9787518716203 +9787518716210 +9787518716234 +9787518716876 +9787518716920 +9787518717705 +9787518717743 +9787518717804 +9787518717866 +9787518717903 +9787518717927 +9787518717972 +9787518718047 +9787518718054 +9787518719297 +9787518720187 +9787518720217 +9787518720293 +9787518720880 +9787518720897 +9787518720903 +9787518720927 +9787518720941 +9787518721290 +9787518721306 +9787518721344 +9787518721566 +9787518721573 +9787518721740 +9787518722242 +9787518800025 +9787518800056 +9787518800131 +9787518800179 +9787518800193 +9787518800209 +9787518800315 +9787518800360 +9787518800384 +9787518800438 +9787518800469 +9787518800537 +9787518800629 +9787518800681 +9787518800735 +9787518800773 +9787518800827 +9787518800889 +9787518800896 +9787518800933 +9787518800964 +9787518800971 +9787518801008 +9787518801077 +9787518801091 +9787518801169 +9787518801411 +9787518801459 +9787518801466 +9787518801510 +9787518801541 +9787518801589 +9787518801596 +9787518801657 +9787518801718 +9787518801725 +9787518801732 +9787518801794 +9787518801831 +9787518801855 +9787518801862 +9787518801886 +9787518801923 +9787518802050 +9787518802203 +9787518802210 +9787518802241 +9787518802494 +9787518802524 +9787518802579 +9787518802654 +9787518802807 +9787518802937 +9787518803002 +9787518803019 +9787518803064 +9787518803163 +9787518803248 +9787518803262 +9787518803286 +9787518803309 +9787518803491 +9787518803576 +9787518803620 +9787518803750 +9787518803798 +9787518803880 +9787518803910 +9787518804009 +9787518804023 +9787518804054 +9787518804061 +9787518804139 +9787518804320 +9787518804344 +9787518804528 +9787518804559 +9787518804580 +9787518804597 +9787518804658 +9787518804726 +9787518804764 +9787518804771 +9787518804962 +9787518804986 +9787518804993 +9787518805037 +9787518805068 +9787518805150 +9787518805174 +9787518805228 +9787518805310 +9787518805327 +9787518805389 +9787518805525 +9787518805563 +9787518805662 +9787518805679 +9787518805792 +9787518805983 +9787518806027 +9787518806034 +9787518806089 +9787518806232 +9787518806256 +9787518806355 +9787518806362 +9787518806591 +9787518806676 +9787518806706 +9787518806744 +9787518806812 +9787518806829 +9787518806898 +9787518806966 +9787518806980 +9787518807161 +9787518807239 +9787518807321 +9787518807413 +9787518807505 +9787518807512 +9787518807529 +9787518807574 +9787518807581 +9787518807628 +9787518807666 +9787518807826 +9787518807901 +9787518807925 +9787518808038 +9787518808083 +9787518808106 +9787518808137 +9787518808144 +9787518808151 +9787518808274 +9787518808311 +9787518808397 +9787518808502 +9787518808786 +9787518808823 +9787518808939 +9787518808946 +9787518808984 +9787518809219 +9787518809264 +9787518809394 +9787518809448 +9787518809455 +9787518809547 +9787518809707 +9787518809721 +9787518809776 +9787518809899 +9787518810154 +9787518810192 +9787518810420 +9787518810468 +9787518810604 +9787518810956 +9787518810963 +9787518811106 +9787518811113 +9787518811205 +9787518811229 +9787518811335 +9787518811632 +9787518811700 +9787518811755 +9787518811823 +9787518811960 +9787518812035 +9787518812080 +9787518812295 +9787518812752 +9787518812806 +9787518812851 +9787518812868 +9787518812905 +9787518812912 +9787518812950 +9787518812981 +9787518813018 +9787518813094 +9787518813131 +9787518813162 +9787518813209 +9787518813261 +9787518813438 +9787518813452 +9787518813476 +9787518813728 +9787518813827 +9787518813919 +9787518813933 +9787518814039 +9787518814114 +9787518814145 +9787518814152 +9787518814299 +9787518814329 +9787518814770 +9787518814848 +9787518814947 +9787518900022 +9787518900497 +9787518901005 +9787518902347 +9787518905003 +9787518907373 +9787518907489 +9787518907564 +9787518908516 +9787518908707 +9787518909186 +9787518911981 +9787518912315 +9787518913602 +9787518913626 +9787518913848 +9787518915200 +9787518916344 +9787518917464 +9787518918454 +9787518919437 +9787518919444 +9787518920006 +9787518920044 +9787518920068 +9787518920655 +9787518921416 +9787518922352 +9787518923694 +9787518925261 +9787518926503 +9787518926763 +9787518927500 +9787518929092 +9787518929252 +9787518929658 +9787518929856 +9787518930593 +9787518930647 +9787518930944 +9787518931514 +9787518931590 +9787518931675 +9787518932337 +9787518932993 +9787518933495 +9787518933518 +9787518934638 +9787518935727 +9787518935888 +9787518937424 +9787518939152 +9787518940547 +9787518940615 +9787518944392 +9787518944408 +9787518944705 +9787518947355 +9787518947508 +9787518947751 +9787518947935 +9787518949304 +9787518949489 +9787518949892 +9787518950669 +9787518950676 +9787518950843 +9787518952397 +9787518952458 +9787518953066 +9787518953134 +9787518953196 +9787518954780 +9787518955428 +9787518955671 +9787518957279 +9787518958719 +9787518959303 +9787518960064 +9787518960941 +9787518961023 +9787518961221 +9787518961474 +9787518961672 +9787518961719 +9787518961733 +9787518962020 +9787518962341 +9787518963454 +9787518963805 +9787518964079 +9787518964338 +9787518965151 +9787518965199 +9787518965328 +9787518966707 +9787518967940 +9787518968619 +9787518970087 +9787518970155 +9787518970582 +9787518971169 +9787518971251 +9787518971411 +9787518972029 +9787518975464 +9787518975945 +9787518976157 +9787518976454 +9787518976478 +9787518976508 +9787518977321 +9787518978786 +9787518979165 +9787518979783 +9787518980314 +9787518983889 +9787518983919 +9787518984091 +9787518984527 +9787518985159 +9787518985753 +9787518986897 +9787518987252 +9787518987511 +9787518987870 +9787518989041 +9787518989409 +9787518989836 +9787518990788 +9787518991402 +9787518992607 +9787518992782 +9787518993512 +9787518993758 +9787518994137 +9787518994434 +9787518994908 +9787518995080 +9787518995431 +9787518995899 +9787518997558 +9787518998395 +9787518998975 +9787518998999 +9787518999569 +9787519000806 +9787519000974 +9787519001193 +9787519001766 +9787519001810 +9787519002237 +9787519002268 +9787519002275 +9787519002329 +9787519002510 +9787519003920 +9787519004446 +9787519004590 +9787519004835 +9787519005894 +9787519005986 +9787519005993 +9787519006013 +9787519006167 +9787519006433 +9787519007638 +9787519008567 +9787519009267 +9787519009366 +9787519010416 +9787519010706 +9787519010720 +9787519012069 +9787519012304 +9787519012519 +9787519012731 +9787519013134 +9787519013325 +9787519013356 +9787519014186 +9787519014858 +9787519015220 +9787519015633 +9787519015985 +9787519016197 +9787519017477 +9787519019679 +9787519019808 +9787519020293 +9787519020521 +9787519020620 +9787519020842 +9787519020927 +9787519021153 +9787519021351 +9787519021573 +9787519022266 +9787519022532 +9787519023089 +9787519023287 +9787519023300 +9787519023539 +9787519023997 +9787519024871 +9787519024956 +9787519025496 +9787519025618 +9787519025656 +9787519025830 +9787519026073 +9787519026547 +9787519026554 +9787519026608 +9787519026783 +9787519027889 +9787519027902 +9787519028404 +9787519028770 +9787519029098 +9787519029104 +9787519029210 +9787519029265 +9787519029357 +9787519029371 +9787519029470 +9787519029586 +9787519030032 +9787519030063 +9787519030520 +9787519030643 +9787519031329 +9787519031824 +9787519032074 +9787519032265 +9787519033200 +9787519033392 +9787519033774 +9787519033798 +9787519033811 +9787519034252 +9787519034344 +9787519034412 +9787519035853 +9787519036294 +9787519037031 +9787519037154 +9787519037161 +9787519037321 +9787519037468 +9787519037567 +9787519037581 +9787519037628 +9787519037680 +9787519037789 +9787519038038 +9787519038106 +9787519038205 +9787519038229 +9787519038335 +9787519038625 +9787519038779 +9787519039240 +9787519039325 +9787519039608 +9787519039882 +9787519039912 +9787519040024 +9787519040116 +9787519040284 +9787519040406 +9787519040628 +9787519041335 +9787519041656 +9787519041830 +9787519041977 +9787519043148 +9787519043520 +9787519043704 +9787519043759 +9787519044220 +9787519044572 +9787519044985 +9787519045326 +9787519045357 +9787519045401 +9787519046064 +9787519046194 +9787519046873 +9787519047610 +9787519048310 +9787519048617 +9787519048723 +9787519049294 +9787519049317 +9787519049690 +9787519050191 +9787519050382 +9787519050740 +9787519051242 +9787519051266 +9787519051501 +9787519051839 +9787519051990 +9787519052034 +9787519052164 +9787519052188 +9787519052287 +9787519052379 +9787519052423 +9787519052713 +9787519052904 +9787519052935 +9787519053390 +9787519053413 +9787519053468 +9787519053505 +9787519053680 +9787519053819 +9787519053970 +9787519054373 +9787519054502 +9787519054786 +9787519054908 +9787519054953 +9787519055011 +9787519055448 +9787519055455 +9787519056353 +9787519056469 +9787519056704 +9787519056711 +9787519057053 +9787519057206 +9787519057466 +9787519058173 +9787519058180 +9787519058500 +9787519102333 +9787519102623 +9787519102777 +9787519104702 +9787519105433 +9787519106416 +9787519106430 +9787519106447 +9787519107567 +9787519107628 +9787519107789 +9787519108137 +9787519110291 +9787519110383 +9787519110925 +9787519111724 +9787519111847 +9787519112660 +9787519113001 +9787519114800 +9787519115616 +9787519115944 +9787519117528 +9787519117580 +9787519118082 +9787519118396 +9787519118419 +9787519118662 +9787519118679 +9787519118686 +9787519118693 +9787519118716 +9787519118792 +9787519118945 +9787519118969 +9787519119478 +9787519119485 +9787519119683 +9787519120054 +9787519120214 +9787519120238 +9787519120405 +9787519120924 +9787519120955 +9787519121808 +9787519121839 +9787519122126 +9787519122263 +9787519122317 +9787519122683 +9787519122744 +9787519122812 +9787519123062 +9787519123291 +9787519123475 +9787519123543 +9787519123628 +9787519124021 +9787519124137 +9787519124373 +9787519124403 +9787519124915 +9787519125103 +9787519125424 +9787519125820 +9787519126001 +9787519126230 +9787519126254 +9787519126261 +9787519126384 +9787519126605 +9787519126759 +9787519126834 +9787519126957 +9787519126964 +9787519126995 +9787519127190 +9787519127282 +9787519127497 +9787519127732 +9787519128142 +9787519128234 +9787519128326 +9787519128340 +9787519128470 +9787519128487 +9787519128517 +9787519128555 +9787519128562 +9787519128623 +9787519128630 +9787519128692 +9787519128708 +9787519128746 +9787519129385 +9787519129408 +9787519129484 +9787519129545 +9787519129637 +9787519129644 +9787519129668 +9787519129682 +9787519129774 +9787519129804 +9787519129828 +9787519130312 +9787519131043 +9787519131067 +9787519131074 +9787519131609 +9787519131845 +9787519131869 +9787519132170 +9787519132187 +9787519132231 +9787519132293 +9787519132347 +9787519132514 +9787519132774 +9787519132941 +9787519132989 +9787519133863 +9787519133917 +9787519133924 +9787519134334 +9787519134907 +9787519134914 +9787519134952 +9787519135126 +9787519135133 +9787519135140 +9787519135164 +9787519135386 +9787519135423 +9787519135553 +9787519135621 +9787519135652 +9787519135713 +9787519135775 +9787519135935 +9787519136079 +9787519136086 +9787519136239 +9787519136260 +9787519136284 +9787519136338 +9787519136413 +9787519136567 +9787519136758 +9787519136772 +9787519136970 +9787519137434 +9787519137465 +9787519137502 +9787519137571 +9787519137649 +9787519137694 +9787519137953 +9787519137977 +9787519137984 +9787519138202 +9787519138219 +9787519138226 +9787519138288 +9787519138295 +9787519138318 +9787519138417 +9787519138561 +9787519138714 +9787519138752 +9787519138790 +9787519138868 +9787519139001 +9787519139018 +9787519139117 +9787519139254 +9787519139506 +9787519139513 +9787519139780 +9787519140083 +9787519140441 +9787519140458 +9787519140465 +9787519140472 +9787519140526 +9787519140793 +9787519141455 +9787519141479 +9787519141578 +9787519141585 +9787519142049 +9787519143176 +9787519143183 +9787519143497 +9787519143886 +9787519144746 +9787519200046 +9787519201036 +9787519201401 +9787519201432 +9787519201791 +9787519202088 +9787519202569 +9787519202910 +9787519203191 +9787519203306 +9787519203344 +9787519203726 +9787519204280 +9787519204570 +9787519204747 +9787519204969 +9787519205362 +9787519206093 +9787519206123 +9787519206147 +9787519206406 +9787519206543 +9787519206550 +9787519206574 +9787519206581 +9787519206628 +9787519208240 +9787519208370 +9787519208639 +9787519208714 +9787519208738 +9787519208820 +9787519209025 +9787519209209 +9787519209278 +9787519209285 +9787519209520 +9787519209674 +9787519209704 +9787519209711 +9787519209728 +9787519209780 +9787519209827 +9787519209858 +9787519210298 +9787519213749 +9787519213756 +9787519213817 +9787519214067 +9787519214098 +9787519214128 +9787519214814 +9787519214869 +9787519215118 +9787519215552 +9787519215590 +9787519215606 +9787519215941 +9787519216368 +9787519217389 +9787519217723 +9787519217785 +9787519217808 +9787519218157 +9787519218218 +9787519218492 +9787519218621 +9787519218744 +9787519218782 +9787519218805 +9787519218812 +9787519219178 +9787519219673 +9787519219819 +9787519219864 +9787519220617 +9787519220723 +9787519220938 +9787519222116 +9787519222130 +9787519222239 +9787519222246 +9787519222383 +9787519222611 +9787519222642 +9787519223069 +9787519223199 +9787519223328 +9787519223793 +9787519223885 +9787519224011 +9787519224042 +9787519224844 +9787519224943 +9787519225520 +9787519225551 +9787519226169 +9787519226268 +9787519229283 +9787519229504 +9787519233402 +9787519233556 +9787519234270 +9787519234379 +9787519234515 +9787519234546 +9787519234799 +9787519235789 +9787519236144 +9787519236885 +9787519237882 +9787519238155 +9787519238469 +9787519238636 +9787519238643 +9787519238650 +9787519238780 +9787519238834 +9787519238872 +9787519239060 +9787519239084 +9787519239459 +9787519239992 +9787519240448 +9787519241407 +9787519241513 +9787519241544 +9787519241551 +9787519243203 +9787519243524 +9787519244149 +9787519244613 +9787519244989 +9787519245641 +9787519246129 +9787519246389 +9787519246860 +9787519247812 +9787519247850 +9787519248116 +9787519248185 +9787519248222 +9787519248369 +9787519248406 +9787519248758 +9787519249922 +9787519250003 +9787519250201 +9787519250959 +9787519250966 +9787519251031 +9787519251406 +9787519252441 +9787519252953 +9787519253509 +9787519253783 +9787519253868 +9787519254414 +9787519254568 +9787519254889 +9787519255053 +9787519255169 +9787519255619 +9787519256111 +9787519256456 +9787519257026 +9787519257521 +9787519257552 +9787519257682 +9787519258276 +9787519258306 +9787519258597 +9787519258702 +9787519259150 +9787519259181 +9787519259204 +9787519259532 +9787519259952 +9787519260118 +9787519260255 +9787519260835 +9787519261139 +9787519261900 +9787519261979 +9787519261993 +9787519262068 +9787519262501 +9787519262556 +9787519262570 +9787519262983 +9787519264000 +9787519264161 +9787519264697 +9787519264901 +9787519264925 +9787519265427 +9787519266011 +9787519266257 +9787519266301 +9787519266509 +9787519268183 +9787519268374 +9787519268473 +9787519268770 +9787519269371 +9787519270490 +9787519270582 +9787519270995 +9787519271701 +9787519272555 +9787519272708 +9787519272739 +9787519272753 +9787519273354 +9787519273392 +9787519273408 +9787519273415 +9787519273699 +9787519273903 +9787519274092 +9787519274221 +9787519274986 +9787519275235 +9787519275679 +9787519275785 +9787519276096 +9787519276225 +9787519277291 +9787519277314 +9787519277321 +9787519277475 +9787519277864 +9787519277888 +9787519277901 +9787519277918 +9787519278366 +9787519278670 +9787519278861 +9787519278908 +9787519279004 +9787519279349 +9787519279554 +9787519279561 +9787519279677 +9787519279684 +9787519279691 +9787519280307 +9787519280574 +9787519280628 +9787519280826 +9787519281175 +9787519281557 +9787519281977 +9787519281984 +9787519282387 +9787519282530 +9787519282554 +9787519282561 +9787519282622 +9787519283117 +9787519283513 +9787519283537 +9787519283544 +9787519283575 +9787519283636 +9787519283803 +9787519284145 +9787519284282 +9787519284299 +9787519284992 +9787519285029 +9787519285326 +9787519285722 +9787519286132 +9787519286514 +9787519286521 +9787519286545 +9787519286552 +9787519286569 +9787519286576 +9787519287207 +9787519287740 +9787519287894 +9787519288457 +9787519288860 +9787519288976 +9787519289065 +9787519289072 +9787519289089 +9787519289096 +9787519289577 +9787519290375 +9787519291082 +9787519291433 +9787519291662 +9787519293130 +9787519293222 +9787519293598 +9787519294397 +9787519294588 +9787519294861 +9787519294939 +9787519295042 +9787519295264 +9787519295295 +9787519295301 +9787519295318 +9787519295349 +9787519295493 +9787519295646 +9787519295653 +9787519295677 +9787519298715 +9787519298739 +9787519298746 +9787519298821 +9787519298944 +9787519299019 +9787519299026 +9787519299033 +9787519299040 +9787519299057 +9787519299545 +9787519299750 +9787519299835 +9787519299842 +9787519299996 +9787519300357 +9787519301217 +9787519301224 +9787519301712 +9787519302566 +9787519302658 +9787519303211 +9787519303907 +9787519303914 +9787519304218 +9787519304942 +9787519304973 +9787519305291 +9787519305307 +9787519305581 +9787519305901 +9787519306151 +9787519306229 +9787519306656 +9787519307202 +9787519307516 +9787519307608 +9787519307646 +9787519307844 +9787519307899 +9787519307905 +9787519307950 +9787519307967 +9787519308346 +9787519308384 +9787519308452 +9787519308469 +9787519308568 +9787519308612 +9787519308629 +9787519308742 +9787519308766 +9787519308797 +9787519308803 +9787519308810 +9787519308865 +9787519308872 +9787519308926 +9787519308933 +9787519308940 +9787519308957 +9787519308971 +9787519309190 +9787519309244 +9787519309251 +9787519309282 +9787519309381 +9787519309404 +9787519309626 +9787519309657 +9787519309763 +9787519309817 +9787519309855 +9787519309978 +9787519310165 +9787519310240 +9787519310288 +9787519310684 +9787519310714 +9787519310769 +9787519310905 +9787519400170 +9787519401375 +9787519401658 +9787519401849 +9787519401856 +9787519402150 +9787519402204 +9787519402624 +9787519402716 +9787519403102 +9787519403126 +9787519403140 +9787519403867 +9787519403874 +9787519404802 +9787519404840 +9787519405298 +9787519405304 +9787519405328 +9787519405335 +9787519405366 +9787519406172 +9787519406912 +9787519407285 +9787519407995 +9787519408121 +9787519408626 +9787519408855 +9787519409982 +9787519410063 +9787519411305 +9787519411695 +9787519415006 +9787519416089 +9787519416263 +9787519416430 +9787519416829 +9787519417826 +9787519418144 +9787519418274 +9787519419189 +9787519419974 +9787519420529 +9787519420789 +9787519420857 +9787519421861 +9787519422264 +9787519422271 +9787519422509 +9787519422516 +9787519422523 +9787519422530 +9787519422653 +9787519423537 +9787519424626 +9787519424930 +9787519424954 +9787519425043 +9787519426897 +9787519427139 +9787519427528 +9787519428112 +9787519428884 +9787519429171 +9787519430177 +9787519430191 +9787519430702 +9787519431372 +9787519431846 +9787519432461 +9787519434502 +9787519434519 +9787519434533 +9787519434540 +9787519434557 +9787519435080 +9787519435660 +9787519435981 +9787519436056 +9787519436599 +9787519436629 +9787519436773 +9787519437602 +9787519437718 +9787519440015 +9787519440084 +9787519440107 +9787519440701 +9787519441623 +9787519441630 +9787519441883 +9787519441890 +9787519442170 +9787519442194 +9787519442712 +9787519442729 +9787519442736 +9787519442743 +9787519442750 +9787519442767 +9787519443030 +9787519443221 +9787519443979 +9787519444945 +9787519444969 +9787519444976 +9787519445324 +9787519445331 +9787519445423 +9787519445430 +9787519445454 +9787519445560 +9787519446147 +9787519446208 +9787519446734 +9787519447052 +9787519447342 +9787519447458 +9787519447601 +9787519447663 +9787519447847 +9787519447908 +9787519449131 +9787519449216 +9787519449490 +9787519450557 +9787519450656 +9787519450663 +9787519450670 +9787519451233 +9787519451363 +9787519451370 +9787519451424 +9787519451585 +9787519452537 +9787519452896 +9787519452919 +9787519453275 +9787519453473 +9787519453596 +9787519453633 +9787519453787 +9787519454418 +9787519454746 +9787519454876 +9787519455019 +9787519455026 +9787519455033 +9787519455224 +9787519455378 +9787519455439 +9787519455552 +9787519455637 +9787519455859 +9787519456382 +9787519456733 +9787519456795 +9787519457037 +9787519457105 +9787519457143 +9787519457549 +9787519457723 +9787519458034 +9787519458614 +9787519459055 +9787519459901 +9787519460297 +9787519460525 +9787519461140 +9787519461317 +9787519461584 +9787519461591 +9787519461607 +9787519461829 +9787519462147 +9787519462512 +9787519462550 +9787519462680 +9787519462772 +9787519463038 +9787519464370 +9787519464592 +9787519464905 +9787519464912 +9787519465612 +9787519465643 +9787519465797 +9787519465889 +9787519466138 +9787519466725 +9787519467159 +9787519467296 +9787519467586 +9787519467609 +9787519468194 +9787519468316 +9787519468323 +9787519468408 +9787519468460 +9787519468545 +9787519468620 +9787519468866 +9787519469092 +9787519469184 +9787519469320 +9787519469375 +9787519469467 +9787519469573 +9787519469665 +9787519470098 +9787519470166 +9787519470203 +9787519470210 +9787519470920 +9787519470975 +9787519471644 +9787519471798 +9787519471828 +9787519471965 +9787519471989 +9787519472016 +9787519472047 +9787519472191 +9787519472474 +9787519472634 +9787519473228 +9787519473761 +9787519473860 +9787519473877 +9787519473938 +9787519474546 +9787519474638 +9787519474669 +9787519474713 +9787519474751 +9787519474959 +9787519474966 +9787519475000 +9787519475079 +9787519475208 +9787519475550 +9787519475666 +9787519475789 +9787519476083 +9787519476090 +9787519476274 +9787519476281 +9787519476854 +9787519477011 +9787519477059 +9787519477172 +9787519477226 +9787519477288 +9787519477516 +9787519477691 +9787519478018 +9787519478025 +9787519478100 +9787519478117 +9787519478148 +9787519478193 +9787519478209 +9787519478285 +9787519478360 +9787519478377 +9787519478384 +9787519478391 +9787519478407 +9787519478414 +9787519478438 +9787519478704 +9787519478759 +9787519478773 +9787519478872 +9787519479244 +9787519479268 +9787519479305 +9787519479466 +9787519479480 +9787519479572 +9787519479688 +9787519479732 +9787519480349 +9787519480547 +9787519480660 +9787519480752 +9787519480790 +9787519480837 +9787519480899 +9787519480912 +9787519480929 +9787519481032 +9787519481148 +9787519481322 +9787519481339 +9787519481377 +9787519481384 +9787519481506 +9787519482565 +9787519482640 +9787519483135 +9787519483333 +9787519483494 +9787519483739 +9787519483777 +9787519483791 +9787519483807 +9787519483838 +9787519484019 +9787519484255 +9787519484897 +9787519485382 +9787519485436 +9787519485740 +9787519486310 +9787519487485 +9787519489014 +9787519500023 +9787519500177 +9787519500405 +9787519500429 +9787519500672 +9787519500702 +9787519500733 +9787519500757 +9787519500832 +9787519500955 +9787519501433 +9787519501471 +9787519501532 +9787519501815 +9787519501822 +9787519501983 +9787519502058 +9787519502102 +9787519502157 +9787519502188 +9787519502195 +9787519502652 +9787519502836 +9787519502942 +9787519503161 +9787519503352 +9787519503505 +9787519503529 +9787519503550 +9787519503680 +9787519503840 +9787519504151 +9787519504274 +9787519504335 +9787519504502 +9787519504755 +9787519504762 +9787519504786 +9787519504793 +9787519504809 +9787519504830 +9787519505547 +9787519505585 +9787519505592 +9787519505608 +9787519505752 +9787519505813 +9787519505875 +9787519506148 +9787519506377 +9787519506384 +9787519600372 +9787519600471 +9787519600990 +9787519601140 +9787519602178 +9787519602468 +9787519603533 +9787519603557 +9787519604639 +9787519604745 +9787519604844 +9787519604974 +9787519605094 +9787519605605 +9787519605766 +9787519606428 +9787519606671 +9787519607128 +9787519607340 +9787519608170 +9787519608651 +9787519608668 +9787519608842 +9787519609054 +9787519609245 +9787519609856 +9787519610258 +9787519610524 +9787519610760 +9787519611101 +9787519612115 +9787519612122 +9787519612160 +9787519612320 +9787519612436 +9787519613235 +9787519613587 +9787519613754 +9787519613792 +9787519613877 +9787519614089 +9787519614393 +9787519700003 +9787519700911 +9787519701086 +9787519701796 +9787519702090 +9787519702274 +9787519702533 +9787519704520 +9787519705916 +9787519706043 +9787519707118 +9787519707385 +9787519708085 +9787519708313 +9787519709310 +9787519709914 +9787519710101 +9787519710224 +9787519710347 +9787519710507 +9787519710583 +9787519710750 +9787519710897 +9787519711412 +9787519711610 +9787519711641 +9787519711702 +9787519711818 +9787519712211 +9787519713584 +9787519713928 +9787519717018 +9787519717162 +9787519718480 +9787519719425 +9787519719715 +9787519720407 +9787519721695 +9787519721909 +9787519722579 +9787519722661 +9787519722791 +9787519724542 +9787519726164 +9787519729875 +9787519730963 +9787519731410 +9787519732189 +9787519732783 +9787519733445 +9787519733995 +9787519735357 +9787519736415 +9787519736583 +9787519737436 +9787519737481 +9787519737894 +9787519738044 +9787519738075 +9787519738266 +9787519739492 +9787519739799 +9787519739942 +9787519740061 +9787519740252 +9787519740443 +9787519740993 +9787519743734 +9787519743741 +9787519743765 +9787519743772 +9787519743840 +9787519744069 +9787519744571 +9787519744892 +9787519744939 +9787519745714 +9787519745882 +9787519745998 +9787519746193 +9787519746940 +9787519747114 +9787519747244 +9787519747800 +9787519748562 +9787519748661 +9787519748678 +9787519748722 +9787519749675 +9787519749897 +9787519750367 +9787519750534 +9787519750633 +9787519750640 +9787519750763 +9787519750831 +9787519751111 +9787519751166 +9787519751296 +9787519751937 +9787519751975 +9787519752064 +9787519752118 +9787519752385 +9787519752477 +9787519752545 +9787519752903 +9787519753238 +9787519753801 +9787519753955 +9787519753979 +9787519754204 +9787519754259 +9787519754273 +9787519755171 +9787519755249 +9787519755546 +9787519755621 +9787519756451 +9787519756468 +9787519757045 +9787519757502 +9787519757557 +9787519757878 +9787519758165 +9787519758493 +9787519758875 +9787519761448 +9787519762445 +9787519762605 +9787519762681 +9787519762728 +9787519762834 +9787519762995 +9787519763862 +9787519764319 +9787519765118 +9787519765378 +9787519765385 +9787519765613 +9787519765705 +9787519765903 +9787519766184 +9787519766382 +9787519766467 +9787519766764 +9787519766832 +9787519766948 +9787519766955 +9787519767068 +9787519767273 +9787519767297 +9787519767310 +9787519767433 +9787519767440 +9787519767457 +9787519767464 +9787519767587 +9787519767778 +9787519767990 +9787519768140 +9787519768232 +9787519768591 +9787519768638 +9787519769017 +9787519769796 +9787519769826 +9787519769963 +9787519769970 +9787519769987 +9787519770273 +9787519770778 +9787519771256 +9787519771317 +9787519771324 +9787519771768 +9787519772154 +9787519772239 +9787519772376 +9787519772697 +9787519772703 +9787519773106 +9787519773175 +9787519773205 +9787519774110 +9787519774134 +9787519774332 +9787519774394 +9787519774608 +9787519774707 +9787519774806 +9787519774837 +9787519774868 +9787519775070 +9787519775131 +9787519775513 +9787519775612 +9787519775889 +9787519775933 +9787519776152 +9787519776169 +9787519776176 +9787519776404 +9787519777005 +9787519777753 +9787519777821 +9787519778071 +9787519778132 +9787519778453 +9787519778460 +9787519778521 +9787519778606 +9787519778903 +9787519779238 +9787519779245 +9787519779573 +9787519779580 +9787519780340 +9787519780449 +9787519780647 +9787519780920 +9787519780944 +9787519781033 +9787519781057 +9787519781132 +9787519781149 +9787519781187 +9787519781286 +9787519781460 +9787519781484 +9787519781552 +9787519781590 +9787519781606 +9787519781620 +9787519781637 +9787519781804 +9787519781811 +9787519781941 +9787519781989 +9787519782047 +9787519782085 +9787519782153 +9787519782177 +9787519782276 +9787519782351 +9787519782382 +9787519782405 +9787519782504 +9787519782542 +9787519782672 +9787519782719 +9787519782825 +9787519782832 +9787519782870 +9787519782955 +9787519783082 +9787519783341 +9787519783365 +9787519783440 +9787519783648 +9787519783716 +9787519783754 +9787519783761 +9787519784133 +9787519784157 +9787519784195 +9787519784201 +9787519784249 +9787519784454 +9787519784461 +9787519784492 +9787519784799 +9787519784843 +9787519784973 +9787519785178 +9787519785239 +9787519785253 +9787519785352 +9787519785420 +9787519785482 +9787519785574 +9787519785581 +9787519785666 +9787519785673 +9787519785697 +9787519785710 +9787519785765 +9787519785772 +9787519785789 +9787519785796 +9787519785802 +9787519785819 +9787519785932 +9787519785963 +9787519785987 +9787519786076 +9787519786199 +9787519786229 +9787519786236 +9787519786243 +9787519786281 +9787519786328 +9787519786342 +9787519786557 +9787519786564 +9787519786656 +9787519786793 +9787519786830 +9787519786861 +9787519786908 +9787519787080 +9787519787097 +9787519787103 +9787519787288 +9787519787349 +9787519787356 +9787519787400 +9787519787455 +9787519787530 +9787519787547 +9787519787639 +9787519787646 +9787519787776 +9787519787882 +9787519787905 +9787519787912 +9787519787943 +9787519788148 +9787519788162 +9787519788216 +9787519788247 +9787519788261 +9787519788285 +9787519788308 +9787519788322 +9787519788346 +9787519788360 +9787519788384 +9787519788414 +9787519788421 +9787519788438 +9787519788452 +9787519788568 +9787519788773 +9787519788810 +9787519788827 +9787519788841 +9787519788988 +9787519789015 +9787519789046 +9787519789121 +9787519789190 +9787519789206 +9787519789268 +9787519789350 +9787519789497 +9787519789534 +9787519789572 +9787519789619 +9787519789930 +9787519789985 +9787519790172 +9787519790196 +9787519790363 +9787519790431 +9787519790448 +9787519790462 +9787519790516 +9787519790578 +9787519790776 +9787519790783 +9787519790899 +9787519790905 +9787519790929 +9787519790981 +9787519791117 +9787519791186 +9787519791292 +9787519791308 +9787519791353 +9787519791377 +9787519791445 +9787519791551 +9787519791827 +9787519791902 +9787519792022 +9787519792053 +9787519792060 +9787519792138 +9787519792206 +9787519792275 +9787519792299 +9787519792664 +9787519792688 +9787519792879 +9787519793104 +9787519793111 +9787519793135 +9787519793166 +9787519793371 +9787519793388 +9787519793692 +9787519793777 +9787519793838 +9787519793906 +9787519793951 +9787519793982 +9787519794033 +9787519794156 +9787519794194 +9787519794392 +9787519794644 +9787519794699 +9787519794743 +9787519794804 +9787519794828 +9787519795429 +9787519795511 +9787519795740 +9787519795757 +9787519795788 +9787519795801 +9787519795894 +9787519796013 +9787519796235 +9787519796242 +9787519796297 +9787519796365 +9787519796372 +9787519796389 +9787519796396 +9787519796440 +9787519796556 +9787519796563 +9787519796617 +9787519796648 +9787519796655 +9787519796662 +9787519796693 +9787519796808 +9787519796853 +9787519797010 +9787519797072 +9787519797188 +9787519797270 +9787519797355 +9787519797393 +9787519797621 +9787519797638 +9787519797669 +9787519798031 +9787519798093 +9787519798161 +9787519798376 +9787519798420 +9787519798444 +9787519798451 +9787519798482 +9787519798673 +9787519798703 +9787519798741 +9787519798918 +9787519799090 +9787519799243 +9787519799328 +9787519799359 +9787519799458 +9787519799649 +9787519799670 +9787519799731 +9787519799861 +9787519799908 +9787519799939 +9787519799946 +9787519800109 +9787519800543 +9787519800925 +9787519800994 +9787519801786 +9787519802004 +9787519802578 +9787519802639 +9787519803759 +9787519804206 +9787519804800 +9787519805296 +9787519807160 +9787519807313 +9787519807566 +9787519807986 +9787519808310 +9787519808457 +9787519809058 +9787519809126 +9787519809331 +9787519811006 +9787519811051 +9787519811655 +9787519812331 +9787519812591 +9787519812690 +9787519813086 +9787519813734 +9787519815073 +9787519815233 +9787519815554 +9787519816322 +9787519817251 +9787519817381 +9787519817619 +9787519817787 +9787519818173 +9787519818579 +9787519818593 +9787519818814 +9787519819606 +9787519820046 +9787519820688 +9787519821166 +9787519821463 +9787519821517 +9787519822200 +9787519822231 +9787519822910 +9787519823627 +9787519824198 +9787519824389 +9787519824396 +9787519824402 +9787519824808 +9787519824969 +9787519825706 +9787519826659 +9787519826765 +9787519826840 +9787519826901 +9787519826918 +9787519827021 +9787519827175 +9787519827502 +9787519827557 +9787519827564 +9787519827571 +9787519827601 +9787519827687 +9787519827762 +9787519828332 +9787519829001 +9787519829636 +9787519829643 +9787519829667 +9787519830274 +9787519830946 +9787519830977 +9787519831158 +9787519831219 +9787519831417 +9787519831578 +9787519831615 +9787519832490 +9787519833169 +9787519833183 +9787519833251 +9787519833619 +9787519833640 +9787519833688 +9787519833817 +9787519834937 +9787519834944 +9787519835439 +9787519835712 +9787519835880 +9787519835989 +9787519836375 +9787519836955 +9787519837181 +9787519838218 +9787519838287 +9787519838539 +9787519838614 +9787519838690 +9787519838706 +9787519838881 +9787519838911 +9787519839420 +9787519839444 +9787519839536 +9787519839581 +9787519839635 +9787519839895 +9787519840273 +9787519842062 +9787519842659 +9787519842833 +9787519843373 +9787519843397 +9787519843410 +9787519843465 +9787519843847 +9787519844134 +9787519845148 +9787519845186 +9787519845674 +9787519846497 +9787519846503 +9787519846633 +9787519846688 +9787519846916 +9787519847050 +9787519849030 +9787519850227 +9787519850241 +9787519851279 +9787519851606 +9787519851774 +9787519852191 +9787519853051 +9787519853297 +9787519853730 +9787519853914 +9787519854041 +9787519854225 +9787519854560 +9787519854614 +9787519854621 +9787519855024 +9787519855215 +9787519855383 +9787519855567 +9787519855642 +9787519856335 +9787519856762 +9787519856779 +9787519857073 +9787519857134 +9787519858032 +9787519858186 +9787519858193 +9787519858216 +9787519858278 +9787519858629 +9787519858865 +9787519859015 +9787519859206 +9787519859350 +9787519859589 +9787519859770 +9787519859824 +9787519859855 +9787519860233 +9787519860356 +9787519860561 +9787519860622 +9787519860660 +9787519861599 +9787519862497 +9787519863081 +9787519863340 +9787519864200 +9787519864491 +9787519864699 +9787519865672 +9787519866129 +9787519866228 +9787519866341 +9787519867119 +9787519867133 +9787519867232 +9787519867430 +9787519867683 +9787519867935 +9787519868222 +9787519868284 +9787519868468 +9787519868703 +9787519868833 +9787519869168 +9787519869397 +9787519869564 +9787519869670 +9787519869793 +9787519869809 +9787519870065 +9787519870430 +9787519870805 +9787519871185 +9787519871222 +9787519871628 +9787519871819 +9787519871857 +9787519872045 +9787519872106 +9787519872151 +9787519872182 +9787519872229 +9787519872465 +9787519872779 +9787519872793 +9787519872922 +9787519873233 +9787519873271 +9787519874032 +9787519874247 +9787519874476 +9787519874575 +9787519874698 +9787519874841 +9787519874865 +9787519874933 +9787519874964 +9787519875008 +9787519875374 +9787519875442 +9787519876104 +9787519876241 +9787519876302 +9787519876371 +9787519876500 +9787519876814 +9787519876944 +9787519877590 +9787519877651 +9787519877743 +9787519877767 +9787519877804 +9787519877842 +9787519878115 +9787519878122 +9787519878153 +9787519878160 +9787519878184 +9787519878207 +9787519878214 +9787519878245 +9787519878443 +9787519878528 +9787519878672 +9787519878726 +9787519878740 +9787519878757 +9787519878962 +9787519878993 +9787519879075 +9787519879082 +9787519879143 +9787519879884 +9787519879907 +9787519879945 +9787519880088 +9787519880118 +9787519880170 +9787519880330 +9787519880422 +9787519880590 +9787519880620 +9787519880644 +9787519880903 +9787519881405 +9787519881511 +9787519881580 +9787519881719 +9787519881771 +9787519882068 +9787519882082 +9787519882112 +9787519882136 +9787519882228 +9787519882280 +9787519882402 +9787519882631 +9787519882648 +9787519882662 +9787519882686 +9787519882693 +9787519882822 +9787519882884 +9787519882907 +9787519882914 +9787519883065 +9787519883386 +9787519883553 +9787519883560 +9787519883751 +9787519884086 +9787519884451 +9787519884512 +9787519884734 +9787519885076 +9787519885151 +9787519885182 +9787519885229 +9787519885601 +9787519885694 +9787519885793 +9787519886219 +9787519886363 +9787519886981 +9787519887247 +9787519887261 +9787519887483 +9787519887759 +9787519887872 +9787519888589 +9787519888701 +9787519888893 +9787519889098 +9787519889159 +9787519889227 +9787519889241 +9787519889333 +9787519889364 +9787519889418 +9787519889463 +9787519889470 +9787519889494 +9787519889555 +9787519889579 +9787519889678 +9787519889739 +9787519890131 +9787519890315 +9787519891053 +9787519891305 +9787519891657 +9787519892005 +9787519892128 +9787519893064 +9787519893835 +9787519893866 +9787519893934 +9787519893958 +9787519894085 +9787519894771 +9787519894788 +9787519897932 +9787519898816 +9787519900175 +9787519900304 +9787519900328 +9787519900373 +9787519900427 +9787519900670 +9787519900700 +9787519901615 +9787519901769 +9787519901981 +9787519902001 +9787519902018 +9787519902186 +9787519902629 +9787519902667 +9787519902698 +9787519902797 +9787519903237 +9787519903268 +9787519903282 +9787519903633 +9787519904333 +9787519904357 +9787519904432 +9787519904715 +9787519905057 +9787519905354 +9787519905446 +9787519905705 +9787519906375 +9787519906382 +9787519906504 +9787519906603 +9787519906634 +9787519907488 +9787519907563 +9787519907570 +9787519907709 +9787519908171 +9787519908386 +9787519908867 +9787519908980 +9787519909345 +9787519909376 +9787519909567 +9787519910112 +9787519910372 +9787519910389 +9787519910556 +9787519910617 +9787519910822 +9787519910884 +9787519911096 +9787519911508 +9787519911713 +9787519911829 +9787519911843 +9787519911867 +9787519912048 +9787519912376 +9787519913038 +9787519913465 +9787519913557 +9787519913564 +9787519913601 +9787519913632 +9787519913724 +9787519913731 +9787519913755 +9787519913762 +9787519913885 +9787519913908 +9787519914387 +9787519914622 +9787519914691 +9787519914813 +9787519914837 +9787519914868 +9787519914882 +9787519914929 +9787519914936 +9787519915131 +9787519915186 +9787519915322 +9787519915469 +9787519915483 +9787519915551 +9787519915605 +9787519915643 +9787519915735 +9787519915810 +9787519915865 +9787519915988 +9787519916008 +9787519916060 +9787519916077 +9787519916183 +9787519916190 +9787519916213 +9787519916305 +9787519916459 +9787519916497 +9787519916527 +9787519916640 +9787519916794 +9787519916916 +9787519916930 +9787519916961 +9787519916992 +9787519917241 +9787519917258 +9787519917265 +9787519917364 +9787519918422 +9787519918682 +9787519918835 +9787519918873 +9787520000369 +9787520000772 +9787520000789 +9787520000802 +9787520000932 +9787520000949 +9787520001434 +9787520001441 +9787520001625 +9787520002172 +9787520002295 +9787520002615 +9787520004534 +9787520004817 +9787520005265 +9787520005296 +9787520005418 +9787520005517 +9787520005845 +9787520005951 +9787520005999 +9787520007733 +9787520008303 +9787520008358 +9787520008389 +9787520008402 +9787520008556 +9787520008563 +9787520008594 +9787520009362 +9787520009836 +9787520009843 +9787520009850 +9787520011112 +9787520013765 +9787520100007 +9787520100335 +9787520100625 +9787520100694 +9787520100854 +9787520101295 +9787520101592 +9787520101837 +9787520102025 +9787520102193 +9787520102490 +9787520102926 +9787520103800 +9787520104678 +9787520104807 +9787520104890 +9787520105545 +9787520106115 +9787520107082 +9787520107389 +9787520107945 +9787520108126 +9787520108393 +9787520109253 +9787520109277 +9787520109864 +9787520109918 +9787520110112 +9787520110297 +9787520110846 +9787520111058 +9787520111102 +9787520111324 +9787520111492 +9787520111973 +9787520112222 +9787520112277 +9787520112376 +9787520112666 +9787520113045 +9787520113519 +9787520113564 +9787520114080 +9787520114479 +9787520114622 +9787520114981 +9787520115728 +9787520116350 +9787520116404 +9787520117043 +9787520117142 +9787520117388 +9787520117951 +9787520118330 +9787520118514 +9787520119115 +9787520119580 +9787520119719 +9787520120210 +9787520120371 +9787520120616 +9787520121057 +9787520121064 +9787520121446 +9787520122054 +9787520122115 +9787520122481 +9787520122528 +9787520122573 +9787520122603 +9787520122672 +9787520122962 +9787520123051 +9787520123259 +9787520123433 +9787520123488 +9787520123747 +9787520123983 +9787520124119 +9787520124164 +9787520124287 +9787520124980 +9787520125031 +9787520125451 +9787520126052 +9787520126069 +9787520126519 +9787520126762 +9787520127370 +9787520127394 +9787520127462 +9787520127899 +9787520127974 +9787520128261 +9787520128438 +9787520128452 +9787520129046 +9787520129299 +9787520129398 +9787520129534 +9787520129794 +9787520130400 +9787520130585 +9787520131032 +9787520131308 +9787520131414 +9787520131575 +9787520131582 +9787520131797 +9787520131810 +9787520132329 +9787520132404 +9787520132992 +9787520133012 +9787520133142 +9787520133531 +9787520133852 +9787520134545 +9787520134989 +9787520135108 +9787520135306 +9787520135610 +9787520135702 +9787520135818 +9787520136037 +9787520136495 +9787520136761 +9787520136792 +9787520136853 +9787520136860 +9787520137539 +9787520137775 +9787520138802 +9787520139595 +9787520140676 +9787520140959 +9787520141086 +9787520141130 +9787520141697 +9787520141765 +9787520142441 +9787520142823 +9787520143028 +9787520143448 +9787520144322 +9787520144582 +9787520144919 +9787520144926 +9787520144971 +9787520144995 +9787520145169 +9787520145251 +9787520145312 +9787520145350 +9787520146098 +9787520146166 +9787520146234 +9787520146661 +9787520146883 +9787520146937 +9787520147286 +9787520147422 +9787520147569 +9787520147668 +9787520147705 +9787520148016 +9787520148023 +9787520148344 +9787520148962 +9787520149310 +9787520149532 +9787520149969 +9787520150767 +9787520150927 +9787520150989 +9787520151313 +9787520151504 +9787520151924 +9787520152259 +9787520152310 +9787520152860 +9787520153119 +9787520153171 +9787520153188 +9787520153713 +9787520153775 +9787520153898 +9787520153904 +9787520154017 +9787520154468 +9787520154734 +9787520154741 +9787520155465 +9787520155663 +9787520155847 +9787520156011 +9787520156103 +9787520156264 +9787520157063 +9787520157117 +9787520158084 +9787520158152 +9787520158503 +9787520158787 +9787520159289 +9787520159470 +9787520159500 +9787520159517 +9787520160575 +9787520160636 +9787520160674 +9787520160728 +9787520160933 +9787520161084 +9787520161114 +9787520161138 +9787520161589 +9787520161794 +9787520161923 +9787520162005 +9787520162043 +9787520162388 +9787520162531 +9787520162623 +9787520162661 +9787520163064 +9787520163217 +9787520163507 +9787520163637 +9787520164177 +9787520164399 +9787520164528 +9787520165075 +9787520165211 +9787520165419 +9787520165846 +9787520165976 +9787520165983 +9787520165990 +9787520166003 +9787520167048 +9787520167376 +9787520167475 +9787520167550 +9787520167901 +9787520168205 +9787520168458 +9787520168540 +9787520168564 +9787520168762 +9787520168809 +9787520168991 +9787520169035 +9787520169073 +9787520169103 +9787520169325 +9787520169356 +9787520169875 +9787520170321 +9787520171007 +9787520171281 +9787520171311 +9787520172035 +9787520172073 +9787520172097 +9787520172219 +9787520172660 +9787520172677 +9787520172820 +9787520173339 +9787520173476 +9787520173919 +9787520174183 +9787520174237 +9787520174855 +9787520175265 +9787520175616 +9787520175920 +9787520176507 +9787520176682 +9787520177276 +9787520178631 +9787520178884 +9787520179164 +9787520179195 +9787520179201 +9787520179478 +9787520179676 +9787520180061 +9787520180078 +9787520180238 +9787520181198 +9787520181334 +9787520181556 +9787520181587 +9787520181631 +9787520182638 +9787520182966 +9787520183376 +9787520183543 +9787520183970 +9787520184076 +9787520184564 +9787520184618 +9787520184632 +9787520184755 +9787520184786 +9787520184984 +9787520185455 +9787520185868 +9787520186346 +9787520186681 +9787520187701 +9787520188128 +9787520188180 +9787520188197 +9787520188319 +9787520188333 +9787520188951 +9787520189392 +9787520189491 +9787520190091 +9787520190343 +9787520190473 +9787520190503 +9787520190633 +9787520190688 +9787520190732 +9787520190978 +9787520191005 +9787520191166 +9787520191203 +9787520191470 +9787520191500 +9787520191654 +9787520191791 +9787520191937 +9787520192057 +9787520192354 +9787520192668 +9787520193009 +9787520193115 +9787520193474 +9787520193511 +9787520193719 +9787520194013 +9787520194501 +9787520194594 +9787520194716 +9787520194907 +9787520195072 +9787520195201 +9787520195645 +9787520195843 +9787520196109 +9787520196116 +9787520196130 +9787520196215 +9787520196604 +9787520197588 +9787520198066 +9787520198158 +9787520198189 +9787520198332 +9787520198417 +9787520198752 +9787520199186 +9787520199193 +9787520199391 +9787520199513 +9787520199520 +9787520199728 +9787520200004 +9787520200318 +9787520200363 +9787520200417 +9787520200431 +9787520200646 +9787520200653 +9787520200738 +9787520200769 +9787520200929 +9787520200974 +9787520201025 +9787520201209 +9787520201650 +9787520201889 +9787520201988 +9787520202060 +9787520202329 +9787520202367 +9787520202428 +9787520202442 +9787520202510 +9787520202527 +9787520202534 +9787520202619 +9787520202633 +9787520202749 +9787520203036 +9787520203043 +9787520203098 +9787520203135 +9787520203289 +9787520203432 +9787520203531 +9787520203715 +9787520204019 +9787520204088 +9787520204828 +9787520204835 +9787520204903 +9787520205146 +9787520205214 +9787520205658 +9787520205689 +9787520206334 +9787520206365 +9787520206556 +9787520206655 +9787520206693 +9787520207003 +9787520207027 +9787520207041 +9787520207065 +9787520207249 +9787520207317 +9787520207324 +9787520207348 +9787520207621 +9787520207652 +9787520207683 +9787520207850 +9787520207874 +9787520207935 +9787520207980 +9787520208024 +9787520208192 +9787520208307 +9787520209069 +9787520209090 +9787520209236 +9787520209526 +9787520209687 +9787520209717 +9787520209724 +9787520209755 +9787520210058 +9787520210126 +9787520210171 +9787520210256 +9787520211130 +9787520211642 +9787520211741 +9787520211772 +9787520211925 +9787520212229 +9787520212236 +9787520212533 +9787520212656 +9787520213103 +9787520213127 +9787520213226 +9787520213240 +9787520213264 +9787520213288 +9787520213295 +9787520213356 +9787520213455 +9787520213462 +9787520213486 +9787520213561 +9787520213608 +9787520213677 +9787520213868 +9787520214056 +9787520214063 +9787520214070 +9787520214117 +9787520214155 +9787520214186 +9787520214230 +9787520214292 +9787520214322 +9787520214360 +9787520214483 +9787520214605 +9787520214681 +9787520214810 +9787520214827 +9787520214926 +9787520214933 +9787520214988 +9787520215022 +9787520215091 +9787520215114 +9787520215121 +9787520215213 +9787520215510 +9787520215756 +9787520215763 +9787520215800 +9787520215855 +9787520215909 +9787520216203 +9787520216210 +9787520216265 +9787520216371 +9787520216388 +9787520217231 +9787520217729 +9787520217897 +9787520218504 +9787520218931 +9787520300056 +9787520300100 +9787520300179 +9787520300209 +9787520300667 +9787520301138 +9787520301336 +9787520301633 +9787520301770 +9787520301817 +9787520301886 +9787520302074 +9787520302210 +9787520302302 +9787520302531 +9787520302913 +9787520303163 +9787520303354 +9787520303965 +9787520304047 +9787520304191 +9787520304436 +9787520305266 +9787520305853 +9787520305938 +9787520306140 +9787520306300 +9787520306553 +9787520306805 +9787520306942 +9787520307154 +9787520307376 +9787520307468 +9787520308373 +9787520308892 +9787520308960 +9787520309875 +9787520309967 +9787520309981 +9787520310239 +9787520310420 +9787520310635 +9787520310741 +9787520310765 +9787520311021 +9787520311243 +9787520311380 +9787520311434 +9787520311519 +9787520311779 +9787520311830 +9787520311946 +9787520311960 +9787520312295 +9787520312325 +9787520313261 +9787520313414 +9787520313445 +9787520313889 +9787520314510 +9787520315906 +9787520315944 +9787520316361 +9787520316446 +9787520316774 +9787520318068 +9787520318150 +9787520318419 +9787520318426 +9787520318532 +9787520318846 +9787520319645 +9787520320214 +9787520320375 +9787520320535 +9787520320900 +9787520321266 +9787520321358 +9787520321549 +9787520321723 +9787520321877 +9787520321945 +9787520322584 +9787520322607 +9787520322614 +9787520322621 +9787520322799 +9787520323154 +9787520323215 +9787520323239 +9787520323291 +9787520323406 +9787520324212 +9787520324571 +9787520324731 +9787520324939 +9787520324984 +9787520325240 +9787520325509 +9787520325554 +9787520325721 +9787520325974 +9787520326421 +9787520326636 +9787520326957 +9787520327008 +9787520327053 +9787520327435 +9787520327589 +9787520327725 +9787520327909 +9787520328265 +9787520328517 +9787520328913 +9787520329231 +9787520329262 +9787520329798 +9787520330039 +9787520330176 +9787520330282 +9787520330510 +9787520330541 +9787520330619 +9787520330978 +9787520331166 +9787520331180 +9787520331463 +9787520331562 +9787520331685 +9787520332125 +9787520332149 +9787520332781 +9787520332828 +9787520333023 +9787520334242 +9787520334693 +9787520334808 +9787520335096 +9787520335133 +9787520335386 +9787520335515 +9787520335614 +9787520335669 +9787520335737 +9787520335775 +9787520335812 +9787520336185 +9787520336192 +9787520336536 +9787520336598 +9787520336666 +9787520336680 +9787520337069 +9787520337335 +9787520337427 +9787520337441 +9787520337984 +9787520338196 +9787520338400 +9787520338974 +9787520339179 +9787520339230 +9787520339322 +9787520339346 +9787520339810 +9787520339940 +9787520340267 +9787520340298 +9787520340328 +9787520340342 +9787520340359 +9787520340533 +9787520340922 +9787520342742 +9787520342834 +9787520342971 +9787520343046 +9787520343060 +9787520343183 +9787520343787 +9787520343855 +9787520343961 +9787520344234 +9787520344630 +9787520344739 +9787520345156 +9787520345446 +9787520345668 +9787520345743 +9787520345910 +9787520345927 +9787520346054 +9787520346245 +9787520346382 +9787520346948 +9787520347631 +9787520348225 +9787520348249 +9787520348355 +9787520349178 +9787520349291 +9787520349307 +9787520349352 +9787520349543 +9787520349789 +9787520349796 +9787520350242 +9787520350259 +9787520350297 +9787520350860 +9787520351195 +9787520351294 +9787520351423 +9787520352567 +9787520352598 +9787520352758 +9787520352888 +9787520353335 +9787520353793 +9787520353847 +9787520353854 +9787520354899 +9787520355674 +9787520356145 +9787520356251 +9787520356916 +9787520357197 +9787520357210 +9787520357258 +9787520358323 +9787520358491 +9787520358552 +9787520358774 +9787520358859 +9787520358910 +9787520359184 +9787520359245 +9787520359634 +9787520359764 +9787520359832 +9787520360142 +9787520360401 +9787520360463 +9787520360975 +9787520361040 +9787520361132 +9787520361187 +9787520361255 +9787520361590 +9787520361897 +9787520362641 +9787520362665 +9787520362689 +9787520362917 +9787520362924 +9787520363297 +9787520363648 +9787520363747 +9787520363860 +9787520364140 +9787520364973 +9787520365017 +9787520365178 +9787520365321 +9787520365512 +9787520365772 +9787520365871 +9787520365932 +9787520365949 +9787520366038 +9787520366069 +9787520366328 +9787520366366 +9787520366465 +9787520366601 +9787520366700 +9787520367028 +9787520367080 +9787520367219 +9787520367417 +9787520367509 +9787520367905 +9787520367967 +9787520368155 +9787520368339 +9787520368445 +9787520368551 +9787520368759 +9787520368810 +9787520368902 +9787520369220 +9787520369398 +9787520369442 +9787520369923 +9787520370110 +9787520370189 +9787520370233 +9787520370707 +9787520370967 +9787520371001 +9787520371292 +9787520371520 +9787520371797 +9787520371902 +9787520371971 +9787520372060 +9787520372176 +9787520372220 +9787520372350 +9787520372817 +9787520372824 +9787520373005 +9787520373364 +9787520373647 +9787520375900 +9787520376051 +9787520376198 +9787520376990 +9787520377553 +9787520377959 +9787520377966 +9787520378178 +9787520378260 +9787520378352 +9787520378376 +9787520378550 +9787520378567 +9787520378888 +9787520379236 +9787520379762 +9787520380157 +9787520380171 +9787520380317 +9787520380577 +9787520380713 +9787520381048 +9787520381406 +9787520381444 +9787520381611 +9787520381727 +9787520381970 +9787520382571 +9787520382854 +9787520382878 +9787520382984 +9787520383103 +9787520383561 +9787520383653 +9787520383813 +9787520384247 +9787520384834 +9787520385046 +9787520385053 +9787520385817 +9787520386746 +9787520386845 +9787520387019 +9787520387156 +9787520387361 +9787520387385 +9787520387439 +9787520387880 +9787520388054 +9787520388115 +9787520388191 +9787520388979 +9787520389228 +9787520389402 +9787520389594 +9787520389747 +9787520389884 +9787520390088 +9787520390293 +9787520390385 +9787520391115 +9787520391160 +9787520391320 +9787520391849 +9787520392709 +9787520393355 +9787520393515 +9787520393553 +9787520393560 +9787520393638 +9787520393959 +9787520394673 +9787520394697 +9787520395052 +9787520395434 +9787520395861 +9787520396158 +9787520396325 +9787520396660 +9787520397544 +9787520397582 +9787520398350 +9787520398596 +9787520398794 +9787520399388 +9787520399555 +9787520399999 +9787520400183 +9787520401647 +9787520401654 +9787520401685 +9787520405874 +9787520406291 +9787520406307 +9787520406772 +9787520406819 +9787520406918 +9787520407168 +9787520407243 +9787520407687 +9787520408264 +9787520408790 +9787520408882 +9787520409117 +9787520409209 +9787520409681 +9787520410403 +9787520411158 +9787520411394 +9787520411752 +9787520412469 +9787520412629 +9787520412650 +9787520412766 +9787520412797 +9787520412896 +9787520412919 +9787520413305 +9787520413862 +9787520414081 +9787520414494 +9787520414579 +9787520414876 +9787520414883 +9787520414890 +9787520414982 +9787520415071 +9787520415262 +9787520415958 +9787520416047 +9787520416511 +9787520417228 +9787520417259 +9787520417327 +9787520417600 +9787520417617 +9787520417655 +9787520417709 +9787520417853 +9787520419093 +9787520419284 +9787520419970 +9787520420051 +9787520420341 +9787520420655 +9787520420983 +9787520421614 +9787520421928 +9787520422123 +9787520422130 +9787520422222 +9787520422246 +9787520422420 +9787520422550 +9787520422642 +9787520422765 +9787520422970 +9787520422994 +9787520423038 +9787520423281 +9787520423298 +9787520423724 +9787520423731 +9787520423755 +9787520423908 +9787520423946 +9787520424745 +9787520424752 +9787520424929 +9787520425766 +9787520426206 +9787520426251 +9787520426268 +9787520426282 +9787520426350 +9787520426404 +9787520426671 +9787520426794 +9787520426800 +9787520427012 +9787520427111 +9787520427227 +9787520427449 +9787520427838 +9787520427845 +9787520427869 +9787520427975 +9787520427982 +9787520428026 +9787520428149 +9787520428385 +9787520429085 +9787520429092 +9787520429252 +9787520429702 +9787520430074 +9787520431224 +9787520431293 +9787520431699 +9787520432184 +9787520432306 +9787520432658 +9787520432818 +9787520432825 +9787520434157 +9787520434195 +9787520434324 +9787520434348 +9787520434461 +9787520434638 +9787520434669 +9787520434706 +9787520434713 +9787520434744 +9787520434751 +9787520434768 +9787520434775 +9787520434812 +9787520434836 +9787520434898 +9787520434904 +9787520435369 +9787520435475 +9787520435482 +9787520435499 +9787520435802 +9787520435840 +9787520435888 +9787520436830 +9787520436885 +9787520436892 +9787520436953 +9787520437394 +9787520437660 +9787520439121 +9787520439343 +9787520439404 +9787520440110 +9787520440233 +9787520440479 +9787520440653 +9787520441032 +9787520442923 +9787520443661 +9787520444040 +9787520444682 +9787520444712 +9787520444743 +9787520444750 +9787520444781 +9787520444804 +9787520444842 +9787520444859 +9787520444866 +9787520444903 +9787520444934 +9787520444989 +9787520445023 +9787520445207 +9787520445214 +9787520445290 +9787520445344 +9787520445351 +9787520445368 +9787520445375 +9787520445382 +9787520445399 +9787520445405 +9787520445412 +9787520445436 +9787520445443 +9787520445474 +9787520445498 +9787520445535 +9787520445597 +9787520445726 +9787520445863 +9787520445979 +9787520446914 +9787520447454 +9787520448260 +9787520449496 +9787520449977 +9787520450195 +9787520501484 +9787520501910 +9787520502368 +9787520503730 +9787520504027 +9787520504720 +9787520504775 +9787520504805 +9787520505130 +9787520505321 +9787520506045 +9787520506076 +9787520506328 +9787520507011 +9787520507295 +9787520507394 +9787520507400 +9787520510387 +9787520512114 +9787520512893 +9787520513098 +9787520513258 +9787520513425 +9787520513562 +9787520514941 +9787520515306 +9787520515368 +9787520515801 +9787520516884 +9787520516976 +9787520518147 +9787520518338 +9787520520072 +9787520520492 +9787520520676 +9787520520898 +9787520521154 +9787520521727 +9787520522410 +9787520522779 +9787520523134 +9787520523387 +9787520523400 +9787520524773 +9787520525220 +9787520525602 +9787520526647 +9787520526678 +9787520526722 +9787520526807 +9787520527033 +9787520527217 +9787520527293 +9787520527460 +9787520527606 +9787520528320 +9787520528603 +9787520528801 +9787520529495 +9787520530194 +9787520530460 +9787520531009 +9787520531085 +9787520531252 +9787520531375 +9787520531443 +9787520531450 +9787520531535 +9787520532266 +9787520532341 +9787520532396 +9787520532808 +9787520533027 +9787520533058 +9787520533782 +9787520533928 +9787520534161 +9787520534352 +9787520534437 +9787520534901 +9787520535458 +9787520535526 +9787520536189 +9787520536615 +9787520536745 +9787520536844 +9787520537216 +9787520537230 +9787520537667 +9787520537766 +9787520538039 +9787520538312 +9787520538527 +9787520538572 +9787520539180 +9787520539968 +9787520540186 +9787520540483 +9787520540599 +9787520540810 +9787520541077 +9787520541114 +9787520541121 +9787520541312 +9787520541336 +9787520541343 +9787520541404 +9787520541473 +9787520541480 +9787520541497 +9787520541534 +9787520541664 +9787520541701 +9787520541831 +9787520542067 +9787520542166 +9787520542333 +9787520542364 +9787520542418 +9787520542432 +9787520542661 +9787520542715 +9787520542814 +9787520542944 +9787520543002 +9787520543019 +9787520543095 +9787520543156 +9787520543613 +9787520543798 +9787520543927 +9787520543934 +9787520543972 +9787520544191 +9787520544214 +9787520544429 +9787520545082 +9787520545181 +9787520545211 +9787520545242 +9787520545778 +9787520545785 +9787520545853 +9787520545990 +9787520546225 +9787520546607 +9787520546690 +9787520546805 +9787520547031 +9787520547055 +9787520547062 +9787520547086 +9787520547338 +9787520547468 +9787520547505 +9787520547611 +9787520547659 +9787520547710 +9787520547826 +9787520549431 +9787520549561 +9787520549790 +9787520550284 +9787520550765 +9787520550871 +9787520551038 +9787520551854 +9787520600859 +9787520600972 +9787520601054 +9787520601429 +9787520601498 +9787520601528 +9787520601559 +9787520602013 +9787520602860 +9787520700245 +9787520700450 +9787520700498 +9787520700757 +9787520701273 +9787520701648 +9787520701655 +9787520701679 +9787520701792 +9787520702249 +9787520703208 +9787520703277 +9787520703802 +9787520704038 +9787520704663 +9787520704953 +9787520704984 +9787520705097 +9787520705462 +9787520705714 +9787520705844 +9787520705851 +9787520706414 +9787520706735 +9787520706988 +9787520707053 +9787520707077 +9787520707213 +9787520707220 +9787520707237 +9787520707244 +9787520707473 +9787520707602 +9787520707619 +9787520707749 +9787520708135 +9787520708968 +9787520709309 +9787520709484 +9787520709521 +9787520709545 +9787520709569 +9787520709729 +9787520710107 +9787520710114 +9787520710145 +9787520710206 +9787520710220 +9787520710527 +9787520710589 +9787520710640 +9787520710749 +9787520710800 +9787520711371 +9787520711760 +9787520711838 +9787520711869 +9787520711944 +9787520711999 +9787520712309 +9787520712590 +9787520712606 +9787520712750 +9787520712804 +9787520712835 +9787520712859 +9787520713467 +9787520713771 +9787520714181 +9787520714198 +9787520714297 +9787520714396 +9787520714426 +9787520714495 +9787520714808 +9787520714921 +9787520714938 +9787520714952 +9787520714976 +9787520715003 +9787520715065 +9787520715072 +9787520715140 +9787520715256 +9787520715324 +9787520715782 +9787520715812 +9787520715843 +9787520715850 +9787520715935 +9787520715942 +9787520716031 +9787520716055 +9787520716376 +9787520716406 +9787520716468 +9787520716697 +9787520716833 +9787520717038 +9787520717045 +9787520717052 +9787520717069 +9787520717106 +9787520717298 +9787520717304 +9787520717359 +9787520717373 +9787520717380 +9787520717397 +9787520717519 +9787520717557 +9787520717601 +9787520717656 +9787520717793 +9787520717878 +9787520718257 +9787520718530 +9787520718769 +9787520719612 +9787520719773 +9787520720588 +9787520720601 +9787520720854 +9787520721035 +9787520721387 +9787520721462 +9787520721684 +9787520721998 +9787520722087 +9787520722391 +9787520722483 +9787520722575 +9787520722599 +9787520722735 +9787520722766 +9787520722841 +9787520723022 +9787520723039 +9787520723084 +9787520723138 +9787520723145 +9787520723176 +9787520723213 +9787520723473 +9787520723534 +9787520723596 +9787520723688 +9787520723701 +9787520723855 +9787520723886 +9787520723961 +9787520724050 +9787520724128 +9787520724807 +9787520725682 +9787520726061 +9787520726078 +9787520726504 +9787520726597 +9787520726627 +9787520726634 +9787520726696 +9787520726757 +9787520726870 +9787520727266 +9787520727341 +9787520727501 +9787520727709 +9787520727846 +9787520727853 +9787520728058 +9787520728089 +9787520728287 +9787520728416 +9787520728485 +9787520728577 +9787520728621 +9787520728638 +9787520728683 +9787520728812 +9787520728973 +9787520729048 +9787520729147 +9787520729345 +9787520729536 +9787520729543 +9787520729734 +9787520729826 +9787520729833 +9787520729840 +9787520729901 +9787520729956 +9787520729994 +9787520730549 +9787520730556 +9787520730655 +9787520730662 +9787520730808 +9787520730815 +9787520730884 +9787520730891 +9787520731478 +9787520731584 +9787520731621 +9787520731676 +9787520731829 +9787520731898 +9787520731911 +9787520732222 +9787520732550 +9787520732581 +9787520732598 +9787520732604 +9787520732628 +9787520732635 +9787520732642 +9787520732727 +9787520732789 +9787520732963 +9787520732987 +9787520732994 +9787520733397 +9787520733403 +9787520733434 +9787520733519 +9787520733526 +9787520733595 +9787520733892 +9787520733946 +9787520733977 +9787520734066 +9787520734103 +9787520734110 +9787520734165 +9787520734226 +9787520734233 +9787520734240 +9787520734325 +9787520734349 +9787520734363 +9787520734479 +9787520734547 +9787520734561 +9787520734615 +9787520734660 +9787520734691 +9787520734714 +9787520735018 +9787520735025 +9787520735117 +9787520735124 +9787520735131 +9787520735179 +9787520735254 +9787520735261 +9787520735292 +9787520735315 +9787520735346 +9787520735353 +9787520735520 +9787520735537 +9787520735636 +9787520735759 +9787520735834 +9787520735841 +9787520735858 +9787520735872 +9787520735902 +9787520735926 +9787520735940 +9787520735995 +9787520736008 +9787520736039 +9787520736077 +9787520736084 +9787520736121 +9787520736152 +9787520736213 +9787520736220 +9787520736336 +9787520736367 +9787520736435 +9787520736770 +9787520736831 +9787520737135 +9787520737166 +9787520737173 +9787520737180 +9787520737319 +9787520737333 +9787520737401 +9787520737425 +9787520737456 +9787520737593 +9787520737616 +9787520737630 +9787520737692 +9787520737739 +9787520737807 +9787520737852 +9787520737982 +9787520737999 +9787520738118 +9787520738262 +9787520738286 +9787520738316 +9787520738507 +9787520738606 +9787520738651 +9787520738668 +9787520738842 +9787520738903 +9787520739047 +9787520739375 +9787520739436 +9787520739443 +9787520739818 +9787520739849 +9787520739856 +9787520739900 +9787520739917 +9787520739979 +9787520740081 +9787520740104 +9787520740128 +9787520740159 +9787520740173 +9787520740302 +9787520740326 +9787520740333 +9787520740357 +9787520740425 +9787520740524 +9787520740630 +9787520740647 +9787520740777 +9787520740821 +9787520741088 +9787520741248 +9787520741309 +9787520741316 +9787520741330 +9787520741569 +9787520742054 +9787520742092 +9787520742108 +9787520742115 +9787520744171 +9787520744195 +9787520744508 +9787520744522 +9787520744775 +9787520800334 +9787520800631 +9787520800808 +9787520800891 +9787520800976 +9787520801102 +9787520801119 +9787520801362 +9787520801621 +9787520802017 +9787520802116 +9787520802420 +9787520802505 +9787520802819 +9787520802956 +9787520803304 +9787520804264 +9787520804424 +9787520804653 +9787520805063 +9787520805193 +9787520806343 +9787520806404 +9787520806626 +9787520807333 +9787520807975 +9787520808477 +9787520808774 +9787520809474 +9787520809948 +9787520810104 +9787520810432 +9787520810500 +9787520810623 +9787520810845 +9787520811439 +9787520811514 +9787520811903 +9787520812054 +9787520812146 +9787520812528 +9787520812658 +9787520812825 +9787520813082 +9787520813228 +9787520813419 +9787520813518 +9787520813624 +9787520813761 +9787520813860 +9787520813983 +9787520814140 +9787520814188 +9787520814379 +9787520814829 +9787520814935 +9787520815017 +9787520815253 +9787520815543 +9787520815871 +9787520815901 +9787520815918 +9787520815925 +9787520815932 +9787520815949 +9787520816274 +9787520816311 +9787520816403 +9787520816434 +9787520816465 +9787520816472 +9787520816618 +9787520816632 +9787520816779 +9787520817288 +9787520817325 +9787520818292 +9787520818384 +9787520818520 +9787520818698 +9787520818742 +9787520818865 +9787520818957 +9787520819190 +9787520819268 +9787520819329 +9787520819428 +9787520819435 +9787520819732 +9787520819770 +9787520819862 +9787520820028 +9787520820165 +9787520821155 +9787520821803 +9787520822787 +9787520823067 +9787520823852 +9787520824057 +9787520824125 +9787520824477 +9787520824644 +9787520824682 +9787520824712 +9787520824958 +9787520825030 +9787520825122 +9787520825283 +9787520825412 +9787520825900 +9787520826464 +9787520826549 +9787520826556 +9787520826679 +9787520826792 +9787520827010 +9787520827423 +9787520827430 +9787520827652 +9787520827867 +9787520828000 +9787520828338 +9787520828673 +9787520828680 +9787520828727 +9787520828734 +9787520828741 +9787520828765 +9787520828819 +9787520828949 +9787520828987 +9787520829083 +9787520829090 +9787520829137 +9787520829175 +9787520829588 +9787520829847 +9787520830140 +9787520830164 +9787520831321 +9787520831369 +9787520831611 +9787520831710 +9787520832878 +9787520832915 +9787520833042 +9787520833073 +9787520833141 +9787520833172 +9787520833219 +9787520833592 +9787520834018 +9787520834346 +9787520835374 +9787520900614 +9787520900713 +9787520900928 +9787520901345 +9787520901369 +9787520901376 +9787520901529 +9787520901536 +9787520901598 +9787520901659 +9787520901697 +9787520901703 +9787520901833 +9787520901871 +9787520902045 +9787520902168 +9787520902243 +9787520902465 +9787520902793 +9787520903073 +9787520903226 +9787521000924 +9787521001167 +9787521002881 +9787521003406 +9787521003666 +9787521003758 +9787521005639 +9787521005905 +9787521005943 +9787521006070 +9787521006698 +9787521007251 +9787521007343 +9787521007923 +9787521008029 +9787521008319 +9787521008487 +9787521009217 +9787521009446 +9787521009774 +9787521010442 +9787521010602 +9787521010794 +9787521011500 +9787521012460 +9787521012743 +9787521012927 +9787521012972 +9787521012989 +9787521013511 +9787521014518 +9787521100020 +9787521100105 +9787521100259 +9787521100273 +9787521100655 +9787521100693 +9787521100822 +9787521101027 +9787521101034 +9787521101058 +9787521101096 +9787521101553 +9787521101584 +9787521101812 +9787521102048 +9787521102123 +9787521102178 +9787521102208 +9787521102222 +9787521102321 +9787521102451 +9787521102581 +9787521103014 +9787521103052 +9787521103366 +9787521103465 +9787521103601 +9787521103823 +9787521103861 +9787521103960 +9787521104110 +9787521104134 +9787521104370 +9787521104479 +9787521104677 +9787521104684 +9787521105100 +9787521105148 +9787521105209 +9787521105285 +9787521105292 +9787521105360 +9787521105377 +9787521200423 +9787521202373 +9787521205107 +9787521205121 +9787521205138 +9787521205145 +9787521206609 +9787521208054 +9787521208696 +9787521209884 +9787521210309 +9787521211191 +9787521211214 +9787521211788 +9787521211993 +9787521212235 +9787521213676 +9787521213751 +9787521215397 +9787521216219 +9787521216349 +9787521216363 +9787521216714 +9787521216776 +9787521217018 +9787521217636 +9787521218183 +9787521218213 +9787521219111 +9787521219647 +9787521220575 +9787521220766 +9787521220896 +9787521221015 +9787521221343 +9787521221367 +9787521221459 +9787521221770 +9787521221947 +9787521221985 +9787521222104 +9787521222357 +9787521222388 +9787521222449 +9787521222586 +9787521222609 +9787521223149 +9787521223156 +9787521223163 +9787521223309 +9787521223316 +9787521223378 +9787521223385 +9787521223453 +9787521223514 +9787521223651 +9787521223699 +9787521223736 +9787521223781 +9787521223804 +9787521223903 +9787521223941 +9787521223972 +9787521223989 +9787521224009 +9787521224146 +9787521224238 +9787521224467 +9787521224528 +9787521224689 +9787521224702 +9787521224764 +9787521224863 +9787521224962 +9787521225112 +9787521225136 +9787521225143 +9787521225174 +9787521225204 +9787521225297 +9787521225327 +9787521225396 +9787521225419 +9787521225594 +9787521225648 +9787521225662 +9787521225693 +9787521225839 +9787521225983 +9787521226102 +9787521226119 +9787521226355 +9787521226652 +9787521226669 +9787521226799 +9787521226805 +9787521226898 +9787521226942 +9787521226966 +9787521227048 +9787521227079 +9787521227161 +9787521227185 +9787521227192 +9787521227338 +9787521227390 +9787521227413 +9787521227420 +9787521227437 +9787521227475 +9787521227499 +9787521227635 +9787521227710 +9787521227840 +9787521227857 +9787521227864 +9787521227871 +9787521227963 +9787521228007 +9787521228038 +9787521228045 +9787521228151 +9787521228434 +9787521228489 +9787521228496 +9787521228571 +9787521228687 +9787521228700 +9787521228717 +9787521228731 +9787521228779 +9787521229080 +9787521229493 +9787521229714 +9787521229721 +9787521229851 +9787521229929 +9787521230499 +9787521230550 +9787521230598 +9787521230727 +9787521230819 +9787521230857 +9787521230925 +9787521230932 +9787521231786 +9787521231960 +9787521231977 +9787521232035 +9787521232097 +9787521232110 +9787521232141 +9787521232158 +9787521232608 +9787521232660 +9787521232844 +9787521232882 +9787521232967 +9787521233001 +9787521233087 +9787521233391 +9787521235098 +9787521235265 +9787521235357 +9787521300598 +9787521300659 +9787521300666 +9787521300727 +9787521300741 +9787521300789 +9787521300864 +9787521300871 +9787521301007 +9787521301021 +9787521301595 +9787521301700 +9787521301939 +9787521301991 +9787521302073 +9787521302097 +9787521302127 +9787521302523 +9787521303278 +9787521303780 +9787521303834 +9787521304411 +9787521304879 +9787521304893 +9787521305043 +9787521305067 +9787521305166 +9787521305265 +9787521305272 +9787521305302 +9787521305319 +9787521305777 +9787521305937 +9787521306040 +9787521306187 +9787521306316 +9787521306835 +9787521306842 +9787521306910 +9787521307221 +9787521307542 +9787521307825 +9787521307863 +9787521307924 +9787521307986 +9787521308044 +9787521308198 +9787521308211 +9787521308297 +9787521308402 +9787521308464 +9787521308501 +9787521308624 +9787521308976 +9787521308990 +9787521309355 +9787521309560 +9787521309881 +9787521309898 +9787521309911 +9787521309928 +9787521309942 +9787521309959 +9787521310382 +9787521310795 +9787521311341 +9787521311402 +9787521311839 +9787521312522 +9787521312683 +9787521312690 +9787521313031 +9787521313178 +9787521313482 +9787521313512 +9787521313529 +9787521315028 +9787521315837 +9787521316414 +9787521316711 +9787521317169 +9787521317220 +9787521317442 +9787521317619 +9787521317701 +9787521317718 +9787521317725 +9787521317800 +9787521317862 +9787521318012 +9787521318210 +9787521318555 +9787521318814 +9787521319330 +9787521319606 +9787521319620 +9787521319637 +9787521319934 +9787521320152 +9787521320572 +9787521320626 +9787521320633 +9787521320787 +9787521320992 +9787521321005 +9787521321029 +9787521321036 +9787521321043 +9787521321135 +9787521321630 +9787521321739 +9787521322446 +9787521322507 +9787521322774 +9787521322866 +9787521322910 +9787521322927 +9787521323825 +9787521323849 +9787521323894 +9787521324228 +9787521324235 +9787521324327 +9787521324488 +9787521324495 +9787521324563 +9787521324587 +9787521324648 +9787521324655 +9787521324662 +9787521324686 +9787521324693 +9787521324716 +9787521324723 +9787521324778 +9787521324808 +9787521324846 +9787521324860 +9787521324914 +9787521324938 +9787521324983 +9787521325027 +9787521325034 +9787521325270 +9787521325416 +9787521325621 +9787521325959 +9787521326345 +9787521326888 +9787521326932 +9787521327267 +9787521327489 +9787521327748 +9787521327786 +9787521328189 +9787521328431 +9787521328776 +9787521328851 +9787521329001 +9787521329155 +9787521329643 +9787521329766 +9787521330076 +9787521330151 +9787521330168 +9787521330182 +9787521330298 +9787521330304 +9787521330472 +9787521331967 +9787521331974 +9787521332018 +9787521332070 +9787521332117 +9787521332506 +9787521332537 +9787521333060 +9787521333107 +9787521333275 +9787521333299 +9787521333367 +9787521333459 +9787521333657 +9787521333718 +9787521333879 +9787521334104 +9787521334111 +9787521334128 +9787521334241 +9787521334319 +9787521334357 +9787521334371 +9787521334418 +9787521334531 +9787521334890 +9787521334968 +9787521335538 +9787521335620 +9787521335644 +9787521335651 +9787521335675 +9787521335705 +9787521335958 +9787521336160 +9787521336269 +9787521336283 +9787521336290 +9787521336450 +9787521336610 +9787521336696 +9787521336825 +9787521337082 +9787521337761 +9787521338485 +9787521338591 +9787521338973 +9787521339086 +9787521339093 +9787521339246 +9787521339918 +9787521340020 +9787521340259 +9787521340365 +9787521340594 +9787521340730 +9787521341027 +9787521341812 +9787521341898 +9787521342048 +9787521342215 +9787521342376 +9787521342659 +9787521342727 +9787521343021 +9787521343366 +9787521343410 +9787521343434 +9787521343472 +9787521343489 +9787521343496 +9787521343571 +9787521343649 +9787521343663 +9787521343724 +9787521343755 +9787521343816 +9787521343823 +9787521343885 +9787521344004 +9787521344042 +9787521344202 +9787521344356 +9787521344790 +9787521344837 +9787521344899 +9787521345353 +9787521345681 +9787521345704 +9787521345711 +9787521345766 +9787521345957 +9787521346008 +9787521346022 +9787521346220 +9787521346398 +9787521346428 +9787521346510 +9787521347005 +9787521347036 +9787521347142 +9787521347203 +9787521347227 +9787521347258 +9787521347296 +9787521347326 +9787521347777 +9787521348019 +9787521348057 +9787521348286 +9787521348347 +9787521348491 +9787521348583 +9787521348613 +9787521349085 +9787521349139 +9787521349382 +9787521349405 +9787521349474 +9787521349566 +9787521349603 +9787521349672 +9787521349771 +9787521349887 +9787521349924 +9787521349948 +9787521350005 +9787521350319 +9787521350395 +9787521350487 +9787521350548 +9787521350562 +9787521350708 +9787521350715 +9787521350746 +9787521350845 +9787521350852 +9787521350913 +9787521350951 +9787521351149 +9787521351170 +9787521351217 +9787521351347 +9787521351408 +9787521351453 +9787521351460 +9787521351507 +9787521351514 +9787521351538 +9787521351552 +9787521351682 +9787521351835 +9787521351859 +9787521351903 +9787521352290 +9787521352337 +9787521352399 +9787521352412 +9787521352481 +9787521352658 +9787521352696 +9787521352719 +9787521352788 +9787521352825 +9787521352832 +9787521353020 +9787521353099 +9787521353693 +9787521353969 +9787521354010 +9787521354027 +9787521354072 +9787521354249 +9787521354386 +9787521354706 +9787521354720 +9787521355352 +9787521355376 +9787521355413 +9787521355819 +9787521355826 +9787521356595 +9787521356618 +9787521356755 +9787521357011 +9787521357196 +9787521357271 +9787521357318 +9787521357547 +9787521357714 +9787521357769 +9787521357820 +9787521358063 +9787521358148 +9787521360400 +9787521361179 +9787521361452 +9787521361506 +9787521361537 +9787521361940 +9787521362510 +9787521400083 +9787521401660 +9787521403671 +9787521406917 +9787521407051 +9787521407181 +9787521408461 +9787521409376 +9787521409475 +9787521409598 +9787521410471 +9787521410747 +9787521413045 +9787521413571 +9787521413588 +9787521413700 +9787521416015 +9787521416251 +9787521416442 +9787521416565 +9787521417449 +9787521418064 +9787521418316 +9787521420241 +9787521421279 +9787521421415 +9787521421477 +9787521421538 +9787521421552 +9787521421637 +9787521421736 +9787521421842 +9787521422917 +9787521423006 +9787521423341 +9787521423723 +9787521423792 +9787521424881 +9787521425741 +9787521427073 +9787521427400 +9787521427455 +9787521427905 +9787521427936 +9787521428193 +9787521428780 +9787521429145 +9787521429312 +9787521429640 +9787521429657 +9787521429718 +9787521429725 +9787521429794 +9787521430080 +9787521430189 +9787521430257 +9787521430516 +9787521431018 +9787521431049 +9787521431247 +9787521431292 +9787521431360 +9787521431681 +9787521433463 +9787521433579 +9787521433630 +9787521433661 +9787521433753 +9787521434583 +9787521435092 +9787521435115 +9787521436952 +9787521437119 +9787521437362 +9787521437386 +9787521437447 +9787521437492 +9787521437515 +9787521437980 +9787521438024 +9787521438246 +9787521438383 +9787521438406 +9787521439168 +9787521439489 +9787521439632 +9787521440270 +9787521440348 +9787521440423 +9787521440447 +9787521440478 +9787521440928 +9787521441154 +9787521441178 +9787521441420 +9787521441437 +9787521441451 +9787521441543 +9787521441642 +9787521441666 +9787521441864 +9787521441895 +9787521442199 +9787521442311 +9787521442342 +9787521442373 +9787521443028 +9787521443042 +9787521443066 +9787521443080 +9787521443219 +9787521443271 +9787521443301 +9787521443561 +9787521443806 +9787521443837 +9787521443851 +9787521443943 +9787521444056 +9787521444414 +9787521444544 +9787521444926 +9787521445121 +9787521445206 +9787521445336 +9787521445794 +9787521445862 +9787521445978 +9787521445985 +9787521446005 +9787521446326 +9787521446364 +9787521446425 +9787521446739 +9787521446753 +9787521446845 +9787521446937 +9787521447088 +9787521447149 +9787521447293 +9787521447408 +9787521447491 +9787521447538 +9787521447552 +9787521447620 +9787521448030 +9787521448160 +9787521448269 +9787521448320 +9787521448641 +9787521448719 +9787521448825 +9787521449105 +9787521449297 +9787521449310 +9787521449464 +9787521449518 +9787521449600 +9787521449617 +9787521449778 +9787521450262 +9787521450705 +9787521450729 +9787521450873 +9787521451931 +9787521452112 +9787521452167 +9787521452891 +9787521500202 +9787521500424 +9787521500431 +9787521500448 +9787521500585 +9787521500905 +9787521500929 +9787521501230 +9787521501254 +9787521501322 +9787521501360 +9787521501537 +9787521501773 +9787521501780 +9787521501797 +9787521501834 +9787521501919 +9787521502077 +9787521502091 +9787521502152 +9787521502442 +9787521502558 +9787521502572 +9787521502626 +9787521502855 +9787521502947 +9787521503210 +9787521503319 +9787521503548 +9787521503555 +9787521503586 +9787521503593 +9787521503609 +9787521503746 +9787521503777 +9787521503784 +9787521503982 +9787521504491 +9787521504668 +9787521505054 +9787521505092 +9787521505276 +9787521505924 +9787521505931 +9787521506112 +9787521506174 +9787521506471 +9787521506518 +9787521506532 +9787521506556 +9787521506563 +9787521506693 +9787521506716 +9787521506778 +9787521506785 +9787521506846 +9787521506877 +9787521506884 +9787521506891 +9787521506945 +9787521506983 +9787521507041 +9787521507164 +9787521507317 +9787521507553 +9787521507577 +9787521507652 +9787521507744 +9787521507751 +9787521507812 +9787521507829 +9787521507836 +9787521507843 +9787521507850 +9787521507898 +9787521508321 +9787521508581 +9787521508673 +9787521508703 +9787521509168 +9787521509564 +9787521509632 +9787521509823 +9787521510157 +9787521510232 +9787521510300 +9787521510553 +9787521510577 +9787521510584 +9787521510591 +9787521510607 +9787521510645 +9787521510652 +9787521510799 +9787521510973 +9787521510980 +9787521511260 +9787521511857 +9787521511864 +9787521511871 +9787521511994 +9787521512007 +9787521512014 +9787521512021 +9787521512038 +9787521512168 +9787521513097 +9787521513448 +9787521513707 +9787521514117 +9787521514704 +9787521600476 +9787521600520 +9787521600605 +9787521601268 +9787521601459 +9787521601848 +9787521601985 +9787521602234 +9787521602241 +9787521602296 +9787521602531 +9787521602630 +9787521602852 +9787521602968 +9787521603439 +9787521603873 +9787521604269 +9787521604306 +9787521604757 +9787521605488 +9787521605808 +9787521605907 +9787521605921 +9787521606027 +9787521606386 +9787521606911 +9787521607383 +9787521607871 +9787521607918 +9787521608007 +9787521608144 +9787521608168 +9787521608373 +9787521608397 +9787521608472 +9787521608618 +9787521608670 +9787521608816 +9787521608861 +9787521609059 +9787521609219 +9787521609233 +9787521609615 +9787521609837 +9787521609882 +9787521610123 +9787521610505 +9787521610604 +9787521610635 +9787521610659 +9787521610673 +9787521610703 +9787521610710 +9787521610727 +9787521610901 +9787521610925 +9787521610932 +9787521610970 +9787521611038 +9787521611205 +9787521611212 +9787521611274 +9787521611359 +9787521611397 +9787521611403 +9787521611564 +9787521611595 +9787521611649 +9787521611724 +9787521611786 +9787521611854 +9787521611977 +9787521612028 +9787521612042 +9787521612059 +9787521612103 +9787521612110 +9787521612134 +9787521612165 +9787521612196 +9787521612202 +9787521612233 +9787521612400 +9787521612417 +9787521612462 +9787521612509 +9787521612554 +9787521612707 +9787521612769 +9787521612776 +9787521612783 +9787521613261 +9787521613339 +9787521613346 +9787521613421 +9787521613438 +9787521613919 +9787521613933 +9787521613971 +9787521614107 +9787521614299 +9787521614473 +9787521614855 +9787521615302 +9787521615319 +9787521615524 +9787521615609 +9787521615616 +9787521615630 +9787521615814 +9787521615852 +9787521615913 +9787521616200 +9787521616422 +9787521616446 +9787521616842 +9787521616866 +9787521617283 +9787521617672 +9787521617726 +9787521617955 +9787521618068 +9787521618099 +9787521618167 +9787521618228 +9787521618334 +9787521618419 +9787521618426 +9787521618525 +9787521618587 +9787521618709 +9787521618747 +9787521618785 +9787521618822 +9787521618884 +9787521618983 +9787521619010 +9787521619119 +9787521619195 +9787521619256 +9787521619300 +9787521619522 +9787521619560 +9787521619867 +9787521619966 +9787521619973 +9787521620016 +9787521620047 +9787521620276 +9787521620474 +9787521620993 +9787521621082 +9787521621204 +9787521621228 +9787521621266 +9787521621280 +9787521621709 +9787521621808 +9787521621891 +9787521622935 +9787521622997 +9787521623000 +9787521623987 +9787521624021 +9787521624885 +9787521624892 +9787521625349 +9787521625547 +9787521625592 +9787521625769 +9787521625813 +9787521625837 +9787521625868 +9787521625929 +9787521625967 +9787521626049 +9787521626117 +9787521626186 +9787521626193 +9787521626209 +9787521626261 +9787521626438 +9787521626551 +9787521626667 +9787521626698 +9787521626728 +9787521626797 +9787521626865 +9787521626896 +9787521626964 +9787521627152 +9787521627282 +9787521627312 +9787521627398 +9787521627497 +9787521627503 +9787521627558 +9787521627671 +9787521627732 +9787521627916 +9787521628005 +9787521628012 +9787521628029 +9787521628036 +9787521628180 +9787521628210 +9787521628357 +9787521628371 +9787521628401 +9787521628425 +9787521628470 +9787521628562 +9787521628661 +9787521628708 +9787521628784 +9787521628890 +9787521628913 +9787521629187 +9787521629200 +9787521629231 +9787521629248 +9787521629255 +9787521629262 +9787521629279 +9787521629286 +9787521629408 +9787521629538 +9787521629620 +9787521629668 +9787521629750 +9787521629798 +9787521629897 +9787521630060 +9787521630169 +9787521630466 +9787521630473 +9787521630633 +9787521630770 +9787521630930 +9787521631470 +9787521631555 +9787521631678 +9787521631685 +9787521631791 +9787521631845 +9787521631869 +9787521632101 +9787521632224 +9787521632262 +9787521632279 +9787521632538 +9787521632699 +9787521632927 +9787521633078 +9787521633108 +9787521633252 +9787521633603 +9787521633641 +9787521633665 +9787521633740 +9787521633801 +9787521633870 +9787521633887 +9787521633979 +9787521633986 +9787521634013 +9787521634020 +9787521634334 +9787521634471 +9787521634518 +9787521634624 +9787521634761 +9787521634846 +9787521634853 +9787521634860 +9787521634945 +9787521634952 +9787521635027 +9787521635034 +9787521635188 +9787521635263 +9787521635317 +9787521635324 +9787521635348 +9787521635386 +9787521635454 +9787521635485 +9787521635669 +9787521635676 +9787521635690 +9787521635706 +9787521635713 +9787521635836 +9787521635911 +9787521635942 +9787521635997 +9787521636079 +9787521636123 +9787521636130 +9787521636215 +9787521636239 +9787521636284 +9787521636468 +9787521636505 +9787521636529 +9787521636710 +9787521636727 +9787521637014 +9787521637151 +9787521637373 +9787521637403 +9787521637434 +9787521637465 +9787521637502 +9787521637519 +9787521637540 +9787521637571 +9787521637656 +9787521637663 +9787521637694 +9787521637748 +9787521637755 +9787521637816 +9787521637861 +9787521638011 +9787521638073 +9787521638233 +9787521638264 +9787521638332 +9787521638400 +9787521638462 +9787521638479 +9787521638554 +9787521638615 +9787521638769 +9787521638790 +9787521639001 +9787521639056 +9787521639063 +9787521639148 +9787521639155 +9787521639162 +9787521639261 +9787521639346 +9787521639384 +9787521639414 +9787521639506 +9787521639520 +9787521639605 +9787521639612 +9787521639681 +9787521639711 +9787521639728 +9787521639773 +9787521639803 +9787521639834 +9787521639926 +9787521639940 +9787521639964 +9787521640090 +9787521640113 +9787521640120 +9787521640168 +9787521640236 +9787521640250 +9787521640342 +9787521640359 +9787521640410 +9787521640700 +9787521640717 +9787521640724 +9787521640779 +9787521640793 +9787521640816 +9787521640908 +9787521641127 +9787521641189 +9787521641219 +9787521641226 +9787521641523 +9787521641721 +9787521641769 +9787521641837 +9787521641844 +9787521641899 +9787521642018 +9787521642087 +9787521642117 +9787521642148 +9787521642155 +9787521642162 +9787521642179 +9787521642193 +9787521642384 +9787521642469 +9787521642520 +9787521642544 +9787521642612 +9787521642681 +9787521642742 +9787521642810 +9787521642858 +9787521643176 +9787521643190 +9787521643237 +9787521643244 +9787521643336 +9787521643442 +9787521643473 +9787521643510 +9787521643527 +9787521643534 +9787521643541 +9787521643626 +9787521643657 +9787521643671 +9787521643718 +9787521643770 +9787521643787 +9787521643800 +9787521643831 +9787521643855 +9787521643886 +9787521643978 +9787521644098 +9787521644135 +9787521644180 +9787521644333 +9787521644388 +9787521644395 +9787521644449 +9787521644494 +9787521644500 +9787521644555 +9787521644661 +9787521644685 +9787521644722 +9787521644753 +9787521644814 +9787521644869 +9787521644913 +9787521645057 +9787521645101 +9787521645187 +9787521645217 +9787521645408 +9787521645460 +9787521645545 +9787521645569 +9787521645668 +9787521645705 +9787521645712 +9787521645729 +9787521645835 +9787521646030 +9787521646191 +9787521646207 +9787521646214 +9787521646290 +9787521646313 +9787521646405 +9787521646443 +9787521646450 +9787521646474 +9787521646627 +9787521646740 +9787521646764 +9787521646887 +9787521646894 +9787521646900 +9787521646931 +9787521647020 +9787521647051 +9787521647341 +9787521647587 +9787521647679 +9787521647693 +9787521647716 +9787521647761 +9787521647785 +9787521647808 +9787521647822 +9787521647860 +9787521647891 +9787521647969 +9787521648058 +9787521648164 +9787521648782 +9787521648829 +9787521648874 +9787521649154 +9787521649208 +9787521649215 +9787521649222 +9787521649246 +9787521649338 +9787521649581 +9787521649796 +9787521649918 +9787521649987 +9787521650013 +9787521650020 +9787521650136 +9787521650167 +9787521650273 +9787521650334 +9787521650389 +9787521650532 +9787521650617 +9787521650655 +9787521650693 +9787521650716 +9787521650853 +9787521650938 +9787521651065 +9787521651119 +9787521651300 +9787521651386 +9787521651416 +9787521651669 +9787521651676 +9787521651850 +9787521652505 +9787521652703 +9787521654028 +9787521654370 +9787521702156 +9787521702347 +9787521702989 +9787521703559 +9787521704723 +9787521704754 +9787521706116 +9787521707069 +9787521707502 +9787521708271 +9787521709841 +9787521709926 +9787521710489 +9787521710496 +9787521710991 +9787521711066 +9787521711837 +9787521711936 +9787521712438 +9787521712803 +9787521713152 +9787521713169 +9787521713190 +9787521713633 +9787521714234 +9787521714678 +9787521714852 +9787521716313 +9787521716351 +9787521716405 +9787521716474 +9787521716498 +9787521716504 +9787521716740 +9787521716887 +9787521718041 +9787521718188 +9787521719116 +9787521719239 +9787521719451 +9787521719826 +9787521719840 +9787521720792 +9787521721423 +9787521722529 +9787521724653 +9787521724769 +9787521725179 +9787521726558 +9787521726572 +9787521726848 +9787521728187 +9787521732306 +9787521733709 +9787521736113 +9787521736984 +9787521737608 +9787521737615 +9787521737813 +9787521737875 +9787521737967 +9787521738087 +9787521738117 +9787521738391 +9787521738803 +9787521738810 +9787521739091 +9787521739428 +9787521739619 +9787521739633 +9787521739725 +9787521739749 +9787521739961 +9787521739985 +9787521740080 +9787521740097 +9787521740479 +9787521740882 +9787521741773 +9787521742534 +9787521742671 +9787521742992 +9787521743067 +9787521743296 +9787521743319 +9787521743661 +9787521743739 +9787521744361 +9787521744460 +9787521744521 +9787521744620 +9787521744804 +9787521744866 +9787521745627 +9787521745658 +9787521745689 +9787521745726 +9787521745795 +9787521746006 +9787521746068 +9787521746303 +9787521746372 +9787521746426 +9787521746730 +9787521746792 +9787521746808 +9787521746822 +9787521746969 +9787521747010 +9787521747072 +9787521747119 +9787521747126 +9787521747164 +9787521747379 +9787521747485 +9787521747744 +9787521747799 +9787521747928 +9787521748031 +9787521748109 +9787521748116 +9787521748185 +9787521748215 +9787521748338 +9787521748376 +9787521748413 +9787521748437 +9787521748444 +9787521748482 +9787521748512 +9787521748857 +9787521749144 +9787521749212 +9787521749243 +9787521749434 +9787521749472 +9787521749489 +9787521749496 +9787521749687 +9787521749861 +9787521749960 +9787521749984 +9787521750010 +9787521750027 +9787521750300 +9787521750591 +9787521750645 +9787521750737 +9787521750829 +9787521750850 +9787521750881 +9787521750928 +9787521751024 +9787521751031 +9787521751086 +9787521751147 +9787521751161 +9787521751178 +9787521751192 +9787521751253 +9787521751260 +9787521751451 +9787521751550 +9787521751628 +9787521751642 +9787521751772 +9787521751789 +9787521751864 +9787521751918 +9787521752205 +9787521752304 +9787521752311 +9787521752403 +9787521752519 +9787521752625 +9787521752649 +9787521752700 +9787521752779 +9787521752809 +9787521752830 +9787521752878 +9787521752908 +9787521752922 +9787521753073 +9787521753080 +9787521753134 +9787521753189 +9787521753196 +9787521753226 +9787521753264 +9787521753325 +9787521753370 +9787521753387 +9787521753394 +9787521753479 +9787521753547 +9787521753660 +9787521753684 +9787521753882 +9787521754049 +9787521754056 +9787521754100 +9787521754155 +9787521754179 +9787521754193 +9787521754209 +9787521754223 +9787521754230 +9787521754247 +9787521754308 +9787521754339 +9787521754384 +9787521754766 +9787521754964 +9787521754971 +9787521755152 +9787521755244 +9787521755305 +9787521755411 +9787521755435 +9787521755534 +9787521755558 +9787521755589 +9787521755794 +9787521755848 +9787521756036 +9787521756043 +9787521756142 +9787521756159 +9787521756166 +9787521756173 +9787521756210 +9787521756302 +9787521756319 +9787521756340 +9787521756401 +9787521756524 +9787521756654 +9787521756685 +9787521756722 +9787521756906 +9787521756937 +9787521756968 +9787521757026 +9787521757057 +9787521757064 +9787521757125 +9787521757262 +9787521757347 +9787521757385 +9787521757392 +9787521757460 +9787521757477 +9787521757491 +9787521757507 +9787521757521 +9787521757620 +9787521757637 +9787521757699 +9787521757774 +9787521757781 +9787521757866 +9787521757934 +9787521757989 +9787521758115 +9787521758146 +9787521758177 +9787521758184 +9787521758207 +9787521758221 +9787521758238 +9787521758269 +9787521758313 +9787521758382 +9787521758450 +9787521758542 +9787521758580 +9787521758597 +9787521758603 +9787521758610 +9787521758658 +9787521758702 +9787521758719 +9787521758733 +9787521758740 +9787521758795 +9787521758856 +9787521758863 +9787521758894 +9787521758962 +9787521759020 +9787521759037 +9787521759051 +9787521759068 +9787521759129 +9787521759136 +9787521759143 +9787521759204 +9787521759228 +9787521759235 +9787521759259 +9787521759273 +9787521759341 +9787521759402 +9787521759426 +9787521759433 +9787521759488 +9787521759495 +9787521759532 +9787521759549 +9787521759556 +9787521759587 +9787521759594 +9787521759600 +9787521759648 +9787521759655 +9787521759891 +9787521759952 +9787521760019 +9787521760026 +9787521760040 +9787521760088 +9787521760095 +9787521760156 +9787521760200 +9787521760262 +9787521760279 +9787521760323 +9787521760354 +9787521760392 +9787521760439 +9787521760477 +9787521760507 +9787521760514 +9787521760576 +9787521760668 +9787521760682 +9787521760712 +9787521760743 +9787521760750 +9787521760774 +9787521760781 +9787521760835 +9787521760866 +9787521760880 +9787521760927 +9787521760958 +9787521761030 +9787521761047 +9787521761054 +9787521761061 +9787521761092 +9787521761146 +9787521761207 +9787521761276 +9787521761283 +9787521761320 +9787521761368 +9787521761375 +9787521761443 +9787521761474 +9787521761528 +9787521761573 +9787521761597 +9787521761603 +9787521761610 +9787521761658 +9787521761665 +9787521761689 +9787521761696 +9787521761702 +9787521761719 +9787521761757 +9787521761764 +9787521761771 +9787521761832 +9787521761849 +9787521761863 +9787521761900 +9787521761917 +9787521761924 +9787521761931 +9787521761948 +9787521761993 +9787521762006 +9787521762013 +9787521762037 +9787521762051 +9787521762068 +9787521762099 +9787521762143 +9787521762167 +9787521762174 +9787521762181 +9787521762204 +9787521762297 +9787521762310 +9787521762341 +9787521762419 +9787521762433 +9787521762440 +9787521762501 +9787521762532 +9787521762556 +9787521762563 +9787521762624 +9787521762686 +9787521762754 +9787521762761 +9787521762792 +9787521762846 +9787521762860 +9787521762877 +9787521762891 +9787521762907 +9787521762945 +9787521762952 +9787521762983 +9787521762990 +9787521763003 +9787521763027 +9787521763058 +9787521763089 +9787521763133 +9787521763140 +9787521763157 +9787521763164 +9787521763171 +9787521763188 +9787521763225 +9787521763270 +9787521763294 +9787521763300 +9787521763331 +9787521763355 +9787521763362 +9787521763393 +9787521763409 +9787521763539 +9787521763560 +9787521763577 +9787521763591 +9787521763614 +9787521763621 +9787521763645 +9787521763669 +9787521763690 +9787521763706 +9787521763713 +9787521763720 +9787521763737 +9787521763775 +9787521763782 +9787521763799 +9787521763829 +9787521763850 +9787521763867 +9787521763898 +9787521763904 +9787521763935 +9787521763942 +9787521763966 +9787521763973 +9787521764017 +9787521764055 +9787521764062 +9787521764079 +9787521764109 +9787521764154 +9787521764178 +9787521764192 +9787521764222 +9787521764246 +9787521764277 +9787521764284 +9787521764291 +9787521764307 +9787521764345 +9787521764352 +9787521764390 +9787521764406 +9787521764413 +9787521764437 +9787521764451 +9787521764505 +9787521764529 +9787521764536 +9787521764543 +9787521764550 +9787521764567 +9787521764574 +9787521764598 +9787521764604 +9787521764611 +9787521764635 +9787521764642 +9787521764666 +9787521764680 +9787521764703 +9787521764741 +9787521764758 +9787521764765 +9787521764772 +9787521764789 +9787521764796 +9787521764802 +9787521764826 +9787521764840 +9787521764857 +9787521764895 +9787521764956 +9787521764970 +9787521764987 +9787521765007 +9787521765014 +9787521765038 +9787521765045 +9787521765069 +9787521765083 +9787521765113 +9787521765144 +9787521765168 +9787521765182 +9787521765304 +9787521765328 +9787521765359 +9787521765366 +9787521765397 +9787521765410 +9787521765427 +9787521765458 +9787521765465 +9787521765472 +9787521765502 +9787521765526 +9787521765533 +9787521765540 +9787521765557 +9787521765588 +9787521765632 +9787521765649 +9787521765700 +9787521765731 +9787521765748 +9787521765755 +9787521765779 +9787521765854 +9787521765885 +9787521765892 +9787521765922 +9787521765939 +9787521765946 +9787521765960 +9787521765984 +9787521766004 +9787521766066 +9787521766189 +9787521766196 +9787521766202 +9787521766233 +9787521766271 +9787521766332 +9787521766349 +9787521766356 +9787521766363 +9787521766370 +9787521766387 +9787521766394 +9787521766400 +9787521766417 +9787521766424 +9787521766479 +9787521766493 +9787521766530 +9787521766592 +9787521766615 +9787521766622 +9787521766677 +9787521766684 +9787521766691 +9787521766707 +9787521766714 +9787521766745 +9787521766752 +9787521766783 +9787521766790 +9787521766912 +9787521766929 +9787521766943 +9787521766950 +9787521766967 +9787521767001 +9787521767032 +9787521767087 +9787521767094 +9787521767100 +9787521767117 +9787521767124 +9787521767131 +9787521767148 +9787521767155 +9787521767179 +9787521767193 +9787521767223 +9787521767285 +9787521767339 +9787521767353 +9787521767360 +9787521767377 +9787521767384 +9787521767445 +9787521767452 +9787521767476 +9787521767483 +9787521767506 +9787521767513 +9787521767520 +9787521767537 +9787521767544 +9787521767551 +9787521767599 +9787521767636 +9787521767742 +9787521767780 +9787521767803 +9787521767810 +9787521767827 +9787521767858 +9787521767865 +9787521767872 +9787521767889 +9787521767919 +9787521767926 +9787521767940 +9787521767957 +9787521767964 +9787521767995 +9787521768008 +9787521768015 +9787521768022 +9787521768046 +9787521768053 +9787521768060 +9787521768084 +9787521768091 +9787521768107 +9787521768114 +9787521768121 +9787521768138 +9787521768145 +9787521768152 +9787521768213 +9787521768244 +9787521768268 +9787521768275 +9787521768282 +9787521768299 +9787521768312 +9787521768336 +9787521768350 +9787521768367 +9787521768480 +9787521768527 +9787521768572 +9787521768602 +9787521768633 +9787521768671 +9787521768688 +9787521768695 +9787521768701 +9787521768756 +9787521768770 +9787521768824 +9787521768831 +9787521768848 +9787521768916 +9787521768923 +9787521768930 +9787521768978 +9787521768985 +9787521768992 +9787521769043 +9787521769111 +9787521769142 +9787521769159 +9787521769166 +9787521769227 +9787521769234 +9787521769272 +9787521769289 +9787521769296 +9787521769302 +9787521769319 +9787521769364 +9787521769371 +9787521769388 +9787521769401 +9787521769425 +9787521769432 +9787521769456 +9787521769463 +9787521769470 +9787521769494 +9787521769500 +9787521769517 +9787521769524 +9787521769555 +9787521769579 +9787521769586 +9787521769593 +9787521769609 +9787521769616 +9787521769623 +9787521769654 +9787521769678 +9787521769685 +9787521769708 +9787521769715 +9787521769814 +9787521769821 +9787521769845 +9787521769869 +9787521769906 +9787521769999 +9787521770001 +9787521770018 +9787521770025 +9787521770094 +9787521770155 +9787521770162 +9787521770216 +9787521770223 +9787521770230 +9787521770247 +9787521770261 +9787521770285 +9787521770292 +9787521770308 +9787521770322 +9787521770339 +9787521770346 +9787521770360 +9787521770391 +9787521770421 +9787521770469 +9787521770476 +9787521770483 +9787521770490 +9787521770513 +9787521770568 +9787521770575 +9787521770582 +9787521770599 +9787521770612 +9787521770674 +9787521770698 +9787521770742 +9787521770759 +9787521770780 +9787521770797 +9787521770827 +9787521770865 +9787521770896 +9787521770926 +9787521771022 +9787521771275 +9787521771282 +9787521771398 +9787521771626 +9787521771633 +9787521771640 +9787521771695 +9787521771701 +9787521771800 +9787521771817 +9787521771848 +9787521771855 +9787521771862 +9787521771916 +9787521771923 +9787521772012 +9787521772050 +9787521772074 +9787521772098 +9787521772128 +9787521772166 +9787521772203 +9787521772234 +9787521772340 +9787521772425 +9787521772432 +9787521772449 +9787521772487 +9787521772517 +9787521772524 +9787521772548 +9787521772555 +9787521772562 +9787521772593 +9787521772814 +9787521773026 +9787521773033 +9787521773040 +9787521773057 +9787521773064 +9787521773071 +9787521773088 +9787521773095 +9787521773101 +9787521773125 +9787521773132 +9787521773156 +9787521773224 +9787521773231 +9787521773248 +9787521773262 +9787521773286 +9787521773446 +9787521773491 +9787521773507 +9787521773521 +9787521773545 +9787521773552 +9787521773569 +9787521773583 +9787521773606 +9787521773620 +9787521773651 +9787521773682 +9787521773712 +9787521773729 +9787521773743 +9787521773774 +9787521773781 +9787521773804 +9787521773811 +9787521773828 +9787521773835 +9787521773842 +9787521773996 +9787521774016 +9787521774023 +9787521774030 +9787521774047 +9787521774054 +9787521774061 +9787521774078 +9787521774122 +9787521774245 +9787521774252 +9787521774306 +9787521774320 +9787521774351 +9787521774412 +9787521774429 +9787521774610 +9787521774641 +9787521774665 +9787521774672 +9787521774733 +9787521774757 +9787521774832 +9787521774986 +9787521774993 +9787521775181 +9787521775204 +9787521775259 +9787521775280 +9787521775358 +9787521775365 +9787521775402 +9787521775426 +9787521775464 +9787521775501 +9787521775518 +9787521775792 +9787521775846 +9787521775921 +9787521776249 +9787521776294 +9787521776423 +9787521776720 +9787521776829 +9787521777383 +9787521777451 +9787521777505 +9787521777512 +9787521777680 +9787521777864 +9787521778151 +9787521778335 +9787521778397 +9787521778694 +9787521778748 +9787521778755 +9787521778854 +9787521779158 +9787521803082 +9787521803334 +9787521803907 +9787521804386 +9787521804430 +9787521804447 +9787521804782 +9787521805659 +9787521805925 +9787521806007 +9787521806526 +9787521807271 +9787521807325 +9787521807684 +9787521807844 +9787521807929 +9787521808315 +9787521808650 +9787521808902 +9787521809169 +9787521809343 +9787521809862 +9787521811216 +9787521811735 +9787521812503 +9787521812633 +9787521812695 +9787521812961 +9787521813210 +9787521813319 +9787521813357 +9787521813487 +9787521814187 +9787521815191 +9787521815269 +9787521815344 +9787521815610 +9787521815658 +9787521815863 +9787521816617 +9787521816761 +9787521817294 +9787521817454 +9787521817652 +9787521817812 +9787521818383 +9787521818451 +9787521818482 +9787521820072 +9787521820478 +9787521821376 +9787521821444 +9787521822670 +9787521822960 +9787521823356 +9787521825138 +9787521825268 +9787521825381 +9787521825558 +9787521825749 +9787521825770 +9787521825800 +9787521826401 +9787521826647 +9787521826999 +9787521827309 +9787521827583 +9787521827705 +9787521827781 +9787521827811 +9787521828368 +9787521828795 +9787521828924 +9787521829006 +9787521829136 +9787521829419 +9787521829426 +9787521829945 +9787521830347 +9787521830798 +9787521830842 +9787521830996 +9787521831405 +9787521831948 +9787521832235 +9787521832464 +9787521833263 +9787521833607 +9787521833997 +9787521834154 +9787521834406 +9787521834437 +9787521834512 +9787521836417 +9787521836707 +9787521836769 +9787521837124 +9787521837339 +9787521837575 +9787521837650 +9787521839203 +9787521839357 +9787521840032 +9787521840049 +9787521840865 +9787521840872 +9787521841503 +9787521841664 +9787521841824 +9787521841923 +9787521842708 +9787521842838 +9787521843446 +9787521843484 +9787521843491 +9787521843767 +9787521843828 +9787521844405 +9787521844825 +9787521844917 +9787521845204 +9787521845266 +9787521845396 +9787521845747 +9787521846430 +9787521846461 +9787521847253 +9787521847352 +9787521847482 +9787521848038 +9787521848113 +9787521848151 +9787521848816 +9787521848854 +9787521849172 +9787521849226 +9787521849233 +9787521849912 +9787521849974 +9787521850079 +9787521850147 +9787521850239 +9787521850475 +9787521850987 +9787521851441 +9787521851809 +9787521851915 +9787521851984 +9787521852202 +9787521852271 +9787521852455 +9787521852592 +9787521852851 +9787521853827 +9787521853919 +9787521853926 +9787521853933 +9787521853940 +9787521854053 +9787521854923 +9787521855050 +9787521855456 +9787521855562 +9787521855623 +9787521855685 +9787521856026 +9787521856545 +9787521856552 +9787521856569 +9787521857221 +9787521857269 +9787521857306 +9787521857320 +9787521857450 +9787521857559 +9787521857924 +9787521857979 +9787521858648 +9787521858662 +9787521859195 +9787521859430 +9787521859867 +9787521860405 +9787521860634 +9787521860887 +9787521861112 +9787521861136 +9787521861297 +9787521862072 +9787521862829 +9787521862836 +9787521863451 +9787521863734 +9787521864946 +9787521864953 +9787521865127 +9787521867350 +9787521867602 +9787521869101 +9787521900484 +9787521900569 +9787521900811 +9787521900941 +9787521901771 +9787521902372 +9787521903003 +9787521903287 +9787521905359 +9787521906059 +9787521906981 +9787521907247 +9787521907506 +9787521907520 +9787521909173 +9787521909678 +9787521909692 +9787521909883 +9787521910452 +9787521910551 +9787521910612 +9787521911527 +9787521911763 +9787521912005 +9787521912050 +9787521912166 +9787521912319 +9787521912548 +9787521912616 +9787521912821 +9787521913712 +9787521914474 +9787521914733 +9787521914917 +9787521915631 +9787521915808 +9787521916591 +9787521917437 +9787521917697 +9787521917819 +9787521918052 +9787521918168 +9787521918441 +9787521918625 +9787521918915 +9787521918984 +9787521919059 +9787521919196 +9787521919455 +9787521919462 +9787521919486 +9787521919509 +9787521919837 +9787521920086 +9787521920154 +9787521920826 +9787521920994 +9787521921694 +9787521921779 +9787521921793 +9787521921915 +9787521921922 +9787521921977 +9787521921984 +9787521921991 +9787521922080 +9787521922172 +9787521922394 +9787521922677 +9787521923438 +9787521923490 +9787521924084 +9787521924183 +9787521924534 +9787521924718 +9787521924923 +9787521925098 +9787521925234 +9787521925777 +9787521925968 +9787521926019 +9787521926187 +9787521926194 +9787521926620 +9787521928310 +9787521929973 +9787522000091 +9787522000206 +9787522000305 +9787522000336 +9787522000343 +9787522000480 +9787522000558 +9787522000565 +9787522000725 +9787522000770 +9787522000978 +9787522001005 +9787522001821 +9787522002026 +9787522002163 +9787522002217 +9787522002460 +9787522002859 +9787522003207 +9787522003252 +9787522003528 +9787522003535 +9787522003573 +9787522003627 +9787522004150 +9787522004402 +9787522004723 +9787522004907 +9787522005003 +9787522005027 +9787522005034 +9787522005140 +9787522005171 +9787522005416 +9787522005447 +9787522005454 +9787522005737 +9787522006048 +9787522006321 +9787522006376 +9787522006444 +9787522006956 +9787522006994 +9787522007113 +9787522007526 +9787522007632 +9787522007878 +9787522007885 +9787522007892 +9787522008028 +9787522008226 +9787522008271 +9787522008356 +9787522008493 +9787522008509 +9787522008523 +9787522008745 +9787522008899 +9787522009001 +9787522009971 +9787522010069 +9787522010205 +9787522010236 +9787522010373 +9787522010564 +9787522010762 +9787522010786 +9787522010816 +9787522010854 +9787522010922 +9787522011127 +9787522011165 +9787522011264 +9787522011325 +9787522011363 +9787522011677 +9787522011776 +9787522011790 +9787522011974 +9787522011981 +9787522012070 +9787522012124 +9787522012179 +9787522012193 +9787522012261 +9787522012353 +9787522012605 +9787522012636 +9787522012926 +9787522013008 +9787522013565 +9787522013626 +9787522013657 +9787522013770 +9787522013978 +9787522014128 +9787522014159 +9787522014401 +9787522014494 +9787522014890 +9787522015095 +9787522015118 +9787522015460 +9787522015606 +9787522016047 +9787522016221 +9787522016238 +9787522016382 +9787522016566 +9787522016702 +9787522016733 +9787522016788 +9787522017068 +9787522017174 +9787522017181 +9787522017334 +9787522017631 +9787522017754 +9787522018058 +9787522018249 +9787522018270 +9787522018331 +9787522018355 +9787522018782 +9787522019031 +9787522019086 +9787522019222 +9787522019307 +9787522019536 +9787522019635 +9787522019666 +9787522019703 +9787522019765 +9787522019802 +9787522019918 +9787522019932 +9787522020129 +9787522020228 +9787522020235 +9787522020297 +9787522020402 +9787522020488 +9787522020495 +9787522020532 +9787522020549 +9787522020556 +9787522020662 +9787522020778 +9787522020792 +9787522020808 +9787522020839 +9787522021041 +9787522021065 +9787522021102 +9787522021133 +9787522021195 +9787522021225 +9787522021430 +9787522021621 +9787522021669 +9787522021683 +9787522021775 +9787522022130 +9787522022239 +9787522022291 +9787522022376 +9787522022406 +9787522022444 +9787522022642 +9787522022673 +9787522022703 +9787522022710 +9787522022765 +9787522023434 +9787522023458 +9787522023465 +9787522023472 +9787522023601 +9787522023656 +9787522023670 +9787522023687 +9787522023816 +9787522023984 +9787522024080 +9787522024127 +9787522024400 +9787522024462 +9787522024851 +9787522024875 +9787522024943 +9787522025018 +9787522025049 +9787522025261 +9787522025285 +9787522025292 +9787522025346 +9787522025582 +9787522026480 +9787522027036 +9787522027296 +9787522100937 +9787522101361 +9787522102948 +9787522103280 +9787522103457 +9787522105444 +9787522105604 +9787522106212 +9787522107691 +9787522107899 +9787522108155 +9787522108339 +9787522108513 +9787522109015 +9787522109718 +9787522110035 +9787522110059 +9787522110547 +9787522110592 +9787522110653 +9787522111650 +9787522111780 +9787522111940 +9787522111957 +9787522111988 +9787522111995 +9787522113197 +9787522113548 +9787522113944 +9787522114026 +9787522114538 +9787522114958 +9787522115207 +9787522115214 +9787522115306 +9787522116884 +9787522117164 +9787522117270 +9787522117317 +9787522117522 +9787522119885 +9787522120362 +9787522121253 +9787522121741 +9787522126586 +9787522127224 +9787522127897 +9787522128030 +9787522128702 +9787522128726 +9787522129136 +9787522129150 +9787522129167 +9787522129372 +9787522129402 +9787522129433 +9787522129457 +9787522129488 +9787522129693 +9787522129846 +9787522130705 +9787522130880 +9787522131108 +9787522132396 +9787522135854 +9787522137117 +9787522200194 +9787522200637 +9787522201238 +9787522201283 +9787522201337 +9787522201344 +9787522201566 +9787522201825 +9787522201832 +9787522202075 +9787522202457 +9787522202655 +9787522202679 +9787522202723 +9787522202853 +9787522203218 +9787522203294 +9787522204147 +9787522204437 +9787522204628 +9787522204642 +9787522204666 +9787522204932 +9787522204963 +9787522205021 +9787522205083 +9787522205090 +9787522205182 +9787522205205 +9787522205229 +9787522205236 +9787522205243 +9787522205250 +9787522205267 +9787522205281 +9787522205328 +9787522205359 +9787522205373 +9787522205434 +9787522205502 +9787522205533 +9787522205601 +9787522205663 +9787522205670 +9787522205694 +9787522205717 +9787522205762 +9787522205984 +9787522206042 +9787522206073 +9787522206127 +9787522206141 +9787522206233 +9787522206264 +9787522206486 +9787522206493 +9787522206509 +9787522206561 +9787522206622 +9787522206691 +9787522206790 +9787522206851 +9787522206875 +9787522206912 +9787522206943 +9787522207032 +9787522207070 +9787522207087 +9787522207148 +9787522207162 +9787522207186 +9787522207261 +9787522207285 +9787522207452 +9787522207476 +9787522207520 +9787522207629 +9787522207643 +9787522207742 +9787522207896 +9787522207971 +9787522208060 +9787522208183 +9787522208305 +9787522208428 +9787522208497 +9787522208541 +9787522208763 +9787522208985 +9787522300030 +9787522300184 +9787522300399 +9787522300610 +9787522301013 +9787522301303 +9787522301525 +9787522301679 +9787522301693 +9787522301792 +9787522302065 +9787522302546 +9787522302669 +9787522302836 +9787522302874 +9787522302898 +9787522303284 +9787522303680 +9787522304007 +9787522304038 +9787522305226 +9787522305325 +9787522305684 +9787522305929 +9787522306032 +9787522306162 +9787522306513 +9787522306537 +9787522306599 +9787522306681 +9787522306773 +9787522306971 +9787522307763 +9787522307800 +9787522308197 +9787522308470 +9787522308500 +9787522308517 +9787522308524 +9787522308999 +9787522309774 +9787522309965 +9787522310060 +9787522310251 +9787522310275 +9787522311081 +9787522311760 +9787522311791 +9787522311845 +9787522311869 +9787522312095 +9787522312453 +9787522312484 +9787522312491 +9787522312507 +9787522313177 +9787522313405 +9787522313412 +9787522313511 +9787522313801 +9787522313863 +9787522313887 +9787522314112 +9787522314549 +9787522314709 +9787522314938 +9787522315089 +9787522315249 +9787522315416 +9787522315447 +9787522315720 +9787522315980 +9787522316451 +9787522316789 +9787522316864 +9787522317762 +9787522317953 +9787522318219 +9787522318370 +9787522318448 +9787522318530 +9787522318875 +9787522319247 +9787522319544 +9787522320014 +9787522320144 +9787522320151 +9787522320380 +9787522320816 +9787522320885 +9787522320953 +9787522321028 +9787522321035 +9787522321059 +9787522321127 +9787522321134 +9787522321257 +9787522321509 +9787522321516 +9787522321547 +9787522321714 +9787522321837 +9787522321875 +9787522322001 +9787522322070 +9787522322247 +9787522322339 +9787522322421 +9787522322643 +9787522322711 +9787522322865 +9787522322964 +9787522323176 +9787522323190 +9787522323244 +9787522323503 +9787522323572 +9787522323725 +9787522323732 +9787522323862 +9787522324227 +9787522324241 +9787522324371 +9787522324432 +9787522324463 +9787522324548 +9787522324555 +9787522324586 +9787522324678 +9787522324753 +9787522324869 +9787522324883 +9787522324920 +9787522324982 +9787522325019 +9787522325118 +9787522325538 +9787522325675 +9787522325804 +9787522325927 +9787522326221 +9787522326238 +9787522326351 +9787522326450 +9787522326542 +9787522326603 +9787522327518 +9787522327723 +9787522327730 +9787522327747 +9787522327761 +9787522327822 +9787522327914 +9787522327976 +9787522328072 +9787522328195 +9787522328225 +9787522328423 +9787522328430 +9787522328447 +9787522328454 +9787522328461 +9787522328478 +9787522328553 +9787522328577 +9787522328584 +9787522328867 +9787522328973 +9787522329239 +9787522329246 +9787522329253 +9787522329260 +9787522329314 +9787522329475 +9787522329505 +9787522329727 +9787522329802 +9787522329819 +9787522329826 +9787522329925 +9787522330068 +9787522330686 +9787522330907 +9787522330976 +9787522331119 +9787522331126 +9787522331164 +9787522331195 +9787522331287 +9787522331324 +9787522331478 +9787522331973 +9787522331997 +9787522332475 +9787522332611 +9787522332697 +9787522332765 +9787522332987 +9787522333472 +9787522333502 +9787522333632 +9787522333786 +9787522333977 +9787522334011 +9787522334028 +9787522334035 +9787522334127 +9787522334318 +9787522334738 +9787522334929 +9787522334936 +9787522335278 +9787522335568 +9787522336657 +9787522336855 +9787522337104 +9787522337456 +9787522337487 +9787522337500 +9787522337517 +9787522337548 +9787522337555 +9787522337692 +9787522338156 +9787522338637 +9787522338866 +9787522409573 +9787522411798 +9787522418124 +9787522500249 +9787522500621 +9787522500959 +9787522501635 +9787522501925 +9787522502533 +9787522502755 +9787522502885 +9787522503301 +9787522504001 +9787522504322 +9787522505527 +9787522506128 +9787522506340 +9787522506357 +9787522506647 +9787522507668 +9787522508481 +9787522508610 +9787522508986 +9787522509358 +9787522509563 +9787522509655 +9787522510125 +9787522510187 +9787522510415 +9787522510422 +9787522511108 +9787522511214 +9787522511870 +9787522511979 +9787522511986 +9787522512471 +9787522512983 +9787522513348 +9787522513355 +9787522513744 +9787522513775 +9787522513911 +9787522514741 +9787522514963 +9787522515038 +9787522515380 +9787522515403 +9787522515519 +9787522515533 +9787522515939 +9787522516578 +9787522516851 +9787522516899 +9787522516929 +9787522517148 +9787522517155 +9787522517179 +9787522517537 +9787522517582 +9787522517643 +9787522517759 +9787522517773 +9787522517896 +9787522518008 +9787522518183 +9787522518626 +9787522518657 +9787522519418 +9787522519616 +9787522520087 +9787522520117 +9787522520322 +9787522520360 +9787522520544 +9787522520780 +9787522521060 +9787522521268 +9787522521428 +9787522521442 +9787522521510 +9787522521527 +9787522521879 +9787522522418 +9787522522449 +9787522522876 +9787522523064 +9787522523385 +9787522523392 +9787522523583 +9787522523729 +9787522523736 +9787522523774 +9787522524092 +9787522524115 +9787522524375 +9787522524412 +9787522524436 +9787522524665 +9787522524726 +9787522524757 +9787522524795 +9787522524818 +9787522524825 +9787522524993 +9787522525020 +9787522525167 +9787522525334 +9787522525396 +9787522525426 +9787522525617 +9787522525631 +9787522526027 +9787522526041 +9787522526058 +9787522526072 +9787522526102 +9787522526171 +9787522526560 +9787522526867 +9787522526973 +9787522526980 +9787522527222 +9787522527383 +9787522527406 +9787522527611 +9787522527635 +9787522527901 +9787522527949 +9787522528007 +9787522528168 +9787522528328 +9787522528564 +9787522528571 +9787522528632 +9787522528649 +9787522528809 +9787522528830 +9787522529271 +9787522529462 +9787522529530 +9787522529844 +9787522530239 +9787522530680 +9787522531717 +9787522531779 +9787522532424 +9787522532486 +9787522532523 +9787522532707 +9787522533339 +9787522533384 +9787522533391 +9787522533438 +9787522533599 +9787522533605 +9787522533711 +9787522533834 +9787522533964 +9787522534008 +9787522534039 +9787522534114 +9787522534145 +9787522535357 +9787522535388 +9787522535722 +9787522536149 +9787522536507 +9787522536705 +9787522537030 +9787522538273 +9787522538280 +9787522538495 +9787522539034 +9787522539041 +9787522539362 +9787522539522 +9787522600475 +9787522601007 +9787522601489 +9787522601885 +9787522602295 +9787522602523 +9787522602851 +9787522602974 +9787522603049 +9787522603315 +9787522603391 +9787522603735 +9787522603834 +9787522604077 +9787522604329 +9787522604435 +9787522604756 +9787522604770 +9787522604800 +9787522605531 +9787522606125 +9787522606187 +9787522606439 +9787522606453 +9787522606484 +9787522606538 +9787522606583 +9787522606613 +9787522606743 +9787522607351 +9787522607481 +9787522607825 +9787522607856 +9787522608327 +9787522608419 +9787522608488 +9787522608495 +9787522608631 +9787522608921 +9787522608938 +9787522609133 +9787522609140 +9787522609218 +9787522609300 +9787522609362 +9787522609645 +9787522609706 +9787522609942 +9787522610047 +9787522610337 +9787522611174 +9787522612249 +9787522612300 +9787522612454 +9787522612683 +9787522612744 +9787522612751 +9787522612874 +9787522612904 +9787522612928 +9787522612973 +9787522613444 +9787522613451 +9787522613789 +9787522614342 +9787522614441 +9787522614557 +9787522614649 +9787522614816 +9787522614908 +9787522615233 +9787522615264 +9787522615363 +9787522615585 +9787522615745 +9787522615783 +9787522615905 +9787522615943 +9787522615950 +9787522615967 +9787522616360 +9787522616483 +9787522616551 +9787522616728 +9787522617190 +9787522617367 +9787522617442 +9787522617657 +9787522617695 +9787522617893 +9787522617916 +9787522618210 +9787522618388 +9787522618401 +9787522618517 +9787522618531 +9787522618647 +9787522619255 +9787522619262 +9787522619699 +9787522619729 +9787522619804 +9787522619842 +9787522620398 +9787522620480 +9787522620596 +9787522620732 +9787522620787 +9787522621029 +9787522621128 +9787522621333 +9787522621616 +9787522622422 +9787522622484 +9787522622507 +9787522622538 +9787522622781 +9787522622972 +9787522623375 +9787522623900 +9787522623962 +9787522623986 +9787522624044 +9787522624327 +9787522624716 +9787522624761 +9787522624860 +9787522624891 +9787522624907 +9787522625027 +9787522625034 +9787522625133 +9787522625256 +9787522625355 +9787522625416 +9787522625508 +9787522625515 +9787522625713 +9787522625775 +9787522626062 +9787522626185 +9787522626192 +9787522626369 +9787522626420 +9787522626963 +9787522627304 +9787522627335 +9787522627359 +9787522627434 +9787522627861 +9787522628479 +9787522629742 +9787522630625 +9787522631691 +9787522631837 +9787522632117 +9787522632643 +9787522633336 +9787522633442 +9787522633749 +9787522633985 +9787522633992 +9787522634043 +9787522700489 +9787522700915 +9787522700960 +9787522701028 +9787522701127 +9787522701141 +9787522701943 +9787522702629 +9787522702896 +9787522703152 +9787522703299 +9787522703411 +9787522703633 +9787522704029 +9787522704630 +9787522705293 +9787522705484 +9787522705538 +9787522705996 +9787522706023 +9787522706191 +9787522707228 +9787522707709 +9787522707884 +9787522708096 +9787522708362 +9787522709147 +9787522709390 +9787522709789 +9787522710259 +9787522710280 +9787522710358 +9787522710679 +9787522710723 +9787522711102 +9787522711294 +9787522711331 +9787522712352 +9787522712642 +9787522713137 +9787522713434 +9787522714202 +9787522714431 +9787522714455 +9787522714905 +9787522715032 +9787522715223 +9787522715452 +9787522715643 +9787522715940 +9787522716091 +9787522716183 +9787522716268 +9787522716282 +9787522716398 +9787522716404 +9787522716473 +9787522716534 +9787522716749 +9787522716756 +9787522716879 +9787522716947 +9787522716992 +9787522717036 +9787522717050 +9787522717210 +9787522717227 +9787522717333 +9787522717708 +9787522717739 +9787522717982 +9787522718002 +9787522718040 +9787522718170 +9787522718217 +9787522718453 +9787522718583 +9787522718668 +9787522718682 +9787522718774 +9787522718996 +9787522719108 +9787522719245 +9787522719436 +9787522719474 +9787522719535 +9787522719610 +9787522719740 +9787522719993 +9787522720074 +9787522720210 +9787522720265 +9787522720562 +9787522720760 +9787522720975 +9787522721163 +9787522721286 +9787522721316 +9787522721361 +9787522721552 +9787522722023 +9787522722559 +9787522722825 +9787522722955 +9787522723525 +9787522723549 +9787522723631 +9787522723686 +9787522723693 +9787522724027 +9787522724058 +9787522724201 +9787522724294 +9787522724355 +9787522724782 +9787522724874 +9787522725130 +9787522725208 +9787522725420 +9787522725741 +9787522726373 +9787522726403 +9787522726410 +9787522726991 +9787522727639 +9787522727752 +9787522727806 +9787522727899 +9787522727998 +9787522728261 +9787522728315 +9787522728421 +9787522728780 +9787522728896 +9787522729916 +9787522730141 +9787522730165 +9787522730226 +9787522730240 +9787522730400 +9787522730691 +9787522730929 +9787522731049 +9787522731162 +9787522731186 +9787522731216 +9787522731278 +9787522731322 +9787522731414 +9787522731469 +9787522731506 +9787522731551 +9787522731568 +9787522731667 +9787522731704 +9787522731742 +9787522732039 +9787522732046 +9787522732060 +9787522732275 +9787522732312 +9787522732343 +9787522732381 +9787522732404 +9787522732848 +9787522733029 +9787522733067 +9787522733319 +9787522733395 +9787522733876 +9787522734118 +9787522734880 +9787522735122 +9787522735146 +9787522735177 +9787522735214 +9787522735252 +9787522735276 +9787522735788 +9787522735863 +9787522735924 +9787522736167 +9787522736174 +9787522736426 +9787522736617 +9787522736914 +9787522736938 +9787522737379 +9787522737607 +9787522737782 +9787522737867 +9787522737911 +9787522737928 +9787522737966 +9787522738017 +9787522738123 +9787522738130 +9787522738642 +9787522738789 +9787522738888 +9787522739038 +9787522739496 +9787522739755 +9787522739946 +9787522740096 +9787522740393 +9787522740454 +9787522740515 +9787522740881 +9787522741017 +9787522741116 +9787522741130 +9787522741475 +9787522741512 +9787522741536 +9787522742045 +9787522742908 +9787522742922 +9787522743189 +9787522743370 +9787522743653 +9787522743660 +9787522743875 +9787522744735 +9787522745428 +9787522745602 +9787522745664 +9787522745695 +9787522747064 +9787522747330 +9787522747484 +9787522748108 +9787522749365 +9787522749778 +9787522800783 +9787522800912 +9787522801018 +9787522801384 +9787522801407 +9787522801599 +9787522801728 +9787522801797 +9787522802619 +9787522802749 +9787522802862 +9787522803128 +9787522803548 +9787522803661 +9787522803708 +9787522803753 +9787522804149 +9787522804385 +9787522804545 +9787522804651 +9787522804712 +9787522804989 +9787522805122 +9787522805368 +9787522805702 +9787522805733 +9787522805818 +9787522806051 +9787522806068 +9787522806198 +9787522806211 +9787522806396 +9787522806655 +9787522806761 +9787522806860 +9787522806877 +9787522806914 +9787522807034 +9787522807119 +9787522807621 +9787522807645 +9787522807805 +9787522807980 +9787522808017 +9787522808031 +9787522808130 +9787522808185 +9787522808321 +9787522808352 +9787522808888 +9787522808901 +9787522808994 +9787522809755 +9787522810171 +9787522810294 +9787522810355 +9787522810409 +9787522810607 +9787522810874 +9787522810959 +9787522811017 +9787522811123 +9787522811345 +9787522811505 +9787522811840 +9787522811888 +9787522811987 +9787522812021 +9787522812205 +9787522812212 +9787522812311 +9787522812328 +9787522812465 +9787522812496 +9787522812649 +9787522812663 +9787522812694 +9787522812885 +9787522812960 +9787522813226 +9787522813608 +9787522813646 +9787522813721 +9787522814360 +9787522814384 +9787522814568 +9787522814636 +9787522815091 +9787522815121 +9787522815343 +9787522815503 +9787522815565 +9787522815572 +9787522815619 +9787522815640 +9787522815732 +9787522815749 +9787522816067 +9787522816081 +9787522816272 +9787522816340 +9787522816425 +9787522816753 +9787522816777 +9787522816838 +9787522816876 +9787522816883 +9787522816913 +9787522816975 +9787522817026 +9787522817088 +9787522817200 +9787522817415 +9787522817569 +9787522817583 +9787522817842 +9787522817859 +9787522817941 +9787522817989 +9787522817996 +9787522818016 +9787522818139 +9787522818245 +9787522818313 +9787522818498 +9787522818764 +9787522819068 +9787522819105 +9787522819181 +9787522819242 +9787522819488 +9787522819693 +9787522819839 +9787522819884 +9787522820002 +9787522820088 +9787522820217 +9787522820224 +9787522820279 +9787522820361 +9787522820378 +9787522820477 +9787522820569 +9787522820606 +9787522820651 +9787522820828 +9787522820835 +9787522820897 +9787522820927 +9787522821047 +9787522821054 +9787522821092 +9787522821108 +9787522821221 +9787522821375 +9787522821597 +9787522821764 +9787522821818 +9787522821979 +9787522822068 +9787522822204 +9787522822280 +9787522822709 +9787522822747 +9787522822792 +9787522822952 +9787522822983 +9787522823102 +9787522823119 +9787522823195 +9787522823317 +9787522823386 +9787522823560 +9787522823591 +9787522823676 +9787522823690 +9787522823713 +9787522823805 +9787522823812 +9787522823904 +9787522823997 +9787522824048 +9787522824116 +9787522824628 +9787522824666 +9787522824710 +9787522824789 +9787522824963 +9787522825045 +9787522825052 +9787522825069 +9787522825236 +9787522825267 +9787522825274 +9787522825298 +9787522825328 +9787522825366 +9787522825571 +9787522825595 +9787522825663 +9787522825748 +9787522825991 +9787522826059 +9787522826080 +9787522826257 +9787522826462 +9787522826509 +9787522826523 +9787522826608 +9787522826615 +9787522826783 +9787522826851 +9787522826912 +9787522826929 +9787522826936 +9787522826943 +9787522826967 +9787522827056 +9787522827063 +9787522827216 +9787522827223 +9787522827230 +9787522827490 +9787522827605 +9787522827629 +9787522827872 +9787522827889 +9787522828015 +9787522828220 +9787522828312 +9787522828374 +9787522828572 +9787522828633 +9787522828671 +9787522828718 +9787522828831 +9787522828893 +9787522829043 +9787522829241 +9787522829289 +9787522829371 +9787522829531 +9787522829548 +9787522829562 +9787522829661 +9787522829746 +9787522830032 +9787522830308 +9787522830452 +9787522830629 +9787522830735 +9787522830933 +9787522830957 +9787522830964 +9787522831251 +9787522831299 +9787522831305 +9787522831435 +9787522831466 +9787522831480 +9787522831671 +9787522831756 +9787522831947 +9787522832159 +9787522832241 +9787522832937 +9787522832968 +9787522832982 +9787522833132 +9787522833231 +9787522833293 +9787522833316 +9787522833323 +9787522833460 +9787522833637 +9787522833750 +9787522833828 +9787522833842 +9787522833972 +9787522834030 +9787522834054 +9787522834092 +9787522834344 +9787522834351 +9787522834382 +9787522834474 +9787522834535 +9787522834580 +9787522834597 +9787522834795 +9787522834894 +9787522834986 +9787522835105 +9787522835143 +9787522835174 +9787522835396 +9787522835402 +9787522835594 +9787522835747 +9787522835853 +9787522836171 +9787522836256 +9787522836461 +9787522836546 +9787522836577 +9787522836775 +9787522836881 +9787522837000 +9787522837086 +9787522837109 +9787522837215 +9787522837314 +9787522837321 +9787522837413 +9787522837581 +9787522837598 +9787522837680 +9787522837734 +9787522837826 +9787522837918 +9787522838137 +9787522838168 +9787522838373 +9787522838472 +9787522838724 +9787522838748 +9787522838755 +9787522838847 +9787522838878 +9787522838915 +9787522838922 +9787522839509 +9787522839523 +9787522839530 +9787522839875 +9787522839998 +9787522840369 +9787522840512 +9787522840567 +9787522841069 +9787522841113 +9787522841700 +9787522841960 +9787522842264 +9787522842592 +9787522842639 +9787522843049 +9787522843070 +9787522843681 +9787522843834 +9787522844299 +9787522844725 +9787522845050 +9787522845081 +9787522845685 +9787522845746 +9787522845821 +9787522845951 +9787522846330 +9787522846842 +9787522847238 +9787522847290 +9787522847412 +9787522848013 +9787522848686 +9787522848761 +9787522848839 +9787522848884 +9787522849379 +9787522849393 +9787522850030 +9787522850344 +9787522850399 +9787522850634 +9787522850764 +9787522850962 +9787522851037 +9787522851242 +9787522852348 +9787522852355 +9787522852553 +9787522852638 +9787522852881 +9787522855226 +9787522900049 +9787522900247 +9787522900544 +9787522900681 +9787522900841 +9787522901541 +9787522901619 +9787522901626 +9787522902210 +9787522902357 +9787522902470 +9787522902586 +9787522902708 +9787522903149 +9787522903255 +9787522903798 +9787522903835 +9787522903859 +9787522903903 +9787522903996 +9787522904160 +9787522904184 +9787522904313 +9787522904610 +9787522904634 +9787522905204 +9787522905273 +9787522905303 +9787522905372 +9787522905396 +9787522905624 +9787522906461 +9787522906492 +9787522906591 +9787522906669 +9787522906713 +9787522906799 +9787522906805 +9787522906942 +9787522907055 +9787522907086 +9787522907291 +9787522908144 +9787522908250 +9787522908373 +9787522908410 +9787522908526 +9787522908601 +9787522908625 +9787522908687 +9787522908694 +9787522908755 +9787522908779 +9787522908823 +9787522909066 +9787522909097 +9787522909141 +9787522909301 +9787522909325 +9787522909479 +9787522909677 +9787522909684 +9787522909875 +9787522910475 +9787522910482 +9787522910628 +9787522910659 +9787522910727 +9787522910925 +9787522910949 +9787522911069 +9787522911281 +9787522911311 +9787522911410 +9787522911571 +9787522911663 +9787522911779 +9787522911793 +9787522911816 +9787522911977 +9787522912141 +9787522912301 +9787522913285 +9787522913698 +9787522913902 +9787522913940 +9787522914169 +9787522914657 +9787522914763 +9787522914787 +9787522914848 +9787522914961 +9787522915272 +9787522915531 +9787522915548 +9787522915586 +9787522915593 +9787522915609 +9787522915630 +9787522915784 +9787522915852 +9787522916002 +9787522916040 +9787522916712 +9787522917054 +9787522917573 +9787522917863 +9787522918754 +9787522918884 +9787522919034 +9787522919102 +9787522919300 +9787522919799 +9787522919843 +9787522919980 +9787522920016 +9787522920252 +9787522920412 +9787522921358 +9787522921389 +9787522921952 +9787522922096 +9787522922201 +9787522923307 +9787522925271 +9787522925394 +9787522925677 +9787522925783 +9787522925844 +9787522926315 +9787522927435 +9787522927619 +9787522929187 +9787522929958 +9787523000267 +9787523001271 +9787523001431 +9787523001905 +9787523001974 +9787523002063 +9787523002193 +9787523003473 +9787523003596 +9787523003602 +9787523003619 +9787523003626 +9787523003671 +9787523003893 +9787523003961 +9787523004135 +9787523004173 +9787523004470 +9787523004869 +9787523005293 +9787523005323 +9787523005569 +9787523101261 +9787523101278 +9787523101445 +9787523101834 +9787523102350 +9787523102916 +9787523103128 +9787523103227 +9787523103258 +9787523103562 +9787523103586 +9787523103609 +9787523103630 +9787523103746 +9787523103869 +9787523104170 +9787523104194 +9787523104361 +9787523104392 +9787523104408 +9787523104569 +9787523104583 +9787523105320 +9787523105344 +9787523106136 +9787523106570 +9787523106679 +9787523106686 +9787523106716 +9787523107140 +9787523107157 +9787523107393 +9787523107553 +9787523107621 +9787523107652 +9787523107782 +9787523108079 +9787523108369 +9787523108376 +9787523108598 +9787523108642 +9787523109014 +9787523109052 +9787523109588 +9787523109793 +9787523110072 +9787523110089 +9787523110096 +9787523110133 +9787523110164 +9787523110782 +9787523111086 +9787523111338 +9787523111970 +9787523112830 +9787523113301 +9787523113745 +9787523113752 +9787523113882 +9787523113998 +9787523114094 +9787523114100 +9787523114193 +9787523116111 +9787523127292 +9787523200186 +9787523200278 +9787523200490 +9787523200582 +9787523200810 +9787523200889 +9787523201008 +9787523201022 +9787523201114 +9787523201596 +9787523201688 +9787523201701 +9787523201725 +9787523201756 +9787523201763 +9787523201848 +9787523201909 +9787523202128 +9787523202166 +9787523202173 +9787523202265 +9787523202395 +9787523202401 +9787523202432 +9787523202449 +9787523202487 +9787523202494 +9787523202500 +9787523202524 +9787523202654 +9787523202708 +9787523202739 +9787523202838 +9787523202845 +9787523202852 +9787523202869 +9787523203101 +9787523203262 +9787523203705 +9787523204092 +9787523204443 +9787523204450 +9787523204481 +9787523204573 +9787523204702 +9787523204849 +9787523204979 +9787523204986 +9787523204993 +9787523205051 +9787523205426 +9787523205457 +9787523205525 +9787523205624 +9787523206249 +9787523206287 +9787523206300 +9787523206324 +9787523206362 +9787523206379 +9787523206416 +9787523206423 +9787523206546 +9787523206577 +9787523206669 +9787523206744 +9787523206775 +9787523206782 +9787523206799 +9787523206805 +9787523207017 +9787523207093 +9787523207444 +9787523207451 +9787523207482 +9787523207888 +9787523207918 +9787523207956 +9787523208120 +9787523208168 +9787523208236 +9787523208359 +9787523208380 +9787523208397 +9787523208649 +9787523208656 +9787523208687 +9787523208762 +9787523209042 +9787523209080 +9787523209097 +9787523209196 +9787523209202 +9787523209578 +9787523209837 +9787523209868 +9787523210024 +9787523210239 +9787523210482 +9787523210499 +9787523210765 +9787523210819 +9787523210963 +9787523211052 +9787523211076 +9787523211137 +9787523211304 +9787523211427 +9787523211557 +9787523211588 +9787523211595 +9787523211601 +9787523211618 +9787523211625 +9787523211717 +9787523211731 +9787523211755 +9787523211762 +9787523211908 +9787523211939 +9787523212158 +9787523212233 +9787523212257 +9787523212622 +9787523212714 +9787523212776 +9787523212783 +9787523213391 +9787523213551 +9787523213650 +9787523213704 +9787523213711 +9787523213735 +9787523213766 +9787523213834 +9787523213957 +9787523214756 +9787523214794 +9787523215197 +9787523215210 +9787523215265 +9787523215784 +9787523216187 +9787523216866 +9787523216873 +9787523217399 +9787523218037 +9787523218235 +9787523218242 +9787523218389 +9787523218402 +9787523218709 +9787523219966 +9787523220672 +9787523221136 +9787523222249 +9787523300008 +9787523400838 +9787523401118 +9787523401149 +9787523401194 +9787523401392 +9787523401507 +9787523401521 +9787523402047 +9787523402085 +9787523402108 +9787523402351 +9787523402375 +9787523402382 +9787523402535 +9787523402573 +9787523402849 +9787523402955 +9787523402962 +9787523403037 +9787523403495 +9787523403563 +9787523403617 +9787523403662 +9787523403785 +9787523403877 +9787523403921 +9787523404140 +9787523404157 +9787523404294 +9787523404348 +9787523404683 +9787523404720 +9787523404768 +9787523404867 +9787523404973 +9787523405079 +9787523405581 +9787523405710 +9787523405734 +9787523405758 +9787523405888 +9787523406021 +9787523406069 +9787523406182 +9787523406755 +9787523406915 +9787523406922 +9787523406977 +9787523407059 +9787523407400 +9787523407738 +9787523407776 +9787523408117 +9787523408131 +9787523408155 +9787523408186 +9787523408292 +9787523408391 +9787523408568 +9787523408674 +9787523409084 +9787523409206 +9787523409237 +9787523409251 +9787523409336 +9787523409343 +9787523410073 +9787523410141 +9787523410158 +9787523410349 +9787523410400 +9787523410622 +9787523410707 +9787523410882 +9787523411438 +9787523411612 +9787523411636 +9787523411704 +9787523411957 +9787523412046 +9787523412138 +9787523412251 +9787523412503 +9787523412527 +9787523412541 +9787523412633 +9787523412947 +9787523412985 +9787523413241 +9787523413555 +9787523413654 +9787523413753 +9787523413814 +9787523413982 +9787523414040 +9787523414118 +9787523414361 +9787523414767 +9787523415092 +9787523415108 +9787523416280 +9787523416303 +9787523416327 +9787523416396 +9787523416464 +9787523416594 +9787523416600 +9787523416655 +9787523416914 +9787523417133 +9787523417164 +9787523417317 +9787523417331 +9787523417362 +9787523417386 +9787523500149 +9787523500507 +9787523500996 +9787523501559 +9787523501740 +9787523501863 +9787523502297 +9787523503188 +9787523503843 +9787523504215 +9787523504826 +9787523505014 +9787523505151 +9787523505915 +9787523506035 +9787523506059 +9787523506158 +9787523506189 +9787523506417 +9787523506646 +9787523507254 +9787523507445 +9787523507742 +9787523507780 +9787523508121 +9787523508138 +9787523508497 +9787523508534 +9787523508657 +9787523508701 +9787523508749 +9787523508763 +9787523508831 +9787523509487 +9787523509937 +9787523510513 +9787523510728 +9787523511091 +9787523511114 +9787523511541 +9787523511565 +9787523511633 +9787523511947 +9787523512258 +9787523512425 +9787523512760 +9787523513255 +9787523513477 +9787523513491 +9787523513569 +9787523513941 +9787523514146 +9787523514382 +9787523514610 +9787523515310 +9787523515471 +9787523515587 +9787523515808 +9787523515969 +9787523516171 +9787523516324 +9787523516799 +9787523517277 +9787523518588 +9787523519080 +9787523519240 +9787523519608 +9787523519936 +9787523520130 +9787523520413 +9787523520666 +9787523521090 +9787523521151 +9787523521434 +9787523521762 +9787523600047 +9787523600115 +9787523600122 +9787523600436 +9787523600504 +9787523600528 +9787523600603 +9787523600740 +9787523600825 +9787523600931 +9787523601099 +9787523601112 +9787523601402 +9787523601501 +9787523601594 +9787523601648 +9787523601693 +9787523601761 +9787523601785 +9787523601969 +9787523602003 +9787523602157 +9787523602232 +9787523602263 +9787523602355 +9787523602461 +9787523602485 +9787523602553 +9787523602577 +9787523602621 +9787523602652 +9787523602768 +9787523602928 +9787523602935 +9787523602980 +9787523603055 +9787523603086 +9787523603130 +9787523603147 +9787523603192 +9787523603253 +9787523603345 +9787523603369 +9787523603437 +9787523603512 +9787523603529 +9787523603581 +9787523603604 +9787523603642 +9787523603659 +9787523603666 +9787523603680 +9787523603703 +9787523603789 +9787523603833 +9787523604021 +9787523604083 +9787523604113 +9787523604120 +9787523604168 +9787523604175 +9787523604182 +9787523604212 +9787523604229 +9787523604274 +9787523604281 +9787523604359 +9787523604366 +9787523604380 +9787523604434 +9787523604564 +9787523604595 +9787523604687 +9787523604755 +9787523604779 +9787523604809 +9787523604816 +9787523604823 +9787523604960 +9787523605103 +9787523605196 +9787523605257 +9787523605264 +9787523605295 +9787523605301 +9787523605349 +9787523605387 +9787523605394 +9787523605400 +9787523605417 +9787523605431 +9787523605455 +9787523605486 +9787523605509 +9787523605516 +9787523605578 +9787523605608 +9787523605622 +9787523605677 +9787523605745 +9787523605790 +9787523605912 +9787523605929 +9787523605936 +9787523605981 +9787523606001 +9787523606032 +9787523606049 +9787523606056 +9787523606148 +9787523606155 +9787523606315 +9787523606339 +9787523606346 +9787523606445 +9787523606469 +9787523606476 +9787523606520 +9787523606599 +9787523606605 +9787523606643 +9787523606711 +9787523606728 +9787523606759 +9787523606803 +9787523607152 +9787523607169 +9787523607268 +9787523607343 +9787523607480 +9787523607541 +9787523607558 +9787523607657 +9787523607664 +9787523607688 +9787523607718 +9787523607763 +9787523607961 +9787523608036 +9787523608043 +9787523608050 +9787523608081 +9787523608135 +9787523608180 +9787523608203 +9787523608289 +9787523608357 +9787523608432 +9787523608487 +9787523608517 +9787523608524 +9787523608531 +9787523608562 +9787523608616 +9787523609309 +9787523609316 +9787523609323 +9787523609330 +9787523609477 +9787523609538 +9787523609576 +9787523609637 +9787523609651 +9787523609675 +9787523609682 +9787523609859 +9787523609903 +9787523610008 +9787523610022 +9787523610039 +9787523610046 +9787523610091 +9787523610107 +9787523610138 +9787523610176 +9787523610183 +9787523610282 +9787523610299 +9787523610343 +9787523610350 +9787523610398 +9787523610404 +9787523610428 +9787523610688 +9787523610763 +9787523610947 +9787523610978 +9787523610992 +9787523611111 +9787523611142 +9787523611197 +9787523611340 +9787523611401 +9787523611432 +9787523611586 +9787523611661 +9787523611678 +9787523611685 +9787523611920 +9787523611982 +9787523612149 +9787523612170 +9787523612279 +9787523612286 +9787523612644 +9787523612651 +9787523613412 +9787523613634 +9787523613672 +9787523613771 +9787523613825 +9787523700082 +9787523700235 +9787523700402 +9787523700426 +9787523700495 +9787523700822 +9787523700976 +9787523701171 +9787523701188 +9787523701195 +9787523701485 +9787523701508 +9787523701522 +9787523701683 +9787523702383 +9787523702512 +9787523702949 +9787523702994 +9787523703625 +9787523703649 +9787523703656 +9787523703687 +9787523703731 +9787523704585 +9787523704769 +9787523704790 +9787523705247 +9787523705261 +9787523705285 +9787523705308 +9787523705322 +9787523705339 +9787523705988 +9787523706145 +9787523706237 +9787523706329 +9787523706619 +9787523706817 +9787523706893 +9787523706930 +9787523707623 +9787523707661 +9787523707685 +9787523707777 +9787523707838 +9787523709061 +9787523710753 +9787523711316 +9787523711675 +9787523711798 +9787523711859 +9787523728468 +9787523802434 +9787523900383 +9787524100379 +9787524301417 +9787524302353 +9787524302667 +9787524400288 +9787524400349 +9787524400455 +9787524400660 +9787524400868 +9787524400905 +9787524400950 +9787524400967 +9787524401483 +9787524401568 +9787524401599 +9787524401643 +9787524401759 +9787524401933 +9787524401988 +9787524402282 +9787524402671 +9787524402817 +9787524403029 +9787524403180 +9787524404668 +9787524404996 +9787524406242 +9787525413782 +9787527602702 +9787530000007 +9787530000106 +9787530000144 +9787530000151 +9787530000236 +9787530000243 +9787530000366 +9787530000380 +9787530000403 +9787530000526 +9787530000625 +9787530000670 +9787530000717 +9787530000823 +9787530000847 +9787530000939 +9787530000946 +9787530000977 +9787530000984 +9787530001028 +9787530001035 +9787530001042 +9787530001134 +9787530001264 +9787530001318 +9787530001356 +9787530001462 +9787530001479 +9787530001585 +9787530001752 +9787530001981 +9787530002315 +9787530002322 +9787530002377 +9787530002384 +9787530002599 +9787530002865 +9787530002872 +9787530002919 +9787530002957 +9787530003169 +9787530003206 +9787530003329 +9787530003381 +9787530003442 +9787530003558 +9787530003565 +9787530003664 +9787530003695 +9787530003879 +9787530004029 +9787530004081 +9787530004234 +9787530004302 +9787530004470 +9787530004487 +9787530004579 +9787530004609 +9787530004623 +9787530004630 +9787530004647 +9787530004678 +9787530004777 +9787530004791 +9787530004814 +9787530004951 +9787530005002 +9787530005019 +9787530005026 +9787530005033 +9787530005194 +9787530005217 +9787530005231 +9787530005255 +9787530005262 +9787530005286 +9787530005309 +9787530005378 +9787530005392 +9787530005491 +9787530005507 +9787530005613 +9787530005859 +9787530005873 +9787530005880 +9787530005903 +9787530005934 +9787530006016 +9787530006238 +9787530006375 +9787530006405 +9787530100134 +9787530100486 +9787530100509 +9787530100516 +9787530100998 +9787530101209 +9787530101292 +9787530101391 +9787530101636 +9787530101971 +9787530101988 +9787530102176 +9787530102572 +9787530103487 +9787530103494 +9787530103807 +9787530104132 +9787530104675 +9787530104927 +9787530104934 +9787530104972 +9787530104989 +9787530104996 +9787530105009 +9787530105016 +9787530105030 +9787530105047 +9787530105054 +9787530105061 +9787530105078 +9787530105085 +9787530105146 +9787530105184 +9787530105481 +9787530105498 +9787530105665 +9787530105702 +9787530105740 +9787530105924 +9787530105993 +9787530106006 +9787530106037 +9787530106051 +9787530106099 +9787530106150 +9787530106310 +9787530106334 +9787530106440 +9787530106471 +9787530106938 +9787530107027 +9787530107706 +9787530107973 +9787530108376 +9787530108871 +9787530109038 +9787530109281 +9787530109298 +9787530109618 +9787530109700 +9787530109748 +9787530109762 +9787530109779 +9787530110034 +9787530110065 +9787530110089 +9787530110447 +9787530110508 +9787530110775 +9787530111130 +9787530111338 +9787530111376 +9787530111383 +9787530111598 +9787530111604 +9787530111666 +9787530111680 +9787530112007 +9787530112014 +9787530112137 +9787530112151 +9787530112359 +9787530112366 +9787530112380 +9787530112403 +9787530112410 +9787530112434 +9787530112571 +9787530112588 +9787530112595 +9787530112601 +9787530112618 +9787530112687 +9787530112700 +9787530112724 +9787530112762 +9787530113059 +9787530113172 +9787530113189 +9787530113370 +9787530113394 +9787530113592 +9787530113868 +9787530113899 +9787530113912 +9787530113936 +9787530113943 +9787530113950 +9787530114636 +9787530114773 +9787530114896 +9787530115329 +9787530115336 +9787530115350 +9787530115718 +9787530115886 +9787530115930 +9787530116173 +9787530116180 +9787530116227 +9787530116258 +9787530116715 +9787530116777 +9787530116845 +9787530116869 +9787530116876 +9787530116937 +9787530116944 +9787530117071 +9787530117309 +9787530117521 +9787530117699 +9787530118481 +9787530118498 +9787530118627 +9787530118702 +9787530118726 +9787530119099 +9787530119143 +9787530119198 +9787530119235 +9787530119242 +9787530119365 +9787530119457 +9787530119464 +9787530119471 +9787530119570 +9787530119914 +9787530120033 +9787530120118 +9787530120347 +9787530120682 +9787530120712 +9787530120729 +9787530120736 +9787530121573 +9787530121702 +9787530122365 +9787530122396 +9787530122815 +9787530123973 +9787530124000 +9787530124277 +9787530124284 +9787530124291 +9787530124314 +9787530124345 +9787530124802 +9787530125069 +9787530125458 +9787530125809 +9787530125878 +9787530126141 +9787530126318 +9787530126332 +9787530126592 +9787530126608 +9787530126639 +9787530126653 +9787530126660 +9787530126677 +9787530126707 +9787530126714 +9787530126721 +9787530126813 +9787530126851 +9787530126905 +9787530127391 +9787530127421 +9787530127445 +9787530127469 +9787530127483 +9787530127490 +9787530127506 +9787530127513 +9787530127520 +9787530127926 +9787530128053 +9787530128077 +9787530128251 +9787530128268 +9787530128350 +9787530128459 +9787530129098 +9787530129128 +9787530129180 +9787530129432 +9787530129456 +9787530129548 +9787530130100 +9787530130131 +9787530130179 +9787530130186 +9787530130759 +9787530130803 +9787530130827 +9787530130841 +9787530130858 +9787530131237 +9787530131510 +9787530131541 +9787530131589 +9787530132012 +9787530132265 +9787530132319 +9787530132456 +9787530132777 +9787530132784 +9787530132791 +9787530132869 +9787530132883 +9787530132920 +9787530132951 +9787530132982 +9787530132999 +9787530133002 +9787530133064 +9787530133071 +9787530133538 +9787530133545 +9787530134320 +9787530134498 +9787530134559 +9787530135372 +9787530135396 +9787530135426 +9787530135501 +9787530135525 +9787530135532 +9787530137345 +9787530137536 +9787530137550 +9787530137642 +9787530137673 +9787530137802 +9787530137963 +9787530137987 +9787530137994 +9787530138038 +9787530138083 +9787530138106 +9787530138151 +9787530138588 +9787530138625 +9787530138656 +9787530138755 +9787530138779 +9787530138793 +9787530138809 +9787530138823 +9787530138977 +9787530139233 +9787530139479 +9787530139493 +9787530139912 +9787530139929 +9787530140383 +9787530140390 +9787530140413 +9787530140420 +9787530140451 +9787530140475 +9787530140482 +9787530140499 +9787530140598 +9787530140628 +9787530141007 +9787530141182 +9787530141199 +9787530141229 +9787530141236 +9787530141472 +9787530141687 +9787530141694 +9787530141700 +9787530141724 +9787530141748 +9787530141762 +9787530142066 +9787530142141 +9787530142165 +9787530142301 +9787530142325 +9787530142363 +9787530142387 +9787530142424 +9787530142561 +9787530143322 +9787530143353 +9787530143483 +9787530143490 +9787530143933 +9787530144312 +9787530144770 +9787530145548 +9787530145586 +9787530145784 +9787530145937 +9787530145944 +9787530145975 +9787530146033 +9787530146057 +9787530146125 +9787530146729 +9787530146880 +9787530146897 +9787530147047 +9787530147054 +9787530147061 +9787530147078 +9787530147085 +9787530147092 +9787530147191 +9787530147443 +9787530147573 +9787530147580 +9787530148006 +9787530148068 +9787530148549 +9787530148709 +9787530149188 +9787530149195 +9787530149201 +9787530149218 +9787530149225 +9787530149232 +9787530149249 +9787530149584 +9787530149874 +9787530149881 +9787530149898 +9787530149904 +9787530149911 +9787530150320 +9787530150337 +9787530150894 +9787530150917 +9787530150931 +9787530151198 +9787530151204 +9787530151211 +9787530151297 +9787530151303 +9787530151617 +9787530151914 +9787530151921 +9787530151938 +9787530152034 +9787530152058 +9787530152065 +9787530152102 +9787530152126 +9787530152157 +9787530153079 +9787530153376 +9787530153536 +9787530153628 +9787530153772 +9787530153949 +9787530153994 +9787530154274 +9787530154328 +9787530154625 +9787530154632 +9787530154649 +9787530154717 +9787530154960 +9787530155028 +9787530155042 +9787530155059 +9787530155066 +9787530155158 +9787530155301 +9787530155363 +9787530155424 +9787530155455 +9787530155585 +9787530155592 +9787530155776 +9787530156025 +9787530156162 +9787530156216 +9787530156551 +9787530156599 +9787530156773 +9787530156803 +9787530156889 +9787530156896 +9787530156902 +9787530156919 +9787530157343 +9787530157459 +9787530157541 +9787530157787 +9787530157848 +9787530158050 +9787530158128 +9787530158197 +9787530158296 +9787530158333 +9787530158371 +9787530158401 +9787530158432 +9787530158487 +9787530158715 +9787530158739 +9787530158753 +9787530158760 +9787530158777 +9787530158784 +9787530158807 +9787530158821 +9787530158838 +9787530158852 +9787530159354 +9787530159361 +9787530159378 +9787530159392 +9787530159408 +9787530159415 +9787530159453 +9787530159477 +9787530159507 +9787530159514 +9787530159521 +9787530159538 +9787530159781 +9787530159804 +9787530159866 +9787530159880 +9787530159903 +9787530159934 +9787530159972 +9787530159989 +9787530159996 +9787530160039 +9787530160602 +9787530160619 +9787530160626 +9787530160633 +9787530160640 +9787530160664 +9787530160688 +9787530160695 +9787530160770 +9787530160862 +9787530160886 +9787530161036 +9787530161050 +9787530161067 +9787530161074 +9787530161081 +9787530161159 +9787530161401 +9787530161425 +9787530161432 +9787530161449 +9787530161463 +9787530161494 +9787530161517 +9787530161524 +9787530161579 +9787530161715 +9787530161739 +9787530162163 +9787530162644 +9787530163573 +9787530163696 +9787530163825 +9787530163863 +9787530163870 +9787530164204 +9787530164389 +9787530164402 +9787530164532 +9787530164570 +9787530164594 +9787530164655 +9787530164778 +9787530165102 +9787530165188 +9787530165355 +9787530165362 +9787530165393 +9787530165546 +9787530165683 +9787530165782 +9787530165898 +9787530166031 +9787530166406 +9787530166901 +9787530167311 +9787530167496 +9787530167502 +9787530169780 +9787530200087 +9787530200155 +9787530200179 +9787530200193 +9787530200209 +9787530200285 +9787530200292 +9787530200315 +9787530200339 +9787530200407 +9787530200414 +9787530200438 +9787530200452 +9787530200490 +9787530200513 +9787530200544 +9787530200582 +9787530200629 +9787530200650 +9787530200698 +9787530200704 +9787530200780 +9787530200803 +9787530200919 +9787530200940 +9787530200995 +9787530201008 +9787530201015 +9787530201053 +9787530201145 +9787530201152 +9787530201237 +9787530201251 +9787530201398 +9787530201404 +9787530201480 +9787530201558 +9787530201725 +9787530201756 +9787530201770 +9787530201817 +9787530201862 +9787530201879 +9787530201909 +9787530201923 +9787530201985 +9787530202005 +9787530202012 +9787530202081 +9787530202340 +9787530202418 +9787530202692 +9787530202739 +9787530202753 +9787530202845 +9787530202906 +9787530202982 +9787530203057 +9787530203149 +9787530203170 +9787530203187 +9787530203248 +9787530203262 +9787530203378 +9787530203385 +9787530203439 +9787530203477 +9787530203507 +9787530203538 +9787530203545 +9787530203552 +9787530203569 +9787530203576 +9787530203620 +9787530203637 +9787530203651 +9787530203675 +9787530203798 +9787530203804 +9787530203842 +9787530203859 +9787530203873 +9787530203880 +9787530203910 +9787530203958 +9787530203989 +9787530204054 +9787530204184 +9787530204207 +9787530204252 +9787530204276 +9787530204290 +9787530204320 +9787530204351 +9787530204368 +9787530204375 +9787530204474 +9787530204481 +9787530204504 +9787530204573 +9787530204580 +9787530204610 +9787530204627 +9787530204634 +9787530204665 +9787530204788 +9787530204801 +9787530204863 +9787530204900 +9787530204962 +9787530205006 +9787530205037 +9787530205129 +9787530205204 +9787530205211 +9787530205235 +9787530205372 +9787530205525 +9787530205686 +9787530205792 +9787530205808 +9787530205839 +9787530205853 +9787530205860 +9787530205877 +9787530205891 +9787530205907 +9787530205914 +9787530205921 +9787530205952 +9787530205976 +9787530205983 +9787530206058 +9787530206102 +9787530206133 +9787530206140 +9787530206188 +9787530206287 +9787530206348 +9787530206355 +9787530206379 +9787530206560 +9787530206607 +9787530206638 +9787530206645 +9787530206676 +9787530206836 +9787530206911 +9787530206928 +9787530206942 +9787530206966 +9787530206980 +9787530207017 +9787530207031 +9787530207062 +9787530207086 +9787530207192 +9787530207246 +9787530207260 +9787530207284 +9787530207291 +9787530207307 +9787530207345 +9787530207482 +9787530207598 +9787530207659 +9787530207833 +9787530207857 +9787530207949 +9787530208106 +9787530208199 +9787530208366 +9787530208458 +9787530208830 +9787530208854 +9787530209097 +9787530209592 +9787530211069 +9787530212059 +9787530212639 +9787530214770 +9787530214961 +9787530215623 +9787530215630 +9787530215654 +9787530215661 +9787530215678 +9787530215685 +9787530215692 +9787530215715 +9787530215739 +9787530215746 +9787530217481 +9787530217610 +9787530219478 +9787530219805 +9787530219911 +9787530219942 +9787530219959 +9787530219966 +9787530220054 +9787530220153 +9787530221389 +9787530222249 +9787530222546 +9787530222744 +9787530222966 +9787530223017 +9787530223031 +9787530223048 +9787530223079 +9787530223161 +9787530223253 +9787530223260 +9787530223277 +9787530223338 +9787530223420 +9787530223437 +9787530223451 +9787530223475 +9787530223482 +9787530223499 +9787530223512 +9787530223529 +9787530223550 +9787530223598 +9787530223604 +9787530223659 +9787530223673 +9787530223680 +9787530223697 +9787530223710 +9787530223734 +9787530223758 +9787530223857 +9787530223963 +9787530223970 +9787530223987 +9787530223994 +9787530224014 +9787530224038 +9787530224052 +9787530224106 +9787530224151 +9787530224175 +9787530224182 +9787530224267 +9787530224304 +9787530224328 +9787530224335 +9787530224359 +9787530224373 +9787530224403 +9787530224441 +9787530224472 +9787530224496 +9787530224540 +9787530224557 +9787530224571 +9787530224595 +9787530224649 +9787530224755 +9787530224762 +9787530224779 +9787530300091 +9787530301586 +9787530301937 +9787530302118 +9787530302392 +9787530302842 +9787530303061 +9787530303214 +9787530303344 +9787530305386 +9787530305683 +9787530307120 +9787530308936 +9787530308943 +9787530310007 +9787530310021 +9787530312148 +9787530312155 +9787530313480 +9787530314456 +9787530315651 +9787530316351 +9787530316511 +9787530317136 +9787530317167 +9787530317563 +9787530317617 +9787530318270 +9787530319871 +9787530320617 +9787530320648 +9787530320778 +9787530321522 +9787530322703 +9787530322970 +9787530322987 +9787530323038 +9787530323632 +9787530324462 +9787530324592 +9787530324608 +9787530324738 +9787530326107 +9787530326275 +9787530326398 +9787530327128 +9787530327753 +9787530329528 +9787530329542 +9787530329559 +9787530329580 +9787530329597 +9787530329610 +9787530329658 +9787530329672 +9787530329689 +9787530331866 +9787530332047 +9787530333389 +9787530337073 +9787530337080 +9787530337103 +9787530337356 +9787530337363 +9787530337394 +9787530337424 +9787530337448 +9787530337486 +9787530337493 +9787530337691 +9787530339404 +9787530339831 +9787530340042 +9787530341889 +9787530342084 +9787530346006 +9787530346082 +9787530346723 +9787530346747 +9787530347423 +9787530347492 +9787530347553 +9787530348420 +9787530348765 +9787530349571 +9787530350478 +9787530350607 +9787530352281 +9787530352847 +9787530352854 +9787530353042 +9787530356340 +9787530356944 +9787530356982 +9787530357194 +9787530360514 +9787530363423 +9787530363638 +9787530364321 +9787530364567 +9787530365151 +9787530365540 +9787530371862 +9787530371930 +9787530373101 +9787530373224 +9787530373361 +9787530373385 +9787530374474 +9787530374498 +9787530374566 +9787530376232 +9787530376300 +9787530376485 +9787530376911 +9787530378243 +9787530378403 +9787530378410 +9787530378427 +9787530378434 +9787530379028 +9787530381830 +9787530387672 +9787530396254 +9787530396506 +9787530397787 +9787530399040 +9787530399187 +9787530399194 +9787530399200 +9787530399248 +9787530399378 +9787530400319 +9787530400487 +9787530400692 +9787530400852 +9787530401064 +9787530401149 +9787530401392 +9787530401606 +9787530401637 +9787530401651 +9787530402078 +9787530402412 +9787530402597 +9787530402993 +9787530403785 +9787530403860 +9787530403976 +9787530404003 +9787530404041 +9787530404065 +9787530404072 +9787530404355 +9787530405611 +9787530405642 +9787530405680 +9787530405727 +9787530405840 +9787530406083 +9787530406281 +9787530406366 +9787530406380 +9787530406427 +9787530406755 +9787530407646 +9787530408124 +9787530408162 +9787530408179 +9787530408223 +9787530408230 +9787530408353 +9787530408414 +9787530408490 +9787530408773 +9787530408957 +9787530408988 +9787530409046 +9787530409077 +9787530409121 +9787530409282 +9787530409305 +9787530409329 +9787530409381 +9787530409558 +9787530410257 +9787530410448 +9787530410554 +9787530410646 +9787530410738 +9787530411063 +9787530411230 +9787530411322 +9787530411339 +9787530411629 +9787530411636 +9787530411964 +9787530412015 +9787530412121 +9787530412633 +9787530412831 +9787530412862 +9787530412886 +9787530412985 +9787530413043 +9787530413111 +9787530413203 +9787530413289 +9787530413722 +9787530413890 +9787530414057 +9787530414712 +9787530414774 +9787530414934 +9787530415108 +9787530415160 +9787530415177 +9787530415467 +9787530415948 +9787530415993 +9787530416006 +9787530416297 +9787530416341 +9787530416372 +9787530416419 +9787530416457 +9787530416518 +9787530416525 +9787530416549 +9787530416563 +9787530416570 +9787530416600 +9787530416648 +9787530416686 +9787530416723 +9787530416747 +9787530417256 +9787530417706 +9787530417713 +9787530417720 +9787530417867 +9787530417898 +9787530418079 +9787530418185 +9787530418215 +9787530418406 +9787530418413 +9787530418468 +9787530418581 +9787530418604 +9787530418628 +9787530418680 +9787530418710 +9787530418765 +9787530418857 +9787530418932 +9787530419038 +9787530419083 +9787530419380 +9787530419397 +9787530419441 +9787530419472 +9787530419496 +9787530419502 +9787530419519 +9787530419656 +9787530420072 +9787530420126 +9787530420157 +9787530420225 +9787530420294 +9787530420485 +9787530420515 +9787530420706 +9787530420720 +9787530420744 +9787530420942 +9787530421024 +9787530421031 +9787530421048 +9787530421055 +9787530421192 +9787530422106 +9787530422328 +9787530422366 +9787530422410 +9787530422427 +9787530422588 +9787530422663 +9787530422823 +9787530422991 +9787530423011 +9787530423059 +9787530423141 +9787530423257 +9787530423325 +9787530423394 +9787530423400 +9787530423516 +9787530423592 +9787530424247 +9787530424575 +9787530424605 +9787530424681 +9787530424926 +9787530425091 +9787530425121 +9787530425145 +9787530425732 +9787530425817 +9787530425909 +9787530425947 +9787530425978 +9787530426142 +9787530426197 +9787530426333 +9787530426340 +9787530426456 +9787530426579 +9787530426883 +9787530427057 +9787530427248 +9787530427255 +9787530427385 +9787530427408 +9787530427606 +9787530427675 +9787530427859 +9787530427903 +9787530427934 +9787530427941 +9787530428153 +9787530428337 +9787530428344 +9787530428504 +9787530428528 +9787530428634 +9787530428740 +9787530428757 +9787530428788 +9787530428795 +9787530429136 +9787530429556 +9787530429563 +9787530429587 +9787530430354 +9787530430392 +9787530430408 +9787530430620 +9787530430804 +9787530430828 +9787530430989 +9787530431085 +9787530431191 +9787530431207 +9787530431214 +9787530431221 +9787530431511 +9787530431603 +9787530431658 +9787530431665 +9787530431672 +9787530431696 +9787530431702 +9787530431719 +9787530431726 +9787530432044 +9787530432167 +9787530432259 +9787530432273 +9787530432334 +9787530432402 +9787530432709 +9787530432723 +9787530432907 +9787530433003 +9787530433010 +9787530433058 +9787530433201 +9787530433225 +9787530433416 +9787530433652 +9787530433676 +9787530433690 +9787530433720 +9787530433904 +9787530433980 +9787530434147 +9787530434284 +9787530434345 +9787530434437 +9787530434475 +9787530434659 +9787530434680 +9787530434925 +9787530434949 +9787530435120 +9787530435205 +9787530435229 +9787530435427 +9787530435526 +9787530435649 +9787530435687 +9787530435717 +9787530435755 +9787530435823 +9787530435878 +9787530436073 +9787530436080 +9787530436110 +9787530436134 +9787530436158 +9787530436257 +9787530436547 +9787530436745 +9787530436752 +9787530436899 +9787530436905 +9787530437001 +9787530437117 +9787530437216 +9787530437469 +9787530437735 +9787530437957 +9787530438459 +9787530438466 +9787530438503 +9787530438527 +9787530438763 +9787530438770 +9787530438817 +9787530439067 +9787530439470 +9787530439555 +9787530439685 +9787530439784 +9787530440124 +9787530440490 +9787530440513 +9787530440537 +9787530440797 +9787530441039 +9787530441084 +9787530441237 +9787530441244 +9787530441749 +9787530441800 +9787530441855 +9787530442272 +9787530442654 +9787530442739 +9787530442753 +9787530443033 +9787530443620 +9787530443644 +9787530443859 +9787530444184 +9787530444207 +9787530444764 +9787530444948 +9787530445099 +9787530445181 +9787530445341 +9787530445549 +9787530446584 +9787530446607 +9787530446621 +9787530446805 +9787530446829 +9787530447048 +9787530447338 +9787530447345 +9787530447352 +9787530447369 +9787530447376 +9787530447475 +9787530447659 +9787530447703 +9787530447895 +9787530447918 +9787530447949 +9787530448052 +9787530448212 +9787530448403 +9787530448410 +9787530448427 +9787530448465 +9787530448816 +9787530448823 +9787530448830 +9787530448885 +9787530448915 +9787530448922 +9787530448946 +9787530448960 +9787530448984 +9787530448991 +9787530449134 +9787530449172 +9787530449677 +9787530449738 +9787530450123 +9787530450147 +9787530450352 +9787530450567 +9787530450642 +9787530450659 +9787530450666 +9787530450680 +9787530450734 +9787530450833 +9787530450871 +9787530450932 +9787530450949 +9787530451007 +9787530451175 +9787530451212 +9787530452318 +9787530452431 +9787530452554 +9787530452622 +9787530452943 +9787530452974 +9787530452998 +9787530453414 +9787530453636 +9787530453759 +9787530453872 +9787530454169 +9787530454251 +9787530454329 +9787530454459 +9787530454800 +9787530454909 +9787530454916 +9787530455043 +9787530455463 +9787530455487 +9787530455494 +9787530456729 +9787530456736 +9787530456750 +9787530456767 +9787530456774 +9787530456804 +9787530457313 +9787530457320 +9787530457351 +9787530457559 +9787530457702 +9787530457771 +9787530458372 +9787530458471 +9787530458730 +9787530458761 +9787530459980 +9787530460016 +9787530460177 +9787530460276 +9787530460399 +9787530460443 +9787530460580 +9787530460696 +9787530460795 +9787530461075 +9787530461396 +9787530461402 +9787530461426 +9787530461433 +9787530461655 +9787530461662 +9787530462003 +9787530462133 +9787530462362 +9787530462416 +9787530462737 +9787530462799 +9787530462928 +9787530463017 +9787530463222 +9787530463253 +9787530463536 +9787530464441 +9787530464472 +9787530464526 +9787530464533 +9787530464632 +9787530465653 +9787530465677 +9787530465691 +9787530465707 +9787530465714 +9787530466636 +9787530466735 +9787530466742 +9787530466759 +9787530466988 +9787530467459 +9787530467848 +9787530468449 +9787530468791 +9787530469538 +9787530469545 +9787530469552 +9787530469583 +9787530469644 +9787530469767 +9787530469774 +9787530469781 +9787530469828 +9787530469842 +9787530469873 +9787530469880 +9787530470664 +9787530470671 +9787530470718 +9787530470725 +9787530470732 +9787530470763 +9787530470770 +9787530470794 +9787530470862 +9787530470879 +9787530470916 +9787530470930 +9787530471142 +9787530471203 +9787530471210 +9787530471227 +9787530471234 +9787530471241 +9787530471258 +9787530471265 +9787530471272 +9787530471296 +9787530471517 +9787530471654 +9787530471685 +9787530472149 +9787530472507 +9787530473061 +9787530473597 +9787530473634 +9787530473771 +9787530473894 +9787530473917 +9787530473931 +9787530473955 +9787530474235 +9787530474303 +9787530474327 +9787530474433 +9787530474440 +9787530474655 +9787530474846 +9787530474983 +9787530475133 +9787530475195 +9787530475201 +9787530475270 +9787530475447 +9787530475720 +9787530475768 +9787530475782 +9787530475904 +9787530475928 +9787530475935 +9787530475997 +9787530476031 +9787530476055 +9787530476062 +9787530476079 +9787530476109 +9787530476291 +9787530476529 +9787530476543 +9787530477106 +9787530477267 +9787530477465 +9787530477472 +9787530477526 +9787530477533 +9787530477847 +9787530477861 +9787530477892 +9787530478035 +9787530478042 +9787530478127 +9787530478554 +9787530478653 +9787530478936 +9787530478967 +9787530479162 +9787530479339 +9787530479575 +9787530479582 +9787530479650 +9787530479667 +9787530479674 +9787530479681 +9787530479698 +9787530479704 +9787530479728 +9787530479735 +9787530479773 +9787530479834 +9787530479841 +9787530479865 +9787530480120 +9787530480267 +9787530480274 +9787530480571 +9787530480915 +9787530481646 +9787530481752 +9787530482025 +9787530482049 +9787530482063 +9787530482070 +9787530482230 +9787530482247 +9787530482254 +9787530482261 +9787530482315 +9787530482575 +9787530483435 +9787530484326 +9787530484388 +9787530484395 +9787530484401 +9787530484999 +9787530485088 +9787530485392 +9787530486436 +9787530486467 +9787530487068 +9787530487235 +9787530487785 +9787530487815 +9787530488263 +9787530488706 +9787530489062 +9787530489130 +9787530489574 +9787530490105 +9787530490464 +9787530490495 +9787530490693 +9787530490785 +9787530490815 +9787530490846 +9787530491133 +9787530491140 +9787530491379 +9787530491522 +9787530491539 +9787530491768 +9787530492628 +9787530492697 +9787530492895 +9787530492925 +9787530493274 +9787530493366 +9787530493717 +9787530493854 +9787530493946 +9787530494103 +9787530494110 +9787530494127 +9787530494226 +9787530494233 +9787530494257 +9787530494974 +9787530494998 +9787530495025 +9787530495056 +9787530495070 +9787530495087 +9787530495704 +9787530495827 +9787530496183 +9787530496190 +9787530496206 +9787530496213 +9787530496220 +9787530496237 +9787530496350 +9787530496633 +9787530496732 +9787530497517 +9787530497883 +9787530498200 +9787530498675 +9787530498699 +9787530498705 +9787530498712 +9787530498781 +9787530498798 +9787530498835 +9787530498903 +9787530499122 +9787530499757 +9787530500019 +9787530500026 +9787530500132 +9787530500224 +9787530500286 +9787530500309 +9787530500316 +9787530500330 +9787530500347 +9787530500606 +9787530500637 +9787530500675 +9787530500804 +9787530501047 +9787530501214 +9787530501351 +9787530501665 +9787530501672 +9787530501719 +9787530501993 +9787530502037 +9787530502167 +9787530502228 +9787530502259 +9787530502310 +9787530502495 +9787530502549 +9787530502587 +9787530502655 +9787530502662 +9787530502709 +9787530502730 +9787530502761 +9787530502815 +9787530502839 +9787530502938 +9787530503225 +9787530503232 +9787530503249 +9787530503362 +9787530503393 +9787530503423 +9787530503539 +9787530504062 +9787530504079 +9787530504185 +9787530504208 +9787530504444 +9787530504451 +9787530504529 +9787530504543 +9787530504857 +9787530504963 +9787530505144 +9787530505243 +9787530505281 +9787530505328 +9787530505342 +9787530505373 +9787530505663 +9787530505700 +9787530505717 +9787530505731 +9787530505786 +9787530505816 +9787530505885 +9787530505908 +9787530505915 +9787530505960 +9787530506080 +9787530506110 +9787530506219 +9787530506332 +9787530506493 +9787530506554 +9787530506578 +9787530506653 +9787530506868 +9787530506875 +9787530507384 +9787530507520 +9787530507599 +9787530507643 +9787530507667 +9787530507674 +9787530507834 +9787530508053 +9787530508060 +9787530508183 +9787530508206 +9787530508251 +9787530509135 +9787530509166 +9787530509258 +9787530509487 +9787530509500 +9787530509517 +9787530509524 +9787530509531 +9787530509548 +9787530509562 +9787530509586 +9787530509609 +9787530509616 +9787530509630 +9787530509647 +9787530509739 +9787530509746 +9787530509760 +9787530509784 +9787530510179 +9787530510209 +9787530510216 +9787530510230 +9787530510261 +9787530510322 +9787530510384 +9787530510421 +9787530510438 +9787530510476 +9787530510537 +9787530510568 +9787530510698 +9787530510766 +9787530510780 +9787530511060 +9787530511091 +9787530511183 +9787530511190 +9787530511251 +9787530511442 +9787530511718 +9787530511817 +9787530511862 +9787530511961 +9787530512029 +9787530512456 +9787530512463 +9787530512487 +9787530512494 +9787530512548 +9787530512647 +9787530512685 +9787530512784 +9787530512845 +9787530512920 +9787530512975 +9787530512982 +9787530513088 +9787530513118 +9787530513200 +9787530513217 +9787530513279 +9787530513286 +9787530513354 +9787530513453 +9787530513538 +9787530513590 +9787530513644 +9787530513651 +9787530513675 +9787530513705 +9787530513828 +9787530513927 +9787530513958 +9787530514009 +9787530514139 +9787530514177 +9787530514412 +9787530514443 +9787530514504 +9787530514573 +9787530514597 +9787530514603 +9787530514627 +9787530514672 +9787530514740 +9787530514825 +9787530514832 +9787530515020 +9787530515112 +9787530515266 +9787530515303 +9787530515969 +9787530516201 +9787530516386 +9787530516546 +9787530516652 +9787530516669 +9787530516706 +9787530516843 +9787530516867 +9787530516874 +9787530516959 +9787530516997 +9787530517048 +9787530517079 +9787530517086 +9787530517109 +9787530517147 +9787530517178 +9787530517246 +9787530517253 +9787530517307 +9787530517437 +9787530517475 +9787530517550 +9787530517567 +9787530517581 +9787530517628 +9787530517949 +9787530518007 +9787530518083 +9787530518175 +9787530518281 +9787530518342 +9787530518496 +9787530518502 +9787530518519 +9787530518953 +9787530519097 +9787530519103 +9787530519134 +9787530519189 +9787530519202 +9787530519240 +9787530519264 +9787530519622 +9787530519721 +9787530519769 +9787530519813 +9787530519820 +9787530519844 +9787530519868 +9787530519882 +9787530520031 +9787530520116 +9787530520130 +9787530520147 +9787530520154 +9787530520192 +9787530520239 +9787530520260 +9787530520277 +9787530520352 +9787530520475 +9787530520512 +9787530520680 +9787530520925 +9787530521045 +9787530521052 +9787530521076 +9787530521106 +9787530521120 +9787530521410 +9787530521427 +9787530521472 +9787530521533 +9787530521700 +9787530521953 +9787530521977 +9787530522059 +9787530522271 +9787530522288 +9787530522332 +9787530522363 +9787530522394 +9787530522417 +9787530522424 +9787530522448 +9787530522479 +9787530522486 +9787530522530 +9787530522622 +9787530522967 +9787530522998 +9787530523032 +9787530523087 +9787530523094 +9787530523216 +9787530523223 +9787530523520 +9787530523636 +9787530523674 +9787530523711 +9787530523728 +9787530523735 +9787530523742 +9787530523766 +9787530523810 +9787530523919 +9787530524091 +9787530524121 +9787530524176 +9787530524183 +9787530524336 +9787530524343 +9787530524350 +9787530524367 +9787530524473 +9787530524855 +9787530524862 +9787530525012 +9787530525135 +9787530525173 +9787530525234 +9787530525241 +9787530525319 +9787530525340 +9787530525500 +9787530525517 +9787530525531 +9787530525548 +9787530525623 +9787530525760 +9787530525791 +9787530525807 +9787530525814 +9787530525869 +9787530525968 +9787530525975 +9787530526279 +9787530526316 +9787530526347 +9787530526361 +9787530526460 +9787530526545 +9787530526675 +9787530526682 +9787530526705 +9787530526736 +9787530526989 +9787530527146 +9787530527283 +9787530527474 +9787530527498 +9787530527627 +9787530527719 +9787530527726 +9787530527795 +9787530527979 +9787530528310 +9787530528372 +9787530528419 +9787530528471 +9787530528679 +9787530528785 +9787530528839 +9787530528907 +9787530528921 +9787530529003 +9787530529027 +9787530529041 +9787530529089 +9787530529164 +9787530529225 +9787530529300 +9787530529331 +9787530529355 +9787530529386 +9787530529485 +9787530529522 +9787530529799 +9787530529812 +9787530529829 +9787530529850 +9787530530221 +9787530530375 +9787530530405 +9787530530429 +9787530530542 +9787530530726 +9787530530740 +9787530530764 +9787530530818 +9787530530825 +9787530530856 +9787530530863 +9787530530887 +9787530530894 +9787530530955 +9787530530979 +9787530531037 +9787530531044 +9787530531136 +9787530531570 +9787530531648 +9787530531655 +9787530531778 +9787530531815 +9787530531839 +9787530531853 +9787530531860 +9787530531884 +9787530532119 +9787530532133 +9787530532164 +9787530532454 +9787530532485 +9787530532638 +9787530532799 +9787530532843 +9787530532850 +9787530532911 +9787530533376 +9787530533420 +9787530533536 +9787530533581 +9787530533925 +9787530533956 +9787530534052 +9787530534069 +9787530534076 +9787530534137 +9787530534144 +9787530534182 +9787530534199 +9787530534236 +9787530534274 +9787530534281 +9787530534304 +9787530534380 +9787530534533 +9787530534618 +9787530534762 +9787530534793 +9787530534816 +9787530534922 +9787530534960 +9787530535066 +9787530535073 +9787530535172 +9787530535240 +9787530535363 +9787530535493 +9787530535523 +9787530535530 +9787530535554 +9787530535585 +9787530535653 +9787530535677 +9787530535714 +9787530535783 +9787530535974 +9787530536001 +9787530536018 +9787530536179 +9787530536193 +9787530536421 +9787530536490 +9787530536506 +9787530536605 +9787530536728 +9787530536735 +9787530536841 +9787530536926 +9787530537510 +9787530537589 +9787530537862 +9787530538067 +9787530538258 +9787530538494 +9787530538623 +9787530538678 +9787530538715 +9787530538821 +9787530538838 +9787530538852 +9787530538869 +9787530538937 +9787530538951 +9787530539231 +9787530539347 +9787530539378 +9787530539453 +9787530539606 +9787530539842 +9787530540114 +9787530540268 +9787530540367 +9787530540510 +9787530540602 +9787530540619 +9787530540671 +9787530540688 +9787530540763 +9787530540770 +9787530540855 +9787530541050 +9787530541128 +9787530541296 +9787530541302 +9787530541647 +9787530542040 +9787530542156 +9787530542200 +9787530542385 +9787530542392 +9787530542637 +9787530542644 +9787530542897 +9787530543009 +9787530543030 +9787530543108 +9787530543184 +9787530543238 +9787530543665 +9787530543771 +9787530543986 +9787530544099 +9787530544914 +9787530544938 +9787530544976 +9787530545072 +9787530545133 +9787530545461 +9787530545522 +9787530545539 +9787530545546 +9787530545621 +9787530546062 +9787530546086 +9787530546154 +9787530546345 +9787530546468 +9787530546475 +9787530547137 +9787530547816 +9787530547854 +9787530547861 +9787530547878 +9787530547939 +9787530548493 +9787530549001 +9787530549414 +9787530549452 +9787530549681 +9787530550038 +9787530550052 +9787530550335 +9787530551509 +9787530551615 +9787530551622 +9787530551707 +9787530552148 +9787530552162 +9787530552186 +9787530552339 +9787530552414 +9787530552421 +9787530552742 +9787530552872 +9787530553169 +9787530553503 +9787530553510 +9787530553800 +9787530553831 +9787530554197 +9787530554920 +9787530554944 +9787530555804 +9787530555941 +9787530556108 +9787530556221 +9787530556450 +9787530556542 +9787530556917 +9787530557112 +9787530557495 +9787530557648 +9787530557822 +9787530558188 +9787530558195 +9787530558225 +9787530558232 +9787530558836 +9787530559093 +9787530559123 +9787530559451 +9787530559543 +9787530559727 +9787530560044 +9787530560266 +9787530560525 +9787530560600 +9787530560648 +9787530560747 +9787530560754 +9787530561072 +9787530561201 +9787530561300 +9787530561348 +9787530561478 +9787530562130 +9787530562291 +9787530562321 +9787530562673 +9787530562758 +9787530562765 +9787530562772 +9787530562864 +9787530563311 +9787530563472 +9787530563533 +9787530563571 +9787530563588 +9787530563847 +9787530564257 +9787530564325 +9787530564691 +9787530564813 +9787530564974 +9787530565513 +9787530565889 +9787530565896 +9787530566190 +9787530566213 +9787530566435 +9787530566527 +9787530566565 +9787530566688 +9787530566763 +9787530566787 +9787530567098 +9787530567241 +9787530567289 +9787530567388 +9787530567616 +9787530568255 +9787530568354 +9787530568361 +9787530568385 +9787530569474 +9787530569580 +9787530569610 +9787530569627 +9787530569634 +9787530569726 +9787530570296 +9787530570456 +9787530570517 +9787530570548 +9787530570562 +9787530570579 +9787530570609 +9787530570616 +9787530571231 +9787530571651 +9787530572818 +9787530572825 +9787530572894 +9787530572962 +9787530573082 +9787530573280 +9787530574263 +9787530574355 +9787530574508 +9787530574706 +9787530574782 +9787530575093 +9787530575130 +9787530575314 +9787530575352 +9787530575369 +9787530575871 +9787530575949 +9787530575963 +9787530576069 +9787530576281 +9787530576311 +9787530576441 +9787530576656 +9787530577011 +9787530578087 +9787530578254 +9787530578964 +9787530579022 +9787530579046 +9787530579053 +9787530579817 +9787530580110 +9787530580127 +9787530580134 +9787530580295 +9787530580813 +9787530581438 +9787530581797 +9787530582114 +9787530582367 +9787530582688 +9787530582749 +9787530582756 +9787530582787 +9787530583494 +9787530583609 +9787530584323 +9787530584491 +9787530584569 +9787530584644 +9787530584651 +9787530584828 +9787530584965 +9787530585054 +9787530585627 +9787530585641 +9787530586266 +9787530586495 +9787530586501 +9787530586556 +9787530587324 +9787530587447 +9787530587492 +9787530587973 +9787530588024 +9787530588055 +9787530588161 +9787530588185 +9787530589151 +9787530589274 +9787530589304 +9787530589434 +9787530589762 +9787530589984 +9787530590409 +9787530590522 +9787530590539 +9787530590713 +9787530590720 +9787530590997 +9787530591079 +9787530591086 +9787530591123 +9787530591321 +9787530591475 +9787530591482 +9787530591611 +9787530591628 +9787530591635 +9787530591666 +9787530591680 +9787530591697 +9787530591819 +9787530591840 +9787530591925 +9787530592298 +9787530592304 +9787530592311 +9787530592373 +9787530592397 +9787530592403 +9787530592427 +9787530592465 +9787530592472 +9787530592526 +9787530592533 +9787530592540 +9787530592595 +9787530592632 +9787530592663 +9787530592700 +9787530592793 +9787530592809 +9787530592908 +9787530592915 +9787530592922 +9787530593059 +9787530593110 +9787530593240 +9787530593318 +9787530593370 +9787530593967 +9787530593974 +9787530593981 +9787530594018 +9787530594032 +9787530594285 +9787530594520 +9787530595381 +9787530595398 +9787530595718 +9787530595756 +9787530595923 +9787530596012 +9787530596395 +9787530596708 +9787530596722 +9787530596814 +9787530596944 +9787530597200 +9787530597224 +9787530598184 +9787530598405 +9787530598443 +9787530598542 +9787530598566 +9787530598627 +9787530598641 +9787530599648 +9787530599679 +9787530599761 +9787530599891 +9787530600023 +9787530600030 +9787530600078 +9787530600085 +9787530600153 +9787530600559 +9787530600610 +9787530600719 +9787530600771 +9787530600900 +9787530600962 +9787530601198 +9787530601266 +9787530601396 +9787530601440 +9787530601501 +9787530601785 +9787530602195 +9787530602379 +9787530602584 +9787530602775 +9787530602904 +9787530602980 +9787530602997 +9787530603000 +9787530603017 +9787530603109 +9787530603192 +9787530603529 +9787530603536 +9787530603628 +9787530603666 +9787530603673 +9787530603796 +9787530603826 +9787530603888 +9787530603895 +9787530603901 +9787530603932 +9787530603963 +9787530604717 +9787530604816 +9787530604861 +9787530604922 +9787530605219 +9787530605547 +9787530605578 +9787530606629 +9787530606667 +9787530606841 +9787530607008 +9787530607527 +9787530607756 +9787530607800 +9787530607978 +9787530608241 +9787530608401 +9787530608463 +9787530608562 +9787530608593 +9787530608760 +9787530608784 +9787530608814 +9787530608821 +9787530608883 +9787530608975 +9787530608982 +9787530609040 +9787530609651 +9787530609767 +9787530610169 +9787530610176 +9787530610237 +9787530610251 +9787530610350 +9787530610855 +9787530610893 +9787530610961 +9787530610978 +9787530611012 +9787530611029 +9787530611203 +9787530611463 +9787530611531 +9787530611623 +9787530611678 +9787530611685 +9787530611807 +9787530612026 +9787530612064 +9787530612125 +9787530612668 +9787530613078 +9787530613153 +9787530613221 +9787530613252 +9787530613429 +9787530613672 +9787530613924 +9787530614051 +9787530614068 +9787530614198 +9787530614662 +9787530614679 +9787530614686 +9787530615027 +9787530615119 +9787530615409 +9787530615539 +9787530615607 +9787530615676 +9787530615911 +9787530615959 +9787530616000 +9787530616017 +9787530616024 +9787530616031 +9787530616062 +9787530616086 +9787530616123 +9787530616154 +9787530616215 +9787530616680 +9787530616710 +9787530616840 +9787530617021 +9787530617052 +9787530617106 +9787530617113 +9787530617519 +9787530617656 +9787530617823 +9787530617885 +9787530618264 +9787530618424 +9787530618431 +9787530618493 +9787530618523 +9787530618691 +9787530618776 +9787530618806 +9787530618813 +9787530618912 +9787530618943 +9787530619001 +9787530619018 +9787530619087 +9787530619360 +9787530619421 +9787530619919 +9787530620113 +9787530620328 +9787530621110 +9787530621141 +9787530621158 +9787530621417 +9787530621493 +9787530621523 +9787530621585 +9787530621592 +9787530621615 +9787530621769 +9787530621776 +9787530622292 +9787530622506 +9787530622650 +9787530622704 +9787530622728 +9787530622766 +9787530622902 +9787530622919 +9787530623008 +9787530623022 +9787530623435 +9787530623473 +9787530623572 +9787530623589 +9787530623596 +9787530623985 +9787530624012 +9787530624036 +9787530624067 +9787530624081 +9787530624098 +9787530624104 +9787530624111 +9787530624128 +9787530624166 +9787530624210 +9787530624241 +9787530624289 +9787530624364 +9787530624579 +9787530624654 +9787530624685 +9787530624722 +9787530624777 +9787530624869 +9787530625033 +9787530625101 +9787530625224 +9787530625293 +9787530625330 +9787530625378 +9787530625477 +9787530625699 +9787530625767 +9787530625811 +9787530625828 +9787530625842 +9787530625903 +9787530625934 +9787530625941 +9787530625996 +9787530626221 +9787530626290 +9787530626320 +9787530626443 +9787530626528 +9787530626566 +9787530626672 +9787530626832 +9787530626849 +9787530626856 +9787530626986 +9787530627020 +9787530627044 +9787530627068 +9787530627174 +9787530627181 +9787530627273 +9787530627297 +9787530627334 +9787530627402 +9787530627426 +9787530627495 +9787530627723 +9787530627761 +9787530627778 +9787530627792 +9787530627877 +9787530627921 +9787530627952 +9787530627983 +9787530628058 +9787530628140 +9787530628164 +9787530628232 +9787530628300 +9787530628515 +9787530628546 +9787530628782 +9787530628867 +9787530628911 +9787530628966 +9787530628973 +9787530629000 +9787530629109 +9787530629123 +9787530629383 +9787530629420 +9787530629437 +9787530629475 +9787530629499 +9787530630037 +9787530630099 +9787530630112 +9787530630167 +9787530630204 +9787530630433 +9787530630532 +9787530630587 +9787530630747 +9787530630884 +9787530630969 +9787530631065 +9787530631188 +9787530631355 +9787530631362 +9787530631416 +9787530631430 +9787530631560 +9787530631584 +9787530631638 +9787530631683 +9787530631706 +9787530631782 +9787530631829 +9787530631911 +9787530631973 +9787530631980 +9787530632093 +9787530632116 +9787530632130 +9787530632321 +9787530632482 +9787530632512 +9787530632628 +9787530632758 +9787530632772 +9787530632918 +9787530632994 +9787530633007 +9787530633014 +9787530633021 +9787530633038 +9787530633090 +9787530633236 +9787530633335 +9787530633342 +9787530633403 +9787530633854 +9787530633878 +9787530633892 +9787530633946 +9787530633991 +9787530634004 +9787530634011 +9787530634035 +9787530634042 +9787530634110 +9787530634240 +9787530634257 +9787530634264 +9787530634288 +9787530634547 +9787530634936 +9787530634974 +9787530635049 +9787530635063 +9787530635179 +9787530635186 +9787530635230 +9787530635247 +9787530635254 +9787530635292 +9787530635360 +9787530635407 +9787530635421 +9787530635506 +9787530635599 +9787530635667 +9787530635759 +9787530635841 +9787530635872 +9787530635902 +9787530635957 +9787530636152 +9787530636183 +9787530636244 +9787530636251 +9787530636268 +9787530636282 +9787530636305 +9787530636572 +9787530636589 +9787530636718 +9787530636879 +9787530636886 +9787530637043 +9787530637166 +9787530637203 +9787530637319 +9787530637333 +9787530637357 +9787530637432 +9787530637524 +9787530637623 +9787530637661 +9787530637678 +9787530637692 +9787530637722 +9787530637791 +9787530637968 +9787530638002 +9787530638026 +9787530638040 +9787530638057 +9787530638064 +9787530638095 +9787530638187 +9787530638255 +9787530638293 +9787530638477 +9787530638507 +9787530638538 +9787530638590 +9787530638668 +9787530638750 +9787530638811 +9787530638828 +9787530638835 +9787530638866 +9787530638903 +9787530638934 +9787530638965 +9787530639085 +9787530639238 +9787530639245 +9787530639290 +9787530639313 +9787530639368 +9787530639535 +9787530639542 +9787530639559 +9787530639597 +9787530639702 +9787530639900 +9787530639924 +9787530640036 +9787530640050 +9787530640128 +9787530640142 +9787530640227 +9787530640340 +9787530640623 +9787530640647 +9787530640678 +9787530640821 +9787530640913 +9787530640982 +9787530641040 +9787530641064 +9787530641071 +9787530641101 +9787530641248 +9787530641309 +9787530641330 +9787530641347 +9787530641361 +9787530641668 +9787530641729 +9787530641941 +9787530642009 +9787530642023 +9787530642092 +9787530642108 +9787530642269 +9787530642276 +9787530642290 +9787530642368 +9787530642375 +9787530642498 +9787530642528 +9787530642702 +9787530643051 +9787530643082 +9787530643143 +9787530643167 +9787530643211 +9787530643228 +9787530643266 +9787530643303 +9787530643341 +9787530643570 +9787530643631 +9787530643778 +9787530643945 +9787530643969 +9787530644010 +9787530644058 +9787530644102 +9787530644119 +9787530644126 +9787530644171 +9787530644348 +9787530644379 +9787530644386 +9787530644454 +9787530644669 +9787530644881 +9787530644911 +9787530645130 +9787530645147 +9787530645208 +9787530645215 +9787530645369 +9787530645383 +9787530645475 +9787530645567 +9787530645642 +9787530645666 +9787530645758 +9787530645840 +9787530646007 +9787530646083 +9787530646199 +9787530646267 +9787530646366 +9787530646441 +9787530646458 +9787530646564 +9787530646786 +9787530646793 +9787530646816 +9787530646847 +9787530646878 +9787530646984 +9787530647066 +9787530647530 +9787530647646 +9787530647745 +9787530647844 +9787530647882 +9787530647998 +9787530648018 +9787530648032 +9787530648049 +9787530648056 +9787530648254 +9787530648391 +9787530648452 +9787530648605 +9787530648674 +9787530648797 +9787530648827 +9787530648834 +9787530649046 +9787530649176 +9787530649213 +9787530649411 +9787530649855 +9787530650134 +9787530650325 +9787530650363 +9787530650431 +9787530650806 +9787530650813 +9787530650851 +9787530650875 +9787530651025 +9787530651131 +9787530651155 +9787530651162 +9787530651315 +9787530651391 +9787530651414 +9787530651452 +9787530652107 +9787530652176 +9787530652183 +9787530652244 +9787530652367 +9787530652572 +9787530652763 +9787530653012 +9787530653050 +9787530653173 +9787530653210 +9787530653234 +9787530653289 +9787530653319 +9787530653357 +9787530653395 +9787530653418 +9787530653432 +9787530653449 +9787530653463 +9787530653470 +9787530653494 +9787530653500 +9787530653647 +9787530653654 +9787530653685 +9787530653708 +9787530653746 +9787530653791 +9787530653814 +9787530653852 +9787530653890 +9787530653906 +9787530653920 +9787530653975 +9787530654064 +9787530654200 +9787530654354 +9787530654361 +9787530654385 +9787530654446 +9787530654491 +9787530654538 +9787530654583 +9787530654651 +9787530654736 +9787530654866 +9787530654996 +9787530655016 +9787530655757 +9787530656686 +9787530657188 +9787530657409 +9787530657485 +9787530657522 +9787530657836 +9787530657980 +9787530658079 +9787530658444 +9787530658574 +9787530659045 +9787530659205 +9787530659212 +9787530659243 +9787530659533 +9787530659700 +9787530659823 +9787530660072 +9787530660119 +9787530660416 +9787530660645 +9787530661116 +9787530661406 +9787530661512 +9787530661857 +9787530661925 +9787530663547 +9787530663677 +9787530664179 +9787530664230 +9787530664537 +9787530665329 +9787530665367 +9787530666920 +9787530669754 +9787530670231 +9787530671290 +9787530672952 +9787530674246 +9787530674369 +9787530675120 +9787530677339 +9787530677773 +9787530678558 +9787530678626 +9787530678855 +9787530679012 +9787530679845 +9787530680001 +9787530680094 +9787530680766 +9787530681022 +9787530681060 +9787530681954 +9787530682166 +9787530682692 +9787530683071 +9787530683170 +9787530683569 +9787530683699 +9787530683750 +9787530683774 +9787530683903 +9787530684016 +9787530684030 +9787530684641 +9787530684870 +9787530685211 +9787530685303 +9787530685884 +9787530686034 +9787530686133 +9787530686300 +9787530686409 +9787530686447 +9787530686676 +9787530686737 +9787530686874 +9787530687024 +9787530687086 +9787530687130 +9787530687314 +9787530687437 +9787530687468 +9787530687598 +9787530687642 +9787530687673 +9787530687710 +9787530687796 +9787530687871 +9787530687888 +9787530687925 +9787530687932 +9787530688281 +9787530688359 +9787530688403 +9787530688427 +9787530688489 +9787530688700 +9787530688939 +9787530689097 +9787530689103 +9787530689387 +9787530689417 +9787530689431 +9787530689448 +9787530689455 +9787530689462 +9787530689646 +9787530689660 +9787530689677 +9787530689790 +9787530689974 +9787530690024 +9787530690185 +9787530690345 +9787530690352 +9787530690451 +9787530690475 +9787530690987 +9787530691076 +9787530691137 +9787530691144 +9787530691274 +9787530700518 +9787530701447 +9787530701898 +9787530703939 +9787530703946 +9787530703953 +9787530703991 +9787530704219 +9787530705292 +9787530705483 +9787530706800 +9787530708392 +9787530710869 +9787530711156 +9787530711699 +9787530715093 +9787530715253 +9787530715710 +9787530715727 +9787530715741 +9787530716632 +9787530718797 +9787530718810 +9787530720264 +9787530720295 +9787530720462 +9787530720790 +9787530722060 +9787530722978 +9787530723425 +9787530723449 +9787530723456 +9787530724132 +9787530724644 +9787530726181 +9787530727492 +9787530727546 +9787530729199 +9787530729489 +9787530729618 +9787530729892 +9787530730225 +9787530731758 +9787530732717 +9787530732755 +9787530732809 +9787530732922 +9787530733875 +9787530733943 +9787530733967 +9787530733981 +9787530734018 +9787530734025 +9787530734162 +9787530734353 +9787530735510 +9787530735527 +9787530735633 +9787530735725 +9787530735787 +9787530735862 +9787530735879 +9787530735961 +9787530736319 +9787530736487 +9787530736630 +9787530737446 +9787530737941 +9787530738702 +9787530738726 +9787530738870 +9787530739167 +9787530739747 +9787530739754 +9787530739785 +9787530740361 +9787530740811 +9787530740989 +9787530741122 +9787530741542 +9787530741627 +9787530742433 +9787530742464 +9787530742549 +9787530742785 +9787530743287 +9787530743294 +9787530743492 +9787530743584 +9787530743621 +9787530743942 +9787530744246 +9787530744765 +9787530744871 +9787530744888 +9787530744987 +9787530745342 +9787530745373 +9787530745380 +9787530745397 +9787530745403 +9787530746356 +9787530746370 +9787530746448 +9787530746738 +9787530746998 +9787530747148 +9787530747261 +9787530747322 +9787530749043 +9787530749227 +9787530749241 +9787530749333 +9787530749456 +9787530749487 +9787530749791 +9787530750100 +9787530750162 +9787530750810 +9787530750841 +9787530750858 +9787530750872 +9787530750896 +9787530750902 +9787530751138 +9787530751176 +9787530751329 +9787530751640 +9787530751916 +9787530752067 +9787530752074 +9787530752494 +9787530752586 +9787530752593 +9787530752777 +9787530752876 +9787530752913 +9787530752951 +9787530753019 +9787530753095 +9787530753170 +9787530753194 +9787530753217 +9787530753248 +9787530753262 +9787530753279 +9787530753286 +9787530753316 +9787530753378 +9787530753682 +9787530753699 +9787530753811 +9787530753989 +9787530754023 +9787530754412 +9787530754443 +9787530754467 +9787530754481 +9787530754801 +9787530754924 +9787530755556 +9787530755570 +9787530756089 +9787530756126 +9787530756300 +9787530756430 +9787530756973 +9787530757260 +9787530757345 +9787530757390 +9787530757635 +9787530757659 +9787530757758 +9787530757826 +9787530757871 +9787530758106 +9787530758205 +9787530758410 +9787530758502 +9787530758632 +9787530758809 +9787530758885 +9787530758960 +9787530759042 +9787530759271 +9787530759332 +9787530759516 +9787530759837 +9787530760024 +9787530760086 +9787530760116 +9787530760338 +9787530760369 +9787530760550 +9787530760567 +9787530760741 +9787530760765 +9787530760802 +9787530760932 +9787530760949 +9787530760963 +9787530761472 +9787530761649 +9787530761656 +9787530761694 +9787530761908 +9787530762394 +9787530762738 +9787530763155 +9787530764305 +9787530764350 +9787530764619 +9787530766101 +9787530767009 +9787530767658 +9787530767665 +9787530768587 +9787530769188 +9787530769430 +9787530769546 +9787530769560 +9787530770146 +9787530770184 +9787530770528 +9787530770702 +9787530770863 +9787530770986 +9787530771303 +9787530771679 +9787530771686 +9787530771839 +9787530771921 +9787530772980 +9787530773161 +9787530773468 +9787530773529 +9787530774021 +9787530774144 +9787530774281 +9787530774472 +9787530774588 +9787530774731 +9787530774908 +9787530774991 +9787530775004 +9787530775141 +9787530775882 +9787530776292 +9787530776490 +9787530776933 +9787530777305 +9787530777329 +9787530777510 +9787530777565 +9787530777695 +9787530777701 +9787530777718 +9787530778340 +9787530778357 +9787530778388 +9787530778494 +9787530778500 +9787530778807 +9787530778975 +9787530779019 +9787530800027 +9787530800072 +9787530800133 +9787530800355 +9787530800386 +9787530800454 +9787530800577 +9787530800669 +9787530801000 +9787530801079 +9787530801314 +9787530801604 +9787530801697 +9787530801727 +9787530801734 +9787530802021 +9787530802151 +9787530802212 +9787530802342 +9787530802588 +9787530802878 +9787530802892 +9787530803523 +9787530804070 +9787530804339 +9787530804612 +9787530804841 +9787530804889 +9787530805152 +9787530805206 +9787530805480 +9787530805565 +9787530805657 +9787530805787 +9787530805855 +9787530806067 +9787530806074 +9787530806128 +9787530806401 +9787530806432 +9787530806548 +9787530806593 +9787530806630 +9787530806838 +9787530806883 +9787530807217 +9787530807415 +9787530807620 +9787530808177 +9787530808443 +9787530808450 +9787530808467 +9787530808832 +9787530808931 +9787530809129 +9787530809259 +9787530809488 +9787530809761 +9787530809785 +9787530810279 +9787530810361 +9787530810385 +9787530810446 +9787530810507 +9787530810545 +9787530811115 +9787530811337 +9787530811368 +9787530811573 +9787530811580 +9787530811849 +9787530812174 +9787530812303 +9787530812563 +9787530812648 +9787530812747 +9787530813133 +9787530813287 +9787530813478 +9787530813621 +9787530814550 +9787530814673 +9787530815359 +9787530815748 +9787530815922 +9787530816035 +9787530816622 +9787530816950 +9787530817254 +9787530817391 +9787530817544 +9787530817575 +9787530817599 +9787530817629 +9787530817643 +9787530817650 +9787530817681 +9787530817735 +9787530818053 +9787530818237 +9787530818503 +9787530818626 +9787530819654 +9787530819777 +9787530819920 +9787530820070 +9787530820230 +9787530820346 +9787530821121 +9787530821152 +9787530821176 +9787530821244 +9787530821329 +9787530821367 +9787530821534 +9787530821602 +9787530821657 +9787530821794 +9787530821824 +9787530822227 +9787530822326 +9787530822487 +9787530822500 +9787530822562 +9787530822838 +9787530822876 +9787530823125 +9787530823385 +9787530823873 +9787530824795 +9787530824818 +9787530824986 +9787530825471 +9787530825488 +9787530825518 +9787530825709 +9787530825990 +9787530826492 +9787530828182 +9787530828861 +9787530828953 +9787530829332 +9787530829899 +9787530830246 +9787530830260 +9787530830321 +9787530830482 +9787530830505 +9787530831144 +9787530831359 +9787530831809 +9787530832035 +9787530832639 +9787530832769 +9787530832837 +9787530832844 +9787530833094 +9787530833124 +9787530833353 +9787530833650 +9787530834510 +9787530834978 +9787530835043 +9787530835166 +9787530835289 +9787530835326 +9787530835449 +9787530835876 +9787530835890 +9787530836637 +9787530837344 +9787530837405 +9787530837412 +9787530837436 +9787530837573 +9787530837603 +9787530837641 +9787530837689 +9787530837788 +9787530837818 +9787530837979 +9787530838341 +9787530838464 +9787530838495 +9787530838624 +9787530838921 +9787530839355 +9787530840252 +9787530840269 +9787530840306 +9787530840542 +9787530840986 +9787530841884 +9787530842379 +9787530843260 +9787530843406 +9787530843475 +9787530844243 +9787530844427 +9787530844434 +9787530844458 +9787530844465 +9787530844564 +9787530844588 +9787530844854 +9787530844946 +9787530845172 +9787530845592 +9787530846292 +9787530846414 +9787530847565 +9787530848111 +9787530848616 +9787530848951 +9787530849026 +9787530849316 +9787530849521 +9787530849590 +9787530849606 +9787530849613 +9787530849682 +9787530849804 +9787530849897 +9787530849958 +9787530850039 +9787530850237 +9787530850244 +9787530850619 +9787530850862 +9787530850879 +9787530851180 +9787530851326 +9787530851838 +9787530852040 +9787530852323 +9787530852491 +9787530852514 +9787530853030 +9787530853344 +9787530853573 +9787530853610 +9787530853757 +9787530853788 +9787530853955 +9787530854167 +9787530854679 +9787530854686 +9787530854754 +9787530854761 +9787530854983 +9787530855126 +9787530855133 +9787530855140 +9787530855157 +9787530856291 +9787530856352 +9787530856796 +9787530857434 +9787530858387 +9787530858394 +9787530858738 +9787530859919 +9787530860205 +9787530860298 +9787530861417 +9787530861608 +9787530862001 +9787530863183 +9787530863367 +9787530863435 +9787530863510 +9787530863626 +9787530863770 +9787530864470 +9787530864487 +9787530864494 +9787530864586 +9787530864593 +9787530864623 +9787530864715 +9787530864838 +9787530864852 +9787530865415 +9787530865439 +9787530865699 +9787530866771 +9787530866825 +9787530867174 +9787530867259 +9787530867280 +9787530867655 +9787530867891 +9787530868584 +9787530868867 +9787530868904 +9787530869031 +9787530869185 +9787530869222 +9787530869345 +9787530869420 +9787530869468 +9787530869680 +9787530869727 +9787530869741 +9787530869758 +9787530869802 +9787530869833 +9787530870068 +9787530870129 +9787530871904 +9787530874196 +9787530875667 +9787530875698 +9787530875803 +9787530875810 +9787530876213 +9787530876220 +9787530876237 +9787530876510 +9787530876855 +9787530876886 +9787530877036 +9787530877449 +9787530877821 +9787530878163 +9787530878453 +9787530878996 +9787530879658 +9787530879665 +9787530879696 +9787530879993 +9787530880159 +9787530880944 +9787530881033 +9787530881040 +9787530881064 +9787530881088 +9787530881248 +9787530881262 +9787530881279 +9787530881309 +9787530881668 +9787530881705 +9787530881712 +9787530881729 +9787530881736 +9787530881767 +9787530881903 +9787530882092 +9787530882153 +9787530882238 +9787530882634 +9787530882726 +9787530882825 +9787530882955 +9787530882962 +9787530883006 +9787530883020 +9787530883037 +9787530883105 +9787530883112 +9787530883747 +9787530884393 +9787530884522 +9787530884591 +9787530884744 +9787530884812 +9787530884843 +9787530884850 +9787530884980 +9787530885208 +9787530885253 +9787530885260 +9787530885314 +9787530885338 +9787530885369 +9787530885376 +9787530885536 +9787530885680 +9787530885703 +9787530885727 +9787530885857 +9787530886007 +9787530886199 +9787530886519 +9787530886588 +9787530886595 +9787530886731 +9787530886915 +9787530886946 +9787530886953 +9787530887462 +9787530888070 +9787530888162 +9787530888216 +9787530888339 +9787530888346 +9787530888711 +9787530888797 +9787530889404 +9787530889435 +9787530889558 +9787530889817 +9787530890363 +9787530890448 +9787530891452 +9787530891568 +9787530891575 +9787530891636 +9787530891889 +9787530892268 +9787530892572 +9787530893173 +9787530893685 +9787530893999 +9787530894002 +9787530894163 +9787530894224 +9787530894293 +9787530894484 +9787530894705 +9787530894804 +9787530894873 +9787530894903 +9787530895023 +9787530895108 +9787530895634 +9787530895764 +9787530895887 +9787530896563 +9787530896754 +9787530897157 +9787530897270 +9787530898017 +9787530898192 +9787530898352 +9787530899052 +9787530899106 +9787530899564 +9787530899670 +9787530899724 +9787530900017 +9787530900772 +9787530901175 +9787530901205 +9787530903308 +9787530904886 +9787530904947 +9787530906651 +9787530906910 +9787530910221 +9787530912164 +9787530912331 +9787530917978 +9787530918777 +9787530919996 +9787530920015 +9787530921586 +9787530922347 +9787530923269 +9787530923337 +9787530923757 +9787530925737 +9787530925829 +9787530925843 +9787530927137 +9787530927267 +9787530927359 +9787530927397 +9787530928837 +9787530929636 +9787530929865 +9787530930373 +9787530931110 +9787530931134 +9787530931257 +9787530932162 +9787530933572 +9787530933800 +9787530933817 +9787530934241 +9787530934265 +9787530936979 +9787530938119 +9787530940006 +9787530940587 +9787530941485 +9787530941522 +9787530941539 +9787530941546 +9787530941560 +9787530941577 +9787530941584 +9787530941690 +9787530941768 +9787530941775 +9787530942079 +9787530942086 +9787530942093 +9787530942369 +9787530942390 +9787530942505 +9787530942680 +9787530943045 +9787530943052 +9787530943670 +9787530943755 +9787530943793 +9787530943854 +9787530944578 +9787530944622 +9787530944837 +9787530945322 +9787530945414 +9787530945438 +9787530945483 +9787530945513 +9787530945803 +9787530945940 +9787530946176 +9787530946213 +9787530946244 +9787530946251 +9787530946282 +9787530946640 +9787530947081 +9787530947258 +9787530947364 +9787530947586 +9787530947784 +9787530947814 +9787530947821 +9787530947944 +9787530948095 +9787530948170 +9787530948200 +9787530948217 +9787530948385 +9787530948446 +9787530948460 +9787530948637 +9787530948897 +9787530948903 +9787530948941 +9787530948989 +9787530949009 +9787530949078 +9787530950159 +9787530950258 +9787530950340 +9787530950418 +9787530950456 +9787530950487 +9787530950524 +9787530950548 +9787530950579 +9787530950630 +9787530950647 +9787530951316 +9787530951330 +9787530951354 +9787530951484 +9787530951835 +9787530951965 +9787530952214 +9787530952702 +9787530952719 +9787530953358 +9787530953921 +9787530953983 +9787530954225 +9787530954317 +9787530954447 +9787530954546 +9787530954706 +9787530954782 +9787530954805 +9787530954881 +9787530954997 +9787530955109 +9787530955130 +9787530955239 +9787530955253 +9787530955420 +9787530955451 +9787530955611 +9787530955765 +9787530955819 +9787530956007 +9787530956083 +9787530956090 +9787530956106 +9787530956120 +9787530956137 +9787530956144 +9787530956205 +9787530956311 +9787530956366 +9787530956595 +9787530956854 +9787530956878 +9787530956946 +9787530956953 +9787530957455 +9787530957646 +9787530957707 +9787530957714 +9787530957837 +9787530958186 +9787530958261 +9787530958322 +9787530958384 +9787530958452 +9787530958506 +9787530959213 +9787530959268 +9787530959701 +9787530959831 +9787530959916 +9787530959923 +9787530960127 +9787530960172 +9787530960363 +9787530960554 +9787530960677 +9787530960837 +9787530960844 +9787530960851 +9787530961346 +9787530961841 +9787530961933 +9787530962053 +9787530962268 +9787530962435 +9787530963876 +9787530964231 +9787530964378 +9787530964545 +9787530964668 +9787530965566 +9787530965610 +9787530965856 +9787530966235 +9787530966433 +9787530966624 +9787530966679 +9787530966778 +9787530966839 +9787530967065 +9787530967140 +9787530967164 +9787530967225 +9787530967409 +9787530967669 +9787530968215 +9787530968819 +9787530968932 +9787530968949 +9787530968994 +9787530969069 +9787530969076 +9787530969168 +9787530969458 +9787530969502 +9787530969540 +9787530969663 +9787530969717 +9787530969908 +9787530970027 +9787530970164 +9787530970775 +9787530971178 +9787530972465 +9787530972878 +9787530973141 +9787530973288 +9787530973387 +9787530973424 +9787530973455 +9787530973462 +9787530973493 +9787530973523 +9787530974032 +9787530974070 +9787530974346 +9787530974353 +9787530974377 +9787530974766 +9787530974858 +9787530975145 +9787530975268 +9787530975725 +9787530976043 +9787530976357 +9787530976869 +9787530977194 +9787530977200 +9787530977248 +9787530977507 +9787530977538 +9787530977552 +9787530977583 +9787530978399 +9787530979105 +9787530979112 +9787530979495 +9787530979525 +9787530979747 +9787530980224 +9787530981917 +9787530981924 +9787530982136 +9787530982143 +9787530982297 +9787530982426 +9787530982518 +9787530982860 +9787530982976 +9787530983003 +9787530983034 +9787530983393 +9787530983744 +9787530984222 +9787530984253 +9787530984376 +9787530984574 +9787530984758 +9787530984772 +9787530984925 +9787530984987 +9787530984994 +9787530985007 +9787530985052 +9787530985069 +9787530985281 +9787530985595 +9787530986431 +9787530987049 +9787530987056 +9787530988800 +9787530988817 +9787530989074 +9787530989357 +9787530989494 +9787530989944 +9787530989951 +9787530990148 +9787530990568 +9787530990995 +9787530992128 +9787530993491 +9787531000181 +9787531000211 +9787531000327 +9787531000365 +9787531000495 +9787531000525 +9787531000617 +9787531000822 +9787531001775 +9787531002024 +9787531002451 +9787531002789 +9787531002840 +9787531004035 +9787531004318 +9787531004523 +9787531004851 +9787531005063 +9787531005308 +9787531005780 +9787531005902 +9787531006022 +9787531006084 +9787531006091 +9787531006398 +9787531006442 +9787531006497 +9787531006879 +9787531006893 +9787531006909 +9787531007012 +9787531007098 +9787531007142 +9787531007241 +9787531007265 +9787531007340 +9787531007357 +9787531007395 +9787531007456 +9787531007500 +9787531008156 +9787531008170 +9787531008194 +9787531008217 +9787531008378 +9787531008385 +9787531008392 +9787531008453 +9787531008477 +9787531008804 +9787531008842 +9787531008880 +9787531008897 +9787531008927 +9787531008934 +9787531009177 +9787531009665 +9787531009726 +9787531009740 +9787531009801 +9787531009818 +9787531009856 +9787531009863 +9787531009962 +9787531010043 +9787531010166 +9787531010180 +9787531010494 +9787531010500 +9787531010708 +9787531010739 +9787531010869 +9787531011118 +9787531011323 +9787531011354 +9787531011408 +9787531011590 +9787531011750 +9787531011798 +9787531011828 +9787531012429 +9787531012566 +9787531012726 +9787531013204 +9787531013679 +9787531014164 +9787531014324 +9787531014461 +9787531014522 +9787531014638 +9787531015239 +9787531015499 +9787531015550 +9787531015574 +9787531015710 +9787531015741 +9787531016397 +9787531016458 +9787531016489 +9787531016557 +9787531016571 +9787531017066 +9787531017257 +9787531017318 +9787531017554 +9787531017615 +9787531018186 +9787531018193 +9787531018247 +9787531018667 +9787531018704 +9787531018940 +9787531019145 +9787531019152 +9787531019244 +9787531019251 +9787531019787 +9787531019800 +9787531019817 +9787531020219 +9787531020295 +9787531020332 +9787531020554 +9787531020592 +9787531020615 +9787531020660 +9787531020684 +9787531020844 +9787531021148 +9787531021391 +9787531021520 +9787531021551 +9787531021582 +9787531021773 +9787531022053 +9787531022183 +9787531022374 +9787531022381 +9787531022398 +9787531022404 +9787531022435 +9787531022442 +9787531022459 +9787531022466 +9787531022527 +9787531022831 +9787531023005 +9787531023517 +9787531023685 +9787531024033 +9787531024040 +9787531024439 +9787531024569 +9787531024644 +9787531024675 +9787531024682 +9787531024699 +9787531025139 +9787531025191 +9787531025436 +9787531025917 +9787531025924 +9787531025986 +9787531026044 +9787531026181 +9787531026259 +9787531026549 +9787531026594 +9787531026778 +9787531027218 +9787531027355 +9787531027775 +9787531028161 +9787531028628 +9787531028635 +9787531028765 +9787531028857 +9787531029168 +9787531029182 +9787531029205 +9787531029267 +9787531029458 +9787531029960 +9787531029977 +9787531030294 +9787531030591 +9787531030867 +9787531031178 +9787531031406 +9787531031727 +9787531031765 +9787531031796 +9787531031994 +9787531032090 +9787531032144 +9787531032182 +9787531032465 +9787531032700 +9787531032779 +9787531032892 +9787531032915 +9787531032953 +9787531032977 +9787531032984 +9787531033011 +9787531033035 +9787531033257 +9787531033295 +9787531033820 +9787531033851 +9787531034049 +9787531034285 +9787531034322 +9787531034520 +9787531034865 +9787531034926 +9787531034988 +9787531035060 +9787531035084 +9787531035121 +9787531035176 +9787531035220 +9787531035237 +9787531035329 +9787531035589 +9787531035909 +9787531035947 +9787531035985 +9787531036937 +9787531036951 +9787531037590 +9787531038344 +9787531038399 +9787531040675 +9787531041658 +9787531041665 +9787531041757 +9787531042440 +9787531042662 +9787531044567 +9787531044871 +9787531045137 +9787531045199 +9787531045274 +9787531046530 +9787531047018 +9787531047216 +9787531047353 +9787531048176 +9787531048190 +9787531048213 +9787531048220 +9787531048237 +9787531048251 +9787531048275 +9787531048442 +9787531048572 +9787531048626 +9787531048695 +9787531048756 +9787531048800 +9787531048848 +9787531048855 +9787531048862 +9787531048879 +9787531048947 +9787531048992 +9787531049012 +9787531049043 +9787531049074 +9787531049128 +9787531049135 +9787531049159 +9787531049203 +9787531049210 +9787531049234 +9787531049258 +9787531049296 +9787531049364 +9787531049531 +9787531049579 +9787531049616 +9787531049661 +9787531049692 +9787531049708 +9787531049715 +9787531050155 +9787531050391 +9787531050537 +9787531050650 +9787531052050 +9787531052586 +9787531052777 +9787531052784 +9787531053606 +9787531053729 +9787531054016 +9787531054818 +9787531055167 +9787531055242 +9787531055273 +9787531055297 +9787531055303 +9787531055334 +9787531055433 +9787531055488 +9787531055709 +9787531055730 +9787531056072 +9787531056133 +9787531056881 +9787531057185 +9787531057338 +9787531057383 +9787531057390 +9787531058519 +9787531058731 +9787531058748 +9787531059196 +9787531059387 +9787531059479 +9787531060345 +9787531060611 +9787531060628 +9787531060956 +9787531061069 +9787531061274 +9787531061618 +9787531061755 +9787531062745 +9787531062998 +9787531063018 +9787531063094 +9787531063193 +9787531063797 +9787531064145 +9787531064367 +9787531066422 +9787531066439 +9787531066491 +9787531066521 +9787531066538 +9787531066545 +9787531066835 +9787531066880 +9787531067061 +9787531067122 +9787531069454 +9787531070122 +9787531071617 +9787531071723 +9787531072072 +9787531073161 +9787531073345 +9787531073406 +9787531073871 +9787531074458 +9787531075349 +9787531076971 +9787531077718 +9787531077855 +9787531078395 +9787531083955 +9787531085270 +9787531085805 +9787531086055 +9787531086383 +9787531086772 +9787531087298 +9787531087458 +9787531087465 +9787531087656 +9787531087663 +9787531087670 +9787531087762 +9787531087823 +9787531088349 +9787531088523 +9787531089162 +9787531089339 +9787531089391 +9787531089407 +9787531089636 +9787531089940 +9787531090571 +9787531090700 +9787531092445 +9787531092926 +9787531093978 +9787531094043 +9787531094180 +9787531094425 +9787531094654 +9787531096108 +9787531096139 +9787531096405 +9787531096740 +9787531096818 +9787531096887 +9787531096931 +9787531096948 +9787531096993 +9787531097334 +9787531097402 +9787531097433 +9787531098461 +9787531098607 +9787531098638 +9787531098713 +9787531098775 +9787531099185 +9787531099307 +9787531099499 +9787531099512 +9787531099741 +9787531110286 +9787531116509 +9787531131014 +9787531134558 +9787531136118 +9787531136644 +9787531140924 +9787531140931 +9787531142881 +9787531144953 +9787531146285 +9787531146308 +9787531146353 +9787531147794 +9787531152255 +9787531152293 +9787531156130 +9787531157243 +9787531158493 +9787531158943 +9787531162209 +9787531162308 +9787531162353 +9787531163114 +9787531163596 +9787531163602 +9787531163640 +9787531164838 +9787531165972 +9787531166054 +9787531166092 +9787531166719 +9787531167105 +9787531168928 +9787531169000 +9787531169833 +9787531171430 +9787531171997 +9787531172079 +9787531173571 +9787531176466 +9787531176718 +9787531176725 +9787531176855 +9787531176862 +9787531176879 +9787531179108 +9787531182900 +9787531182917 +9787531183358 +9787531183808 +9787531183877 +9787531185253 +9787531185321 +9787531185345 +9787531186489 +9787531186793 +9787531186816 +9787531186915 +9787531189961 +9787531192527 +9787531198420 +9787531200178 +9787531204077 +9787531204251 +9787531204558 +9787531204732 +9787531205302 +9787531206545 +9787531206927 +9787531206941 +9787531206965 +9787531207474 +9787531207733 +9787531207795 +9787531207801 +9787531207818 +9787531207825 +9787531207924 +9787531207986 +9787531208112 +9787531208501 +9787531209072 +9787531209218 +9787531209355 +9787531209379 +9787531209614 +9787531209645 +9787531210085 +9787531210153 +9787531210511 +9787531211006 +9787531211051 +9787531211631 +9787531211716 +9787531212188 +9787531212263 +9787531212287 +9787531212430 +9787531213246 +9787531213284 +9787531213321 +9787531213451 +9787531213468 +9787531213475 +9787531213659 +9787531214007 +9787531214014 +9787531214090 +9787531214151 +9787531214205 +9787531214519 +9787531214724 +9787531214939 +9787531215011 +9787531215172 +9787531215721 +9787531215936 +9787531216100 +9787531216186 +9787531216681 +9787531217312 +9787531217442 +9787531217756 +9787531217787 +9787531218173 +9787531218296 +9787531219859 +9787531219934 +9787531220039 +9787531220053 +9787531220305 +9787531220435 +9787531220459 +9787531221005 +9787531221661 +9787531221944 +9787531223870 +9787531224860 +9787531227021 +9787531228080 +9787531228615 +9787531228707 +9787531228776 +9787531229056 +9787531229230 +9787531229254 +9787531229438 +9787531229452 +9787531230816 +9787531233398 +9787531240334 +9787531242383 +9787531242550 +9787531243328 +9787531250203 +9787531250210 +9787531250715 +9787531251071 +9787531251446 +9787531251552 +9787531252078 +9787531254096 +9787531254218 +9787531254249 +9787531254591 +9787531300021 +9787531300069 +9787531300083 +9787531300120 +9787531300137 +9787531300182 +9787531300199 +9787531300205 +9787531300212 +9787531300229 +9787531300250 +9787531300304 +9787531300335 +9787531300342 +9787531300403 +9787531300410 +9787531300472 +9787531300540 +9787531300557 +9787531300618 +9787531300632 +9787531300717 +9787531300885 +9787531301172 +9787531301189 +9787531301202 +9787531301257 +9787531301288 +9787531301295 +9787531301356 +9787531301363 +9787531301646 +9787531301721 +9787531301752 +9787531301769 +9787531301820 +9787531301943 +9787531302001 +9787531302025 +9787531302056 +9787531302100 +9787531302131 +9787531302155 +9787531302186 +9787531302209 +9787531302261 +9787531302308 +9787531302407 +9787531302667 +9787531303008 +9787531303107 +9787531304685 +9787531304692 +9787531305477 +9787531305569 +9787531305620 +9787531305675 +9787531305750 +9787531305811 +9787531305835 +9787531305866 +9787531305965 +9787531305989 +9787531306184 +9787531306290 +9787531306474 +9787531306528 +9787531306771 +9787531306795 +9787531307037 +9787531307129 +9787531307211 +9787531307273 +9787531307365 +9787531307419 +9787531307686 +9787531308027 +9787531308034 +9787531308195 +9787531308263 +9787531308317 +9787531308386 +9787531308393 +9787531308546 +9787531308553 +9787531308713 +9787531308720 +9787531308768 +9787531308836 +9787531309284 +9787531309307 +9787531309314 +9787531309321 +9787531309338 +9787531309345 +9787531309352 +9787531309369 +9787531309376 +9787531309390 +9787531309857 +9787531310044 +9787531310235 +9787531310280 +9787531310556 +9787531310846 +9787531310853 +9787531310945 +9787531311256 +9787531311508 +9787531311553 +9787531311584 +9787531311652 +9787531311744 +9787531311768 +9787531311928 +9787531311935 +9787531312048 +9787531312147 +9787531312154 +9787531312260 +9787531312369 +9787531312376 +9787531312499 +9787531312543 +9787531312970 +9787531312987 +9787531312994 +9787531313014 +9787531313052 +9787531313182 +9787531313205 +9787531313267 +9787531313359 +9787531313373 +9787531313380 +9787531313397 +9787531313410 +9787531313427 +9787531313441 +9787531313472 +9787531313489 +9787531313496 +9787531313632 +9787531313717 +9787531313748 +9787531313755 +9787531313793 +9787531313823 +9787531313847 +9787531313878 +9787531313939 +9787531313946 +9787531313960 +9787531313977 +9787531313984 +9787531314004 +9787531314134 +9787531314196 +9787531314202 +9787531314226 +9787531314288 +9787531314417 +9787531314462 +9787531314479 +9787531314493 +9787531314509 +9787531314554 +9787531314646 +9787531314660 +9787531314707 +9787531314837 +9787531314851 +9787531314905 +9787531315001 +9787531315018 +9787531315032 +9787531315056 +9787531315193 +9787531315285 +9787531315469 +9787531315520 +9787531315599 +9787531315605 +9787531315865 +9787531315957 +9787531316008 +9787531316121 +9787531316206 +9787531316220 +9787531316282 +9787531316381 +9787531316428 +9787531316442 +9787531316589 +9787531316619 +9787531316909 +9787531316978 +9787531316992 +9787531317319 +9787531317340 +9787531317371 +9787531317395 +9787531317555 +9787531317616 +9787531317760 +9787531317784 +9787531317791 +9787531317906 +9787531318118 +9787531318125 +9787531318156 +9787531318163 +9787531318231 +9787531318347 +9787531318361 +9787531318378 +9787531318392 +9787531318422 +9787531318545 +9787531318644 +9787531318699 +9787531318873 +9787531319061 +9787531319184 +9787531319368 +9787531319450 +9787531319511 +9787531319559 +9787531319566 +9787531319689 +9787531319702 +9787531319719 +9787531319870 +9787531319986 +9787531320210 +9787531320227 +9787531320272 +9787531320296 +9787531320302 +9787531320401 +9787531320425 +9787531320456 +9787531320555 +9787531320593 +9787531320722 +9787531320814 +9787531320838 +9787531321200 +9787531321224 +9787531321392 +9787531321477 +9787531321590 +9787531321675 +9787531321767 +9787531321859 +9787531321866 +9787531322030 +9787531322146 +9787531322177 +9787531322238 +9787531322429 +9787531322450 +9787531322504 +9787531322924 +9787531322931 +9787531322979 +9787531323112 +9787531323211 +9787531323471 +9787531323624 +9787531323655 +9787531323730 +9787531323815 +9787531323822 +9787531323860 +9787531323983 +9787531324232 +9787531324249 +9787531324263 +9787531324287 +9787531324294 +9787531324386 +9787531324447 +9787531324584 +9787531324768 +9787531324775 +9787531324850 +9787531324959 +9787531324966 +9787531325000 +9787531325017 +9787531325307 +9787531325314 +9787531325338 +9787531325345 +9787531325352 +9787531325406 +9787531325437 +9787531325536 +9787531325543 +9787531325727 +9787531325826 +9787531325840 +9787531325857 +9787531325901 +9787531326069 +9787531326113 +9787531326168 +9787531326182 +9787531326199 +9787531326205 +9787531326212 +9787531326236 +9787531326243 +9787531326328 +9787531326410 +9787531326489 +9787531326564 +9787531326755 +9787531326809 +9787531326861 +9787531326885 +9787531327028 +9787531327295 +9787531327356 +9787531327639 +9787531327653 +9787531327714 +9787531327745 +9787531327752 +9787531327820 +9787531327875 +9787531327967 +9787531327974 +9787531327981 +9787531328001 +9787531328025 +9787531328261 +9787531328384 +9787531328506 +9787531328643 +9787531328667 +9787531328704 +9787531328735 +9787531328810 +9787531328834 +9787531328971 +9787531329107 +9787531329121 +9787531329343 +9787531329602 +9787531329718 +9787531329770 +9787531329886 +9787531330059 +9787531330158 +9787531330202 +9787531330332 +9787531330523 +9787531330660 +9787531330707 +9787531330813 +9787531330929 +9787531330998 +9787531331124 +9787531331179 +9787531331742 +9787531331964 +9787531332046 +9787531332466 +9787531332497 +9787531332510 +9787531332572 +9787531332602 +9787531332787 +9787531332794 +9787531332800 +9787531332909 +9787531333159 +9787531333289 +9787531333333 +9787531333371 +9787531333449 +9787531333586 +9787531333746 +9787531333777 +9787531333883 +9787531333944 +9787531334040 +9787531334149 +9787531334156 +9787531334187 +9787531334194 +9787531334217 +9787531334224 +9787531334316 +9787531334392 +9787531334491 +9787531334682 +9787531334705 +9787531334729 +9787531334750 +9787531335252 +9787531335283 +9787531335665 +9787531335849 +9787531335979 +9787531336020 +9787531336105 +9787531336181 +9787531336204 +9787531336211 +9787531336471 +9787531336518 +9787531336624 +9787531336730 +9787531336754 +9787531337041 +9787531337058 +9787531337355 +9787531337508 +9787531337720 +9787531337782 +9787531337874 +9787531337942 +9787531337980 +9787531338154 +9787531338178 +9787531338215 +9787531338260 +9787531338390 +9787531338697 +9787531338789 +9787531338895 +9787531339021 +9787531339137 +9787531339229 +9787531339335 +9787531339441 +9787531339649 +9787531339663 +9787531339915 +9787531340430 +9787531340447 +9787531340645 +9787531340706 +9787531340782 +9787531340942 +9787531341031 +9787531341086 +9787531341185 +9787531341413 +9787531341444 +9787531341703 +9787531341918 +9787531341925 +9787531342069 +9787531342205 +9787531342397 +9787531342540 +9787531342557 +9787531342700 +9787531342892 +9787531342960 +9787531343295 +9787531343387 +9787531343400 +9787531343950 +9787531343981 +9787531344001 +9787531344179 +9787531344285 +9787531344308 +9787531344315 +9787531344353 +9787531344490 +9787531344513 +9787531344537 +9787531344704 +9787531344834 +9787531344872 +9787531344889 +9787531344971 +9787531345015 +9787531345183 +9787531345237 +9787531345282 +9787531345718 +9787531345824 +9787531345978 +9787531346302 +9787531346586 +9787531346647 +9787531346838 +9787531346890 +9787531347118 +9787531347262 +9787531347293 +9787531347323 +9787531347330 +9787531347347 +9787531347354 +9787531347392 +9787531347576 +9787531347583 +9787531347712 +9787531347866 +9787531347927 +9787531348115 +9787531348481 +9787531349150 +9787531349327 +9787531349655 +9787531350170 +9787531350231 +9787531350255 +9787531350323 +9787531350422 +9787531350446 +9787531350934 +9787531351009 +9787531351191 +9787531351214 +9787531351443 +9787531351481 +9787531351542 +9787531351818 +9787531351825 +9787531351863 +9787531351955 +9787531352006 +9787531352112 +9787531352242 +9787531352341 +9787531352358 +9787531352907 +9787531353492 +9787531353553 +9787531353614 +9787531353768 +9787531354154 +9787531354390 +9787531354406 +9787531354413 +9787531354741 +9787531355168 +9787531355175 +9787531355441 +9787531355700 +9787531355717 +9787531355793 +9787531355861 +9787531356080 +9787531356097 +9787531356134 +9787531356448 +9787531356493 +9787531356547 +9787531356585 +9787531356622 +9787531356653 +9787531356790 +9787531356929 +9787531357261 +9787531357926 +9787531358084 +9787531358305 +9787531358510 +9787531358688 +9787531359005 +9787531359012 +9787531359029 +9787531359036 +9787531359388 +9787531359395 +9787531359470 +9787531359548 +9787531359579 +9787531359647 +9787531359661 +9787531359692 +9787531359708 +9787531359814 +9787531359845 +9787531359876 +9787531360223 +9787531360612 +9787531360681 +9787531360704 +9787531360735 +9787531360742 +9787531360766 +9787531360803 +9787531360810 +9787531360933 +9787531361053 +9787531362258 +9787531362401 +9787531362494 +9787531362890 +9787531362920 +9787531362944 +9787531363125 +9787531363132 +9787531363583 +9787531363712 +9787531363750 +9787531363767 +9787531363774 +9787531363798 +9787531363842 +9787531363873 +9787531363880 +9787531363903 +9787531363927 +9787531363941 +9787531363965 +9787531364023 +9787531364245 +9787531364467 +9787531364511 +9787531364740 +9787531364764 +9787531364900 +9787531364948 +9787531364962 +9787531364993 +9787531365082 +9787531365099 +9787531365235 +9787531365259 +9787531365266 +9787531365273 +9787531365327 +9787531365556 +9787531365587 +9787531365594 +9787531365662 +9787531365815 +9787531365884 +9787531366058 +9787531366065 +9787531366119 +9787531366140 +9787531366157 +9787531366225 +9787531366256 +9787531366270 +9787531366294 +9787531366416 +9787531366461 +9787531366737 +9787531366966 +9787531367031 +9787531367062 +9787531367079 +9787531367147 +9787531367215 +9787531367246 +9787531367574 +9787531367659 +9787531367765 +9787531367871 +9787531367963 +9787531367987 +9787531368168 +9787531368274 +9787531368472 +9787531368632 +9787531369103 +9787531369387 +9787531369462 +9787531400196 +9787531400332 +9787531402206 +9787531402220 +9787531402459 +9787531404125 +9787531406822 +9787531406846 +9787531407218 +9787531407959 +9787531407966 +9787531408642 +9787531408659 +9787531408949 +9787531408987 +9787531409052 +9787531409335 +9787531409434 +9787531409571 +9787531409588 +9787531409632 +9787531409649 +9787531409793 +9787531409960 +9787531410041 +9787531410249 +9787531410270 +9787531410324 +9787531410430 +9787531410546 +9787531410911 +9787531410935 +9787531410942 +9787531410966 +9787531411529 +9787531411567 +9787531412274 +9787531412311 +9787531412373 +9787531412502 +9787531412533 +9787531412816 +9787531413370 +9787531413455 +9787531413844 +9787531413868 +9787531413905 +9787531414063 +9787531414094 +9787531414407 +9787531414490 +9787531414896 +9787531416081 +9787531416210 +9787531416302 +9787531416623 +9787531416692 +9787531416739 +9787531416951 +9787531417217 +9787531417224 +9787531417538 +9787531418078 +9787531418870 +9787531419044 +9787531419655 +9787531419730 +9787531419839 +9787531419891 +9787531419921 +9787531420002 +9787531420064 +9787531420071 +9787531420163 +9787531420194 +9787531420507 +9787531420583 +9787531420699 +9787531420774 +9787531420972 +9787531421009 +9787531421078 +9787531421474 +9787531421573 +9787531421597 +9787531421689 +9787531421825 +9787531421894 +9787531421955 +9787531421979 +9787531422099 +9787531422419 +9787531422495 +9787531422747 +9787531422877 +9787531423089 +9787531423539 +9787531423546 +9787531423720 +9787531423898 +9787531424079 +9787531424086 +9787531424123 +9787531424147 +9787531424208 +9787531424222 +9787531424376 +9787531424499 +9787531424574 +9787531424697 +9787531424802 +9787531424864 +9787531424970 +9787531425007 +9787531425120 +9787531425304 +9787531425342 +9787531425427 +9787531425472 +9787531425496 +9787531425564 +9787531425656 +9787531425854 +9787531425991 +9787531426196 +9787531426400 +9787531426424 +9787531426547 +9787531426714 +9787531426738 +9787531426875 +9787531427124 +9787531427346 +9787531427506 +9787531427612 +9787531427704 +9787531427773 +9787531427896 +9787531427919 +9787531427926 +9787531428091 +9787531428206 +9787531428244 +9787531428251 +9787531428299 +9787531428312 +9787531428381 +9787531428404 +9787531428619 +9787531428664 +9787531428749 +9787531429357 +9787531429418 +9787531429531 +9787531429678 +9787531429777 +9787531429791 +9787531429838 +9787531430001 +9787531430049 +9787531430155 +9787531430285 +9787531430360 +9787531430605 +9787531430643 +9787531430803 +9787531430995 +9787531431039 +9787531431046 +9787531431268 +9787531431350 +9787531431886 +9787531432098 +9787531432654 +9787531432661 +9787531433958 +9787531434276 +9787531434467 +9787531434474 +9787531434603 +9787531434870 +9787531437116 +9787531437123 +9787531437246 +9787531439417 +9787531439929 +9787531440192 +9787531440567 +9787531440598 +9787531440635 +9787531441557 +9787531442097 +9787531442103 +9787531442639 +9787531442691 +9787531442905 +9787531444992 +9787531445081 +9787531445142 +9787531445739 +9787531445944 +9787531446118 +9787531446132 +9787531446248 +9787531446460 +9787531446583 +9787531446644 +9787531446880 +9787531447382 +9787531448990 +9787531449447 +9787531449713 +9787531450375 +9787531451341 +9787531451372 +9787531451679 +9787531451983 +9787531452775 +9787531453918 +9787531454083 +9787531454106 +9787531454328 +9787531454847 +9787531458227 +9787531459682 +9787531459712 +9787531459774 +9787531459804 +9787531461043 +9787531461470 +9787531462170 +9787531462521 +9787531462989 +9787531463160 +9787531463191 +9787531463467 +9787531463528 +9787531463542 +9787531463771 +9787531466475 +9787531470366 +9787531470977 +9787531473190 +9787531473220 +9787531473367 +9787531473671 +9787531473701 +9787531474265 +9787531474289 +9787531474449 +9787531474470 +9787531474746 +9787531475019 +9787531475323 +9787531476740 +9787531476979 +9787531476986 +9787531476993 +9787531477020 +9787531477112 +9787531477310 +9787531478058 +9787531478102 +9787531478133 +9787531478461 +9787531478614 +9787531478638 +9787531478836 +9787531479093 +9787531479147 +9787531479208 +9787531479871 +9787531481164 +9787531481270 +9787531481287 +9787531481522 +9787531481812 +9787531482222 +9787531482352 +9787531482970 +9787531483335 +9787531483366 +9787531483502 +9787531483618 +9787531483694 +9787531483724 +9787531483793 +9787531483922 +9787531483953 +9787531484042 +9787531484585 +9787531484592 +9787531484615 +9787531484882 +9787531485100 +9787531485186 +9787531485193 +9787531485209 +9787531485506 +9787531485629 +9787531485711 +9787531485735 +9787531485766 +9787531485797 +9787531485810 +9787531485834 +9787531485841 +9787531486053 +9787531486114 +9787531486121 +9787531486152 +9787531486206 +9787531486411 +9787531486558 +9787531486893 +9787531486978 +9787531487029 +9787531487425 +9787531487739 +9787531487753 +9787531487838 +9787531488002 +9787531488132 +9787531488224 +9787531488255 +9787531488330 +9787531488361 +9787531488569 +9787531488651 +9787531488835 +9787531488873 +9787531489290 +9787531489313 +9787531489382 +9787531489627 +9787531489665 +9787531489733 +9787531490425 +9787531490470 +9787531490883 +9787531490920 +9787531490944 +9787531491002 +9787531491309 +9787531491385 +9787531491507 +9787531491576 +9787531491842 +9787531491866 +9787531492009 +9787531492047 +9787531492443 +9787531492474 +9787531492498 +9787531492597 +9787531492658 +9787531492733 +9787531493136 +9787531493198 +9787531493310 +9787531494188 +9787531494607 +9787531495444 +9787531495611 +9787531497370 +9787531497394 +9787531497721 +9787531498018 +9787531498506 +9787531498797 +9787531500124 +9787531500193 +9787531500254 +9787531500261 +9787531500308 +9787531500575 +9787531501541 +9787531501558 +9787531502845 +9787531502869 +9787531503040 +9787531503057 +9787531503118 +9787531503187 +9787531503439 +9787531503576 +9787531503767 +9787531503996 +9787531504122 +9787531505846 +9787531506157 +9787531507260 +9787531508977 +9787531511922 +9787531512936 +9787531513957 +9787531514572 +9787531514749 +9787531518136 +9787531526414 +9787531526780 +9787531527091 +9787531528074 +9787531528920 +9787531529446 +9787531531234 +9787531532538 +9787531534099 +9787531534518 +9787531535096 +9787531535126 +9787531536116 +9787531536819 +9787531537083 +9787531537243 +9787531538271 +9787531540311 +9787531540847 +9787531541028 +9787531541097 +9787531541448 +9787531541455 +9787531541462 +9787531541493 +9787531541523 +9787531542469 +9787531542605 +9787531543480 +9787531543497 +9787531543954 +9787531544050 +9787531544418 +9787531544494 +9787531545453 +9787531547143 +9787531547150 +9787531547624 +9787531548126 +9787531549253 +9787531549598 +9787531549734 +9787531550259 +9787531550396 +9787531550600 +9787531551393 +9787531551492 +9787531551706 +9787531551720 +9787531551751 +9787531552536 +9787531552543 +9787531552567 +9787531552574 +9787531552581 +9787531553151 +9787531553168 +9787531553175 +9787531553182 +9787531553496 +9787531553526 +9787531553564 +9787531554356 +9787531554400 +9787531554455 +9787531554721 +9787531554790 +9787531554806 +9787531554813 +9787531555124 +9787531555131 +9787531555148 +9787531555162 +9787531555193 +9787531555216 +9787531555520 +9787531556237 +9787531557524 +9787531557531 +9787531557548 +9787531558354 +9787531558378 +9787531558385 +9787531558514 +9787531558521 +9787531558552 +9787531558569 +9787531558835 +9787531558910 +9787531559184 +9787531559337 +9787531559368 +9787531560548 +9787531561330 +9787531561798 +9787531561958 +9787531562214 +9787531562832 +9787531563105 +9787531563372 +9787531563396 +9787531563419 +9787531563549 +9787531563556 +9787531564294 +9787531564331 +9787531564676 +9787531564683 +9787531564904 +9787531565055 +9787531565062 +9787531565093 +9787531565154 +9787531565161 +9787531565550 +9787531565802 +9787531565864 +9787531565901 +9787531565925 +9787531566083 +9787531566090 +9787531566120 +9787531566137 +9787531566151 +9787531566830 +9787531566915 +9787531566984 +9787531567479 +9787531567486 +9787531567752 +9787531568063 +9787531568650 +9787531568667 +9787531568698 +9787531568711 +9787531568742 +9787531570059 +9787531570110 +9787531570271 +9787531570448 +9787531570547 +9787531570578 +9787531570660 +9787531570684 +9787531570936 +9787531570998 +9787531571063 +9787531571179 +9787531571209 +9787531571605 +9787531571612 +9787531571636 +9787531571667 +9787531571674 +9787531571780 +9787531571957 +9787531572398 +9787531572503 +9787531572527 +9787531572701 +9787531572886 +9787531572978 +9787531573036 +9787531573043 +9787531573159 +9787531573418 +9787531573487 +9787531573494 +9787531573500 +9787531573609 +9787531573647 +9787531573661 +9787531573814 +9787531573975 +9787531574026 +9787531574033 +9787531574057 +9787531574064 +9787531574248 +9787531574293 +9787531574361 +9787531574378 +9787531574385 +9787531574392 +9787531574767 +9787531575245 +9787531575450 +9787531575887 +9787531575986 +9787531576006 +9787531576068 +9787531576600 +9787531576877 +9787531576983 +9787531577461 +9787531577546 +9787531577584 +9787531577720 +9787531577737 +9787531577904 +9787531578154 +9787531578550 +9787531578819 +9787531578963 +9787531578970 +9787531578987 +9787531578994 +9787531579014 +9787531579021 +9787531579038 +9787531579045 +9787531579083 +9787531579090 +9787531579182 +9787531579199 +9787531579205 +9787531579212 +9787531579229 +9787531579236 +9787531579328 +9787531579427 +9787531579434 +9787531579755 +9787531579984 +9787531580072 +9787531580393 +9787531580447 +9787531580553 +9787531581215 +9787531581222 +9787531581451 +9787531581512 +9787531581864 +9787531581932 +9787531582397 +9787531582465 +9787531582694 +9787531583202 +9787531583417 +9787531583660 +9787531583875 +9787531586265 +9787531586302 +9787531586425 +9787531586531 +9787531586791 +9787531586807 +9787531587033 +9787531587071 +9787531587125 +9787531587637 +9787531588627 +9787531589228 +9787531589624 +9787531590354 +9787531590873 +9787531590880 +9787531590910 +9787531590927 +9787531591092 +9787531591160 +9787531592273 +9787531592280 +9787531592297 +9787531592303 +9787531592365 +9787531592747 +9787531592983 +9787531593232 +9787531593461 +9787531593607 +9787531593843 +9787531593867 +9787531594246 +9787531594345 +9787531594390 +9787531594413 +9787531594420 +9787531595175 +9787531595953 +9787531596110 +9787531596127 +9787531596905 +9787531596981 +9787531597384 +9787531597636 +9787531597643 +9787531598305 +9787531599265 +9787531603702 +9787531603757 +9787531603771 +9787531603795 +9787531603887 +9787531603986 +9787531604563 +9787531604785 +9787531605096 +9787531607601 +9787531611806 +9787531612407 +9787531615002 +9787531616474 +9787531622147 +9787531623021 +9787531624288 +9787531624387 +9787531625063 +9787531628613 +9787531629320 +9787531633600 +9787531633631 +9787531633716 +9787531634461 +9787531634867 +9787531635086 +9787531635178 +9787531636892 +9787531637240 +9787531637387 +9787531637509 +9787531637912 +9787531638032 +9787531638063 +9787531638117 +9787531638148 +9787531638315 +9787531638469 +9787531639275 +9787531639534 +9787531640127 +9787531640837 +9787531640851 +9787531640912 +9787531641018 +9787531641254 +9787531641261 +9787531641322 +9787531641490 +9787531642220 +9787531642480 +9787531645689 +9787531646570 +9787531646792 +9787531649434 +9787531649465 +9787531651376 +9787531652441 +9787531652465 +9787531653813 +9787531653936 +9787531654223 +9787531654735 +9787531655350 +9787531655770 +9787531656357 +9787531657200 +9787531657620 +9787531657675 +9787531658115 +9787531658870 +9787531658887 +9787531661108 +9787531661443 +9787531661481 +9787531661528 +9787531661771 +9787531664178 +9787531664185 +9787531664192 +9787531664901 +9787531664963 +9787531665250 +9787531665298 +9787531666103 +9787531666714 +9787531667162 +9787531667759 +9787531667902 +9787531667995 +9787531668015 +9787531668053 +9787531668077 +9787531668084 +9787531668114 +9787531668121 +9787531668169 +9787531668473 +9787531668480 +9787531668503 +9787531669029 +9787531669128 +9787531669142 +9787531670483 +9787531670742 +9787531670971 +9787531671275 +9787531671374 +9787531671404 +9787531671602 +9787531672128 +9787531672197 +9787531673354 +9787531673361 +9787531673378 +9787531673385 +9787531673392 +9787531673408 +9787531673545 +9787531674757 +9787531674849 +9787531674856 +9787531674931 +9787531675051 +9787531675068 +9787531675143 +9787531676577 +9787531676584 +9787531676607 +9787531676614 +9787531677574 +9787531678885 +9787531679936 +9787531680529 +9787531684428 +9787531685609 +9787531687016 +9787531687603 +9787531688372 +9787531688518 +9787531689164 +9787531689720 +9787531690023 +9787531690436 +9787531690993 +9787531691525 +9787531691808 +9787531692034 +9787531692171 +9787531692201 +9787531692218 +9787531692225 +9787531693758 +9787531693871 +9787531693994 +9787531695004 +9787531695196 +9787531695851 +9787531696223 +9787531699712 +9787531699729 +9787531699736 +9787531699743 +9787531699750 +9787531699774 +9787531700043 +9787531700081 +9787531700715 +9787531700722 +9787531700746 +9787531700753 +9787531700791 +9787531700890 +9787531700999 +9787531701026 +9787531701040 +9787531701057 +9787531701064 +9787531701101 +9787531701118 +9787531701132 +9787531701170 +9787531701316 +9787531701637 +9787531701651 +9787531701699 +9787531701804 +9787531702313 +9787531702375 +9787531702689 +9787531703235 +9787531703471 +9787531703549 +9787531703679 +9787531703716 +9787531703846 +9787531705116 +9787531705895 +9787531706007 +9787531706250 +9787531706502 +9787531706557 +9787531707097 +9787531707851 +9787531707882 +9787531708490 +9787531708520 +9787531708797 +9787531708834 +9787531708926 +9787531708988 +9787531709220 +9787531709237 +9787531709442 +9787531709473 +9787531709497 +9787531709510 +9787531709527 +9787531709558 +9787531709596 +9787531709671 +9787531709763 +9787531709923 +9787531709954 +9787531709985 +9787531710011 +9787531710035 +9787531710127 +9787531710165 +9787531710288 +9787531710295 +9787531710356 +9787531710363 +9787531710448 +9787531710646 +9787531710653 +9787531710660 +9787531710783 +9787531710929 +9787531710950 +9787531711049 +9787531711094 +9787531711100 +9787531711131 +9787531711148 +9787531711186 +9787531711193 +9787531711230 +9787531711308 +9787531711322 +9787531711469 +9787531711490 +9787531711575 +9787531711599 +9787531711612 +9787531711643 +9787531711896 +9787531711919 +9787531711926 +9787531711933 +9787531711940 +9787531711964 +9787531711988 +9787531712008 +9787531712015 +9787531712107 +9787531712152 +9787531712169 +9787531712299 +9787531712312 +9787531712503 +9787531712541 +9787531712664 +9787531712688 +9787531712770 +9787531712961 +9787531713289 +9787531713302 +9787531713319 +9787531713456 +9787531713463 +9787531713531 +9787531713562 +9787531713586 +9787531714217 +9787531714484 +9787531714491 +9787531714514 +9787531714583 +9787531714590 +9787531714606 +9787531714729 +9787531715153 +9787531715726 +9787531716068 +9787531716112 +9787531716235 +9787531716518 +9787531716679 +9787531716709 +9787531717171 +9787531717256 +9787531717355 +9787531717478 +9787531717577 +9787531717591 +9787531717805 +9787531717881 +9787531717898 +9787531718055 +9787531718062 +9787531718123 +9787531718130 +9787531718192 +9787531718444 +9787531718574 +9787531718628 +9787531718635 +9787531718642 +9787531718727 +9787531718734 +9787531718819 +9787531718857 +9787531718956 +9787531719007 +9787531719298 +9787531719335 +9787531719342 +9787531719397 +9787531719403 +9787531719410 +9787531719441 +9787531719663 +9787531719700 +9787531719793 +9787531719823 +9787531719922 +9787531719939 +9787531719960 +9787531720010 +9787531720027 +9787531720058 +9787531720201 +9787531720300 +9787531720386 +9787531720393 +9787531720492 +9787531720539 +9787531720553 +9787531720614 +9787531720621 +9787531720638 +9787531720669 +9787531720690 +9787531720720 +9787531721017 +9787531721031 +9787531721055 +9787531721222 +9787531721253 +9787531721338 +9787531721383 +9787531721413 +9787531721475 +9787531721529 +9787531721543 +9787531721567 +9787531721574 +9787531721604 +9787531721659 +9787531721680 +9787531721857 +9787531722069 +9787531722083 +9787531722229 +9787531722311 +9787531722427 +9787531722434 +9787531722458 +9787531722465 +9787531722489 +9787531722533 +9787531722588 +9787531722649 +9787531722670 +9787531722687 +9787531722908 +9787531722915 +9787531722922 +9787531722939 +9787531722984 +9787531722991 +9787531723004 +9787531723028 +9787531723066 +9787531723097 +9787531723134 +9787531723141 +9787531723158 +9787531723202 +9787531723417 +9787531723455 +9787531723486 +9787531723547 +9787531723578 +9787531723677 +9787531723684 +9787531723837 +9787531723943 +9787531724124 +9787531724407 +9787531724537 +9787531724612 +9787531724940 +9787531724957 +9787531725022 +9787531725237 +9787531725275 +9787531725282 +9787531725329 +9787531725503 +9787531725510 +9787531725923 +9787531726043 +9787531726197 +9787531726289 +9787531726371 +9787531726395 +9787531726449 +9787531726463 +9787531727255 +9787531727262 +9787531727538 +9787531727569 +9787531727637 +9787531727910 +9787531728009 +9787531728177 +9787531728283 +9787531728399 +9787531728696 +9787531729273 +9787531730095 +9787531730385 +9787531730392 +9787531730453 +9787531730842 +9787531731542 +9787531731856 +9787531732099 +9787531732105 +9787531732969 +9787531733058 +9787531733348 +9787531733614 +9787531734482 +9787531734802 +9787531735946 +9787531736004 +9787531736530 +9787531737100 +9787531738992 +9787531739128 +9787531740575 +9787531740674 +9787531740896 +9787531742340 +9787531742593 +9787531742609 +9787531742630 +9787531742647 +9787531742746 +9787531743491 +9787531743835 +9787531743859 +9787531744313 +9787531744757 +9787531745655 +9787531747642 +9787531748670 +9787531749707 +9787531749752 +9787531749776 +9787531750161 +9787531750444 +9787531751045 +9787531751540 +9787531751595 +9787531753391 +9787531754039 +9787531754961 +9787531755708 +9787531755753 +9787531755777 +9787531755784 +9787531755807 +9787531755814 +9787531755821 +9787531755838 +9787531756125 +9787531756491 +9787531756781 +9787531756859 +9787531757665 +9787531757764 +9787531758037 +9787531758532 +9787531758655 +9787531758679 +9787531758754 +9787531758969 +9787531759102 +9787531759256 +9787531760078 +9787531760085 +9787531760122 +9787531760825 +9787531760894 +9787531760962 +9787531761600 +9787531762089 +9787531762218 +9787531762713 +9787531762720 +9787531762829 +9787531763321 +9787531764700 +9787531765479 +9787531766551 +9787531766575 +9787531800675 +9787531801160 +9787531801429 +9787531801573 +9787531801917 +9787531802440 +9787531802532 +9787531802570 +9787531803072 +9787531803133 +9787531803171 +9787531803188 +9787531803225 +9787531803249 +9787531803386 +9787531803485 +9787531803539 +9787531803713 +9787531803768 +9787531803874 +9787531803942 +9787531804130 +9787531804185 +9787531804192 +9787531804208 +9787531804239 +9787531804468 +9787531804529 +9787531804536 +9787531804635 +9787531804666 +9787531804918 +9787531804970 +9787531805007 +9787531805137 +9787531805380 +9787531805601 +9787531805670 +9787531805823 +9787531805830 +9787531805854 +9787531805922 +9787531805946 +9787531806080 +9787531806127 +9787531806158 +9787531806233 +9787531806295 +9787531806363 +9787531806370 +9787531806561 +9787531806752 +9787531807063 +9787531807230 +9787531807360 +9787531807445 +9787531807476 +9787531807865 +9787531807926 +9787531808008 +9787531808084 +9787531808107 +9787531808138 +9787531808152 +9787531808169 +9787531808176 +9787531808220 +9787531808299 +9787531808381 +9787531808411 +9787531808428 +9787531808541 +9787531808725 +9787531808749 +9787531808787 +9787531809364 +9787531809487 +9787531809616 +9787531809784 +9787531809807 +9787531809838 +9787531809951 +9787531809968 +9787531810032 +9787531810261 +9787531810322 +9787531810360 +9787531810476 +9787531810513 +9787531810599 +9787531810711 +9787531810728 +9787531810742 +9787531810759 +9787531811084 +9787531811213 +9787531811473 +9787531811909 +9787531812005 +9787531812074 +9787531812289 +9787531812357 +9787531812401 +9787531812463 +9787531812531 +9787531812654 +9787531812951 +9787531813255 +9787531813422 +9787531813965 +9787531814252 +9787531814269 +9787531814740 +9787531814818 +9787531814924 +9787531815037 +9787531815198 +9787531815204 +9787531815266 +9787531815273 +9787531815532 +9787531815549 +9787531815648 +9787531816096 +9787531816119 +9787531816249 +9787531816386 +9787531816409 +9787531816461 +9787531816515 +9787531816904 +9787531816980 +9787531817017 +9787531817048 +9787531817376 +9787531817406 +9787531817567 +9787531817598 +9787531817642 +9787531817697 +9787531817789 +9787531817857 +9787531817956 +9787531817963 +9787531817987 +9787531818076 +9787531818144 +9787531819035 +9787531819271 +9787531819394 +9787531819721 +9787531819806 +9787531819837 +9787531820086 +9787531820321 +9787531820543 +9787531820574 +9787531820604 +9787531820666 +9787531820673 +9787531820680 +9787531820727 +9787531821014 +9787531821021 +9787531821083 +9787531821113 +9787531821472 +9787531821489 +9787531821571 +9787531821588 +9787531822370 +9787531822479 +9787531822615 +9787531823087 +9787531823315 +9787531823346 +9787531823582 +9787531824114 +9787531824176 +9787531824299 +9787531824541 +9787531824558 +9787531824589 +9787531824626 +9787531824664 +9787531824732 +9787531824893 +9787531825210 +9787531825241 +9787531825463 +9787531825500 +9787531825753 +9787531825807 +9787531826019 +9787531826064 +9787531826460 +9787531826606 +9787531826637 +9787531826682 +9787531827320 +9787531827702 +9787531828204 +9787531828501 +9787531828532 +9787531828846 +9787531828884 +9787531828938 +9787531829171 +9787531829249 +9787531830108 +9787531830283 +9787531830399 +9787531830795 +9787531831259 +9787531831419 +9787531831716 +9787531831853 +9787531831921 +9787531832010 +9787531832355 +9787531832386 +9787531832430 +9787531832492 +9787531832508 +9787531832676 +9787531832805 +9787531832997 +9787531833161 +9787531833192 +9787531833390 +9787531833536 +9787531833543 +9787531833635 +9787531834090 +9787531834151 +9787531834182 +9787531834809 +9787531835134 +9787531835158 +9787531835356 +9787531835509 +9787531835585 +9787531835707 +9787531836476 +9787531836582 +9787531836599 +9787531836865 +9787531836940 +9787531837008 +9787531837329 +9787531837466 +9787531837503 +9787531837527 +9787531837565 +9787531837701 +9787531838289 +9787531838531 +9787531838722 +9787531838753 +9787531838777 +9787531838814 +9787531838852 +9787531838890 +9787531839118 +9787531839187 +9787531839279 +9787531839286 +9787531839330 +9787531839422 +9787531839460 +9787531840121 +9787531840176 +9787531840435 +9787531840473 +9787531840824 +9787531841418 +9787531841685 +9787531841760 +9787531841838 +9787531841845 +9787531841937 +9787531842057 +9787531842064 +9787531842101 +9787531843184 +9787531843214 +9787531843429 +9787531843504 +9787531843689 +9787531843719 +9787531843788 +9787531843795 +9787531843870 +9787531843962 +9787531843979 +9787531844068 +9787531844082 +9787531844273 +9787531844525 +9787531844532 +9787531844570 +9787531844594 +9787531844600 +9787531844884 +9787531844914 +9787531844952 +9787531845256 +9787531845416 +9787531845522 +9787531845546 +9787531845621 +9787531845638 +9787531845652 +9787531845744 +9787531845751 +9787531845980 +9787531846062 +9787531846079 +9787531846086 +9787531846123 +9787531846222 +9787531846253 +9787531846277 +9787531846567 +9787531846680 +9787531846697 +9787531846727 +9787531847458 +9787531848271 +9787531848578 +9787531848646 +9787531848653 +9787531849414 +9787531849513 +9787531849728 +9787531850397 +9787531850403 +9787531850755 +9787531850793 +9787531851127 +9787531851172 +9787531851226 +9787531851301 +9787531851769 +9787531851790 +9787531851806 +9787531851837 +9787531851967 +9787531852056 +9787531852223 +9787531852445 +9787531852636 +9787531852896 +9787531852926 +9787531852940 +9787531853084 +9787531853091 +9787531853114 +9787531853152 +9787531853169 +9787531853374 +9787531853466 +9787531854128 +9787531854326 +9787531854357 +9787531854364 +9787531854395 +9787531854401 +9787531854425 +9787531854548 +9787531854623 +9787531854890 +9787531854982 +9787531855354 +9787531855705 +9787531856474 +9787531856689 +9787531856771 +9787531856993 +9787531857013 +9787531857020 +9787531857037 +9787531857044 +9787531857976 +9787531858973 +9787531858980 +9787531859284 +9787531859338 +9787531859420 +9787531859437 +9787531859598 +9787531860488 +9787531860976 +9787531861270 +9787531861300 +9787531861522 +9787531861812 +9787531861829 +9787531861836 +9787531861997 +9787531862178 +9787531862260 +9787531862307 +9787531862420 +9787531862468 +9787531863069 +9787531863083 +9787531864103 +9787531864493 +9787531864561 +9787531864660 +9787531864684 +9787531865476 +9787531865483 +9787531865490 +9787531865506 +9787531865520 +9787531865575 +9787531865599 +9787531865933 +9787531865971 +9787531866121 +9787531866701 +9787531866763 +9787531866886 +9787531866909 +9787531866947 +9787531867913 +9787531868361 +9787531869320 +9787531869641 +9787531869917 +9787531870043 +9787531870449 +9787531870494 +9787531870555 +9787531871323 +9787531872146 +9787531872337 +9787531872900 +9787531872917 +9787531873259 +9787531873365 +9787531873402 +9787531873419 +9787531874010 +9787531874027 +9787531874065 +9787531874072 +9787531874324 +9787531874331 +9787531874393 +9787531874508 +9787531874522 +9787531874621 +9787531874928 +9787531874935 +9787531874942 +9787531875543 +9787531875550 +9787531875574 +9787531875598 +9787531875642 +9787531875888 +9787531875895 +9787531875901 +9787531875918 +9787531876267 +9787531876274 +9787531876304 +9787531876519 +9787531876663 +9787531877165 +9787531877479 +9787531877493 +9787531877677 +9787531877974 +9787531878353 +9787531878360 +9787531878384 +9787531878391 +9787531878407 +9787531878414 +9787531878582 +9787531878599 +9787531878612 +9787531878674 +9787531879091 +9787531880042 +9787531880370 +9787531880448 +9787531880721 +9787531881346 +9787531881940 +9787531882466 +9787531882862 +9787531883456 +9787531883586 +9787531883661 +9787531883715 +9787531883838 +9787531883982 +9787531884132 +9787531884330 +9787531884460 +9787531885597 +9787531885641 +9787531885832 +9787531886433 +9787531886815 +9787531887058 +9787531887638 +9787531887812 +9787531887881 +9787531888055 +9787531888161 +9787531888185 +9787531889915 +9787531890119 +9787531891253 +9787531892113 +9787531892144 +9787531892779 +9787531893264 +9787531893554 +9787531894179 +9787531894445 +9787531894513 +9787531895398 +9787531895428 +9787531895534 +9787531896272 +9787531896340 +9787531896357 +9787531896371 +9787531896388 +9787531896395 +9787531896401 +9787531896463 +9787531896517 +9787531897231 +9787531897439 +9787531897453 +9787531897484 +9787531897675 +9787531897712 +9787531897774 +9787531898153 +9787531902942 +9787531904892 +9787531909323 +9787531912781 +9787531912972 +9787531914464 +9787531914501 +9787531916260 +9787531917588 +9787531917786 +9787531917793 +9787531917809 +9787531917847 +9787531919162 +9787531925453 +9787531926535 +9787531927068 +9787531927945 +9787531927969 +9787531928812 +9787531929406 +9787531929536 +9787531929543 +9787531929567 +9787531929598 +9787531930327 +9787531930365 +9787531930754 +9787531933434 +9787531933489 +9787531933496 +9787531934882 +9787531939412 +9787531940838 +9787531942054 +9787531942207 +9787531942993 +9787531944706 +9787531946717 +9787531948612 +9787531949572 +9787531950899 +9787531951193 +9787531951834 +9787531952138 +9787531952985 +9787531953029 +9787531953579 +9787531954934 +9787531955030 +9787531955801 +9787531959847 +9787531959953 +9787531960553 +9787531960720 +9787531960737 +9787531960744 +9787531960805 +9787531960829 +9787531960836 +9787531960850 +9787531961833 +9787531961840 +9787531961888 +9787531962236 +9787531962243 +9787531962267 +9787531962274 +9787531962427 +9787531962700 +9787531962939 +9787531963028 +9787531963035 +9787531963103 +9787531963332 +9787531963349 +9787531964803 +9787531964841 +9787531965299 +9787531965329 +9787531965343 +9787531965381 +9787531965473 +9787531965718 +9787531965923 +9787531966333 +9787531966364 +9787531966883 +9787531967422 +9787531968467 +9787531970088 +9787531970354 +9787531970491 +9787531971498 +9787531972945 +9787531972969 +9787531973843 +9787531974291 +9787531974307 +9787531975410 +9787531975427 +9787531976219 +9787531979333 +9787531979449 +9787531979609 +9787531979937 +9787531981657 +9787531981831 +9787531982531 +9787531982548 +9787531983231 +9787531983538 +9787531983576 +9787531983583 +9787531983606 +9787531983798 +9787531983835 +9787531985075 +9787531985105 +9787531986065 +9787531986072 +9787531988243 +9787531988311 +9787531989325 +9787532000357 +9787532001385 +9787532001392 +9787532001484 +9787532001620 +9787532001637 +9787532001729 +9787532002016 +9787532002115 +9787532002177 +9787532002238 +9787532002269 +9787532002276 +9787532002757 +9787532002795 +9787532002856 +9787532002887 +9787532003464 +9787532003471 +9787532004690 +9787532005284 +9787532005536 +9787532005673 +9787532005727 +9787532005802 +9787532006137 +9787532006519 +9787532006618 +9787532006915 +9787532007493 +9787532007981 +9787532007998 +9787532008209 +9787532008469 +9787532009848 +9787532010387 +9787532010936 +9787532011155 +9787532011223 +9787532011537 +9787532013036 +9787532013609 +9787532013722 +9787532013975 +9787532014316 +9787532014606 +9787532015924 +9787532016099 +9787532016792 +9787532017492 +9787532017584 +9787532018321 +9787532018420 +9787532018529 +9787532018680 +9787532019601 +9787532020263 +9787532020676 +9787532020737 +9787532022588 +9787532022687 +9787532022748 +9787532022755 +9787532023028 +9787532023257 +9787532023288 +9787532023332 +9787532023448 +9787532023554 +9787532023660 +9787532023974 +9787532025121 +9787532025305 +9787532025855 +9787532026265 +9787532026449 +9787532027033 +9787532027309 +9787532027415 +9787532027514 +9787532027545 +9787532027613 +9787532028047 +9787532028191 +9787532028467 +9787532028542 +9787532029631 +9787532032730 +9787532033546 +9787532033850 +9787532034390 +9787532034710 +9787532035557 +9787532035922 +9787532036172 +9787532036691 +9787532036899 +9787532037162 +9787532038060 +9787532038527 +9787532038671 +9787532038787 +9787532039012 +9787532039258 +9787532039326 +9787532039432 +9787532039487 +9787532039548 +9787532039555 +9787532039722 +9787532040391 +9787532041350 +9787532041633 +9787532041824 +9787532042227 +9787532043323 +9787532045402 +9787532046720 +9787532047208 +9787532047925 +9787532047963 +9787532048014 +9787532048113 +9787532048236 +9787532048267 +9787532048533 +9787532048540 +9787532048793 +9787532048892 +9787532048946 +9787532048991 +9787532049066 +9787532049257 +9787532052097 +9787532052134 +9787532052370 +9787532052431 +9787532052820 +9787532052837 +9787532052950 +9787532052967 +9787532052974 +9787532052998 +9787532053360 +9787532053698 +9787532053803 +9787532053926 +9787532054190 +9787532054213 +9787532054329 +9787532054350 +9787532054510 +9787532054602 +9787532054701 +9787532055234 +9787532055494 +9787532055630 +9787532056255 +9787532056439 +9787532056460 +9787532056477 +9787532058075 +9787532058266 +9787532058587 +9787532059126 +9787532059690 +9787532059775 +9787532060153 +9787532060405 +9787532060528 +9787532060894 +9787532061297 +9787532061341 +9787532061365 +9787532061617 +9787532061631 +9787532061938 +9787532062294 +9787532062584 +9787532062799 +9787532062843 +9787532062850 +9787532062904 +9787532063048 +9787532063147 +9787532063420 +9787532063444 +9787532063482 +9787532063499 +9787532063918 +9787532064557 +9787532064793 +9787532064892 +9787532065004 +9787532065080 +9787532065363 +9787532065370 +9787532065431 +9787532065929 +9787532065950 +9787532066025 +9787532066186 +9787532066193 +9787532066919 +9787532066933 +9787532067350 +9787532067374 +9787532067824 +9787532067831 +9787532067886 +9787532068173 +9787532068494 +9787532069675 +9787532069798 +9787532069859 +9787532070268 +9787532070282 +9787532071241 +9787532071296 +9787532071579 +9787532072323 +9787532072521 +9787532072538 +9787532072545 +9787532072569 +9787532072651 +9787532072989 +9787532073252 +9787532073481 +9787532073498 +9787532073528 +9787532074259 +9787532074815 +9787532074945 +9787532075010 +9787532075133 +9787532075294 +9787532075874 +9787532076574 +9787532076949 +9787532077120 +9787532077168 +9787532077175 +9787532077472 +9787532077762 +9787532077779 +9787532077922 +9787532077939 +9787532077946 +9787532077953 +9787532077960 +9787532078110 +9787532078882 +9787532079155 +9787532080786 +9787532081851 +9787532082063 +9787532082490 +9787532082711 +9787532082926 +9787532083664 +9787532084418 +9787532084555 +9787532084661 +9787532084753 +9787532085330 +9787532085835 +9787532086160 +9787532086177 +9787532086535 +9787532086795 +9787532087013 +9787532087068 +9787532087075 +9787532087181 +9787532087204 +9787532087693 +9787532087792 +9787532089314 +9787532090280 +9787532090556 +9787532091584 +9787532091591 +9787532091676 +9787532091881 +9787532091966 +9787532091973 +9787532092178 +9787532092888 +9787532092901 +9787532093625 +9787532094066 +9787532094387 +9787532094684 +9787532095032 +9787532095063 +9787532095469 +9787532095490 +9787532095551 +9787532095827 +9787532095988 +9787532096220 +9787532096381 +9787532096602 +9787532097111 +9787532097180 +9787532097210 +9787532097883 +9787532098316 +9787532098590 +9787532098767 +9787532098866 +9787532098897 +9787532099054 +9787532099252 +9787532099719 +9787532099818 +9787532100132 +9787532100309 +9787532100316 +9787532100323 +9787532100330 +9787532100361 +9787532100378 +9787532100538 +9787532100569 +9787532100606 +9787532100651 +9787532100774 +9787532100958 +9787532101085 +9787532101375 +9787532101467 +9787532101498 +9787532101542 +9787532101634 +9787532101658 +9787532101672 +9787532101948 +9787532102068 +9787532102099 +9787532102112 +9787532102297 +9787532102341 +9787532102433 +9787532102686 +9787532102723 +9787532102761 +9787532102778 +9787532102815 +9787532102976 +9787532103058 +9787532103065 +9787532103089 +9787532103133 +9787532103201 +9787532103416 +9787532103478 +9787532103577 +9787532103676 +9787532103799 +9787532103805 +9787532104093 +9787532104147 +9787532104178 +9787532104253 +9787532104284 +9787532104321 +9787532104529 +9787532104550 +9787532104628 +9787532104642 +9787532104895 +9787532104925 +9787532105113 +9787532105182 +9787532105472 +9787532105533 +9787532105557 +9787532105588 +9787532105625 +9787532105656 +9787532105724 +9787532105830 +9787532105854 +9787532105878 +9787532106127 +9787532106271 +9787532106356 +9787532106516 +9787532106660 +9787532106752 +9787532106905 +9787532106929 +9787532107001 +9787532107049 +9787532107216 +9787532107278 +9787532107377 +9787532107544 +9787532107582 +9787532107667 +9787532107674 +9787532107742 +9787532107797 +9787532107889 +9787532107957 +9787532108022 +9787532108114 +9787532108121 +9787532108213 +9787532108305 +9787532108350 +9787532108503 +9787532108510 +9787532108589 +9787532108770 +9787532108848 +9787532109074 +9787532109180 +9787532109432 +9787532109449 +9787532109609 +9787532109623 +9787532109678 +9787532109715 +9787532109845 +9787532110223 +9787532110339 +9787532110599 +9787532110636 +9787532110643 +9787532110889 +9787532110919 +9787532111022 +9787532111107 +9787532111121 +9787532111138 +9787532111169 +9787532111190 +9787532111220 +9787532111510 +9787532111589 +9787532111688 +9787532111725 +9787532111848 +9787532112043 +9787532112050 +9787532112135 +9787532112142 +9787532112173 +9787532112210 +9787532112227 +9787532112302 +9787532112333 +9787532112401 +9787532112456 +9787532112586 +9787532112654 +9787532112777 +9787532112791 +9787532112814 +9787532112821 +9787532112845 +9787532112876 +9787532112937 +9787532113002 +9787532113101 +9787532113132 +9787532113149 +9787532113156 +9787532113255 +9787532113293 +9787532113316 +9787532113378 +9787532113507 +9787532113514 +9787532113552 +9787532113620 +9787532113682 +9787532113729 +9787532113750 +9787532113767 +9787532113774 +9787532113781 +9787532113859 +9787532113873 +9787532113897 +9787532113934 +9787532113989 +9787532114047 +9787532114054 +9787532114092 +9787532114115 +9787532114122 +9787532114139 +9787532114146 +9787532114184 +9787532114207 +9787532114221 +9787532114252 +9787532114276 +9787532114351 +9787532114375 +9787532114504 +9787532114542 +9787532114641 +9787532114726 +9787532114733 +9787532114870 +9787532114887 +9787532114924 +9787532114986 +9787532115044 +9787532115082 +9787532115273 +9787532115310 +9787532115525 +9787532115570 +9787532115723 +9787532115792 +9787532115815 +9787532115853 +9787532116072 +9787532116089 +9787532116096 +9787532116102 +9787532116140 +9787532116249 +9787532116256 +9787532116263 +9787532116287 +9787532116331 +9787532116485 +9787532116515 +9787532116522 +9787532116546 +9787532116645 +9787532116706 +9787532116713 +9787532116720 +9787532116744 +9787532116751 +9787532116782 +9787532116881 +9787532116942 +9787532117093 +9787532117130 +9787532117406 +9787532117451 +9787532117468 +9787532117499 +9787532117536 +9787532117574 +9787532117680 +9787532117697 +9787532117703 +9787532117710 +9787532117772 +9787532117796 +9787532117802 +9787532117819 +9787532117888 +9787532117918 +9787532117932 +9787532117970 +9787532117994 +9787532118052 +9787532118076 +9787532118083 +9787532118090 +9787532118168 +9787532118205 +9787532118250 +9787532118298 +9787532118311 +9787532118335 +9787532118519 +9787532118625 +9787532118670 +9787532118700 +9787532118748 +9787532118762 +9787532118779 +9787532118823 +9787532118922 +9787532118939 +9787532118977 +9787532118984 +9787532118991 +9787532119059 +9787532119097 +9787532119141 +9787532119172 +9787532119233 +9787532119257 +9787532119271 +9787532119288 +9787532119493 +9787532119523 +9787532119554 +9787532119608 +9787532119677 +9787532119684 +9787532119691 +9787532119974 +9787532120000 +9787532120055 +9787532120062 +9787532120109 +9787532120116 +9787532120222 +9787532120260 +9787532120390 +9787532120475 +9787532120567 +9787532120574 +9787532120598 +9787532120604 +9787532120659 +9787532120741 +9787532120772 +9787532120796 +9787532120857 +9787532120871 +9787532121076 +9787532121137 +9787532121274 +9787532121304 +9787532121342 +9787532121441 +9787532121458 +9787532121502 +9787532121748 +9787532121830 +9787532121908 +9787532122004 +9787532122134 +9787532122226 +9787532122332 +9787532122400 +9787532122486 +9787532122523 +9787532122592 +9787532122608 +9787532122622 +9787532122646 +9787532122714 +9787532122820 +9787532122981 +9787532123025 +9787532123070 +9787532123339 +9787532123353 +9787532123360 +9787532123377 +9787532123407 +9787532123469 +9787532123551 +9787532123582 +9787532123599 +9787532123650 +9787532123674 +9787532123698 +9787532123735 +9787532123742 +9787532123803 +9787532123889 +9787532123926 +9787532124046 +9787532124084 +9787532124145 +9787532124213 +9787532124299 +9787532124428 +9787532124435 +9787532124466 +9787532124473 +9787532124480 +9787532124510 +9787532124527 +9787532124558 +9787532124589 +9787532124619 +9787532124794 +9787532124817 +9787532124831 +9787532124855 +9787532124879 +9787532124909 +9787532124923 +9787532124985 +9787532125036 +9787532125197 +9787532125401 +9787532125456 +9787532125470 +9787532125586 +9787532125746 +9787532126064 +9787532126071 +9787532126163 +9787532126484 +9787532126804 +9787532126835 +9787532126880 +9787532126996 +9787532127054 +9787532127061 +9787532127177 +9787532127184 +9787532127207 +9787532127542 +9787532127566 +9787532127580 +9787532127702 +9787532127719 +9787532127788 +9787532127979 +9787532128402 +9787532128471 +9787532128549 +9787532128563 +9787532128648 +9787532128679 +9787532128723 +9787532128754 +9787532128884 +9787532128914 +9787532128945 +9787532129058 +9787532129225 +9787532129256 +9787532129355 +9787532129379 +9787532129386 +9787532129447 +9787532129454 +9787532129584 +9787532129652 +9787532129720 +9787532129744 +9787532129768 +9787532129775 +9787532129911 +9787532129980 +9787532129997 +9787532130061 +9787532130306 +9787532130351 +9787532130399 +9787532130504 +9787532130566 +9787532130696 +9787532130801 +9787532130900 +9787532131259 +9787532131303 +9787532131396 +9787532131440 +9787532131457 +9787532131488 +9787532131594 +9787532131600 +9787532131631 +9787532131679 +9787532131686 +9787532131709 +9787532131808 +9787532131815 +9787532131976 +9787532132096 +9787532132119 +9787532132270 +9787532132607 +9787532132720 +9787532132867 +9787532132898 +9787532132928 +9787532133055 +9787532133253 +9787532133338 +9787532133390 +9787532133413 +9787532133482 +9787532133703 +9787532133758 +9787532133895 +9787532133987 +9787532134021 +9787532134304 +9787532134489 +9787532134717 +9787532134731 +9787532134861 +9787532134939 +9787532135042 +9787532135066 +9787532135387 +9787532135394 +9787532135448 +9787532135455 +9787532135509 +9787532135530 +9787532135561 +9787532135769 +9787532135790 +9787532135813 +9787532135820 +9787532135936 +9787532136087 +9787532136162 +9787532136308 +9787532136520 +9787532136537 +9787532136681 +9787532136810 +9787532136865 +9787532136988 +9787532137022 +9787532137046 +9787532137138 +9787532137145 +9787532137237 +9787532137299 +9787532137350 +9787532137411 +9787532137510 +9787532137527 +9787532137602 +9787532137701 +9787532137855 +9787532137862 +9787532138036 +9787532138043 +9787532138067 +9787532138081 +9787532138135 +9787532138210 +9787532138289 +9787532138340 +9787532138364 +9787532138388 +9787532138425 +9787532138654 +9787532138661 +9787532138753 +9787532138845 +9787532138951 +9787532139194 +9787532139200 +9787532139422 +9787532139507 +9787532139538 +9787532139620 +9787532139743 +9787532139972 +9787532140145 +9787532140220 +9787532140268 +9787532140282 +9787532140381 +9787532141180 +9787532141388 +9787532141586 +9787532141647 +9787532141746 +9787532141906 +9787532141920 +9787532142101 +9787532142187 +9787532142231 +9787532142248 +9787532142262 +9787532142446 +9787532142606 +9787532142651 +9787532142668 +9787532142835 +9787532143139 +9787532143191 +9787532144105 +9787532144129 +9787532144310 +9787532144709 +9787532145447 +9787532145621 +9787532145874 +9787532145928 +9787532146000 +9787532146055 +9787532146062 +9787532146246 +9787532146468 +9787532146567 +9787532146741 +9787532146819 +9787532146833 +9787532146840 +9787532146864 +9787532146871 +9787532147298 +9787532147885 +9787532148233 +9787532148332 +9787532148882 +9787532150250 +9787532150687 +9787532151363 +9787532151912 +9787532152339 +9787532152858 +9787532152957 +9787532153404 +9787532155262 +9787532155651 +9787532155729 +9787532156375 +9787532158157 +9787532159499 +9787532159963 +9787532160112 +9787532160891 +9787532161836 +9787532162260 +9787532162925 +9787532163045 +9787532164813 +9787532167128 +9787532167135 +9787532167418 +9787532168026 +9787532169108 +9787532170159 +9787532170395 +9787532170944 +9787532171026 +9787532171187 +9787532171491 +9787532172535 +9787532172917 +9787532172986 +9787532173754 +9787532174195 +9787532174294 +9787532174492 +9787532174775 +9787532175048 +9787532175123 +9787532175147 +9787532175369 +9787532175512 +9787532176021 +9787532176038 +9787532176243 +9787532176915 +9787532177202 +9787532177516 +9787532177783 +9787532178193 +9787532179046 +9787532179275 +9787532179480 +9787532180035 +9787532180073 +9787532180158 +9787532180271 +9787532180868 +9787532181292 +9787532181490 +9787532181858 +9787532182459 +9787532182510 +9787532182701 +9787532182930 +9787532183036 +9787532183050 +9787532183241 +9787532183555 +9787532184828 +9787532184842 +9787532184989 +9787532185139 +9787532185306 +9787532185375 +9787532185474 +9787532185504 +9787532185696 +9787532185900 +9787532186051 +9787532186129 +9787532186211 +9787532186242 +9787532186341 +9787532186419 +9787532186426 +9787532186433 +9787532186457 +9787532186495 +9787532186563 +9787532186594 +9787532186662 +9787532186693 +9787532186716 +9787532186853 +9787532187133 +9787532187201 +9787532187218 +9787532187270 +9787532187324 +9787532187423 +9787532187515 +9787532187782 +9787532187867 +9787532187935 +9787532187942 +9787532187997 +9787532188048 +9787532188093 +9787532188116 +9787532188130 +9787532188246 +9787532188420 +9787532188444 +9787532188451 +9787532188550 +9787532188604 +9787532188673 +9787532188680 +9787532188703 +9787532188741 +9787532188772 +9787532188949 +9787532188963 +9787532188970 +9787532189007 +9787532189052 +9787532189069 +9787532189281 +9787532189311 +9787532189342 +9787532189373 +9787532189397 +9787532189403 +9787532189434 +9787532189458 +9787532189526 +9787532189595 +9787532189625 +9787532189670 +9787532189694 +9787532189700 +9787532189786 +9787532189793 +9787532189823 +9787532189854 +9787532189861 +9787532189885 +9787532189908 +9787532189915 +9787532189922 +9787532189939 +9787532189946 +9787532189953 +9787532189960 +9787532190034 +9787532190119 +9787532190133 +9787532190164 +9787532190171 +9787532190225 +9787532190287 +9787532190294 +9787532190317 +9787532190362 +9787532190386 +9787532190447 +9787532190461 +9787532190508 +9787532190515 +9787532190577 +9787532190652 +9787532190706 +9787532190713 +9787532190751 +9787532190768 +9787532190775 +9787532190782 +9787532190805 +9787532190836 +9787532190843 +9787532190881 +9787532191017 +9787532191062 +9787532191079 +9787532191086 +9787532191093 +9787532191109 +9787532191130 +9787532191161 +9787532191215 +9787532191222 +9787532191253 +9787532191291 +9787532191413 +9787532191444 +9787532191475 +9787532191543 +9787532191604 +9787532191611 +9787532191628 +9787532191642 +9787532191727 +9787532191765 +9787532191796 +9787532191802 +9787532191819 +9787532191833 +9787532191857 +9787532191888 +9787532191956 +9787532192052 +9787532192304 +9787532192342 +9787532192458 +9787532192502 +9787532192526 +9787532192632 +9787532192656 +9787532192670 +9787532192717 +9787532192892 +9787532192977 +9787532192991 +9787532193011 +9787532193059 +9787532193158 +9787532200023 +9787532200146 +9787532200283 +9787532200320 +9787532200634 +9787532200788 +9787532200832 +9787532200955 +9787532201051 +9787532201068 +9787532201198 +9787532201266 +9787532201310 +9787532201938 +9787532202096 +9787532202102 +9787532202355 +9787532202423 +9787532203024 +9787532203031 +9787532203093 +9787532203161 +9787532203208 +9787532203277 +9787532203284 +9787532203321 +9787532203376 +9787532203451 +9787532203468 +9787532203482 +9787532203499 +9787532203581 +9787532203635 +9787532204373 +9787532204427 +9787532204496 +9787532204526 +9787532204533 +9787532204694 +9787532204717 +9787532204809 +9787532204892 +9787532204960 +9787532205028 +9787532205042 +9787532205059 +9787532205066 +9787532205387 +9787532205615 +9787532205622 +9787532206087 +9787532206155 +9787532206209 +9787532206216 +9787532206261 +9787532206278 +9787532206452 +9787532206582 +9787532206636 +9787532206711 +9787532206742 +9787532206759 +9787532206773 +9787532206803 +9787532207060 +9787532207091 +9787532207350 +9787532207404 +9787532208043 +9787532208449 +9787532208524 +9787532208647 +9787532208975 +9787532209217 +9787532209255 +9787532209460 +9787532209514 +9787532209521 +9787532209644 +9787532210121 +9787532210381 +9787532210404 +9787532210497 +9787532210527 +9787532210541 +9787532210589 +9787532210596 +9787532210640 +9787532210824 +9787532210923 +9787532210985 +9787532211241 +9787532211579 +9787532211715 +9787532211807 +9787532211883 +9787532211913 +9787532212149 +9787532212330 +9787532212385 +9787532212439 +9787532212460 +9787532212538 +9787532212545 +9787532212606 +9787532212651 +9787532212712 +9787532212835 +9787532213078 +9787532213184 +9787532213191 +9787532213382 +9787532213443 +9787532213450 +9787532213498 +9787532213566 +9787532213573 +9787532213610 +9787532213634 +9787532213689 +9787532213719 +9787532214006 +9787532214020 +9787532214075 +9787532214105 +9787532214150 +9787532214204 +9787532214419 +9787532214877 +9787532215089 +9787532215201 +9787532215225 +9787532215287 +9787532215300 +9787532215485 +9787532215737 +9787532215775 +9787532215799 +9787532215812 +9787532215829 +9787532215836 +9787532215843 +9787532216055 +9787532216277 +9787532216314 +9787532216529 +9787532216604 +9787532216741 +9787532216758 +9787532216765 +9787532216789 +9787532216796 +9787532216802 +9787532216826 +9787532216895 +9787532216932 +9787532217076 +9787532217205 +9787532217328 +9787532217335 +9787532217342 +9787532217359 +9787532217366 +9787532217380 +9787532217427 +9787532217434 +9787532217571 +9787532217656 +9787532217724 +9787532217748 +9787532217816 +9787532217847 +9787532217861 +9787532218264 +9787532218301 +9787532218387 +9787532218486 +9787532218714 +9787532218875 +9787532218936 +9787532218943 +9787532218950 +9787532218967 +9787532218974 +9787532219001 +9787532219049 +9787532219186 +9787532219193 +9787532219223 +9787532219308 +9787532219384 +9787532219919 +9787532219926 +9787532219933 +9787532219957 +9787532219995 +9787532220007 +9787532220014 +9787532220021 +9787532220489 +9787532220533 +9787532220557 +9787532220564 +9787532220601 +9787532220755 +9787532220809 +9787532220816 +9787532220953 +9787532220991 +9787532221011 +9787532221165 +9787532221172 +9787532221301 +9787532221431 +9787532221615 +9787532221936 +9787532221974 +9787532222018 +9787532222025 +9787532222124 +9787532222261 +9787532222322 +9787532222346 +9787532222605 +9787532222704 +9787532222865 +9787532222957 +9787532223060 +9787532223251 +9787532224135 +9787532224159 +9787532224210 +9787532224258 +9787532224302 +9787532224326 +9787532224340 +9787532224371 +9787532224425 +9787532224463 +9787532224685 +9787532224746 +9787532224890 +9787532225064 +9787532225187 +9787532225309 +9787532225347 +9787532225354 +9787532225361 +9787532225422 +9787532225446 +9787532225477 +9787532225538 +9787532225743 +9787532225798 +9787532225804 +9787532225828 +9787532226009 +9787532226047 +9787532226061 +9787532226085 +9787532226092 +9787532226122 +9787532226146 +9787532226160 +9787532226184 +9787532226573 +9787532226726 +9787532226801 +9787532227815 +9787532227846 +9787532228027 +9787532228034 +9787532228089 +9787532228133 +9787532228164 +9787532228171 +9787532228188 +9787532228225 +9787532228690 +9787532228768 +9787532228782 +9787532228805 +9787532228812 +9787532228959 +9787532228966 +9787532229031 +9787532229109 +9787532229154 +9787532229192 +9787532229260 +9787532229345 +9787532229482 +9787532229987 +9787532230365 +9787532230556 +9787532230983 +9787532231010 +9787532231027 +9787532231218 +9787532231553 +9787532231669 +9787532231775 +9787532231782 +9787532231928 +9787532232222 +9787532232369 +9787532232437 +9787532232567 +9787532232581 +9787532232673 +9787532232833 +9787532232857 +9787532233182 +9787532233557 +9787532233632 +9787532233649 +9787532233663 +9787532233670 +9787532233724 +9787532233748 +9787532233953 +9787532233960 +9787532234066 +9787532234196 +9787532234394 +9787532234530 +9787532234561 +9787532235278 +9787532235292 +9787532235346 +9787532235445 +9787532235506 +9787532235544 +9787532235667 +9787532236268 +9787532236282 +9787532236329 +9787532236558 +9787532236589 +9787532236626 +9787532236671 +9787532236848 +9787532236855 +9787532236978 +9787532237067 +9787532237111 +9787532237272 +9787532237371 +9787532237418 +9787532237432 +9787532237746 +9787532237821 +9787532237913 +9787532237975 +9787532238194 +9787532238200 +9787532238361 +9787532238644 +9787532238736 +9787532238910 +9787532239801 +9787532239887 +9787532239979 +9787532240012 +9787532240050 +9787532240128 +9787532240630 +9787532240678 +9787532240746 +9787532241033 +9787532241453 +9787532241651 +9787532241699 +9787532241798 +9787532241934 +9787532241941 +9787532242191 +9787532242221 +9787532242313 +9787532242474 +9787532242528 +9787532242559 +9787532242597 +9787532242764 +9787532242795 +9787532242849 +9787532242986 +9787532243068 +9787532243365 +9787532243389 +9787532243396 +9787532243419 +9787532243426 +9787532243563 +9787532243587 +9787532243785 +9787532243921 +9787532243938 +9787532244225 +9787532244324 +9787532244553 +9787532244713 +9787532244744 +9787532245000 +9787532245017 +9787532245093 +9787532245123 +9787532245451 +9787532245468 +9787532245543 +9787532245581 +9787532245826 +9787532246014 +9787532246069 +9787532246113 +9787532246182 +9787532246731 +9787532246991 +9787532247196 +9787532247226 +9787532247264 +9787532247288 +9787532247356 +9787532247486 +9787532247561 +9787532247790 +9787532247851 +9787532247868 +9787532247875 +9787532248001 +9787532248025 +9787532248032 +9787532248131 +9787532248261 +9787532248278 +9787532248285 +9787532248292 +9787532248308 +9787532248346 +9787532248353 +9787532248360 +9787532248377 +9787532248384 +9787532248414 +9787532248605 +9787532248728 +9787532248834 +9787532248841 +9787532249121 +9787532249176 +9787532249299 +9787532249510 +9787532249602 +9787532249664 +9787532249794 +9787532249954 +9787532250059 +9787532250110 +9787532250127 +9787532250561 +9787532250660 +9787532250783 +9787532250912 +9787532251179 +9787532251186 +9787532251193 +9787532251223 +9787532251254 +9787532251742 +9787532251759 +9787532251810 +9787532251896 +9787532252183 +9787532252237 +9787532252350 +9787532252701 +9787532253012 +9787532253166 +9787532253173 +9787532253388 +9787532253456 +9787532253531 +9787532253715 +9787532253968 +9787532254064 +9787532254088 +9787532254095 +9787532254170 +9787532254217 +9787532254248 +9787532254255 +9787532254262 +9787532254286 +9787532254613 +9787532254620 +9787532254668 +9787532254774 +9787532254842 +9787532255238 +9787532255528 +9787532255566 +9787532255573 +9787532255597 +9787532255610 +9787532255627 +9787532255634 +9787532255641 +9787532255658 +9787532255672 +9787532255849 +9787532255856 +9787532255870 +9787532255894 +9787532255917 +9787532256266 +9787532256310 +9787532256402 +9787532256419 +9787532256457 +9787532256471 +9787532256600 +9787532256747 +9787532256761 +9787532256792 +9787532256808 +9787532256877 +9787532256891 +9787532256907 +9787532256969 +9787532257003 +9787532257140 +9787532257164 +9787532257201 +9787532257263 +9787532257287 +9787532257492 +9787532257515 +9787532257546 +9787532258017 +9787532258109 +9787532258161 +9787532258260 +9787532258307 +9787532258468 +9787532258628 +9787532258635 +9787532258703 +9787532258840 +9787532259168 +9787532259403 +9787532259687 +9787532259694 +9787532259809 +9787532259816 +9787532260362 +9787532260409 +9787532260416 +9787532260423 +9787532260478 +9787532260515 +9787532260898 +9787532260928 +9787532260942 +9787532261154 +9787532261215 +9787532261444 +9787532261451 +9787532261529 +9787532261857 +9787532261864 +9787532262069 +9787532262243 +9787532262427 +9787532262434 +9787532262533 +9787532262564 +9787532262601 +9787532262717 +9787532263028 +9787532263578 +9787532263615 +9787532263622 +9787532263721 +9787532263875 +9787532263929 +9787532263943 +9787532264025 +9787532264155 +9787532264209 +9787532264216 +9787532264223 +9787532264230 +9787532264254 +9787532264292 +9787532264308 +9787532264315 +9787532264322 +9787532264353 +9787532264377 +9787532264476 +9787532264551 +9787532264568 +9787532264643 +9787532264704 +9787532264728 +9787532264766 +9787532264803 +9787532264902 +9787532264957 +9787532265114 +9787532265145 +9787532265428 +9787532265602 +9787532265633 +9787532265763 +9787532265770 +9787532265787 +9787532265800 +9787532265817 +9787532266395 +9787532266401 +9787532266418 +9787532266463 +9787532266470 +9787532266524 +9787532266548 +9787532266593 +9787532266746 +9787532266845 +9787532266852 +9787532266968 +9787532267033 +9787532267217 +9787532267347 +9787532267439 +9787532267491 +9787532267811 +9787532267897 +9787532267941 +9787532268085 +9787532268382 +9787532268641 +9787532268702 +9787532268870 +9787532268887 +9787532268894 +9787532268924 +9787532268955 +9787532269143 +9787532269297 +9787532269341 +9787532269419 +9787532269464 +9787532269563 +9787532269709 +9787532269792 +9787532269808 +9787532270033 +9787532270194 +9787532270446 +9787532270477 +9787532271016 +9787532271023 +9787532271207 +9787532271689 +9787532271801 +9787532271818 +9787532272266 +9787532272297 +9787532272440 +9787532272761 +9787532273393 +9787532273454 +9787532273614 +9787532273843 +9787532274000 +9787532274017 +9787532274048 +9787532274147 +9787532274246 +9787532274772 +9787532274987 +9787532274994 +9787532275311 +9787532275519 +9787532275533 +9787532275700 +9787532275724 +9787532275731 +9787532275786 +9787532275793 +9787532275892 +9787532275922 +9787532275939 +9787532276127 +9787532276240 +9787532276264 +9787532276271 +9787532276295 +9787532276318 +9787532276325 +9787532276370 +9787532276448 +9787532276646 +9787532276776 +9787532276837 +9787532277483 +9787532277544 +9787532277636 +9787532277735 +9787532277834 +9787532277858 +9787532278336 +9787532278367 +9787532278374 +9787532278381 +9787532278404 +9787532278459 +9787532278480 +9787532278497 +9787532278602 +9787532278657 +9787532278725 +9787532278749 +9787532278756 +9787532278848 +9787532278947 +9787532278961 +9787532278992 +9787532279012 +9787532279111 +9787532279319 +9787532279333 +9787532279340 +9787532279531 +9787532279548 +9787532279661 +9787532279739 +9787532279777 +9787532279784 +9787532279791 +9787532279821 +9787532279890 +9787532279913 +9787532279951 +9787532279968 +9787532280001 +9787532280131 +9787532280223 +9787532280230 +9787532280247 +9787532280476 +9787532280490 +9787532280506 +9787532280568 +9787532280612 +9787532280957 +9787532281077 +9787532281206 +9787532281237 +9787532281282 +9787532281336 +9787532281497 +9787532281503 +9787532281527 +9787532281565 +9787532281626 +9787532281633 +9787532281657 +9787532281695 +9787532281725 +9787532281954 +9787532281961 +9787532282050 +9787532282128 +9787532282210 +9787532282357 +9787532282371 +9787532282388 +9787532282395 +9787532282401 +9787532282845 +9787532283460 +9787532283491 +9787532284009 +9787532284153 +9787532284221 +9787532284313 +9787532284481 +9787532284528 +9787532284566 +9787532284962 +9787532285501 +9787532285532 +9787532285570 +9787532285624 +9787532285730 +9787532286065 +9787532286089 +9787532286188 +9787532286195 +9787532286218 +9787532286393 +9787532286478 +9787532286911 +9787532286942 +9787532287215 +9787532287284 +9787532287376 +9787532287697 +9787532287734 +9787532287802 +9787532287956 +9787532287963 +9787532287970 +9787532288120 +9787532288182 +9787532288663 +9787532289295 +9787532289417 +9787532289424 +9787532289653 +9787532289691 +9787532289943 +9787532290062 +9787532290079 +9787532290222 +9787532290307 +9787532290321 +9787532290451 +9787532290468 +9787532290574 +9787532290604 +9787532291007 +9787532291106 +9787532291144 +9787532291175 +9787532291199 +9787532291304 +9787532291342 +9787532291526 +9787532291618 +9787532291984 +9787532292288 +9787532293063 +9787532293070 +9787532293162 +9787532293629 +9787532293636 +9787532293858 +9787532294466 +9787532294480 +9787532294831 +9787532295791 +9787532296019 +9787532296194 +9787532296378 +9787532296712 +9787532296774 +9787532296798 +9787532296811 +9787532297160 +9787532297184 +9787532297443 +9787532297528 +9787532297665 +9787532297870 +9787532299119 +9787532299270 +9787532299331 +9787532300020 +9787532300181 +9787532300280 +9787532300617 +9787532300723 +9787532300815 +9787532300839 +9787532301553 +9787532301683 +9787532301874 +9787532301942 +9787532302932 +9787532302987 +9787532303021 +9787532303045 +9787532303496 +9787532303540 +9787532303557 +9787532303618 +9787532303748 +9787532303892 +9787532304219 +9787532305018 +9787532305087 +9787532305315 +9787532305322 +9787532305353 +9787532305438 +9787532305568 +9787532305582 +9787532305674 +9787532305704 +9787532305995 +9787532306213 +9787532306336 +9787532306558 +9787532306626 +9787532306718 +9787532306817 +9787532306824 +9787532306886 +9787532306961 +9787532307159 +9787532307494 +9787532307852 +9787532307968 +9787532308378 +9787532308477 +9787532308644 +9787532308712 +9787532308736 +9787532308873 +9787532308996 +9787532309528 +9787532309801 +9787532309931 +9787532309962 +9787532310142 +9787532310296 +9787532310647 +9787532310739 +9787532310890 +9787532311125 +9787532311255 +9787532311286 +9787532311354 +9787532312658 +9787532313044 +9787532313150 +9787532313525 +9787532313570 +9787532314126 +9787532314492 +9787532314539 +9787532314614 +9787532314775 +9787532315154 +9787532315215 +9787532315222 +9787532315307 +9787532315468 +9787532315482 +9787532315512 +9787532315529 +9787532315574 +9787532316663 +9787532316724 +9787532317578 +9787532317752 +9787532318230 +9787532318414 +9787532318919 +9787532318933 +9787532319190 +9787532319213 +9787532319732 +9787532320073 +9787532320141 +9787532320301 +9787532320530 +9787532320547 +9787532320561 +9787532320578 +9787532320615 +9787532320929 +9787532321162 +9787532321476 +9787532322039 +9787532322053 +9787532322060 +9787532322138 +9787532322190 +9787532322428 +9787532322497 +9787532322732 +9787532322909 +9787532323029 +9787532323043 +9787532323135 +9787532323203 +9787532323326 +9787532323371 +9787532323395 +9787532323418 +9787532323555 +9787532323906 +9787532324033 +9787532324064 +9787532324071 +9787532324125 +9787532324279 +9787532324347 +9787532324477 +9787532324576 +9787532324583 +9787532324590 +9787532324606 +9787532324934 +9787532325238 +9787532325245 +9787532325351 +9787532325399 +9787532325979 +9787532326334 +9787532326501 +9787532326792 +9787532327096 +9787532327201 +9787532327218 +9787532327331 +9787532327348 +9787532328109 +9787532328413 +9787532328581 +9787532328604 +9787532328642 +9787532328741 +9787532328758 +9787532328789 +9787532329106 +9787532329366 +9787532329496 +9787532330287 +9787532330324 +9787532330560 +9787532330669 +9787532330973 +9787532331994 +9787532332076 +9787532332120 +9787532332304 +9787532332694 +9787532332946 +9787532332953 +9787532332960 +9787532332991 +9787532333004 +9787532333035 +9787532333103 +9787532333370 +9787532333516 +9787532333530 +9787532334032 +9787532334414 +9787532334445 +9787532334650 +9787532334841 +9787532334964 +9787532335145 +9787532335244 +9787532335367 +9787532335978 +9787532336050 +9787532336074 +9787532336302 +9787532336593 +9787532336609 +9787532336623 +9787532336913 +9787532337750 +9787532337767 +9787532337934 +9787532338283 +9787532338344 +9787532338375 +9787532338511 +9787532338542 +9787532339013 +9787532339112 +9787532339129 +9787532339167 +9787532339266 +9787532339457 +9787532339495 +9787532339723 +9787532339884 +9787532340484 +9787532340675 +9787532340873 +9787532341030 +9787532341184 +9787532341795 +9787532341832 +9787532341856 +9787532341863 +9787532341894 +9787532341979 +9787532342020 +9787532342037 +9787532342044 +9787532342068 +9787532342105 +9787532342723 +9787532342945 +9787532343041 +9787532343119 +9787532343218 +9787532343690 +9787532343737 +9787532343911 +9787532343942 +9787532343973 +9787532344017 +9787532344048 +9787532344178 +9787532345045 +9787532345052 +9787532345069 +9787532345083 +9787532345199 +9787532345205 +9787532345236 +9787532345267 +9787532345434 +9787532345441 +9787532345519 +9787532345533 +9787532345656 +9787532345663 +9787532345687 +9787532345861 +9787532345915 +9787532345991 +9787532346196 +9787532346578 +9787532346585 +9787532346608 +9787532346615 +9787532346660 +9787532346677 +9787532346707 +9787532347483 +9787532347513 +9787532347551 +9787532347605 +9787532347667 +9787532347735 +9787532347759 +9787532347780 +9787532348114 +9787532348176 +9787532348251 +9787532348299 +9787532348398 +9787532348589 +9787532348879 +9787532349517 +9787532349845 +9787532350247 +9787532350254 +9787532350322 +9787532350360 +9787532350384 +9787532350476 +9787532350506 +9787532350919 +9787532351039 +9787532351046 +9787532351060 +9787532351169 +9787532351640 +9787532351749 +9787532351848 +9787532351862 +9787532352005 +9787532352012 +9787532352036 +9787532352074 +9787532352838 +9787532352852 +9787532352890 +9787532352968 +9787532353019 +9787532353118 +9787532353163 +9787532353187 +9787532353545 +9787532353583 +9787532353682 +9787532353729 +9787532353828 +9787532353934 +9787532353958 +9787532354023 +9787532354030 +9787532354092 +9787532354160 +9787532354283 +9787532354443 +9787532354672 +9787532355099 +9787532355112 +9787532355266 +9787532355341 +9787532355464 +9787532355525 +9787532355914 +9787532355921 +9787532356065 +9787532356089 +9787532356102 +9787532356119 +9787532356140 +9787532356171 +9787532356287 +9787532356577 +9787532356652 +9787532356836 +9787532356973 +9787532357109 +9787532357116 +9787532357147 +9787532357246 +9787532357314 +9787532357369 +9787532357376 +9787532357635 +9787532357758 +9787532357956 +9787532358083 +9787532358656 +9787532358755 +9787532358854 +9787532358878 +9787532358885 +9787532359257 +9787532359288 +9787532359332 +9787532359356 +9787532359431 +9787532359455 +9787532359622 +9787532359691 +9787532359707 +9787532359783 +9787532359806 +9787532360123 +9787532360673 +9787532360796 +9787532360871 +9787532361144 +9787532361229 +9787532361434 +9787532361533 +9787532361564 +9787532361595 +9787532361748 +9787532361786 +9787532361809 +9787532361922 +9787532362493 +9787532362752 +9787532362905 +9787532362967 +9787532363018 +9787532363186 +9787532363339 +9787532363476 +9787532363513 +9787532363872 +9787532364206 +9787532364343 +9787532364374 +9787532364428 +9787532364497 +9787532364718 +9787532364787 +9787532364893 +9787532365104 +9787532365128 +9787532365210 +9787532365272 +9787532365326 +9787532365371 +9787532365630 +9787532365845 +9787532365937 +9787532365999 +9787532366231 +9787532366293 +9787532366330 +9787532366514 +9787532366552 +9787532366651 +9787532367047 +9787532367061 +9787532367443 +9787532367597 +9787532368273 +9787532368495 +9787532368549 +9787532368587 +9787532368617 +9787532368679 +9787532368693 +9787532368747 +9787532368778 +9787532368785 +9787532368846 +9787532369126 +9787532369188 +9787532369195 +9787532369218 +9787532369300 +9787532369386 +9787532369478 +9787532369720 +9787532369812 +9787532369829 +9787532369928 +9787532370023 +9787532370290 +9787532370320 +9787532370344 +9787532370399 +9787532370542 +9787532370665 +9787532370719 +9787532370726 +9787532370740 +9787532370979 +9787532371013 +9787532371020 +9787532371068 +9787532371112 +9787532371167 +9787532371204 +9787532371297 +9787532371433 +9787532371495 +9787532371648 +9787532371709 +9787532371723 +9787532371877 +9787532372102 +9787532372225 +9787532372270 +9787532372614 +9787532372669 +9787532372751 +9787532372911 +9787532372980 +9787532373314 +9787532373437 +9787532373666 +9787532373840 +9787532374199 +9787532374298 +9787532374359 +9787532374441 +9787532374526 +9787532374878 +9787532375363 +9787532375585 +9787532375974 +9787532376742 +9787532376803 +9787532376933 +9787532377121 +9787532377374 +9787532377466 +9787532377541 +9787532377572 +9787532377589 +9787532377596 +9787532377718 +9787532377947 +9787532377992 +9787532378050 +9787532378289 +9787532378401 +9787532378524 +9787532378555 +9787532378685 +9787532378692 +9787532378807 +9787532378845 +9787532378920 +9787532379057 +9787532379088 +9787532379101 +9787532379118 +9787532379132 +9787532379163 +9787532379286 +9787532379316 +9787532379415 +9787532379729 +9787532379910 +9787532379958 +9787532380053 +9787532380121 +9787532380176 +9787532380220 +9787532380404 +9787532380473 +9787532380480 +9787532380664 +9787532380671 +9787532380718 +9787532380831 +9787532380848 +9787532380855 +9787532380886 +9787532380992 +9787532381180 +9787532381296 +9787532381340 +9787532381784 +9787532381982 +9787532382088 +9787532382200 +9787532382279 +9787532382361 +9787532382446 +9787532382675 +9787532382682 +9787532382750 +9787532382781 +9787532383191 +9787532383221 +9787532383368 +9787532383412 +9787532383689 +9787532383771 +9787532383924 +9787532384037 +9787532384112 +9787532384150 +9787532384655 +9787532384716 +9787532385218 +9787532385225 +9787532385478 +9787532385843 +9787532385867 +9787532385942 +9787532386123 +9787532386277 +9787532386345 +9787532386376 +9787532387007 +9787532387052 +9787532387205 +9787532387403 +9787532387519 +9787532387953 +9787532388974 +9787532389261 +9787532389407 +9787532389438 +9787532389452 +9787532389650 +9787532389940 +9787532390137 +9787532390151 +9787532390403 +9787532390472 +9787532390533 +9787532390731 +9787532390960 +9787532391141 +9787532391158 +9787532391196 +9787532391257 +9787532391271 +9787532391547 +9787532391608 +9787532391752 +9787532392209 +9787532392704 +9787532392872 +9787532392896 +9787532393046 +9787532393077 +9787532393176 +9787532393237 +9787532393275 +9787532393343 +9787532393374 +9787532393480 +9787532393619 +9787532393640 +9787532393886 +9787532394104 +9787532394258 +9787532394265 +9787532394333 +9787532394371 +9787532394524 +9787532394654 +9787532394890 +9787532395002 +9787532395101 +9787532395248 +9787532395347 +9787532395453 +9787532395521 +9787532395682 +9787532395989 +9787532396641 +9787532396870 +9787532397099 +9787532397877 +9787532397884 +9787532397945 +9787532398096 +9787532398171 +9787532398300 +9787532398508 +9787532398652 +9787532398683 +9787532398874 +9787532399147 +9787532399581 +9787532399666 +9787532399697 +9787532399994 +9787532400133 +9787532400232 +9787532400294 +9787532400300 +9787532400355 +9787532400607 +9787532401871 +9787532402069 +9787532402496 +9787532402557 +9787532402816 +9787532402830 +9787532403462 +9787532404186 +9787532404612 +9787532405060 +9787532405145 +9787532405237 +9787532405428 +9787532405862 +9787532405879 +9787532405985 +9787532406081 +9787532406364 +9787532406418 +9787532407217 +9787532407415 +9787532407521 +9787532408016 +9787532408412 +9787532408566 +9787532408788 +9787532408825 +9787532409235 +9787532409693 +9787532410095 +9787532410217 +9787532410569 +9787532410583 +9787532410590 +9787532410972 +9787532411191 +9787532411207 +9787532411214 +9787532411221 +9787532411979 +9787532412211 +9787532412280 +9787532412341 +9787532412518 +9787532412686 +9787532413195 +9787532413355 +9787532413522 +9787532413539 +9787532413669 +9787532413744 +9787532413751 +9787532414031 +9787532414628 +9787532414642 +9787532414666 +9787532414673 +9787532415014 +9787532415021 +9787532415083 +9787532415090 +9787532415267 +9787532415519 +9787532415526 +9787532415533 +9787532415595 +9787532415601 +9787532415762 +9787532415953 +9787532416127 +9787532417292 +9787532417308 +9787532417636 +9787532417889 +9787532417896 +9787532418855 +9787532418992 +9787532419005 +9787532419012 +9787532419074 +9787532419104 +9787532419227 +9787532420056 +9787532420384 +9787532421923 +9787532421992 +9787532422821 +9787532422838 +9787532422876 +9787532424764 +9787532424962 +9787532425785 +9787532426300 +9787532426416 +9787532426584 +9787532427017 +9787532427185 +9787532428212 +9787532428250 +9787532428281 +9787532428359 +9787532428366 +9787532428458 +9787532428564 +9787532428892 +9787532428953 +9787532429141 +9787532429202 +9787532429547 +9787532429592 +9787532429622 +9787532430239 +9787532430642 +9787532430901 +9787532431281 +9787532431342 +9787532431366 +9787532431489 +9787532431557 +9787532431618 +9787532431892 +9787532432011 +9787532432028 +9787532432110 +9787532432127 +9787532432134 +9787532432516 +9787532432523 +9787532432561 +9787532432578 +9787532433070 +9787532433124 +9787532433131 +9787532433148 +9787532433278 +9787532433285 +9787532433353 +9787532433377 +9787532433445 +9787532433629 +9787532433711 +9787532433780 +9787532433933 +9787532434015 +9787532434053 +9787532434077 +9787532434107 +9787532435074 +9787532435203 +9787532435340 +9787532436064 +9787532436279 +9787532436712 +9787532436750 +9787532436934 +9787532437344 +9787532437917 +9787532438082 +9787532438143 +9787532439393 +9787532439621 +9787532439690 +9787532439706 +9787532439836 +9787532439942 +9787532439959 +9787532440023 +9787532440085 +9787532440368 +9787532440665 +9787532440696 +9787532442515 +9787532442621 +9787532442683 +9787532443505 +9787532443833 +9787532443840 +9787532444366 +9787532444588 +9787532445509 +9787532446629 +9787532446636 +9787532446643 +9787532446650 +9787532446667 +9787532446926 +9787532446964 +9787532447244 +9787532447589 +9787532449064 +9787532449286 +9787532449996 +9787532452279 +9787532452422 +9787532452439 +9787532453276 +9787532453313 +9787532453344 +9787532453504 +9787532453511 +9787532453542 +9787532453931 +9787532454082 +9787532455126 +9787532456000 +9787532456840 +9787532457540 +9787532458356 +9787532459100 +9787532459124 +9787532460243 +9787532460274 +9787532460663 +9787532461974 +9787532462049 +9787532462919 +9787532462926 +9787532462933 +9787532462940 +9787532463541 +9787532463695 +9787532464111 +9787532464135 +9787532464227 +9787532464654 +9787532465255 +9787532465309 +9787532465316 +9787532465460 +9787532465484 +9787532465859 +9787532465996 +9787532466122 +9787532466153 +9787532466368 +9787532467280 +9787532467518 +9787532467754 +9787532467839 +9787532467976 +9787532468003 +9787532468072 +9787532468126 +9787532468416 +9787532468454 +9787532468560 +9787532469406 +9787532469741 +9787532470426 +9787532470433 +9787532470822 +9787532470839 +9787532471126 +9787532471133 +9787532471317 +9787532471379 +9787532471690 +9787532471720 +9787532471737 +9787532472260 +9787532472338 +9787532472345 +9787532472390 +9787532472444 +9787532472451 +9787532472499 +9787532472963 +9787532473243 +9787532473298 +9787532473304 +9787532473373 +9787532473441 +9787532473687 +9787532473700 +9787532473724 +9787532473762 +9787532473878 +9787532474028 +9787532474677 +9787532474691 +9787532474844 +9787532475186 +9787532475322 +9787532475346 +9787532475438 +9787532475452 +9787532475483 +9787532475513 +9787532475537 +9787532476367 +9787532476381 +9787532476398 +9787532476596 +9787532476619 +9787532476749 +9787532476787 +9787532476930 +9787532476978 +9787532477593 +9787532477838 +9787532477999 +9787532478026 +9787532478361 +9787532478569 +9787532478637 +9787532478644 +9787532478651 +9787532478668 +9787532478699 +9787532478705 +9787532478880 +9787532479016 +9787532479047 +9787532479351 +9787532479399 +9787532479412 +9787532479986 +9787532480005 +9787532480531 +9787532480562 +9787532480838 +9787532480968 +9787532480999 +9787532481071 +9787532481118 +9787532481262 +9787532481545 +9787532481569 +9787532481835 +9787532482146 +9787532482207 +9787532482221 +9787532482313 +9787532482443 +9787532482450 +9787532482603 +9787532483068 +9787532483082 +9787532483105 +9787532483129 +9787532483228 +9787532483235 +9787532483242 +9787532483747 +9787532483921 +9787532483945 +9787532484126 +9787532484157 +9787532484188 +9787532484478 +9787532484973 +9787532484997 +9787532485000 +9787532485444 +9787532485611 +9787532485628 +9787532485635 +9787532485642 +9787532485819 +9787532486298 +9787532486403 +9787532486441 +9787532486540 +9787532486571 +9787532486595 +9787532487028 +9787532487141 +9787532487233 +9787532487257 +9787532487301 +9787532487622 +9787532487646 +9787532487653 +9787532487745 +9787532488056 +9787532488261 +9787532488292 +9787532488308 +9787532488360 +9787532488377 +9787532488384 +9787532488414 +9787532488506 +9787532488629 +9787532488650 +9787532488681 +9787532488780 +9787532488810 +9787532488858 +9787532488896 +9787532489411 +9787532489435 +9787532489558 +9787532489626 +9787532489657 +9787532489787 +9787532489848 +9787532489909 +9787532490486 +9787532490530 +9787532490622 +9787532490653 +9787532490684 +9787532491070 +9787532491216 +9787532491339 +9787532491483 +9787532491575 +9787532491643 +9787532491735 +9787532491803 +9787532491919 +9787532491926 +9787532492176 +9787532492244 +9787532492251 +9787532492527 +9787532492640 +9787532492657 +9787532492688 +9787532492831 +9787532492848 +9787532492862 +9787532492947 +9787532492961 +9787532493159 +9787532493456 +9787532493500 +9787532493821 +9787532493838 +9787532494088 +9787532494095 +9787532494286 +9787532494408 +9787532494477 +9787532494583 +9787532494644 +9787532494705 +9787532494743 +9787532494798 +9787532495023 +9787532495108 +9787532495238 +9787532495320 +9787532495344 +9787532495375 +9787532495382 +9787532495450 +9787532495528 +9787532495535 +9787532495603 +9787532495795 +9787532495818 +9787532495832 +9787532495863 +9787532495870 +9787532496051 +9787532496174 +9787532496648 +9787532496716 +9787532496723 +9787532496792 +9787532497126 +9787532497195 +9787532497294 +9787532497386 +9787532497393 +9787532497454 +9787532497591 +9787532497614 +9787532497676 +9787532497812 +9787532497829 +9787532497973 +9787532498468 +9787532498550 +9787532498567 +9787532498642 +9787532498734 +9787532498765 +9787532498840 +9787532499007 +9787532499069 +9787532499137 +9787532499168 +9787532499335 +9787532499533 +9787532499540 +9787532499649 +9787532499731 +9787532499809 +9787532500031 +9787532500130 +9787532500215 +9787532500246 +9787532500307 +9787532500314 +9787532500338 +9787532500413 +9787532500420 +9787532500468 +9787532500581 +9787532500635 +9787532500642 +9787532500697 +9787532500710 +9787532500826 +9787532500864 +9787532500871 +9787532500918 +9787532500956 +9787532500963 +9787532501045 +9787532501076 +9787532501175 +9787532501199 +9787532501229 +9787532501274 +9787532501366 +9787532501434 +9787532501441 +9787532501472 +9787532501489 +9787532501496 +9787532501519 +9787532501526 +9787532501540 +9787532501571 +9787532501595 +9787532501601 +9787532501632 +9787532501748 +9787532501755 +9787532501830 +9787532501847 +9787532501854 +9787532501922 +9787532501939 +9787532501953 +9787532501991 +9787532502035 +9787532502097 +9787532502103 +9787532502110 +9787532502219 +9787532502325 +9787532502356 +9787532502363 +9787532502493 +9787532502547 +9787532502684 +9787532502691 +9787532502813 +9787532502851 +9787532502943 +9787532503063 +9787532503070 +9787532503087 +9787532503155 +9787532503162 +9787532503223 +9787532503315 +9787532503353 +9787532503407 +9787532503414 +9787532503445 +9787532503452 +9787532503483 +9787532503506 +9787532503520 +9787532503551 +9787532503575 +9787532503681 +9787532503698 +9787532503704 +9787532503728 +9787532503742 +9787532504046 +9787532504084 +9787532504183 +9787532504398 +9787532504473 +9787532504497 +9787532504510 +9787532504626 +9787532504633 +9787532504640 +9787532504794 +9787532504817 +9787532504824 +9787532504848 +9787532504862 +9787532504886 +9787532504954 +9787532505043 +9787532505050 +9787532505074 +9787532505081 +9787532505142 +9787532505159 +9787532505241 +9787532505272 +9787532505487 +9787532505500 +9787532505548 +9787532505555 +9787532505616 +9787532505654 +9787532505883 +9787532505890 +9787532505913 +9787532506026 +9787532506040 +9787532506057 +9787532506064 +9787532506071 +9787532506088 +9787532506095 +9787532506101 +9787532506118 +9787532506149 +9787532506170 +9787532506187 +9787532506224 +9787532506231 +9787532506262 +9787532506286 +9787532506309 +9787532506347 +9787532506354 +9787532506378 +9787532506385 +9787532506392 +9787532506408 +9787532506446 +9787532506484 +9787532506507 +9787532506538 +9787532506552 +9787532506613 +9787532506637 +9787532506651 +9787532506699 +9787532506705 +9787532506811 +9787532506897 +9787532506965 +9787532506972 +9787532507016 +9787532507023 +9787532507030 +9787532507047 +9787532507061 +9787532507078 +9787532507092 +9787532507146 +9787532507153 +9787532507184 +9787532507191 +9787532507207 +9787532507245 +9787532507351 +9787532507429 +9787532507436 +9787532507443 +9787532507474 +9787532507481 +9787532507504 +9787532507511 +9787532507696 +9787532507726 +9787532507771 +9787532507863 +9787532507900 +9787532508006 +9787532508013 +9787532508020 +9787532508051 +9787532508099 +9787532508136 +9787532508150 +9787532508198 +9787532508204 +9787532508228 +9787532508266 +9787532508297 +9787532508334 +9787532508341 +9787532508358 +9787532508426 +9787532508433 +9787532508440 +9787532508457 +9787532508464 +9787532508488 +9787532508495 +9787532508600 +9787532508679 +9787532508747 +9787532508792 +9787532508853 +9787532508860 +9787532508877 +9787532508884 +9787532508921 +9787532508976 +9787532509010 +9787532509034 +9787532509041 +9787532509133 +9787532509256 +9787532509300 +9787532509553 +9787532509607 +9787532509652 +9787532509669 +9787532509812 +9787532509829 +9787532509843 +9787532509874 +9787532509898 +9787532509904 +9787532509942 +9787532509959 +9787532510054 +9787532510078 +9787532510092 +9787532510139 +9787532510146 +9787532510160 +9787532510191 +9787532510214 +9787532510351 +9787532510757 +9787532510801 +9787532511020 +9787532511037 +9787532511051 +9787532511075 +9787532511396 +9787532511402 +9787532511419 +9787532511471 +9787532511501 +9787532511525 +9787532511600 +9787532511860 +9787532511877 +9787532511891 +9787532511945 +9787532511976 +9787532511983 +9787532511990 +9787532512010 +9787532512027 +9787532512034 +9787532512041 +9787532512058 +9787532512065 +9787532512089 +9787532512102 +9787532512119 +9787532512157 +9787532512201 +9787532512232 +9787532512249 +9787532512256 +9787532512270 +9787532512355 +9787532512362 +9787532512386 +9787532512423 +9787532512430 +9787532512454 +9787532512461 +9787532512478 +9787532512485 +9787532512539 +9787532512553 +9787532512638 +9787532512706 +9787532512713 +9787532512720 +9787532512737 +9787532512744 +9787532512768 +9787532512775 +9787532512782 +9787532512799 +9787532512812 +9787532512829 +9787532512843 +9787532512850 +9787532512867 +9787532512881 +9787532512904 +9787532512928 +9787532513260 +9787532513307 +9787532513321 +9787532513567 +9787532513710 +9787532513758 +9787532513772 +9787532513789 +9787532513796 +9787532513864 +9787532513888 +9787532513949 +9787532513994 +9787532514007 +9787532514168 +9787532514175 +9787532514243 +9787532514564 +9787532514632 +9787532514656 +9787532514724 +9787532514830 +9787532514892 +9787532514922 +9787532514946 +9787532514953 +9787532514977 +9787532514991 +9787532515011 +9787532515073 +9787532515097 +9787532515110 +9787532515158 +9787532515172 +9787532515196 +9787532515233 +9787532515264 +9787532515363 +9787532515370 +9787532515400 +9787532515424 +9787532515431 +9787532515455 +9787532515479 +9787532515493 +9787532515646 +9787532515721 +9787532515776 +9787532515783 +9787532515820 +9787532515844 +9787532516094 +9787532516124 +9787532516209 +9787532516384 +9787532516612 +9787532516636 +9787532516728 +9787532516780 +9787532516797 +9787532516803 +9787532516827 +9787532516841 +9787532516971 +9787532517091 +9787532517152 +9787532517169 +9787532517220 +9787532517251 +9787532517312 +9787532517350 +9787532517442 +9787532517473 +9787532517572 +9787532517596 +9787532517619 +9787532517633 +9787532517657 +9787532517671 +9787532517695 +9787532517718 +9787532517725 +9787532517732 +9787532517749 +9787532517756 +9787532517770 +9787532517800 +9787532517855 +9787532517909 +9787532518005 +9787532518258 +9787532518333 +9787532518357 +9787532518371 +9787532518388 +9787532518586 +9787532518630 +9787532518647 +9787532518654 +9787532518692 +9787532518746 +9787532518920 +9787532518951 +9787532519033 +9787532519156 +9787532519187 +9787532519194 +9787532519200 +9787532519262 +9787532519286 +9787532519309 +9787532519347 +9787532519378 +9787532519385 +9787532519439 +9787532519446 +9787532519460 +9787532519491 +9787532519545 +9787532519576 +9787532519613 +9787532519637 +9787532519651 +9787532519699 +9787532519705 +9787532519729 +9787532519743 +9787532519781 +9787532519903 +9787532519910 +9787532519934 +9787532519965 +9787532519989 +9787532519996 +9787532520107 +9787532520152 +9787532520176 +9787532520183 +9787532520220 +9787532520251 +9787532520343 +9787532520381 +9787532520404 +9787532520428 +9787532520459 +9787532520466 +9787532520480 +9787532520510 +9787532520541 +9787532520565 +9787532520688 +9787532520695 +9787532520701 +9787532520718 +9787532520732 +9787532520749 +9787532520756 +9787532520763 +9787532520770 +9787532520787 +9787532520824 +9787532520879 +9787532520930 +9787532520954 +9787532520978 +9787532521029 +9787532521098 +9787532521142 +9787532521197 +9787532521210 +9787532521227 +9787532521241 +9787532521265 +9787532521425 +9787532521470 +9787532521487 +9787532521494 +9787532521500 +9787532521531 +9787532521555 +9787532521562 +9787532521609 +9787532521678 +9787532521715 +9787532521739 +9787532521784 +9787532521791 +9787532521876 +9787532521883 +9787532521913 +9787532521937 +9787532521968 +9787532521982 +9787532521999 +9787532522002 +9787532522019 +9787532522040 +9787532522071 +9787532522088 +9787532522187 +9787532522194 +9787532522200 +9787532522361 +9787532522392 +9787532522408 +9787532522415 +9787532522439 +9787532522446 +9787532522453 +9787532522477 +9787532522507 +9787532522545 +9787532522552 +9787532522576 +9787532522644 +9787532522651 +9787532522682 +9787532522699 +9787532522736 +9787532522811 +9787532522880 +9787532522903 +9787532522972 +9787532522989 +9787532522996 +9787532523009 +9787532523016 +9787532523023 +9787532523047 +9787532523061 +9787532523078 +9787532523115 +9787532523122 +9787532523146 +9787532523153 +9787532523160 +9787532523184 +9787532523191 +9787532523207 +9787532523221 +9787532523238 +9787532523245 +9787532523313 +9787532523344 +9787532523382 +9787532523399 +9787532523412 +9787532523429 +9787532523436 +9787532523450 +9787532523467 +9787532523481 +9787532523566 +9787532523603 +9787532523658 +9787532523689 +9787532523696 +9787532523719 +9787532523740 +9787532523917 +9787532524051 +9787532524174 +9787532524211 +9787532524259 +9787532524273 +9787532524297 +9787532524365 +9787532524389 +9787532524471 +9787532524532 +9787532524570 +9787532524617 +9787532524631 +9787532524655 +9787532524716 +9787532524723 +9787532524761 +9787532524778 +9787532524815 +9787532524839 +9787532524846 +9787532524891 +9787532524907 +9787532524938 +9787532525010 +9787532525034 +9787532525041 +9787532525058 +9787532525096 +9787532525102 +9787532525140 +9787532525164 +9787532525188 +9787532525294 +9787532525386 +9787532525430 +9787532525485 +9787532525492 +9787532525508 +9787532525522 +9787532525577 +9787532525607 +9787532525690 +9787532525713 +9787532525744 +9787532525782 +9787532525836 +9787532525874 +9787532525898 +9787532525904 +9787532525973 +9787532526048 +9787532526055 +9787532526109 +9787532526116 +9787532526123 +9787532526130 +9787532526192 +9787532526260 +9787532526277 +9787532526321 +9787532526499 +9787532526604 +9787532526628 +9787532526635 +9787532526673 +9787532526697 +9787532526727 +9787532526802 +9787532526840 +9787532527168 +9787532527199 +9787532527236 +9787532527243 +9787532527267 +9787532527298 +9787532527311 +9787532527397 +9787532527410 +9787532527434 +9787532527458 +9787532527472 +9787532527519 +9787532527533 +9787532527557 +9787532527601 +9787532527632 +9787532527663 +9787532527687 +9787532527700 +9787532527717 +9787532527724 +9787532527748 +9787532527786 +9787532527793 +9787532527809 +9787532527847 +9787532528097 +9787532528127 +9787532528134 +9787532528165 +9787532528189 +9787532528530 +9787532528547 +9787532528561 +9787532528578 +9787532528585 +9787532528615 +9787532528622 +9787532528660 +9787532528776 +9787532528813 +9787532528820 +9787532528844 +9787532528899 +9787532528943 +9787532528998 +9787532529063 +9787532529070 +9787532529131 +9787532529179 +9787532529285 +9787532529308 +9787532529315 +9787532529339 +9787532529360 +9787532529483 +9787532529490 +9787532529582 +9787532529667 +9787532529735 +9787532529780 +9787532529919 +9787532530083 +9787532530106 +9787532530267 +9787532530373 +9787532530397 +9787532530403 +9787532530595 +9787532530632 +9787532530670 +9787532530779 +9787532530793 +9787532530809 +9787532530885 +9787532530915 +9787532530977 +9787532531202 +9787532531288 +9787532531349 +9787532531370 +9787532531417 +9787532531448 +9787532531509 +9787532531554 +9787532531578 +9787532531592 +9787532531615 +9787532531684 +9787532531714 +9787532531745 +9787532531769 +9787532532070 +9787532532094 +9787532532117 +9787532532131 +9787532532148 +9787532532155 +9787532532254 +9787532532261 +9787532532308 +9787532532544 +9787532532568 +9787532532575 +9787532532773 +9787532532858 +9787532532872 +9787532532919 +9787532532933 +9787532532957 +9787532532964 +9787532533060 +9787532533091 +9787532533121 +9787532533145 +9787532533190 +9787532533305 +9787532533381 +9787532533442 +9787532533480 +9787532533725 +9787532533732 +9787532533817 +9787532533824 +9787532533930 +9787532534036 +9787532534111 +9787532534432 +9787532534593 +9787532534630 +9787532534678 +9787532534685 +9787532534692 +9787532534715 +9787532535026 +9787532535033 +9787532535125 +9787532535132 +9787532535149 +9787532535170 +9787532535262 +9787532535330 +9787532535361 +9787532535453 +9787532535484 +9787532535569 +9787532535606 +9787532535958 +9787532535989 +9787532536269 +9787532536283 +9787532536344 +9787532536382 +9787532536443 +9787532536450 +9787532536559 +9787532536610 +9787532536641 +9787532536764 +9787532536795 +9787532537051 +9787532537341 +9787532537464 +9787532537471 +9787532537631 +9787532537907 +9787532537990 +9787532538010 +9787532538058 +9787532538102 +9787532538140 +9787532538201 +9787532538218 +9787532538270 +9787532538393 +9787532538591 +9787532538997 +9787532539154 +9787532539161 +9787532539178 +9787532539192 +9787532539338 +9787532539574 +9787532539673 +9787532539772 +9787532539833 +9787532539871 +9787532540150 +9787532540228 +9787532540495 +9787532540631 +9787532540785 +9787532540884 +9787532541003 +9787532541072 +9787532541140 +9787532541157 +9787532541164 +9787532541201 +9787532541324 +9787532541362 +9787532541607 +9787532541645 +9787532541836 +9787532541898 +9787532541966 +9787532542154 +9787532542222 +9787532542246 +9787532542369 +9787532542437 +9787532542604 +9787532542628 +9787532542697 +9787532542703 +9787532542871 +9787532542956 +9787532543168 +9787532543175 +9787532543311 +9787532543410 +9787532543564 +9787532543625 +9787532543670 +9787532543892 +9787532544127 +9787532544189 +9787532544240 +9787532544363 +9787532544448 +9787532544455 +9787532544479 +9787532544554 +9787532544615 +9787532544622 +9787532544691 +9787532544974 +9787532545254 +9787532545438 +9787532545995 +9787532546145 +9787532546275 +9787532546459 +9787532546633 +9787532546671 +9787532546718 +9787532546862 +9787532546954 +9787532546978 +9787532547241 +9787532547456 +9787532547876 +9787532548002 +9787532548026 +9787532548163 +9787532548460 +9787532548613 +9787532548774 +9787532549207 +9787532549221 +9787532549351 +9787532549405 +9787532549894 +9787532550012 +9787532550036 +9787532550098 +9787532550180 +9787532550463 +9787532550685 +9787532550784 +9787532550807 +9787532550890 +9787532551033 +9787532551491 +9787532551675 +9787532552887 +9787532553167 +9787532553587 +9787532553617 +9787532553648 +9787532553808 +9787532553860 +9787532553976 +9787532554942 +9787532555314 +9787532555352 +9787532555543 +9787532555789 +9787532555987 +9787532556113 +9787532556380 +9787532556564 +9787532556625 +9787532556694 +9787532556878 +9787532556953 +9787532557097 +9787532557462 +9787532557523 +9787532557608 +9787532557813 +9787532558247 +9787532558896 +9787532558964 +9787532559138 +9787532559268 +9787532559343 +9787532559398 +9787532559428 +9787532560356 +9787532560370 +9787532560561 +9787532561261 +9787532561827 +9787532562077 +9787532562114 +9787532562381 +9787532562411 +9787532563043 +9787532563746 +9787532564224 +9787532564323 +9787532564514 +9787532564590 +9787532564613 +9787532565429 +9787532565580 +9787532565856 +9787532566273 +9787532567614 +9787532567911 +9787532568994 +9787532569168 +9787532569250 +9787532570256 +9787532570423 +9787532570546 +9787532571475 +9787532571727 +9787532571789 +9787532571970 +9787532572076 +9787532572175 +9787532572335 +9787532572465 +9787532574407 +9787532574865 +9787532575015 +9787532575138 +9787532575381 +9787532575435 +9787532575541 +9787532575558 +9787532575855 +9787532575879 +9787532575947 +9787532576029 +9787532576661 +9787532576722 +9787532577026 +9787532577071 +9787532577279 +9787532577712 +9787532578023 +9787532578146 +9787532578290 +9787532579297 +9787532579587 +9787532579976 +9787532580095 +9787532580101 +9787532580200 +9787532580415 +9787532580422 +9787532580453 +9787532580880 +9787532581689 +9787532582785 +9787532583881 +9787532584031 +9787532584055 +9787532585397 +9787532587001 +9787532588176 +9787532589265 +9787532590902 +9787532591206 +9787532592043 +9787532592562 +9787532594047 +9787532594146 +9787532594412 +9787532594986 +9787532595471 +9787532596096 +9787532596140 +9787532596263 +9787532596454 +9787532596775 +9787532597055 +9787532597062 +9787532597581 +9787532597857 +9787532597918 +9787532597956 +9787532598496 +9787532599110 +9787532599295 +9787532599516 +9787532599790 +9787532599967 +9787532600052 +9787532600069 +9787532600076 +9787532600120 +9787532600199 +9787532600205 +9787532600236 +9787532600274 +9787532600311 +9787532600335 +9787532600373 +9787532600397 +9787532600427 +9787532600519 +9787532600557 +9787532600571 +9787532600588 +9787532600595 +9787532600618 +9787532600625 +9787532600649 +9787532600656 +9787532600694 +9787532600700 +9787532600748 +9787532600786 +9787532600793 +9787532600816 +9787532600823 +9787532600892 +9787532600908 +9787532600953 +9787532600960 +9787532601004 +9787532601011 +9787532601028 +9787532601059 +9787532601073 +9787532601158 +9787532601165 +9787532601233 +9787532601295 +9787532601301 +9787532601349 +9787532601356 +9787532601363 +9787532601370 +9787532601431 +9787532601448 +9787532601486 +9787532601608 +9787532601646 +9787532601660 +9787532601677 +9787532601752 +9787532601769 +9787532601776 +9787532601899 +9787532601912 +9787532601943 +9787532601950 +9787532601974 +9787532601998 +9787532602001 +9787532602018 +9787532602094 +9787532602100 +9787532602117 +9787532602131 +9787532602193 +9787532602254 +9787532602261 +9787532602285 +9787532602292 +9787532602308 +9787532602315 +9787532602339 +9787532602353 +9787532602360 +9787532602407 +9787532602421 +9787532602490 +9787532602506 +9787532602520 +9787532602544 +9787532602575 +9787532602582 +9787532602599 +9787532602605 +9787532602612 +9787532602629 +9787532602681 +9787532602704 +9787532602711 +9787532602735 +9787532602810 +9787532602827 +9787532602834 +9787532602858 +9787532602872 +9787532602889 +9787532602902 +9787532602933 +9787532602940 +9787532602995 +9787532603008 +9787532603039 +9787532603077 +9787532603084 +9787532603114 +9787532603152 +9787532603169 +9787532603176 +9787532603251 +9787532603268 +9787532603299 +9787532603312 +9787532603329 +9787532603343 +9787532603381 +9787532603404 +9787532603510 +9787532603527 +9787532603534 +9787532603688 +9787532603695 +9787532603725 +9787532603756 +9787532603770 +9787532603831 +9787532603855 +9787532603909 +9787532603923 +9787532603961 +9787532604012 +9787532604067 +9787532604074 +9787532604104 +9787532604128 +9787532604227 +9787532604272 +9787532604289 +9787532604296 +9787532604326 +9787532604371 +9787532604388 +9787532604395 +9787532604418 +9787532604432 +9787532604517 +9787532604579 +9787532604593 +9787532604630 +9787532604647 +9787532604685 +9787532604746 +9787532604944 +9787532605026 +9787532605064 +9787532605101 +9787532605132 +9787532605279 +9787532605316 +9787532605354 +9787532605484 +9787532605569 +9787532605606 +9787532605620 +9787532605705 +9787532605750 +9787532605842 +9787532605873 +9787532605880 +9787532605903 +9787532605910 +9787532605996 +9787532606009 +9787532606184 +9787532606368 +9787532606412 +9787532606580 +9787532606610 +9787532606634 +9787532606658 +9787532606764 +9787532606801 +9787532606856 +9787532606900 +9787532607037 +9787532607044 +9787532607228 +9787532607235 +9787532607341 +9787532607372 +9787532607457 +9787532607624 +9787532607747 +9787532607914 +9787532607921 +9787532608010 +9787532608034 +9787532608041 +9787532608102 +9787532608119 +9787532608140 +9787532608201 +9787532608362 +9787532608409 +9787532608430 +9787532608461 +9787532608485 +9787532608508 +9787532608607 +9787532608683 +9787532608812 +9787532609222 +9787532609246 +9787532609383 +9787532609499 +9787532609604 +9787532609697 +9787532609765 +9787532609833 +9787532609888 +9787532609895 +9787532610181 +9787532610310 +9787532610365 +9787532610402 +9787532610723 +9787532610730 +9787532610808 +9787532611010 +9787532611188 +9787532611324 +9787532611331 +9787532611423 +9787532611966 +9787532612017 +9787532612031 +9787532612048 +9787532612116 +9787532612130 +9787532612154 +9787532612185 +9787532612505 +9787532612598 +9787532612833 +9787532613045 +9787532613359 +9787532613717 +9787532613762 +9787532613915 +9787532613977 +9787532614004 +9787532614035 +9787532614257 +9787532614295 +9787532614332 +9787532614523 +9787532614554 +9787532614639 +9787532614707 +9787532614738 +9787532615001 +9787532615131 +9787532615322 +9787532615414 +9787532615445 +9787532615537 +9787532615711 +9787532615926 +9787532615971 +9787532616046 +9787532616152 +9787532616275 +9787532616305 +9787532616558 +9787532616848 +9787532616992 +9787532617098 +9787532617395 +9787532617449 +9787532617630 +9787532617722 +9787532617913 +9787532618026 +9787532618064 +9787532618071 +9787532618118 +9787532618125 +9787532618149 +9787532618378 +9787532618415 +9787532618453 +9787532618507 +9787532618590 +9787532618637 +9787532618682 +9787532618699 +9787532618743 +9787532618859 +9787532618941 +9787532619009 +9787532619221 +9787532619283 +9787532619313 +9787532619337 +9787532619344 +9787532619351 +9787532619368 +9787532619382 +9787532619436 +9787532620104 +9787532620135 +9787532620265 +9787532620272 +9787532620319 +9787532620333 +9787532620357 +9787532620548 +9787532620654 +9787532620692 +9787532620715 +9787532620821 +9787532620913 +9787532620920 +9787532620968 +9787532621019 +9787532621057 +9787532621361 +9787532621378 +9787532621491 +9787532621606 +9787532621644 +9787532621651 +9787532621750 +9787532621767 +9787532621811 +9787532621880 +9787532621897 +9787532621941 +9787532621965 +9787532622061 +9787532622177 +9787532622214 +9787532622245 +9787532622351 +9787532622382 +9787532622405 +9787532622474 +9787532622511 +9787532622702 +9787532622795 +9787532622801 +9787532623310 +9787532623501 +9787532623594 +9787532623792 +9787532623822 +9787532623990 +9787532624003 +9787532624010 +9787532624027 +9787532624065 +9787532624102 +9787532624218 +9787532624225 +9787532624324 +9787532624362 +9787532624379 +9787532624393 +9787532624409 +9787532624430 +9787532624539 +9787532624577 +9787532624621 +9787532624782 +9787532624799 +9787532625031 +9787532625093 +9787532625178 +9787532625185 +9787532625208 +9787532625239 +9787532625307 +9787532625536 +9787532625574 +9787532625819 +9787532625826 +9787532625901 +9787532625970 +9787532626052 +9787532626083 +9787532626342 +9787532626526 +9787532626540 +9787532626984 +9787532627226 +9787532627240 +9787532627448 +9787532627585 +9787532627905 +9787532627912 +9787532627974 +9787532628216 +9787532628483 +9787532628513 +9787532628551 +9787532628858 +9787532628971 +9787532629541 +9787532629800 +9787532629916 +9787532630158 +9787532630165 +9787532630202 +9787532630226 +9787532630271 +9787532630561 +9787532630646 +9787532630738 +9787532630783 +9787532630790 +9787532630974 +9787532631018 +9787532631025 +9787532631148 +9787532631452 +9787532631575 +9787532631629 +9787532632190 +9787532632206 +9787532632565 +9787532632596 +9787532632671 +9787532632787 +9787532633036 +9787532633111 +9787532633487 +9787532633562 +9787532633982 +9787532634033 +9787532634095 +9787532634286 +9787532634460 +9787532634583 +9787532634590 +9787532634644 +9787532634651 +9787532634835 +9787532634989 +9787532634996 +9787532635009 +9787532635085 +9787532635313 +9787532635320 +9787532635399 +9787532635481 +9787532635634 +9787532635702 +9787532636310 +9787532636495 +9787532636990 +9787532637430 +9787532637546 +9787532637638 +9787532637652 +9787532637706 +9787532637799 +9787532637881 +9787532637928 +9787532638031 +9787532638284 +9787532638550 +9787532638574 +9787532638673 +9787532639113 +9787532639199 +9787532639878 +9787532640119 +9787532640256 +9787532640355 +9787532640454 +9787532640461 +9787532640515 +9787532640539 +9787532640546 +9787532640744 +9787532641277 +9787532641291 +9787532641321 +9787532641383 +9787532641864 +9787532642038 +9787532642052 +9787532642076 +9787532642168 +9787532642274 +9787532642427 +9787532642533 +9787532642700 +9787532642731 +9787532642793 +9787532643318 +9787532644186 +9787532644742 +9787532644919 +9787532644926 +9787532644957 +9787532645053 +9787532645350 +9787532645640 +9787532645886 +9787532646036 +9787532646753 +9787532646784 +9787532646791 +9787532646975 +9787532646999 +9787532647101 +9787532648870 +9787532648917 +9787532649105 +9787532649150 +9787532649242 +9787532649433 +9787532649846 +9787532650088 +9787532650941 +9787532651283 +9787532651931 +9787532651962 +9787532652303 +9787532652464 +9787532653591 +9787532653997 +9787532654628 +9787532654963 +9787532655700 +9787532655915 +9787532656172 +9787532656288 +9787532657148 +9787532657674 +9787532657827 +9787532658046 +9787532658237 +9787532658510 +9787532659074 +9787532659111 +9787532659456 +9787532659555 +9787532659685 +9787532659999 +9787532660124 +9787532660155 +9787532660193 +9787532660209 +9787532660230 +9787532660247 +9787532660308 +9787532660322 +9787532660360 +9787532660452 +9787532660759 +9787532660810 +9787532660827 +9787532660834 +9787532660841 +9787532660872 +9787532660896 +9787532660919 +9787532661008 +9787532661015 +9787532661046 +9787532661169 +9787532661213 +9787532661220 +9787532661237 +9787532661336 +9787532661404 +9787532661411 +9787532661480 +9787532661671 +9787532661725 +9787532661824 +9787532662036 +9787532662241 +9787532662296 +9787532662432 +9787532662494 +9787532662531 +9787532662579 +9787532662708 +9787532662890 +9787532662913 +9787532662944 +9787532662968 +9787532663279 +9787532663880 +9787532700035 +9787532700066 +9787532700073 +9787532700097 +9787532700325 +9787532700387 +9787532700455 +9787532700592 +9787532700639 +9787532700684 +9787532700738 +9787532700882 +9787532700899 +9787532700905 +9787532700912 +9787532700929 +9787532700974 +9787532700981 +9787532701025 +9787532701032 +9787532701049 +9787532701162 +9787532701209 +9787532701278 +9787532701575 +9787532701650 +9787532701773 +9787532701926 +9787532701957 +9787532702053 +9787532702091 +9787532702206 +9787532702220 +9787532702237 +9787532702275 +9787532702312 +9787532702329 +9787532702367 +9787532702404 +9787532702411 +9787532702428 +9787532702435 +9787532702442 +9787532702480 +9787532702572 +9787532702633 +9787532702640 +9787532702657 +9787532702763 +9787532702787 +9787532702985 +9787532703166 +9787532703203 +9787532703319 +9787532703739 +9787532703746 +9787532703784 +9787532703791 +9787532703807 +9787532703821 +9787532703838 +9787532703982 +9787532703999 +9787532704002 +9787532704019 +9787532704118 +9787532704125 +9787532704385 +9787532704439 +9787532704521 +9787532704637 +9787532704644 +9787532704804 +9787532704866 +9787532704897 +9787532704910 +9787532705009 +9787532705054 +9787532705214 +9787532705559 +9787532705580 +9787532705726 +9787532705894 +9787532705931 +9787532705962 +9787532706129 +9787532706150 +9787532706235 +9787532706334 +9787532706433 +9787532706471 +9787532706617 +9787532706624 +9787532706662 +9787532706730 +9787532706785 +9787532706853 +9787532706952 +9787532706969 +9787532707034 +9787532707072 +9787532707140 +9787532707188 +9787532707201 +9787532707218 +9787532707300 +9787532707379 +9787532707454 +9787532707492 +9787532707577 +9787532707676 +9787532707713 +9787532707720 +9787532707768 +9787532707843 +9787532707911 +9787532707997 +9787532708048 +9787532708611 +9787532708628 +9787532709199 +9787532709236 +9787532709243 +9787532709267 +9787532709274 +9787532709281 +9787532709311 +9787532709359 +9787532709472 +9787532709519 +9787532709779 +9787532709861 +9787532710072 +9787532710409 +9787532710416 +9787532710492 +9787532710584 +9787532710614 +9787532710911 +9787532710928 +9787532711222 +9787532711512 +9787532711574 +9787532711765 +9787532711789 +9787532711796 +9787532711949 +9787532711970 +9787532712052 +9787532712069 +9787532712090 +9787532712113 +9787532712120 +9787532712205 +9787532712229 +9787532712304 +9787532712656 +9787532712731 +9787532712786 +9787532712908 +9787532713028 +9787532713035 +9787532713219 +9787532713233 +9787532713257 +9787532713431 +9787532713486 +9787532713493 +9787532713530 +9787532713561 +9787532713585 +9787532713677 +9787532713714 +9787532713721 +9787532713783 +9787532713790 +9787532713868 +9787532713882 +9787532713974 +9787532714001 +9787532714018 +9787532714070 +9787532714117 +9787532714162 +9787532714216 +9787532714223 +9787532714230 +9787532714254 +9787532714452 +9787532714476 +9787532714513 +9787532714520 +9787532714599 +9787532714674 +9787532714681 +9787532714766 +9787532714773 +9787532714858 +9787532714889 +9787532714940 +9787532715015 +9787532715039 +9787532715053 +9787532715190 +9787532715213 +9787532715251 +9787532715336 +9787532715435 +9787532715510 +9787532715527 +9787532715572 +9787532715589 +9787532715671 +9787532715688 +9787532715718 +9787532715749 +9787532715787 +9787532715794 +9787532715954 +9787532715992 +9787532716012 +9787532716043 +9787532716098 +9787532716142 +9787532716388 +9787532716395 +9787532716418 +9787532716425 +9787532716555 +9787532716661 +9787532716678 +9787532716746 +9787532716753 +9787532716883 +9787532716944 +9787532716951 +9787532716968 +9787532716975 +9787532717002 +9787532717057 +9787532717071 +9787532717088 +9787532717095 +9787532717132 +9787532717149 +9787532717217 +9787532717224 +9787532717293 +9787532717453 +9787532717583 +9787532717620 +9787532717736 +9787532717996 +9787532718009 +9787532718054 +9787532718078 +9787532718092 +9787532718122 +9787532718139 +9787532718238 +9787532718283 +9787532718306 +9787532718337 +9787532718351 +9787532718368 +9787532718405 +9787532718429 +9787532718436 +9787532718443 +9787532718504 +9787532718528 +9787532718634 +9787532718795 +9787532718818 +9787532718849 +9787532718856 +9787532719006 +9787532719020 +9787532719037 +9787532719044 +9787532719075 +9787532719099 +9787532719105 +9787532719129 +9787532719150 +9787532719167 +9787532719181 +9787532719198 +9787532719211 +9787532719228 +9787532719242 +9787532719334 +9787532719389 +9787532719556 +9787532719587 +9787532719600 +9787532719662 +9787532719686 +9787532719914 +9787532719969 +9787532719976 +9787532719983 +9787532720057 +9787532720095 +9787532720125 +9787532720217 +9787532720224 +9787532720347 +9787532720408 +9787532720415 +9787532720422 +9787532720460 +9787532720484 +9787532720507 +9787532720521 +9787532720538 +9787532720590 +9787532720644 +9787532720767 +9787532720873 +9787532720880 +9787532720927 +9787532720958 +9787532721030 +9787532721061 +9787532721184 +9787532721214 +9787532721276 +9787532721337 +9787532721450 +9787532721498 +9787532721504 +9787532721528 +9787532721535 +9787532721559 +9787532721702 +9787532721733 +9787532721757 +9787532721788 +9787532721795 +9787532721887 +9787532721948 +9787532722037 +9787532722099 +9787532722464 +9787532722471 +9787532722488 +9787532722495 +9787532722549 +9787532722686 +9787532722716 +9787532722860 +9787532722921 +9787532722945 +9787532723034 +9787532723041 +9787532723065 +9787532723089 +9787532723140 +9787532723171 +9787532723287 +9787532723300 +9787532723324 +9787532723454 +9787532723478 +9787532723539 +9787532723553 +9787532723645 +9787532723652 +9787532723805 +9787532723829 +9787532723928 +9787532724048 +9787532724123 +9787532724154 +9787532724161 +9787532724178 +9787532724192 +9787532724284 +9787532724291 +9787532724307 +9787532724338 +9787532724567 +9787532724666 +9787532724710 +9787532724789 +9787532724864 +9787532724987 +9787532725014 +9787532725182 +9787532725199 +9787532725311 +9787532725328 +9787532725335 +9787532725441 +9787532725748 +9787532725779 +9787532725816 +9787532725946 +9787532726035 +9787532726134 +9787532726295 +9787532726332 +9787532726349 +9787532726363 +9787532726400 +9787532726486 +9787532726509 +9787532726547 +9787532726585 +9787532726882 +9787532726899 +9787532727193 +9787532727223 +9787532727247 +9787532727254 +9787532727315 +9787532727506 +9787532727520 +9787532727568 +9787532727810 +9787532727889 +9787532727957 +9787532727988 +9787532728008 +9787532728015 +9787532728039 +9787532728053 +9787532728152 +9787532728176 +9787532728282 +9787532728435 +9787532728503 +9787532728688 +9787532728749 +9787532728787 +9787532728947 +9787532729135 +9787532729258 +9787532729265 +9787532729302 +9787532729319 +9787532729449 +9787532729661 +9787532729678 +9787532729722 +9787532729746 +9787532730049 +9787532730056 +9787532730087 +9787532730162 +9787532730438 +9787532730582 +9787532730605 +9787532730636 +9787532730698 +9787532730704 +9787532730803 +9787532730964 +9787532731138 +9787532731176 +9787532731305 +9787532731381 +9787532731404 +9787532731459 +9787532731565 +9787532731589 +9787532731695 +9787532731701 +9787532731787 +9787532731848 +9787532731916 +9787532731954 +9787532732128 +9787532732272 +9787532732494 +9787532732586 +9787532732623 +9787532732890 +9787532732920 +9787532733002 +9787532733262 +9787532733514 +9787532733613 +9787532733736 +9787532733774 +9787532733828 +9787532733873 +9787532734139 +9787532734184 +9787532734320 +9787532734337 +9787532734368 +9787532734429 +9787532734450 +9787532734467 +9787532734498 +9787532734504 +9787532734689 +9787532734771 +9787532734795 +9787532734870 +9787532735013 +9787532735181 +9787532735204 +9787532735303 +9787532735402 +9787532735679 +9787532735709 +9787532735778 +9787532735952 +9787532735990 +9787532736058 +9787532736089 +9787532736157 +9787532736263 +9787532736355 +9787532736522 +9787532736829 +9787532737000 +9787532737109 +9787532737321 +9787532737345 +9787532737420 +9787532737802 +9787532737819 +9787532737901 +9787532737987 +9787532738021 +9787532738076 +9787532738199 +9787532738205 +9787532738397 +9787532738489 +9787532738564 +9787532738618 +9787532738649 +9787532738755 +9787532738854 +9787532738861 +9787532738885 +9787532738991 +9787532739172 +9787532739189 +9787532739400 +9787532739479 +9787532739509 +9787532739561 +9787532739677 +9787532739752 +9787532739769 +9787532740550 +9787532740574 +9787532740666 +9787532740680 +9787532740833 +9787532740949 +9787532741120 +9787532741144 +9787532741151 +9787532741298 +9787532741311 +9787532741625 +9787532742196 +9787532742233 +9787532742264 +9787532742592 +9787532742820 +9787532742981 +9787532743001 +9787532743209 +9787532743230 +9787532743322 +9787532743360 +9787532743421 +9787532743636 +9787532743780 +9787532743865 +9787532743940 +9787532744138 +9787532744213 +9787532744404 +9787532744411 +9787532744558 +9787532744633 +9787532745302 +9787532745531 +9787532745654 +9787532745739 +9787532745869 +9787532746170 +9787532746347 +9787532746675 +9787532746750 +9787532746767 +9787532746774 +9787532747153 +9787532747467 +9787532747542 +9787532747825 +9787532747870 +9787532747955 +9787532748136 +9787532748143 +9787532748228 +9787532748433 +9787532748440 +9787532748532 +9787532748655 +9787532749331 +9787532749423 +9787532749959 +9787532750023 +9787532750108 +9787532750207 +9787532750511 +9787532750580 +9787532750672 +9787532750696 +9787532750702 +9787532751860 +9787532752010 +9787532753772 +9787532753789 +9787532753888 +9787532753987 +9787532754120 +9787532754342 +9787532754755 +9787532754809 +9787532754885 +9787532755073 +9787532755172 +9787532755264 +9787532755585 +9787532755707 +9787532756193 +9787532756353 +9787532756407 +9787532756865 +9787532756896 +9787532757169 +9787532757756 +9787532757893 +9787532757909 +9787532758050 +9787532758319 +9787532758616 +9787532758661 +9787532758739 +9787532758890 +9787532759347 +9787532759415 +9787532759927 +9787532760473 +9787532760978 +9787532761067 +9787532761098 +9787532761470 +9787532761746 +9787532762170 +9787532762521 +9787532762620 +9787532762637 +9787532762644 +9787532763061 +9787532763092 +9787532763795 +9787532763818 +9787532764341 +9787532764471 +9787532764716 +9787532765348 +9787532766222 +9787532766758 +9787532767571 +9787532768004 +9787532768899 +9787532768912 +9787532770434 +9787532770441 +9787532770649 +9787532770755 +9787532770854 +9787532770960 +9787532771882 +9787532772421 +9787532772773 +9787532774722 +9787532775316 +9787532776153 +9787532776832 +9787532777464 +9787532777891 +9787532778775 +9787532778829 +9787532779758 +9787532779864 +9787532780051 +9787532780334 +9787532780952 +9787532780969 +9787532781560 +9787532781638 +9787532781683 +9787532782017 +9787532782345 +9787532783021 +9787532783281 +9787532783342 +9787532783489 +9787532783700 +9787532784042 +9787532784349 +9787532784370 +9787532784509 +9787532784592 +9787532784844 +9787532784936 +9787532784967 +9787532785018 +9787532785070 +9787532785100 +9787532786800 +9787532786824 +9787532787067 +9787532787708 +9787532787739 +9787532787821 +9787532788972 +9787532789191 +9787532789726 +9787532790166 +9787532790203 +9787532790494 +9787532791057 +9787532791149 +9787532791637 +9787532791729 +9787532791941 +9787532792023 +9787532792047 +9787532792399 +9787532792504 +9787532792627 +9787532792849 +9787532792856 +9787532792900 +9787532792993 +9787532793112 +9787532793204 +9787532793211 +9787532793273 +9787532793396 +9787532793518 +9787532793532 +9787532793556 +9787532793600 +9787532793617 +9787532793624 +9787532793631 +9787532793648 +9787532793662 +9787532793693 +9787532793709 +9787532793839 +9787532793846 +9787532793921 +9787532794102 +9787532794126 +9787532794164 +9787532794188 +9787532794331 +9787532794379 +9787532794430 +9787532794461 +9787532794522 +9787532794560 +9787532794591 +9787532794621 +9787532794669 +9787532794744 +9787532794782 +9787532794812 +9787532794829 +9787532794867 +9787532794874 +9787532794881 +9787532794904 +9787532794928 +9787532794942 +9787532794959 +9787532794966 +9787532794973 +9787532794980 +9787532795000 +9787532795024 +9787532795031 +9787532795048 +9787532795086 +9787532795093 +9787532795116 +9787532795154 +9787532795161 +9787532795208 +9787532795215 +9787532795222 +9787532795253 +9787532795277 +9787532795307 +9787532795376 +9787532795406 +9787532795437 +9787532795444 +9787532795567 +9787532795581 +9787532795710 +9787532795727 +9787532795734 +9787532795758 +9787532795765 +9787532795833 +9787532795871 +9787532795895 +9787532795901 +9787532795918 +9787532795932 +9787532796090 +9787532796151 +9787532796175 +9787532796205 +9787532796212 +9787532796281 +9787532796359 +9787532796366 +9787532796373 +9787532796397 +9787532796434 +9787532796649 +9787532796779 +9787532796793 +9787532796823 +9787532796830 +9787532796854 +9787532796861 +9787532796878 +9787532796892 +9787532796953 +9787532797004 +9787532797035 +9787532797042 +9787532797073 +9787532797158 +9787532797189 +9787532797202 +9787532797226 +9787532797257 +9787532797264 +9787532797271 +9787532797288 +9787532797318 +9787532797325 +9787532797332 +9787532797349 +9787532797356 +9787532797363 +9787532797493 +9787532797530 +9787532797547 +9787532797561 +9787532797608 +9787532797615 +9787532797622 +9787532797721 +9787532797738 +9787532797745 +9787532797776 +9787532797783 +9787532797820 +9787532797875 +9787532797899 +9787532797936 +9787532797950 +9787532797967 +9787532797974 +9787532797998 +9787532798094 +9787532798100 +9787532798117 +9787532798131 +9787532798155 +9787532798162 +9787532798193 +9787532798230 +9787532798360 +9787532798438 +9787532798520 +9787532798650 +9787532798674 +9787532798681 +9787532798704 +9787532798711 +9787532798728 +9787532798766 +9787532798773 +9787532798810 +9787532798940 +9787532799121 +9787532799190 +9787532799336 +9787532799411 +9787532799435 +9787532799893 +9787532800261 +9787532800490 +9787532800551 +9787532800711 +9787532801848 +9787532801855 +9787532801909 +9787532802111 +9787532802197 +9787532802296 +9787532802395 +9787532803705 +9787532804610 +9787532804832 +9787532804931 +9787532804948 +9787532806430 +9787532806515 +9787532806706 +9787532806812 +9787532806829 +9787532806973 +9787532807765 +9787532807963 +9787532809028 +9787532809035 +9787532810208 +9787532810512 +9787532810772 +9787532810932 +9787532810949 +9787532810987 +9787532810994 +9787532811137 +9787532811915 +9787532812028 +9787532812219 +9787532812240 +9787532813551 +9787532813575 +9787532813636 +9787532813667 +9787532813681 +9787532813728 +9787532814664 +9787532814718 +9787532817733 +9787532817757 +9787532817795 +9787532817825 +9787532817856 +9787532819720 +9787532819829 +9787532819836 +9787532820627 +9787532821082 +9787532821211 +9787532821365 +9787532821457 +9787532821945 +9787532822089 +9787532822270 +9787532822553 +9787532822942 +9787532823307 +9787532823369 +9787532823390 +9787532823680 +9787532824274 +9787532824281 +9787532824465 +9787532824588 +9787532824731 +9787532824861 +9787532824878 +9787532824885 +9787532825769 +9787532825806 +9787532825820 +9787532825837 +9787532825868 +9787532825882 +9787532825981 +9787532825998 +9787532826094 +9787532826179 +9787532826186 +9787532826193 +9787532826216 +9787532826223 +9787532826247 +9787532826285 +9787532826469 +9787532826476 +9787532826520 +9787532826544 +9787532826551 +9787532826599 +9787532826605 +9787532826612 +9787532826636 +9787532826698 +9787532826704 +9787532826759 +9787532826827 +9787532826841 +9787532826865 +9787532826926 +9787532827022 +9787532827138 +9787532827220 +9787532827329 +9787532827428 +9787532828005 +9787532828340 +9787532828388 +9787532828395 +9787532828456 +9787532828555 +9787532828609 +9787532828616 +9787532828654 +9787532828661 +9787532828784 +9787532828838 +9787532828906 +9787532829057 +9787532829118 +9787532829422 +9787532829545 +9787532829637 +9787532830084 +9787532830176 +9787532830282 +9787532831012 +9787532831081 +9787532831234 +9787532831319 +9787532831548 +9787532832002 +9787532833269 +9787532833535 +9787532834242 +9787532834259 +9787532834280 +9787532834518 +9787532834525 +9787532834945 +9787532835379 +9787532835553 +9787532836567 +9787532836574 +9787532836598 +9787532836611 +9787532841165 +9787532842032 +9787532842261 +9787532842315 +9787532842322 +9787532842582 +9787532844067 +9787532847600 +9787532848027 +9787532849222 +9787532849345 +9787532849406 +9787532849413 +9787532849420 +9787532849581 +9787532849796 +9787532849826 +9787532851065 +9787532851331 +9787532852420 +9787532853915 +9787532853939 +9787532853946 +9787532854523 +9787532855438 +9787532856077 +9787532856145 +9787532856206 +9787532856237 +9787532856244 +9787532856602 +9787532856787 +9787532856893 +9787532857364 +9787532857388 +9787532857418 +9787532857432 +9787532858330 +9787532858408 +9787532859122 +9787532859139 +9787532859146 +9787532859153 +9787532859450 +9787532859719 +9787532859757 +9787532860043 +9787532860098 +9787532860470 +9787532860852 +9787532861569 +9787532861767 +9787532862085 +9787532862375 +9787532862429 +9787532862436 +9787532862474 +9787532862481 +9787532862528 +9787532862542 +9787532862566 +9787532862573 +9787532862672 +9787532862764 +9787532862818 +9787532863068 +9787532864522 +9787532865994 +9787532866809 +9787532867936 +9787532868063 +9787532868148 +9787532868438 +9787532870240 +9787532870516 +9787532870608 +9787532870806 +9787532871056 +9787532871537 +9787532871551 +9787532871568 +9787532871575 +9787532872190 +9787532872206 +9787532872213 +9787532872619 +9787532876969 +9787532876983 +9787532877072 +9787532877096 +9787532877188 +9787532877195 +9787532877584 +9787532877799 +9787532877812 +9787532878888 +9787532881505 +9787532881550 +9787532881598 +9787532881826 +9787532882977 +9787532883608 +9787532884230 +9787532884506 +9787532884605 +9787532885404 +9787532886692 +9787532887903 +9787532887958 +9787532888078 +9787532888276 +9787532888511 +9787532889051 +9787532889082 +9787532890606 +9787532891207 +9787532891245 +9787532891481 +9787532892044 +9787532892129 +9787532892136 +9787532892303 +9787532892426 +9787532892570 +9787532892594 +9787532893201 +9787532893218 +9787532894260 +9787532894611 +9787532894659 +9787532894987 +9787532897179 +9787532897247 +9787532897254 +9787532897292 +9787532897537 +9787532898107 +9787532898619 +9787532898916 +9787532899623 +9787532899760 +9787532899852 +9787532899944 +9787532900107 +9787532900114 +9787532900138 +9787532900237 +9787532900404 +9787532900442 +9787532900466 +9787532900633 +9787532900756 +9787532900787 +9787532900916 +9787532900985 +9787532901159 +9787532901180 +9787532901289 +9787532901524 +9787532901555 +9787532901876 +9787532902293 +9787532902309 +9787532902637 +9787532902651 +9787532902699 +9787532902705 +9787532902712 +9787532903313 +9787532904587 +9787532904723 +9787532904884 +9787532906093 +9787532906109 +9787532906666 +9787532906826 +9787532907182 +9787532907625 +9787532907717 +9787532908097 +9787532908103 +9787532908110 +9787532908165 +9787532908400 +9787532908554 +9787532908578 +9787532908974 +9787532909100 +9787532909117 +9787532909421 +9787532909599 +9787532909926 +9787532909940 +9787532909971 +9787532910366 +9787532910557 +9787532911387 +9787532911400 +9787532911424 +9787532911448 +9787532911653 +9787532911714 +9787532911882 +9787532912131 +9787532912223 +9787532912247 +9787532912322 +9787532912346 +9787532912407 +9787532912421 +9787532912438 +9787532912490 +9787532912544 +9787532912582 +9787532912612 +9787532912810 +9787532913039 +9787532913121 +9787532913213 +9787532913596 +9787532913909 +9787532913916 +9787532914005 +9787532914081 +9787532914098 +9787532914302 +9787532914319 +9787532914364 +9787532914401 +9787532914456 +9787532914470 +9787532914531 +9787532914579 +9787532914739 +9787532915101 +9787532915330 +9787532915569 +9787532915798 +9787532915859 +9787532915866 +9787532915910 +9787532915941 +9787532916139 +9787532916160 +9787532916207 +9787532916245 +9787532916313 +9787532916405 +9787532916474 +9787532916542 +9787532916573 +9787532916672 +9787532916696 +9787532916887 +9787532916955 +9787532916986 +9787532917402 +9787532917457 +9787532917679 +9787532917808 +9787532917822 +9787532917839 +9787532918096 +9787532918102 +9787532918348 +9787532918362 +9787532918386 +9787532918461 +9787532918478 +9787532918492 +9787532918829 +9787532918850 +9787532919031 +9787532919369 +9787532919437 +9787532919444 +9787532919468 +9787532919499 +9787532919567 +9787532919826 +9787532919857 +9787532920143 +9787532920242 +9787532920259 +9787532920303 +9787532920372 +9787532920518 +9787532920655 +9787532920679 +9787532921287 +9787532921485 +9787532921591 +9787532921775 +9787532922475 +9787532922543 +9787532923212 +9787532923427 +9787532923496 +9787532923526 +9787532923588 +9787532923601 +9787532923618 +9787532923649 +9787532923656 +9787532923861 +9787532924011 +9787532924080 +9787532924141 +9787532924257 +9787532924530 +9787532924639 +9787532924721 +9787532924943 +9787532924950 +9787532924974 +9787532925346 +9787532925414 +9787532925438 +9787532925490 +9787532926336 +9787532926527 +9787532926541 +9787532926558 +9787532926756 +9787532927340 +9787532927494 +9787532928088 +9787532928828 +9787532928989 +9787532929160 +9787532929191 +9787532929252 +9787532929276 +9787532929344 +9787532929368 +9787532929757 +9787532929979 +9787532930104 +9787532930241 +9787532930807 +9787532931392 +9787532931422 +9787532931453 +9787532931989 +9787532932610 +9787532932627 +9787532932979 +9787532933358 +9787532933556 +9787532933716 +9787532933730 +9787532933976 +9787532934317 +9787532934607 +9787532934621 +9787532934881 +9787532936878 +9787532937226 +9787532937240 +9787532937257 +9787532937295 +9787532937325 +9787532939763 +9787532940356 +9787532940363 +9787532940387 +9787532940462 +9787532940479 +9787532940554 +9787532940592 +9787532940615 +9787532940639 +9787532940660 +9787532940752 +9787532941568 +9787532941582 +9787532941605 +9787532941636 +9787532941674 +9787532942152 +9787532942688 +9787532942756 +9787532943609 +9787532943715 +9787532943784 +9787532944040 +9787532944156 +9787532944637 +9787532944644 +9787532944743 +9787532944781 +9787532945184 +9787532945757 +9787532945863 +9787532946013 +9787532947225 +9787532947676 +9787532947713 +9787532947720 +9787532948031 +9787532949199 +9787532949663 +9787532949755 +9787532949823 +9787532951444 +9787532951567 +9787532951635 +9787532952120 +9787532952427 +9787532952588 +9787532952960 +9787532954681 +9787532954834 +9787532954896 +9787532955374 +9787532955398 +9787532955664 +9787532956203 +9787532956722 +9787532956937 +9787532956968 +9787532957897 +9787532958078 +9787532958290 +9787532958320 +9787532958436 +9787532958467 +9787532958474 +9787532958733 +9787532959143 +9787532960378 +9787532960422 +9787532960606 +9787532960620 +9787532961238 +9787532962129 +9787532963508 +9787532963515 +9787532963690 +9787532964536 +9787532964543 +9787532964901 +9787532965489 +9787532965502 +9787532966271 +9787532966301 +9787532966332 +9787532966363 +9787532966370 +9787532966394 +9787532967629 +9787532967650 +9787532968497 +9787532968503 +9787532968572 +9787532968695 +9787532968862 +9787532969029 +9787532969043 +9787532969074 +9787532969111 +9787532969159 +9787532969180 +9787532969197 +9787532969234 +9787532969364 +9787532969746 +9787532969784 +9787532969807 +9787532969814 +9787532969876 +9787532969883 +9787532970445 +9787532970452 +9787532971428 +9787532971459 +9787532971558 +9787532971626 +9787532972029 +9787532972876 +9787533000042 +9787533000073 +9787533000097 +9787533000325 +9787533000332 +9787533000448 +9787533000479 +9787533000493 +9787533000578 +9787533000585 +9787533000592 +9787533000608 +9787533000646 +9787533000660 +9787533000837 +9787533000868 +9787533001247 +9787533001346 +9787533001360 +9787533001513 +9787533001551 +9787533001575 +9787533001599 +9787533001636 +9787533001698 +9787533001780 +9787533002176 +9787533002251 +9787533002770 +9787533002787 +9787533003128 +9787533003395 +9787533004002 +9787533004361 +9787533004460 +9787533004552 +9787533004866 +9787533005603 +9787533006273 +9787533006433 +9787533006464 +9787533006488 +9787533008017 +9787533008192 +9787533008246 +9787533008451 +9787533008574 +9787533008642 +9787533008659 +9787533008888 +9787533009120 +9787533009229 +9787533009427 +9787533009519 +9787533009526 +9787533009540 +9787533009557 +9787533009663 +9787533009717 +9787533009724 +9787533009786 +9787533009939 +9787533010034 +9787533010072 +9787533010089 +9787533010119 +9787533010133 +9787533010188 +9787533010706 +9787533010713 +9787533010850 +9787533010911 +9787533011079 +9787533011109 +9787533011130 +9787533011147 +9787533011161 +9787533011192 +9787533011215 +9787533011420 +9787533011864 +9787533011895 +9787533011970 +9787533012311 +9787533012427 +9787533012458 +9787533012489 +9787533012526 +9787533012601 +9787533012748 +9787533012922 +9787533012953 +9787533013080 +9787533013295 +9787533013486 +9787533013622 +9787533013707 +9787533013943 +9787533014018 +9787533014094 +9787533014100 +9787533014124 +9787533014131 +9787533014230 +9787533014308 +9787533014445 +9787533014469 +9787533014544 +9787533014551 +9787533014582 +9787533014605 +9787533014766 +9787533014803 +9787533014834 +9787533014841 +9787533014995 +9787533015077 +9787533015114 +9787533015220 +9787533015374 +9787533015565 +9787533015725 +9787533015749 +9787533015800 +9787533015817 +9787533015824 +9787533015831 +9787533015848 +9787533015862 +9787533015886 +9787533015893 +9787533015978 +9787533016012 +9787533016067 +9787533016074 +9787533016135 +9787533016142 +9787533016159 +9787533016166 +9787533016340 +9787533016395 +9787533016494 +9787533016562 +9787533016630 +9787533016890 +9787533016913 +9787533016937 +9787533017200 +9787533017293 +9787533017408 +9787533017842 +9787533017958 +9787533018054 +9787533018245 +9787533018276 +9787533018283 +9787533018597 +9787533018603 +9787533018733 +9787533018849 +9787533018863 +9787533018870 +9787533018924 +9787533018931 +9787533019075 +9787533019136 +9787533019204 +9787533019235 +9787533019372 +9787533019525 +9787533019549 +9787533019556 +9787533019617 +9787533019662 +9787533019846 +9787533019976 +9787533019990 +9787533020088 +9787533020330 +9787533020354 +9787533020477 +9787533020507 +9787533020514 +9787533020521 +9787533021214 +9787533021221 +9787533021238 +9787533021290 +9787533021412 +9787533021559 +9787533021672 +9787533021689 +9787533021726 +9787533021825 +9787533021931 +9787533022068 +9787533022136 +9787533022280 +9787533022402 +9787533022518 +9787533022600 +9787533022624 +9787533022709 +9787533022723 +9787533023324 +9787533023348 +9787533023409 +9787533023447 +9787533023676 +9787533023706 +9787533023713 +9787533023775 +9787533023805 +9787533023928 +9787533024062 +9787533024093 +9787533024239 +9787533024277 +9787533024406 +9787533024864 +9787533024987 +9787533025342 +9787533025366 +9787533025373 +9787533025397 +9787533025410 +9787533025502 +9787533025540 +9787533025632 +9787533025663 +9787533025816 +9787533025823 +9787533026028 +9787533026271 +9787533026332 +9787533026448 +9787533026714 +9787533026738 +9787533026899 +9787533027087 +9787533027100 +9787533027117 +9787533027131 +9787533027162 +9787533027247 +9787533027520 +9787533028039 +9787533028046 +9787533028688 +9787533028725 +9787533029197 +9787533029289 +9787533029395 +9787533029418 +9787533029432 +9787533029876 +9787533030346 +9787533030384 +9787533030766 +9787533030773 +9787533030889 +9787533031084 +9787533031138 +9787533031688 +9787533031770 +9787533031978 +9787533032715 +9787533032739 +9787533033316 +9787533033545 +9787533033552 +9787533033675 +9787533034023 +9787533034108 +9787533034177 +9787533034214 +9787533034702 +9787533034733 +9787533034795 +9787533034801 +9787533034849 +9787533035112 +9787533035143 +9787533035327 +9787533035365 +9787533036065 +9787533036072 +9787533036164 +9787533036683 +9787533036935 +9787533036966 +9787533037147 +9787533037253 +9787533037277 +9787533037550 +9787533038625 +9787533038632 +9787533038663 +9787533038724 +9787533039325 +9787533039332 +9787533040420 +9787533040444 +9787533041748 +9787533042158 +9787533042288 +9787533042387 +9787533042486 +9787533044046 +9787533044176 +9787533046408 +9787533046989 +9787533047221 +9787533047344 +9787533047368 +9787533047856 +9787533047955 +9787533049157 +9787533049478 +9787533049539 +9787533050306 +9787533051068 +9787533051464 +9787533051495 +9787533051501 +9787533051518 +9787533052041 +9787533053604 +9787533053611 +9787533054519 +9787533054724 +9787533054915 +9787533055912 +9787533056063 +9787533056322 +9787533058395 +9787533058548 +9787533058685 +9787533058760 +9787533058845 +9787533059163 +9787533059323 +9787533059354 +9787533059378 +9787533059385 +9787533059392 +9787533059897 +9787533060008 +9787533060053 +9787533060350 +9787533062507 +9787533062873 +9787533062910 +9787533064082 +9787533064174 +9787533065515 +9787533065584 +9787533065645 +9787533065713 +9787533065836 +9787533065867 +9787533066055 +9787533066253 +9787533066376 +9787533066772 +9787533067588 +9787533067663 +9787533068080 +9787533068097 +9787533068639 +9787533069001 +9787533070434 +9787533071509 +9787533072544 +9787533073640 +9787533073657 +9787533073664 +9787533073671 +9787533073848 +9787533074272 +9787533075958 +9787533075965 +9787533076108 +9787533078812 +9787533078829 +9787533078836 +9787533079017 +9787533080235 +9787533080853 +9787533081232 +9787533081256 +9787533081607 +9787533084325 +9787533084516 +9787533084530 +9787533084646 +9787533087456 +9787533087913 +9787533088859 +9787533089405 +9787533089962 +9787533089979 +9787533089986 +9787533090500 +9787533090739 +9787533090746 +9787533090753 +9787533090760 +9787533090869 +9787533093075 +9787533093310 +9787533093334 +9787533093341 +9787533093358 +9787533093365 +9787533093372 +9787533093662 +9787533094911 +9787533094997 +9787533095079 +9787533095758 +9787533096021 +9787533097905 +9787533098261 +9787533098285 +9787533098605 +9787533098797 +9787533099169 +9787533099503 +9787533099596 +9787533099602 +9787533099619 +9787533099633 +9787533099640 +9787533099664 +9787533099763 +9787533100070 +9787533100292 +9787533100513 +9787533100605 +9787533100704 +9787533101176 +9787533101626 +9787533101664 +9787533102043 +9787533102586 +9787533102609 +9787533103194 +9787533103729 +9787533103774 +9787533104245 +9787533104313 +9787533104375 +9787533104535 +9787533104757 +9787533104887 +9787533104924 +9787533105020 +9787533105044 +9787533105297 +9787533106287 +9787533106348 +9787533106409 +9787533106522 +9787533106676 +9787533106812 +9787533107031 +9787533107383 +9787533107482 +9787533108434 +9787533108465 +9787533108502 +9787533108533 +9787533109073 +9787533109295 +9787533109462 +9787533109875 +9787533109950 +9787533110444 +9787533110703 +9787533110710 +9787533110727 +9787533110970 +9787533111038 +9787533111311 +9787533111663 +9787533111724 +9787533111960 +9787533111984 +9787533112547 +9787533112684 +9787533112899 +9787533112998 +9787533113193 +9787533113599 +9787533113629 +9787533113810 +9787533113827 +9787533113902 +9787533114091 +9787533114190 +9787533114398 +9787533114534 +9787533114602 +9787533114817 +9787533114879 +9787533115180 +9787533115463 +9787533115548 +9787533115739 +9787533115746 +9787533115791 +9787533115869 +9787533115913 +9787533116026 +9787533116033 +9787533116170 +9787533116378 +9787533116477 +9787533116545 +9787533116613 +9787533116859 +9787533117030 +9787533117238 +9787533117627 +9787533117726 +9787533117795 +9787533118303 +9787533118778 +9787533118808 +9787533118952 +9787533119058 +9787533119096 +9787533119188 +9787533119270 +9787533119324 +9787533119409 +9787533119522 +9787533119881 +9787533120177 +9787533120436 +9787533120979 +9787533121242 +9787533121310 +9787533121419 +9787533121495 +9787533121563 +9787533121754 +9787533121761 +9787533121938 +9787533122119 +9787533122188 +9787533122201 +9787533122362 +9787533122898 +9787533123130 +9787533123444 +9787533123598 +9787533123796 +9787533123864 +9787533124045 +9787533124243 +9787533124427 +9787533124472 +9787533124625 +9787533124694 +9787533124953 +9787533125110 +9787533125271 +9787533125301 +9787533125394 +9787533125486 +9787533125608 +9787533125622 +9787533125844 +9787533125981 +9787533126049 +9787533126261 +9787533126278 +9787533126377 +9787533126414 +9787533126513 +9787533126650 +9787533126995 +9787533127060 +9787533127077 +9787533127367 +9787533127411 +9787533127428 +9787533127640 +9787533127824 +9787533127831 +9787533127848 +9787533127978 +9787533128012 +9787533128098 +9787533128302 +9787533128319 +9787533128340 +9787533128548 +9787533128678 +9787533128685 +9787533128999 +9787533129002 +9787533129057 +9787533129071 +9787533129330 +9787533129576 +9787533130190 +9787533130275 +9787533130282 +9787533130411 +9787533130749 +9787533130787 +9787533130794 +9787533130893 +9787533131005 +9787533131012 +9787533131036 +9787533131050 +9787533131227 +9787533131319 +9787533131364 +9787533131968 +9787533131982 +9787533132293 +9787533132361 +9787533132439 +9787533132590 +9787533132873 +9787533132927 +9787533132941 +9787533133375 +9787533133436 +9787533133771 +9787533133832 +9787533133979 +9787533134143 +9787533134297 +9787533134402 +9787533134440 +9787533134624 +9787533135638 +9787533135836 +9787533136291 +9787533136970 +9787533137045 +9787533137120 +9787533137168 +9787533137397 +9787533137779 +9787533138011 +9787533138271 +9787533138714 +9787533139964 +9787533139971 +9787533140328 +9787533140601 +9787533141646 +9787533141707 +9787533141769 +9787533141912 +9787533142636 +9787533142759 +9787533143176 +9787533143343 +9787533143374 +9787533143381 +9787533143480 +9787533143572 +9787533143954 +9787533144203 +9787533144296 +9787533144401 +9787533144432 +9787533144487 +9787533144708 +9787533144999 +9787533145002 +9787533145248 +9787533145781 +9787533146757 +9787533146788 +9787533146825 +9787533146924 +9787533146948 +9787533147402 +9787533147440 +9787533148157 +9787533148188 +9787533148317 +9787533148515 +9787533148638 +9787533148737 +9787533148898 +9787533149376 +9787533149635 +9787533149819 +9787533150327 +9787533150600 +9787533150662 +9787533150785 +9787533150990 +9787533151003 +9787533151034 +9787533151201 +9787533151324 +9787533151409 +9787533151423 +9787533151447 +9787533151638 +9787533151928 +9787533152031 +9787533152604 +9787533152642 +9787533152710 +9787533152864 +9787533152970 +9787533153441 +9787533154660 +9787533155285 +9787533155513 +9787533155643 +9787533155704 +9787533155742 +9787533156190 +9787533156558 +9787533157029 +9787533157050 +9787533157333 +9787533157388 +9787533157425 +9787533157463 +9787533159016 +9787533161163 +9787533161965 +9787533163105 +9787533163372 +9787533163402 +9787533163563 +9787533164171 +9787533165130 +9787533165178 +9787533167936 +9787533168193 +9787533168209 +9787533170240 +9787533170325 +9787533170387 +9787533170417 +9787533170424 +9787533170486 +9787533170493 +9787533170523 +9787533170530 +9787533170639 +9787533170660 +9787533170806 +9787533170912 +9787533171407 +9787533173029 +9787533173180 +9787533175283 +9787533175818 +9787533175979 +9787533176273 +9787533176327 +9787533176471 +9787533176495 +9787533176648 +9787533177492 +9787533177539 +9787533177652 +9787533177669 +9787533177676 +9787533177713 +9787533178031 +9787533178307 +9787533178567 +9787533178581 +9787533178987 +9787533179557 +9787533179564 +9787533179991 +9787533181352 +9787533181369 +9787533181772 +9787533181901 +9787533182441 +9787533182823 +9787533183738 +9787533185626 +9787533186296 +9787533186302 +9787533187903 +9787533188061 +9787533188467 +9787533188535 +9787533188788 +9787533189419 +9787533189587 +9787533190309 +9787533190958 +9787533191283 +9787533191290 +9787533192525 +9787533193287 +9787533193379 +9787533195250 +9787533195267 +9787533195564 +9787533195854 +9787533196691 +9787533197124 +9787533197216 +9787533197469 +9787533197506 +9787533197513 +9787533197629 +9787533197896 +9787533197940 +9787533197988 +9787533198022 +9787533198206 +9787533198480 +9787533198497 +9787533198558 +9787533198572 +9787533198985 +9787533199128 +9787533199456 +9787533199517 +9787533199616 +9787533199692 +9787533199876 +9787533199906 +9787533200220 +9787533200602 +9787533201142 +9787533206031 +9787533206635 +9787533209124 +9787533209711 +9787533210144 +9787533210151 +9787533210175 +9787533210489 +9787533212506 +9787533214210 +9787533215019 +9787533215026 +9787533215057 +9787533215934 +9787533216061 +9787533217860 +9787533217983 +9787533218645 +9787533219987 +9787533219994 +9787533221614 +9787533221683 +9787533222550 +9787533222598 +9787533223205 +9787533224509 +9787533225308 +9787533225681 +9787533225711 +9787533225919 +9787533225926 +9787533225964 +9787533227449 +9787533228057 +9787533229368 +9787533229887 +9787533230692 +9787533231101 +9787533231231 +9787533233082 +9787533233242 +9787533233747 +9787533233921 +9787533235413 +9787533235437 +9787533235789 +9787533235840 +9787533236007 +9787533236359 +9787533236373 +9787533236380 +9787533236397 +9787533236403 +9787533237349 +9787533240851 +9787533241636 +9787533242794 +9787533242848 +9787533242855 +9787533242893 +9787533243609 +9787533243630 +9787533243951 +9787533244699 +9787533244767 +9787533245276 +9787533245337 +9787533247331 +9787533247515 +9787533247836 +9787533248215 +9787533248543 +9787533249014 +9787533249250 +9787533249397 +9787533249403 +9787533249427 +9787533249472 +9787533251895 +9787533252175 +9787533252366 +9787533252441 +9787533252472 +9787533252830 +9787533254827 +9787533254834 +9787533254858 +9787533254926 +9787533255794 +9787533256579 +9787533259143 +9787533259181 +9787533259198 +9787533259204 +9787533259235 +9787533259389 +9787533259815 +9787533260095 +9787533260897 +9787533261115 +9787533261900 +9787533261993 +9787533262020 +9787533262242 +9787533262556 +9787533262860 +9787533263089 +9787533263232 +9787533263256 +9787533264079 +9787533264161 +9787533264505 +9787533264512 +9787533265427 +9787533266691 +9787533267308 +9787533267629 +9787533267834 +9787533269395 +9787533271077 +9787533271824 +9787533271886 +9787533272128 +9787533273149 +9787533273378 +9787533273651 +9787533273767 +9787533274313 +9787533274900 +9787533274917 +9787533274955 +9787533275280 +9787533275471 +9787533275716 +9787533275723 +9787533275785 +9787533276225 +9787533276249 +9787533276263 +9787533276270 +9787533276287 +9787533276294 +9787533276386 +9787533276522 +9787533276591 +9787533276614 +9787533277970 +9787533277987 +9787533278168 +9787533279899 +9787533280857 +9787533281168 +9787533282110 +9787533282875 +9787533284770 +9787533285470 +9787533286392 +9787533286507 +9787533286934 +9787533288143 +9787533288419 +9787533289676 +9787533290108 +9787533290177 +9787533291150 +9787533291556 +9787533291853 +9787533291945 +9787533292508 +9787533292751 +9787533293659 +9787533296827 +9787533296926 +9787533297039 +9787533297497 +9787533298401 +9787533300098 +9787533300104 +9787533300180 +9787533300241 +9787533300265 +9787533300296 +9787533300357 +9787533300418 +9787533300425 +9787533300449 +9787533300463 +9787533300487 +9787533300500 +9787533300517 +9787533300531 +9787533300616 +9787533300654 +9787533300678 +9787533300746 +9787533300814 +9787533300821 +9787533300852 +9787533300869 +9787533300951 +9787533300968 +9787533301019 +9787533301026 +9787533301057 +9787533301064 +9787533301163 +9787533301217 +9787533301224 +9787533301323 +9787533301453 +9787533301460 +9787533301484 +9787533301538 +9787533301545 +9787533301620 +9787533301637 +9787533301644 +9787533301729 +9787533301743 +9787533301750 +9787533301811 +9787533301859 +9787533301941 +9787533301965 +9787533302214 +9787533302221 +9787533302283 +9787533302313 +9787533302382 +9787533302504 +9787533302559 +9787533302573 +9787533302818 +9787533302849 +9787533303075 +9787533303143 +9787533303297 +9787533303334 +9787533303365 +9787533303389 +9787533303396 +9787533303419 +9787533303495 +9787533303525 +9787533303556 +9787533303570 +9787533303716 +9787533303730 +9787533303761 +9787533304096 +9787533304133 +9787533304188 +9787533304195 +9787533304232 +9787533304249 +9787533304324 +9787533304355 +9787533304416 +9787533304447 +9787533304508 +9787533304515 +9787533304522 +9787533304546 +9787533304577 +9787533304584 +9787533304621 +9787533304669 +9787533304683 +9787533304713 +9787533304775 +9787533304782 +9787533304812 +9787533304829 +9787533304959 +9787533305062 +9787533305192 +9787533305291 +9787533305321 +9787533305406 +9787533305475 +9787533305499 +9787533305598 +9787533305642 +9787533305741 +9787533305796 +9787533305963 +9787533305994 +9787533306311 +9787533306380 +9787533306557 +9787533306601 +9787533306649 +9787533306786 +9787533306793 +9787533306885 +9787533306892 +9787533306915 +9787533307004 +9787533307110 +9787533307127 +9787533307141 +9787533307158 +9787533307165 +9787533307219 +9787533307226 +9787533307486 +9787533307493 +9787533307776 +9787533308148 +9787533308254 +9787533308315 +9787533308469 +9787533308506 +9787533308995 +9787533309008 +9787533309138 +9787533309305 +9787533310097 +9787533310141 +9787533310219 +9787533310455 +9787533310691 +9787533310714 +9787533310769 +9787533310837 +9787533310912 +9787533310929 +9787533311162 +9787533311285 +9787533311346 +9787533311391 +9787533311438 +9787533311513 +9787533311711 +9787533311902 +9787533312039 +9787533312084 +9787533312237 +9787533312268 +9787533312275 +9787533312312 +9787533312336 +9787533312503 +9787533312657 +9787533312701 +9787533312749 +9787533313371 +9787533313531 +9787533313739 +9787533313791 +9787533313845 +9787533314026 +9787533314101 +9787533314170 +9787533314279 +9787533314323 +9787533314460 +9787533314576 +9787533314828 +9787533314835 +9787533314842 +9787533314866 +9787533315085 +9787533315092 +9787533315146 +9787533315320 +9787533315337 +9787533315344 +9787533315399 +9787533315429 +9787533315436 +9787533315665 +9787533315757 +9787533315900 +9787533315917 +9787533315979 +9787533316082 +9787533316129 +9787533316143 +9787533316389 +9787533316488 +9787533316549 +9787533316815 +9787533316846 +9787533317133 +9787533317164 +9787533317270 +9787533317423 +9787533317690 +9787533317997 +9787533318055 +9787533318215 +9787533318260 +9787533318383 +9787533318451 +9787533318475 +9787533318550 +9787533318666 +9787533318833 +9787533318888 +9787533319144 +9787533319458 +9787533319472 +9787533319533 +9787533319588 +9787533319953 +9787533319960 +9787533320218 +9787533320294 +9787533320300 +9787533320522 +9787533320546 +9787533320614 +9787533320867 +9787533320874 +9787533320928 +9787533320966 +9787533321031 +9787533321123 +9787533321215 +9787533321260 +9787533321635 +9787533321703 +9787533321710 +9787533322038 +9787533322045 +9787533322236 +9787533322243 +9787533322397 +9787533322649 +9787533322779 +9787533323042 +9787533323066 +9787533323417 +9787533323448 +9787533323509 +9787533323615 +9787533323639 +9787533323806 +9787533323929 +9787533323967 +9787533324087 +9787533324179 +9787533324384 +9787533324803 +9787533324964 +9787533324995 +9787533325008 +9787533325039 +9787533325404 +9787533325442 +9787533325688 +9787533325718 +9787533325855 +9787533325930 +9787533325954 +9787533326050 +9787533326678 +9787533326715 +9787533326814 +9787533327118 +9787533327453 +9787533327460 +9787533327545 +9787533327606 +9787533328061 +9787533328184 +9787533328191 +9787533330194 +9787533330217 +9787533330262 +9787533330477 +9787533331238 +9787533331382 +9787533331443 +9787533331634 +9787533331672 +9787533331719 +9787533331764 +9787533332402 +9787533332693 +9787533332846 +9787533333003 +9787533333041 +9787533333058 +9787533333300 +9787533333355 +9787533333386 +9787533334048 +9787533334222 +9787533334352 +9787533334475 +9787533334932 +9787533335786 +9787533336424 +9787533336523 +9787533336547 +9787533336790 +9787533337315 +9787533337346 +9787533337537 +9787533337551 +9787533337896 +9787533337957 +9787533337964 +9787533338527 +9787533338589 +9787533338961 +9787533339005 +9787533339166 +9787533339418 +9787533339487 +9787533339647 +9787533339654 +9787533339869 +9787533340223 +9787533340254 +9787533340285 +9787533340506 +9787533340520 +9787533341039 +9787533341169 +9787533341275 +9787533341329 +9787533341343 +9787533341930 +9787533342210 +9787533342234 +9787533342241 +9787533342296 +9787533342401 +9787533342418 +9787533342432 +9787533342586 +9787533343231 +9787533343248 +9787533343255 +9787533343293 +9787533343422 +9787533343491 +9787533343507 +9787533343606 +9787533343958 +9787533344078 +9787533344481 +9787533344658 +9787533344801 +9787533344948 +9787533345310 +9787533345464 +9787533346324 +9787533346355 +9787533346393 +9787533346416 +9787533346546 +9787533346591 +9787533346607 +9787533346829 +9787533346843 +9787533346898 +9787533347147 +9787533347277 +9787533347444 +9787533347468 +9787533347505 +9787533347550 +9787533347574 +9787533347758 +9787533347840 +9787533347871 +9787533347918 +9787533347949 +9787533348250 +9787533348281 +9787533348342 +9787533348397 +9787533348519 +9787533348892 +9787533349158 +9787533349219 +9787533349226 +9787533349264 +9787533349271 +9787533349288 +9787533349295 +9787533349325 +9787533349332 +9787533349363 +9787533349387 +9787533349394 +9787533349448 +9787533349455 +9787533349479 +9787533349486 +9787533349493 +9787533349516 +9787533349523 +9787533349530 +9787533349738 +9787533349851 +9787533349868 +9787533350246 +9787533350284 +9787533350291 +9787533350420 +9787533350505 +9787533350512 +9787533350680 +9787533350901 +9787533350918 +9787533350956 +9787533351588 +9787533401368 +9787533403508 +9787533405625 +9787533405823 +9787533405915 +9787533406073 +9787533406233 +9787533406295 +9787533406783 +9787533407254 +9787533407261 +9787533407827 +9787533408770 +9787533410339 +9787533410926 +9787533411121 +9787533411480 +9787533412425 +9787533412807 +9787533413163 +9787533414214 +9787533414245 +9787533414337 +9787533414689 +9787533414719 +9787533416225 +9787533417048 +9787533419387 +9787533419400 +9787533419431 +9787533419509 +9787533419530 +9787533420185 +9787533420291 +9787533420420 +9787533421731 +9787533421748 +9787533423032 +9787533423650 +9787533424565 +9787533424589 +9787533424626 +9787533424862 +9787533424879 +9787533425845 +9787533425890 +9787533425975 +9787533426361 +9787533427269 +9787533428075 +9787533428099 +9787533429430 +9787533429799 +9787533429997 +9787533430023 +9787533431488 +9787533431532 +9787533431877 +9787533432218 +9787533432836 +9787533434489 +9787533435226 +9787533435318 +9787533436308 +9787533437978 +9787533439767 +9787533439781 +9787533439798 +9787533439804 +9787533440725 +9787533440930 +9787533441104 +9787533441166 +9787533441173 +9787533441289 +9787533443740 +9787533445089 +9787533445225 +9787533445324 +9787533445379 +9787533446512 +9787533446833 +9787533446895 +9787533446901 +9787533447076 +9787533447250 +9787533447748 +9787533448240 +9787533448875 +9787533448943 +9787533448950 +9787533449001 +9787533449759 +9787533449797 +9787533449810 +9787533449834 +9787533450106 +9787533450335 +9787533450380 +9787533450861 +9787533450915 +9787533451028 +9787533451196 +9787533451486 +9787533451660 +9787533451684 +9787533451714 +9787533451745 +9787533451776 +9787533451790 +9787533451844 +9787533451851 +9787533451929 +9787533452469 +9787533452476 +9787533452612 +9787533452643 +9787533452711 +9787533452742 +9787533452759 +9787533452940 +9787533452971 +9787533453213 +9787533453480 +9787533453718 +9787533453879 +9787533454098 +9787533454128 +9787533454418 +9787533454425 +9787533454449 +9787533454838 +9787533454890 +9787533454982 +9787533455002 +9787533455309 +9787533455491 +9787533455514 +9787533455828 +9787533456085 +9787533456429 +9787533456825 +9787533456955 +9787533457136 +9787533457600 +9787533457617 +9787533457976 +9787533458492 +9787533458577 +9787533459338 +9787533459550 +9787533459567 +9787533459710 +9787533460112 +9787533460396 +9787533460556 +9787533460563 +9787533460600 +9787533460686 +9787533461256 +9787533461775 +9787533461782 +9787533461966 +9787533462024 +9787533462086 +9787533462147 +9787533462222 +9787533462307 +9787533462512 +9787533462932 +9787533463335 +9787533463489 +9787533463540 +9787533463700 +9787533463724 +9787533463878 +9787533463984 +9787533464011 +9787533464721 +9787533465087 +9787533465254 +9787533465612 +9787533465841 +9787533465865 +9787533466091 +9787533466206 +9787533466244 +9787533466572 +9787533467517 +9787533467524 +9787533467845 +9787533467937 +9787533468132 +9787533468477 +9787533469313 +9787533469412 +9787533469474 +9787533469504 +9787533469573 +9787533469863 +9787533469931 +9787533469986 +9787533470302 +9787533470524 +9787533470562 +9787533470579 +9787533470753 +9787533471101 +9787533471538 +9787533471613 +9787533471781 +9787533472160 +9787533472177 +9787533472412 +9787533472467 +9787533472603 +9787533473365 +9787533473433 +9787533473440 +9787533474119 +9787533474317 +9787533474355 +9787533474577 +9787533474607 +9787533474737 +9787533474782 +9787533474843 +9787533474928 +9787533475055 +9787533475185 +9787533475239 +9787533475260 +9787533475901 +9787533476410 +9787533476472 +9787533476656 +9787533476762 +9787533476878 +9787533477233 +9787533477387 +9787533477592 +9787533477646 +9787533477721 +9787533477738 +9787533477783 +9787533477844 +9787533478070 +9787533478339 +9787533478377 +9787533478445 +9787533478568 +9787533478698 +9787533478735 +9787533478803 +9787533480004 +9787533480394 +9787533480530 +9787533480639 +9787533480707 +9787533481032 +9787533481360 +9787533481476 +9787533481490 +9787533481599 +9787533481704 +9787533481872 +9787533481940 +9787533482190 +9787533482213 +9787533482244 +9787533482282 +9787533482381 +9787533482411 +9787533482435 +9787533482442 +9787533482480 +9787533482497 +9787533482640 +9787533482787 +9787533482817 +9787533482824 +9787533482916 +9787533483142 +9787533483265 +9787533483586 +9787533483593 +9787533483654 +9787533483838 +9787533483845 +9787533484088 +9787533484248 +9787533484255 +9787533484316 +9787533484330 +9787533484408 +9787533484835 +9787533484880 +9787533484910 +9787533485177 +9787533485207 +9787533485269 +9787533485276 +9787533485283 +9787533485337 +9787533485344 +9787533485467 +9787533485573 +9787533485726 +9787533485733 +9787533485757 +9787533485795 +9787533486136 +9787533486495 +9787533486891 +9787533486945 +9787533487140 +9787533487522 +9787533487553 +9787533487607 +9787533487614 +9787533487850 +9787533488031 +9787533488345 +9787533488352 +9787533489892 +9787533490485 +9787533491802 +9787533492007 +9787533492236 +9787533492342 +9787533492694 +9787533493363 +9787533493578 +9787533493691 +9787533493738 +9787533493905 +9787533494469 +9787533494537 +9787533494896 +9787533494933 +9787533495190 +9787533495312 +9787533496166 +9787533496371 +9787533496456 +9787533496531 +9787533496579 +9787533496708 +9787533496937 +9787533497286 +9787533497385 +9787533497798 +9787533497842 +9787533497958 +9787533497972 +9787533498016 +9787533498191 +9787533498351 +9787533498658 +9787533498979 +9787533499099 +9787533499204 +9787533499419 +9787533499433 +9787533499464 +9787533499501 +9787533499556 +9787533499846 +9787533499907 +9787533500146 +9787533500368 +9787533500504 +9787533500542 +9787533500627 +9787533500665 +9787533500726 +9787533500733 +9787533501167 +9787533501259 +9787533501358 +9787533501372 +9787533501440 +9787533501631 +9787533501761 +9787533501778 +9787533501884 +9787533502089 +9787533502201 +9787533502423 +9787533502584 +9787533502652 +9787533502799 +9787533502911 +9787533503048 +9787533503086 +9787533503161 +9787533503178 +9787533503222 +9787533503260 +9787533503642 +9787533503659 +9787533503963 +9787533504175 +9787533504236 +9787533504410 +9787533504519 +9787533504526 +9787533504625 +9787533504724 +9787533504854 +9787533505172 +9787533505202 +9787533505455 +9787533505714 +9787533505806 +9787533505974 +9787533506377 +9787533506537 +9787533506742 +9787533506926 +9787533507664 +9787533507695 +9787533507824 +9787533507923 +9787533508586 +9787533508609 +9787533508685 +9787533508753 +9787533508807 +9787533509019 +9787533509033 +9787533509170 +9787533509408 +9787533509514 +9787533509545 +9787533509811 +9787533509828 +9787533509842 +9787533510015 +9787533510091 +9787533510121 +9787533510251 +9787533510565 +9787533510619 +9787533510688 +9787533510978 +9787533511241 +9787533511265 +9787533511814 +9787533511876 +9787533512064 +9787533512316 +9787533512323 +9787533512750 +9787533512767 +9787533512842 +9787533512866 +9787533513092 +9787533513139 +9787533513160 +9787533514075 +9787533514136 +9787533514501 +9787533514549 +9787533514655 +9787533514884 +9787533514983 +9787533515096 +9787533515539 +9787533515553 +9787533515560 +9787533515614 +9787533515775 +9787533515850 +9787533515898 +9787533515973 +9787533516055 +9787533516123 +9787533516147 +9787533516345 +9787533516543 +9787533516765 +9787533517038 +9787533517175 +9787533517335 +9787533517397 +9787533517557 +9787533517571 +9787533517762 +9787533517915 +9787533517984 +9787533518196 +9787533518301 +9787533518400 +9787533518479 +9787533518509 +9787533518516 +9787533518806 +9787533518912 +9787533518967 +9787533519070 +9787533519087 +9787533519254 +9787533519292 +9787533519346 +9787533519513 +9787533519551 +9787533519582 +9787533520014 +9787533520137 +9787533520366 +9787533520373 +9787533520557 +9787533520663 +9787533520779 +9787533520793 +9787533520816 +9787533520861 +9787533520984 +9787533521301 +9787533521363 +9787533521554 +9787533521769 +9787533521936 +9787533521967 +9787533522230 +9787533522421 +9787533522599 +9787533522605 +9787533522759 +9787533522834 +9787533522926 +9787533523039 +9787533523091 +9787533523251 +9787533523497 +9787533523527 +9787533523633 +9787533523701 +9787533524616 +9787533524630 +9787533524654 +9787533524678 +9787533524746 +9787533524760 +9787533524913 +9787533524951 +9787533525248 +9787533525613 +9787533525651 +9787533525736 +9787533525743 +9787533525880 +9787533526375 +9787533526382 +9787533526412 +9787533526672 +9787533526863 +9787533526955 +9787533526979 +9787533526986 +9787533527020 +9787533527105 +9787533527204 +9787533527433 +9787533527686 +9787533527792 +9787533527990 +9787533528140 +9787533528164 +9787533528317 +9787533528386 +9787533528485 +9787533528546 +9787533528737 +9787533528898 +9787533528928 +9787533529154 +9787533529178 +9787533529185 +9787533529208 +9787533529215 +9787533529390 +9787533529574 +9787533529628 +9787533529635 +9787533529642 +9787533529710 +9787533530068 +9787533530099 +9787533530112 +9787533530259 +9787533530266 +9787533530358 +9787533530372 +9787533530389 +9787533530402 +9787533530464 +9787533530532 +9787533530686 +9787533530976 +9787533530983 +9787533531065 +9787533531263 +9787533531331 +9787533531409 +9787533531508 +9787533531515 +9787533531584 +9787533531676 +9787533531690 +9787533531751 +9787533531768 +9787533531928 +9787533531942 +9787533531966 +9787533532017 +9787533532260 +9787533532291 +9787533532307 +9787533532499 +9787533532918 +9787533532970 +9787533532987 +9787533532994 +9787533533090 +9787533533120 +9787533533311 +9787533533335 +9787533533366 +9787533533403 +9787533533465 +9787533533625 +9787533533953 +9787533534042 +9787533534172 +9787533534240 +9787533534363 +9787533534387 +9787533534622 +9787533534653 +9787533534677 +9787533534707 +9787533534899 +9787533535292 +9787533535391 +9787533535551 +9787533535568 +9787533535582 +9787533535629 +9787533535636 +9787533536244 +9787533536251 +9787533536329 +9787533536381 +9787533536534 +9787533536633 +9787533536855 +9787533537104 +9787533537197 +9787533537425 +9787533537470 +9787533537517 +9787533537548 +9787533537562 +9787533537616 +9787533537630 +9787533537760 +9787533537845 +9787533537890 +9787533537937 +9787533538064 +9787533538101 +9787533538194 +9787533538200 +9787533538408 +9787533538590 +9787533538606 +9787533538613 +9787533538651 +9787533538712 +9787533538729 +9787533538736 +9787533539030 +9787533539290 +9787533539344 +9787533539597 +9787533539740 +9787533539931 +9787533539962 +9787533539986 +9787533540029 +9787533540128 +9787533540142 +9787533540272 +9787533540289 +9787533540319 +9787533540487 +9787533540821 +9787533540982 +9787533540999 +9787533541019 +9787533541095 +9787533541163 +9787533541170 +9787533541217 +9787533541255 +9787533541569 +9787533541712 +9787533541774 +9787533541804 +9787533541811 +9787533541842 +9787533541958 +9787533542009 +9787533542023 +9787533542290 +9787533542405 +9787533542597 +9787533542634 +9787533542641 +9787533542689 +9787533542726 +9787533542764 +9787533542931 +9787533543099 +9787533543143 +9787533543181 +9787533543198 +9787533543235 +9787533543525 +9787533543549 +9787533543617 +9787533543631 +9787533543662 +9787533543761 +9787533543853 +9787533543860 +9787533543938 +9787533544072 +9787533544201 +9787533544348 +9787533544362 +9787533544430 +9787533544461 +9787533544577 +9787533544584 +9787533544591 +9787533544638 +9787533544898 +9787533545208 +9787533545215 +9787533545239 +9787533545277 +9787533545307 +9787533545314 +9787533545376 +9787533545659 +9787533545710 +9787533545789 +9787533545819 +9787533545857 +9787533545987 +9787533546076 +9787533546090 +9787533546182 +9787533546281 +9787533546519 +9787533546618 +9787533546625 +9787533546755 +9787533547011 +9787533547035 +9787533547059 +9787533547066 +9787533547103 +9787533547295 +9787533547424 +9787533547677 +9787533547691 +9787533547783 +9787533547875 +9787533547905 +9787533547912 +9787533547981 +9787533548063 +9787533548377 +9787533548414 +9787533548544 +9787533548629 +9787533548650 +9787533548698 +9787533548728 +9787533548735 +9787533548971 +9787533549053 +9787533549077 +9787533549121 +9787533549275 +9787533549336 +9787533549602 +9787533549992 +9787533550011 +9787533550073 +9787533550165 +9787533550172 +9787533550196 +9787533550318 +9787533550325 +9787533550561 +9787533550776 +9787533550783 +9787533550790 +9787533550806 +9787533551032 +9787533551322 +9787533551346 +9787533551445 +9787533551568 +9787533551667 +9787533551674 +9787533551735 +9787533551766 +9787533551780 +9787533552862 +9787533553555 +9787533553562 +9787533554064 +9787533554125 +9787533554309 +9787533554460 +9787533554552 +9787533554651 +9787533554842 +9787533555238 +9787533555306 +9787533555436 +9787533555443 +9787533555740 +9787533555757 +9787533556099 +9787533556112 +9787533556136 +9787533556143 +9787533556587 +9787533556822 +9787533557225 +9787533557232 +9787533557737 +9787533557751 +9787533557829 +9787533557928 +9787533558000 +9787533558048 +9787533558260 +9787533558505 +9787533558642 +9787533558765 +9787533558901 +9787533559021 +9787533559335 +9787533559397 +9787533559403 +9787533559502 +9787533559595 +9787533559724 +9787533560355 +9787533560843 +9787533560911 +9787533560959 +9787533561574 +9787533561819 +9787533562199 +9787533562274 +9787533562601 +9787533562632 +9787533563158 +9787533563165 +9787533563172 +9787533563264 +9787533563332 +9787533563370 +9787533563899 +9787533563912 +9787533563929 +9787533563967 +9787533564131 +9787533564162 +9787533564322 +9787533564544 +9787533564636 +9787533564667 +9787533564841 +9787533564872 +9787533565039 +9787533565060 +9787533565114 +9787533565121 +9787533565220 +9787533565282 +9787533565404 +9787533565435 +9787533565473 +9787533565633 +9787533565732 +9787533565770 +9787533565855 +9787533565886 +9787533566371 +9787533566548 +9787533566999 +9787533567002 +9787533567606 +9787533567675 +9787533567903 +9787533567910 +9787533567996 +9787533568009 +9787533568269 +9787533568382 +9787533568450 +9787533568504 +9787533568634 +9787533568658 +9787533568757 +9787533569495 +9787533569587 +9787533569617 +9787533569815 +9787533570170 +9787533570316 +9787533570613 +9787533570620 +9787533570699 +9787533570859 +9787533570972 +9787533571009 +9787533571030 +9787533571047 +9787533571184 +9787533571306 +9787533571559 +9787533572358 +9787533572457 +9787533572464 +9787533572501 +9787533573409 +9787533573508 +9787533573751 +9787533600761 +9787533601027 +9787533601034 +9787533601089 +9787533601164 +9787533601522 +9787533603366 +9787533603632 +9787533603915 +9787533606183 +9787533606947 +9787533606954 +9787533607128 +9787533607289 +9787533607296 +9787533607500 +9787533607678 +9787533607920 +9787533608705 +9787533609313 +9787533609382 +9787533609450 +9787533609887 +9787533611491 +9787533611590 +9787533614188 +9787533615376 +9787533615727 +9787533616106 +9787533616311 +9787533617295 +9787533617509 +9787533617912 +9787533618001 +9787533618667 +9787533618896 +9787533619336 +9787533619350 +9787533619473 +9787533619527 +9787533620660 +9787533621070 +9787533621223 +9787533621254 +9787533621261 +9787533621636 +9787533621933 +9787533622084 +9787533622336 +9787533622589 +9787533622848 +9787533622855 +9787533622930 +9787533623166 +9787533623517 +9787533623630 +9787533623876 +9787533624835 +9787533626099 +9787533626167 +9787533626549 +9787533626730 +9787533626754 +9787533626761 +9787533627010 +9787533627560 +9787533628345 +9787533628758 +9787533629632 +9787533629656 +9787533630560 +9787533630843 +9787533631086 +9787533631505 +9787533633738 +9787533634636 +9787533636043 +9787533636203 +9787533636623 +9787533636708 +9787533637200 +9787533637217 +9787533637231 +9787533637699 +9787533637750 +9787533637828 +9787533637842 +9787533639518 +9787533639525 +9787533639808 +9787533639839 +9787533639891 +9787533641689 +9787533642730 +9787533643287 +9787533643386 +9787533644390 +9787533644468 +9787533644475 +9787533644550 +9787533645021 +9787533646400 +9787533646417 +9787533646745 +9787533646752 +9787533646820 +9787533647223 +9787533647513 +9787533647650 +9787533647674 +9787533648268 +9787533648336 +9787533648442 +9787533648749 +9787533649302 +9787533649470 +9787533649661 +9787533651145 +9787533651282 +9787533651367 +9787533651466 +9787533651633 +9787533651916 +9787533653149 +9787533653941 +9787533654238 +9787533654580 +9787533654702 +9787533655785 +9787533655792 +9787533655839 +9787533655952 +9787533656140 +9787533656188 +9787533656478 +9787533656492 +9787533656621 +9787533656720 +9787533657369 +9787533658168 +9787533658410 +9787533658854 +9787533658946 +9787533661427 +9787533661434 +9787533661588 +9787533661595 +9787533661694 +9787533661700 +9787533661861 +9787533661878 +9787533661908 +9787533662318 +9787533662783 +9787533662882 +9787533663049 +9787533663230 +9787533663599 +9787533664091 +9787533664152 +9787533664183 +9787533664992 +9787533665005 +9787533665074 +9787533665296 +9787533665302 +9787533665319 +9787533665326 +9787533666408 +9787533667030 +9787533667856 +9787533669393 +9787533669416 +9787533669423 +9787533669577 +9787533669645 +9787533669805 +9787533669980 +9787533672874 +9787533672935 +9787533674014 +9787533674052 +9787533674489 +9787533675363 +9787533675554 +9787533675585 +9787533675608 +9787533675745 +9787533675813 +9787533675929 +9787533676414 +9787533677473 +9787533677817 +9787533678159 +9787533678173 +9787533678241 +9787533678258 +9787533678326 +9787533678395 +9787533678807 +9787533678937 +9787533679019 +9787533679026 +9787533679323 +9787533679767 +9787533680084 +9787533680091 +9787533680107 +9787533680145 +9787533681050 +9787533681067 +9787533681074 +9787533681234 +9787533681241 +9787533681906 +9787533681937 +9787533682088 +9787533682354 +9787533682668 +9787533682675 +9787533682712 +9787533682736 +9787533684242 +9787533684259 +9787533684266 +9787533684273 +9787533684310 +9787533684457 +9787533684471 +9787533684891 +9787533685898 +9787533686604 +9787533686611 +9787533686635 +9787533686673 +9787533686680 +9787533686697 +9787533687113 +9787533687137 +9787533687229 +9787533687243 +9787533687359 +9787533687373 +9787533687427 +9787533687441 +9787533687694 +9787533687724 +9787533687748 +9787533688066 +9787533688134 +9787533688370 +9787533688424 +9787533688547 +9787533688660 +9787533689001 +9787533689025 +9787533689049 +9787533689070 +9787533689346 +9787533689537 +9787533689919 +9787533690113 +9787533690137 +9787533690151 +9787533690175 +9787533690182 +9787533690663 +9787533690823 +9787533691707 +9787533692773 +9787533692940 +9787533693206 +9787533693978 +9787533694012 +9787533694647 +9787533695248 +9787533695286 +9787533695408 +9787533695873 +9787533696269 +9787533696757 +9787533697624 +9787533698249 +9787533698720 +9787533698768 +9787533699239 +9787533699260 +9787533699567 +9787533699789 +9787533699949 +9787533700010 +9787533700027 +9787533700034 +9787533700041 +9787533700072 +9787533700089 +9787533700126 +9787533700348 +9787533700478 +9787533700560 +9787533700775 +9787533700829 +9787533700836 +9787533701024 +9787533701031 +9787533701291 +9787533701451 +9787533701529 +9787533702243 +9787533702724 +9787533703042 +9787533703134 +9787533703158 +9787533703219 +9787533703486 +9787533703592 +9787533704070 +9787533704186 +9787533705626 +9787533705909 +9787533705947 +9787533705985 +9787533705992 +9787533706791 +9787533706821 +9787533706876 +9787533706890 +9787533706937 +9787533706975 +9787533707224 +9787533707446 +9787533707538 +9787533707576 +9787533707811 +9787533708047 +9787533708115 +9787533708160 +9787533708320 +9787533708450 +9787533708511 +9787533708542 +9787533708627 +9787533708634 +9787533710064 +9787533710347 +9787533710361 +9787533710538 +9787533710545 +9787533710651 +9787533710934 +9787533710941 +9787533711108 +9787533711245 +9787533711313 +9787533711375 +9787533711504 +9787533711535 +9787533711597 +9787533712099 +9787533712112 +9787533712167 +9787533712389 +9787533713195 +9787533713201 +9787533713331 +9787533713539 +9787533713591 +9787533714048 +9787533714154 +9787533714420 +9787533714574 +9787533714680 +9787533714802 +9787533714833 +9787533714888 +9787533714932 +9787533714970 +9787533715458 +9787533715601 +9787533715762 +9787533715885 +9787533716547 +9787533716882 +9787533717582 +9787533717827 +9787533717841 +9787533718015 +9787533718114 +9787533718121 +9787533718299 +9787533718749 +9787533718763 +9787533718879 +9787533719371 +9787533719531 +9787533719661 +9787533719975 +9787533720018 +9787533720025 +9787533720483 +9787533720490 +9787533720506 +9787533720520 +9787533720728 +9787533720735 +9787533721541 +9787533722739 +9787533722937 +9787533723903 +9787533724771 +9787533724849 +9787533725068 +9787533725075 +9787533725181 +9787533725327 +9787533725921 +9787533726478 +9787533726553 +9787533726713 +9787533726843 +9787533728113 +9787533728137 +9787533728687 +9787533728724 +9787533728793 +9787533728885 +9787533728991 +9787533729639 +9787533729660 +9787533729684 +9787533729851 +9787533730499 +9787533730574 +9787533730581 +9787533730925 +9787533731625 +9787533731755 +9787533731854 +9787533732097 +9787533732103 +9787533732172 +9787533732257 +9787533732417 +9787533732684 +9787533732981 +9787533733520 +9787533733568 +9787533733766 +9787533733797 +9787533733803 +9787533733827 +9787533733834 +9787533733858 +9787533733957 +9787533734015 +9787533734299 +9787533734466 +9787533734565 +9787533734657 +9787533734718 +9787533735166 +9787533735395 +9787533735517 +9787533735531 +9787533735661 +9787533736248 +9787533736286 +9787533736309 +9787533736323 +9787533736347 +9787533736439 +9787533736477 +9787533736897 +9787533736989 +9787533737078 +9787533737085 +9787533737115 +9787533737481 +9787533737535 +9787533737542 +9787533737665 +9787533737733 +9787533737818 +9787533737948 +9787533737962 +9787533739058 +9787533739072 +9787533739089 +9787533739195 +9787533740405 +9787533740542 +9787533740801 +9787533741143 +9787533741341 +9787533741563 +9787533741969 +9787533742324 +9787533742638 +9787533742669 +9787533742720 +9787533742836 +9787533743314 +9787533743741 +9787533743994 +9787533744007 +9787533745097 +9787533745103 +9787533745110 +9787533745141 +9787533745530 +9787533747053 +9787533747381 +9787533747886 +9787533748104 +9787533748395 +9787533748494 +9787533748654 +9787533749200 +9787533749682 +9787533749699 +9787533750886 +9787533750985 +9787533751067 +9787533751470 +9787533751777 +9787533752378 +9787533752866 +9787533752873 +9787533752880 +9787533753207 +9787533753221 +9787533753306 +9787533753351 +9787533753610 +9787533753689 +9787533753887 +9787533753986 +9787533754167 +9787533754389 +9787533754457 +9787533754891 +9787533755263 +9787533756376 +9787533757663 +9787533757694 +9787533757717 +9787533758455 +9787533758684 +9787533759391 +9787533759469 +9787533759865 +9787533759995 +9787533760205 +9787533760311 +9787533760595 +9787533761431 +9787533761455 +9787533761462 +9787533761752 +9787533761868 +9787533762094 +9787533762100 +9787533762117 +9787533763480 +9787533763503 +9787533763862 +9787533764036 +9787533764302 +9787533764401 +9787533764777 +9787533764944 +9787533765095 +9787533765101 +9787533765118 +9787533765132 +9787533765323 +9787533765330 +9787533765392 +9787533766122 +9787533766313 +9787533766665 +9787533766740 +9787533766757 +9787533766771 +9787533766832 +9787533767150 +9787533767358 +9787533767839 +9787533768263 +9787533768652 +9787533768720 +9787533768973 +9787533769840 +9787533769857 +9787533769918 +9787533770136 +9787533770426 +9787533770723 +9787533770754 +9787533770860 +9787533771072 +9787533771300 +9787533771546 +9787533771898 +9787533771980 +9787533772222 +9787533772239 +9787533772628 +9787533772970 +9787533773120 +9787533773380 +9787533773465 +9787533773700 +9787533774417 +9787533774479 +9787533774486 +9787533774493 +9787533774615 +9787533774646 +9787533774783 +9787533774806 +9787533774813 +9787533775148 +9787533775346 +9787533775490 +9787533775520 +9787533775681 +9787533775698 +9787533775872 +9787533775889 +9787533776732 +9787533776909 +9787533777258 +9787533777388 +9787533777401 +9787533777418 +9787533777425 +9787533777432 +9787533777517 +9787533777555 +9787533777876 +9787533777906 +9787533777982 +9787533778194 +9787533778293 +9787533778309 +9787533778316 +9787533778323 +9787533778330 +9787533778347 +9787533778538 +9787533778620 +9787533778637 +9787533778644 +9787533778699 +9787533779009 +9787533779023 +9787533779030 +9787533779221 +9787533779382 +9787533779443 +9787533779504 +9787533779801 +9787533780418 +9787533780449 +9787533780951 +9787533781460 +9787533782115 +9787533782276 +9787533782320 +9787533782467 +9787533783396 +9787533783433 +9787533784706 +9787533784980 +9787533785291 +9787533785840 +9787533785956 +9787533786045 +9787533786052 +9787533786205 +9787533786816 +9787533786854 +9787533787035 +9787533787264 +9787533787271 +9787533787424 +9787533787554 +9787533788377 +9787533788636 +9787533788728 +9787533789091 +9787533789152 +9787533789329 +9787533790042 +9787533791483 +9787533792077 +9787533800598 +9787533800734 +9787533801069 +9787533801199 +9787533801229 +9787533801816 +9787533801854 +9787533801861 +9787533802196 +9787533802493 +9787533803896 +9787533804435 +9787533804459 +9787533804879 +9787533805531 +9787533806279 +9787533806392 +9787533806422 +9787533806958 +9787533807092 +9787533808167 +9787533809560 +9787533809584 +9787533809690 +9787533811150 +9787533811440 +9787533816957 +9787533817015 +9787533817961 +9787533818395 +9787533818401 +9787533818746 +9787533819484 +9787533820589 +9787533821630 +9787533821678 +9787533821715 +9787533821753 +9787533822811 +9787533823405 +9787533823412 +9787533823436 +9787533823597 +9787533825003 +9787533825300 +9787533825379 +9787533825393 +9787533825409 +9787533825836 +9787533826680 +9787533827458 +9787533827953 +9787533828059 +9787533828141 +9787533828424 +9787533829179 +9787533829216 +9787533829643 +9787533829865 +9787533830656 +9787533830687 +9787533830960 +9787533831158 +9787533831578 +9787533831868 +9787533831974 +9787533832094 +9787533832278 +9787533832544 +9787533832582 +9787533832810 +9787533835354 +9787533836498 +9787533837372 +9787533837822 +9787533839314 +9787533839642 +9787533839772 +9787533840983 +9787533842833 +9787533843168 +9787533843243 +9787533844202 +9787533845087 +9787533845728 +9787533845735 +9787533845773 +9787533846107 +9787533846145 +9787533846220 +9787533846411 +9787533846428 +9787533846480 +9787533846510 +9787533848347 +9787533848354 +9787533849535 +9787533849542 +9787533849573 +9787533849627 +9787533852191 +9787533854874 +9787533856366 +9787533861032 +9787533863548 +9787533865696 +9787533865948 +9787533866082 +9787533866129 +9787533866952 +9787533867034 +9787533867751 +9787533867805 +9787533868673 +9787533868680 +9787533868741 +9787533870911 +9787533872977 +9787533873141 +9787533873400 +9787533874285 +9787533874315 +9787533874322 +9787533874339 +9787533874575 +9787533874599 +9787533874605 +9787533874629 +9787533875084 +9787533875602 +9787533877057 +9787533878290 +9787533878986 +9787533879112 +9787533879327 +9787533879396 +9787533879815 +9787533880293 +9787533881726 +9787533881948 +9787533882129 +9787533882266 +9787533882297 +9787533882525 +9787533882761 +9787533883508 +9787533883706 +9787533883843 +9787533884321 +9787533884413 +9787533884437 +9787533884703 +9787533884796 +9787533885205 +9787533885236 +9787533885441 +9787533887155 +9787533887582 +9787533887810 +9787533888794 +9787533889470 +9787533889937 +9787533889999 +9787533891046 +9787533891312 +9787533891510 +9787533892036 +9787533892289 +9787533892579 +9787533892586 +9787533893088 +9787533893200 +9787533893316 +9787533893378 +9787533893453 +9787533893613 +9787533894115 +9787533894184 +9787533894276 +9787533894290 +9787533894306 +9787533894979 +9787533896386 +9787533896430 +9787533896522 +9787533896539 +9787533896553 +9787533897048 +9787533897093 +9787533897185 +9787533897444 +9787533897833 +9787533897857 +9787533897871 +9787533898380 +9787533898434 +9787533900045 +9787533900090 +9787533900205 +9787533900212 +9787533900250 +9787533900373 +9787533900441 +9787533900465 +9787533900533 +9787533900588 +9787533900601 +9787533900670 +9787533900694 +9787533900717 +9787533900748 +9787533900755 +9787533900779 +9787533900830 +9787533900847 +9787533900946 +9787533901004 +9787533901080 +9787533901189 +9787533901219 +9787533901271 +9787533901356 +9787533901431 +9787533901622 +9787533901752 +9787533901769 +9787533901844 +9787533901899 +9787533901967 +9787533902100 +9787533902117 +9787533902346 +9787533902353 +9787533902407 +9787533902582 +9787533902636 +9787533902667 +9787533902728 +9787533902759 +9787533903145 +9787533903152 +9787533903268 +9787533903305 +9787533903312 +9787533903329 +9787533903565 +9787533903589 +9787533903763 +9787533903770 +9787533903855 +9787533903992 +9787533904173 +9787533904203 +9787533904227 +9787533904234 +9787533904456 +9787533904463 +9787533904579 +9787533904630 +9787533904678 +9787533904746 +9787533904760 +9787533904807 +9787533904814 +9787533904821 +9787533904852 +9787533904876 +9787533905002 +9787533905019 +9787533905064 +9787533905118 +9787533905149 +9787533905231 +9787533905255 +9787533905262 +9787533905316 +9787533905330 +9787533905378 +9787533905941 +9787533905958 +9787533906054 +9787533906108 +9787533906221 +9787533906238 +9787533906276 +9787533906290 +9787533906306 +9787533906337 +9787533906535 +9787533906597 +9787533906764 +9787533906795 +9787533906863 +9787533906887 +9787533906894 +9787533907006 +9787533907174 +9787533907235 +9787533907242 +9787533907259 +9787533907280 +9787533907327 +9787533907334 +9787533907365 +9787533907396 +9787533907457 +9787533907464 +9787533907532 +9787533907587 +9787533907617 +9787533907648 +9787533907679 +9787533907686 +9787533907693 +9787533907716 +9787533907723 +9787533907761 +9787533907846 +9787533907891 +9787533907907 +9787533907952 +9787533907969 +9787533907976 +9787533907983 +9787533907990 +9787533908034 +9787533908065 +9787533908119 +9787533908126 +9787533908195 +9787533908218 +9787533908249 +9787533908454 +9787533908478 +9787533908485 +9787533908522 +9787533908546 +9787533908607 +9787533908638 +9787533908737 +9787533908805 +9787533908867 +9787533908904 +9787533908911 +9787533908928 +9787533908942 +9787533908966 +9787533908980 +9787533909000 +9787533909017 +9787533909024 +9787533909031 +9787533909079 +9787533909123 +9787533909130 +9787533909192 +9787533909253 +9787533909291 +9787533909338 +9787533909352 +9787533909468 +9787533909475 +9787533909512 +9787533909529 +9787533909581 +9787533909598 +9787533909673 +9787533909697 +9787533909703 +9787533909840 +9787533909871 +9787533909895 +9787533909987 +9787533910143 +9787533910204 +9787533910242 +9787533910303 +9787533910372 +9787533910525 +9787533910556 +9787533910624 +9787533910761 +9787533910785 +9787533910792 +9787533910808 +9787533910853 +9787533910914 +9787533910983 +9787533910990 +9787533911010 +9787533911119 +9787533911157 +9787533911188 +9787533911201 +9787533911270 +9787533911317 +9787533911379 +9787533911423 +9787533911768 +9787533911782 +9787533911799 +9787533911812 +9787533911829 +9787533911836 +9787533912017 +9787533912024 +9787533912048 +9787533912062 +9787533912079 +9787533912086 +9787533912093 +9787533912116 +9787533912246 +9787533912390 +9787533912406 +9787533912468 +9787533912482 +9787533912642 +9787533912703 +9787533912741 +9787533912758 +9787533912802 +9787533912826 +9787533913014 +9787533913113 +9787533913212 +9787533913250 +9787533913328 +9787533913373 +9787533913670 +9787533913830 +9787533913885 +9787533913946 +9787533914004 +9787533914110 +9787533914127 +9787533914134 +9787533914387 +9787533914417 +9787533914424 +9787533914646 +9787533914981 +9787533915124 +9787533915162 +9787533915582 +9787533915636 +9787533915858 +9787533915933 +9787533916152 +9787533916312 +9787533916619 +9787533916640 +9787533916749 +9787533916879 +9787533917012 +9787533917135 +9787533917166 +9787533917180 +9787533917258 +9787533917272 +9787533917487 +9787533917678 +9787533917814 +9787533918354 +9787533918484 +9787533918859 +9787533919641 +9787533919719 +9787533919726 +9787533919832 +9787533920388 +9787533920463 +9787533920555 +9787533920630 +9787533920982 +9787533921347 +9787533921392 +9787533921415 +9787533921538 +9787533921569 +9787533921897 +9787533922559 +9787533922634 +9787533922641 +9787533922948 +9787533922993 +9787533923280 +9787533923686 +9787533923693 +9787533923709 +9787533923860 +9787533923952 +9787533924447 +9787533924515 +9787533924928 +9787533924966 +9787533925154 +9787533925215 +9787533925420 +9787533925901 +9787533925970 +9787533926540 +9787533926915 +9787533927066 +9787533927196 +9787533927233 +9787533927363 +9787533927592 +9787533928506 +9787533928551 +9787533928698 +9787533929114 +9787533929121 +9787533929473 +9787533929725 +9787533930615 +9787533930714 +9787533931100 +9787533931261 +9787533931582 +9787533931629 +9787533931643 +9787533932206 +9787533932794 +9787533933241 +9787533933258 +9787533933340 +9787533933609 +9787533933777 +9787533934392 +9787533934545 +9787533934927 +9787533935085 +9787533935139 +9787533935276 +9787533935443 +9787533935498 +9787533935771 +9787533935900 +9787533936426 +9787533936570 +9787533936600 +9787533936679 +9787533936716 +9787533936754 +9787533937041 +9787533937188 +9787533937218 +9787533937423 +9787533937607 +9787533937836 +9787533937973 +9787533938130 +9787533938260 +9787533939984 +9787533939991 +9787533940010 +9787533940300 +9787533940539 +9787533940713 +9787533940751 +9787533941093 +9787533941567 +9787533941697 +9787533942076 +9787533942441 +9787533942892 +9787533943608 +9787533943639 +9787533944391 +9787533944803 +9787533945282 +9787533945305 +9787533947606 +9787533947958 +9787533947989 +9787533948368 +9787533948412 +9787533949037 +9787533949570 +9787533953225 +9787533955267 +9787533955304 +9787533956998 +9787533957124 +9787533957209 +9787533957544 +9787533958060 +9787533958763 +9787533958886 +9787533959548 +9787533960230 +9787533961633 +9787533961978 +9787533962791 +9787533962876 +9787533964047 +9787533964245 +9787533964580 +9787533964610 +9787533964849 +9787533964955 +9787533964979 +9787533965136 +9787533966157 +9787533966195 +9787533966577 +9787533966744 +9787533966850 +9787533967840 +9787533967987 +9787533968410 +9787533969905 +9787533970789 +9787533971052 +9787533971106 +9787533971120 +9787533971144 +9787533971342 +9787533971557 +9787533971892 +9787533972226 +9787533972295 +9787533972356 +9787533972387 +9787533972448 +9787533972479 +9787533972493 +9787533972509 +9787533972516 +9787533972530 +9787533972554 +9787533972578 +9787533972585 +9787533972592 +9787533972998 +9787533973216 +9787533973230 +9787533973391 +9787533973414 +9787533973681 +9787533973803 +9787533973841 +9787533973933 +9787533974022 +9787533974084 +9787533974107 +9787533974114 +9787533974145 +9787533974244 +9787533974275 +9787533974305 +9787533974503 +9787533974640 +9787533974824 +9787533974961 +9787533974992 +9787533975029 +9787533975319 +9787533975357 +9787533975401 +9787533975449 +9787533975494 +9787533975500 +9787533975517 +9787533975524 +9787533975555 +9787533975715 +9787533975777 +9787533975807 +9787533975814 +9787533975821 +9787533975869 +9787533975944 +9787533976071 +9787533976293 +9787533976385 +9787533976392 +9787533976408 +9787533976514 +9787533976569 +9787533976576 +9787533976583 +9787533976606 +9787533976668 +9787533976699 +9787533976705 +9787533976903 +9787533976910 +9787533976934 +9787533977023 +9787533977078 +9787533977153 +9787533977245 +9787533977306 +9787533977313 +9787533977337 +9787533977375 +9787533977412 +9787533977504 +9787533977610 +9787533977627 +9787533977733 +9787533978037 +9787533978204 +9787533978280 +9787533978389 +9787533978624 +9787533978631 +9787533978648 +9787533978730 +9787533978754 +9787533978785 +9787533978860 +9787533979027 +9787533979119 +9787533979140 +9787533979157 +9787533979171 +9787533979300 +9787533979331 +9787533979348 +9787533979607 +9787533979621 +9787533979782 +9787533979829 +9787533979959 +9787534000010 +9787534000027 +9787534000041 +9787534000058 +9787534000065 +9787534000072 +9787534000089 +9787534000270 +9787534000379 +9787534000690 +9787534000706 +9787534000713 +9787534001024 +9787534001031 +9787534001048 +9787534001055 +9787534002335 +9787534002359 +9787534002519 +9787534002533 +9787534002540 +9787534002557 +9787534002564 +9787534002571 +9787534002694 +9787534002700 +9787534002915 +9787534002922 +9787534003035 +9787534003196 +9787534003325 +9787534003356 +9787534003394 +9787534003509 +9787534003653 +9787534003677 +9787534003684 +9787534003691 +9787534003707 +9787534003714 +9787534003721 +9787534003738 +9787534003776 +9787534004018 +9787534004025 +9787534004049 +9787534004148 +9787534004186 +9787534004216 +9787534004315 +9787534004339 +9787534004360 +9787534004384 +9787534004452 +9787534005015 +9787534005183 +9787534005589 +9787534005664 +9787534006074 +9787534006258 +9787534006326 +9787534006401 +9787534006524 +9787534006708 +9787534006722 +9787534006746 +9787534006753 +9787534006906 +9787534007163 +9787534007170 +9787534007224 +9787534007330 +9787534007354 +9787534007392 +9787534007422 +9787534007460 +9787534007484 +9787534007514 +9787534007583 +9787534007613 +9787534008092 +9787534008276 +9787534008290 +9787534008559 +9787534008665 +9787534008764 +9787534008870 +9787534009006 +9787534009082 +9787534009174 +9787534009341 +9787534009631 +9787534009655 +9787534009716 +9787534009945 +9787534009952 +9787534009969 +9787534010071 +9787534010217 +9787534010248 +9787534010286 +9787534010422 +9787534010507 +9787534010521 +9787534010552 +9787534010576 +9787534010835 +9787534010965 +9787534011016 +9787534011092 +9787534011122 +9787534011245 +9787534011252 +9787534011382 +9787534011405 +9787534011535 +9787534011542 +9787534011580 +9787534011610 +9787534011634 +9787534011764 +9787534011788 +9787534012099 +9787534012150 +9787534012204 +9787534012273 +9787534012297 +9787534012372 +9787534012471 +9787534012587 +9787534012600 +9787534012853 +9787534012945 +9787534012952 +9787534013089 +9787534013096 +9787534013126 +9787534013133 +9787534013140 +9787534013171 +9787534013188 +9787534013294 +9787534013317 +9787534013355 +9787534013386 +9787534013423 +9787534013522 +9787534013539 +9787534013607 +9787534013614 +9787534014222 +9787534014987 +9787534015083 +9787534015137 +9787534015212 +9787534015250 +9787534015281 +9787534015410 +9787534015465 +9787534015489 +9787534015496 +9787534015533 +9787534015571 +9787534015595 +9787534015601 +9787534015885 +9787534016837 +9787534017018 +9787534017032 +9787534017049 +9787534017230 +9787534017261 +9787534017308 +9787534017551 +9787534017612 +9787534017728 +9787534017841 +9787534018046 +9787534018152 +9787534018305 +9787534018459 +9787534018800 +9787534018916 +9787534018923 +9787534018961 +9787534019142 +9787534019401 +9787534019418 +9787534019449 +9787534019456 +9787534019500 +9787534019517 +9787534019753 +9787534019937 +9787534020551 +9787534020773 +9787534021336 +9787534021473 +9787534021510 +9787534021534 +9787534022210 +9787534022425 +9787534022555 +9787534023507 +9787534023729 +9787534024221 +9787534024269 +9787534024610 +9787534024757 +9787534024900 +9787534024917 +9787534025037 +9787534025303 +9787534025464 +9787534025693 +9787534025839 +9787534026423 +9787534027048 +9787534027055 +9787534027093 +9787534027321 +9787534027505 +9787534027840 +9787534028335 +9787534028465 +9787534029097 +9787534029530 +9787534029684 +9787534029899 +9787534030147 +9787534030260 +9787534030550 +9787534030680 +9787534031090 +9787534031212 +9787534031533 +9787534031564 +9787534031571 +9787534031588 +9787534031601 +9787534031748 +9787534031960 +9787534032158 +9787534032172 +9787534032387 +9787534032707 +9787534032738 +9787534032752 +9787534032783 +9787534032981 +9787534033018 +9787534033087 +9787534033469 +9787534033926 +9787534034398 +9787534034503 +9787534034602 +9787534035043 +9787534035111 +9787534035135 +9787534035159 +9787534035258 +9787534035760 +9787534036064 +9787534036088 +9787534036101 +9787534036217 +9787534036279 +9787534036361 +9787534036408 +9787534037108 +9787534037146 +9787534037177 +9787534037184 +9787534037214 +9787534037221 +9787534038129 +9787534038181 +9787534038327 +9787534038365 +9787534038501 +9787534038914 +9787534039263 +9787534039409 +9787534039607 +9787534039614 +9787534039676 +9787534039997 +9787534040023 +9787534040078 +9787534040283 +9787534040924 +9787534040948 +9787534041020 +9787534041174 +9787534042157 +9787534042188 +9787534042461 +9787534042720 +9787534042737 +9787534042843 +9787534043444 +9787534043604 +9787534043697 +9787534043796 +9787534044052 +9787534044076 +9787534044083 +9787534044502 +9787534044649 +9787534044786 +9787534045783 +9787534046056 +9787534046070 +9787534046087 +9787534046315 +9787534047084 +9787534047459 +9787534047930 +9787534048470 +9787534048579 +9787534048616 +9787534048678 +9787534048753 +9787534048777 +9787534049316 +9787534049323 +9787534049354 +9787534049361 +9787534050275 +9787534050305 +9787534050381 +9787534050442 +9787534050688 +9787534050695 +9787534050701 +9787534050718 +9787534050800 +9787534050954 +9787534051043 +9787534051326 +9787534051357 +9787534051401 +9787534051814 +9787534053450 +9787534053474 +9787534053498 +9787534053535 +9787534053955 +9787534054013 +9787534054198 +9787534054266 +9787534055089 +9787534055492 +9787534055560 +9787534055713 +9787534056031 +9787534056345 +9787534056772 +9787534057250 +9787534057359 +9787534057397 +9787534057625 +9787534057779 +9787534057915 +9787534058073 +9787534058080 +9787534058301 +9787534058547 +9787534059162 +9787534059209 +9787534059285 +9787534059315 +9787534059360 +9787534059438 +9787534059452 +9787534059469 +9787534059711 +9787534059773 +9787534059803 +9787534059810 +9787534059834 +9787534059865 +9787534059872 +9787534059889 +9787534059926 +9787534059933 +9787534060052 +9787534060274 +9787534060298 +9787534060441 +9787534060755 +9787534060809 +9787534060892 +9787534060922 +9787534061080 +9787534061097 +9787534061189 +9787534061226 +9787534061257 +9787534061448 +9787534061493 +9787534061653 +9787534062223 +9787534062230 +9787534062254 +9787534062346 +9787534062353 +9787534062483 +9787534062650 +9787534062667 +9787534062674 +9787534062797 +9787534062872 +9787534062889 +9787534062896 +9787534062902 +9787534062919 +9787534062926 +9787534062933 +9787534063015 +9787534063022 +9787534063077 +9787534063695 +9787534063732 +9787534063770 +9787534063831 +9787534063855 +9787534064111 +9787534064142 +9787534064159 +9787534064401 +9787534064579 +9787534064869 +9787534064999 +9787534066016 +9787534066108 +9787534066474 +9787534066511 +9787534066658 +9787534067495 +9787534067600 +9787534067617 +9787534067631 +9787534067815 +9787534067846 +9787534067914 +9787534068287 +9787534068546 +9787534068560 +9787534068768 +9787534069048 +9787534069499 +9787534069505 +9787534069659 +9787534069666 +9787534069925 +9787534070112 +9787534070136 +9787534070143 +9787534070150 +9787534070167 +9787534070204 +9787534070228 +9787534070266 +9787534070310 +9787534070426 +9787534070549 +9787534070587 +9787534070754 +9787534070808 +9787534070884 +9787534070907 +9787534071003 +9787534071010 +9787534071034 +9787534071140 +9787534071539 +9787534071959 +9787534071980 +9787534072031 +9787534072048 +9787534072055 +9787534072260 +9787534072277 +9787534072284 +9787534072321 +9787534072338 +9787534072345 +9787534072369 +9787534072376 +9787534072468 +9787534072475 +9787534072536 +9787534072581 +9787534072598 +9787534072635 +9787534072697 +9787534072826 +9787534072840 +9787534072895 +9787534073540 +9787534073656 +9787534073663 +9787534073694 +9787534073748 +9787534073793 +9787534073861 +9787534073915 +9787534073939 +9787534074028 +9787534074073 +9787534074141 +9787534074868 +9787534074882 +9787534074967 +9787534074974 +9787534075025 +9787534075049 +9787534075094 +9787534075148 +9787534075179 +9787534075278 +9787534075339 +9787534075360 +9787534075391 +9787534075438 +9787534075575 +9787534075605 +9787534075629 +9787534075711 +9787534075735 +9787534075865 +9787534075964 +9787534076008 +9787534076015 +9787534076053 +9787534076190 +9787534076237 +9787534076299 +9787534076336 +9787534076343 +9787534076428 +9787534076459 +9787534076565 +9787534076572 +9787534076589 +9787534076664 +9787534076671 +9787534076701 +9787534076886 +9787534077128 +9787534077487 +9787534077692 +9787534077753 +9787534077869 +9787534077913 +9787534077937 +9787534077968 +9787534078026 +9787534078040 +9787534078095 +9787534078163 +9787534078248 +9787534078255 +9787534078279 +9787534078460 +9787534078514 +9787534078545 +9787534078583 +9787534078644 +9787534078675 +9787534078811 +9787534079016 +9787534079290 +9787534079320 +9787534079368 +9787534079375 +9787534079436 +9787534079559 +9787534079573 +9787534079658 +9787534079818 +9787534079979 +9787534079993 +9787534080005 +9787534080012 +9787534080029 +9787534080050 +9787534080074 +9787534080081 +9787534080159 +9787534080166 +9787534080173 +9787534080234 +9787534080258 +9787534080265 +9787534080401 +9787534080579 +9787534080784 +9787534080791 +9787534080876 +9787534080913 +9787534080937 +9787534080944 +9787534080975 +9787534080982 +9787534081118 +9787534081224 +9787534081460 +9787534081484 +9787534081583 +9787534081590 +9787534081644 +9787534081705 +9787534081712 +9787534081729 +9787534081736 +9787534081743 +9787534081804 +9787534081828 +9787534081835 +9787534081859 +9787534082047 +9787534082061 +9787534082078 +9787534082108 +9787534082139 +9787534082153 +9787534082238 +9787534082252 +9787534082320 +9787534082580 +9787534082634 +9787534082696 +9787534082986 +9787534083082 +9787534083167 +9787534083242 +9787534083259 +9787534083648 +9787534083846 +9787534083860 +9787534083891 +9787534083969 +9787534083976 +9787534084003 +9787534084102 +9787534084348 +9787534084546 +9787534084645 +9787534084898 +9787534084973 +9787534085093 +9787534085451 +9787534085475 +9787534085543 +9787534085581 +9787534085659 +9787534085734 +9787534086007 +9787534086045 +9787534086083 +9787534086106 +9787534086281 +9787534086724 +9787534087189 +9787534087240 +9787534087295 +9787534087448 +9787534087615 +9787534087806 +9787534087820 +9787534087837 +9787534087875 +9787534087912 +9787534087967 +9787534087974 +9787534088025 +9787534088124 +9787534088131 +9787534088353 +9787534088490 +9787534088551 +9787534088568 +9787534088575 +9787534088599 +9787534088889 +9787534089220 +9787534089282 +9787534089589 +9787534089657 +9787534089732 +9787534089770 +9787534089879 +9787534089985 +9787534090004 +9787534090257 +9787534090387 +9787534090394 +9787534090783 +9787534090837 +9787534091087 +9787534091445 +9787534091452 +9787534092022 +9787534092145 +9787534092367 +9787534092381 +9787534092527 +9787534092664 +9787534092671 +9787534092848 +9787534092909 +9787534093067 +9787534093081 +9787534093272 +9787534093777 +9787534094217 +9787534094286 +9787534094408 +9787534094644 +9787534094651 +9787534095122 +9787534095283 +9787534095498 +9787534095719 +9787534095801 +9787534095849 +9787534096020 +9787534096174 +9787534096228 +9787534096464 +9787534096501 +9787534096631 +9787534096648 +9787534096693 +9787534096808 +9787534097140 +9787534097317 +9787534097324 +9787534097515 +9787534097539 +9787534097591 +9787534097782 +9787534098109 +9787534098352 +9787534098390 +9787534098697 +9787534098703 +9787534098994 +9787534099366 +9787534099373 +9787534099557 +9787534099564 +9787534099946 +9787534100048 +9787534100147 +9787534100154 +9787534100185 +9787534100352 +9787534100468 +9787534100581 +9787534100598 +9787534100963 +9787534101281 +9787534101403 +9787534102219 +9787534102400 +9787534102462 +9787534102479 +9787534102523 +9787534102547 +9787534102738 +9787534102783 +9787534102820 +9787534103087 +9787534103117 +9787534103148 +9787534103292 +9787534103339 +9787534103353 +9787534103360 +9787534103391 +9787534103407 +9787534103599 +9787534104350 +9787534104404 +9787534104473 +9787534104947 +9787534105166 +9787534105739 +9787534105852 +9787534105968 +9787534106286 +9787534106415 +9787534106460 +9787534106590 +9787534106705 +9787534106897 +9787534107047 +9787534107320 +9787534107337 +9787534107344 +9787534107429 +9787534107436 +9787534107566 +9787534107672 +9787534107825 +9787534108006 +9787534108143 +9787534108150 +9787534108426 +9787534108891 +9787534109034 +9787534109041 +9787534109072 +9787534109232 +9787534109317 +9787534109539 +9787534110610 +9787534110719 +9787534111037 +9787534111075 +9787534111242 +9787534111259 +9787534111303 +9787534111358 +9787534111518 +9787534112492 +9787534112638 +9787534112645 +9787534112720 +9787534113062 +9787534113383 +9787534113512 +9787534113567 +9787534113642 +9787534113857 +9787534113932 +9787534113963 +9787534114038 +9787534114465 +9787534114847 +9787534115028 +9787534115318 +9787534116346 +9787534116414 +9787534116537 +9787534116773 +9787534116865 +9787534116902 +9787534117527 +9787534117756 +9787534118067 +9787534118081 +9787534118319 +9787534118876 +9787534118890 +9787534118906 +9787534118920 +9787534119118 +9787534119507 +9787534119903 +9787534120015 +9787534120022 +9787534120046 +9787534120121 +9787534120947 +9787534121043 +9787534121050 +9787534121210 +9787534121616 +9787534121692 +9787534121890 +9787534123184 +9787534123757 +9787534125508 +9787534125942 +9787534126178 +9787534126208 +9787534126321 +9787534126918 +9787534127298 +9787534127700 +9787534127915 +9787534128103 +9787534128202 +9787534129360 +9787534129384 +9787534130373 +9787534130427 +9787534131851 +9787534131981 +9787534132247 +9787534132308 +9787534132544 +9787534132995 +9787534133091 +9787534133145 +9787534133299 +9787534133411 +9787534133527 +9787534134456 +9787534134623 +9787534134685 +9787534135217 +9787534135606 +9787534135958 +9787534136320 +9787534136337 +9787534137198 +9787534137341 +9787534137976 +9787534138041 +9787534138409 +9787534138485 +9787534138706 +9787534138751 +9787534138768 +9787534138881 +9787534139086 +9787534139505 +9787534139550 +9787534139567 +9787534139581 +9787534139734 +9787534139901 +9787534139932 +9787534139970 +9787534139987 +9787534140167 +9787534140709 +9787534141140 +9787534141362 +9787534141379 +9787534141904 +9787534141911 +9787534142284 +9787534142932 +9787534143434 +9787534143441 +9787534143458 +9787534143830 +9787534144417 +9787534144707 +9787534144783 +9787534144875 +9787534144882 +9787534144912 +9787534144950 +9787534145056 +9787534146442 +9787534147777 +9787534148439 +9787534148538 +9787534148552 +9787534148569 +9787534150999 +9787534152306 +9787534154164 +9787534155406 +9787534155468 +9787534155901 +9787534157431 +9787534157493 +9787534158049 +9787534158070 +9787534158445 +9787534158629 +9787534158834 +9787534158841 +9787534158865 +9787534159718 +9787534159800 +9787534160158 +9787534160172 +9787534160363 +9787534160455 +9787534162688 +9787534163104 +9787534164132 +9787534164750 +9787534165573 +9787534165580 +9787534171536 +9787534171970 +9787534172212 +9787534172861 +9787534173950 +9787534173967 +9787534174056 +9787534174070 +9787534174759 +9787534175657 +9787534175671 +9787534176920 +9787534176937 +9787534177101 +9787534177194 +9787534177200 +9787534177323 +9787534177361 +9787534177729 +9787534178283 +9787534179068 +9787534179310 +9787534179594 +9787534179839 +9787534180071 +9787534181030 +9787534181092 +9787534181153 +9787534181450 +9787534181535 +9787534182341 +9787534182839 +9787534183263 +9787534183294 +9787534184451 +9787534184512 +9787534184581 +9787534186127 +9787534186233 +9787534186592 +9787534186769 +9787534186790 +9787534186943 +9787534187520 +9787534187568 +9787534187681 +9787534187711 +9787534187926 +9787534188541 +9787534189562 +9787534189586 +9787534190056 +9787534190087 +9787534190155 +9787534190711 +9787534191350 +9787534193316 +9787534194108 +9787534194313 +9787534195198 +9787534195716 +9787534195853 +9787534196775 +9787534196782 +9787534197222 +9787534197239 +9787534197253 +9787534197680 +9787534198120 +9787534198182 +9787534198229 +9787534198267 +9787534198861 +9787534199004 +9787534201509 +9787534203381 +9787534203589 +9787534204265 +9787534204272 +9787534206528 +9787534206856 +9787534207693 +9787534207709 +9787534207839 +9787534207846 +9787534207938 +9787534208102 +9787534208874 +9787534210105 +9787534211270 +9787534211294 +9787534211416 +9787534211737 +9787534211744 +9787534211997 +9787534212000 +9787534212130 +9787534212871 +9787534213502 +9787534213731 +9787534213915 +9787534213939 +9787534213946 +9787534213984 +9787534214110 +9787534214127 +9787534214264 +9787534214271 +9787534214769 +9787534215742 +9787534217029 +9787534217890 +9787534218064 +9787534218422 +9787534218705 +9787534219429 +9787534220111 +9787534220807 +9787534221033 +9787534221958 +9787534222160 +9787534222313 +9787534222429 +9787534222924 +9787534223426 +9787534223440 +9787534223570 +9787534223686 +9787534223761 +9787534224348 +9787534224362 +9787534224393 +9787534224515 +9787534224607 +9787534225109 +9787534225185 +9787534225192 +9787534225208 +9787534225222 +9787534225383 +9787534225444 +9787534225963 +9787534226045 +9787534226373 +9787534226380 +9787534226397 +9787534226403 +9787534226410 +9787534226427 +9787534226441 +9787534226465 +9787534226472 +9787534226502 +9787534226519 +9787534226533 +9787534227257 +9787534227318 +9787534227349 +9787534227363 +9787534228049 +9787534228230 +9787534228254 +9787534228261 +9787534228414 +9787534228476 +9787534228490 +9787534228520 +9787534228537 +9787534228544 +9787534228797 +9787534228810 +9787534229336 +9787534229947 +9787534230110 +9787534230134 +9787534231445 +9787534231612 +9787534231650 +9787534231711 +9787534231766 +9787534231803 +9787534231827 +9787534231926 +9787534231933 +9787534231940 +9787534231964 +9787534232329 +9787534232480 +9787534232497 +9787534233050 +9787534233258 +9787534233340 +9787534233371 +9787534233814 +9787534234651 +9787534234811 +9787534235894 +9787534236235 +9787534237362 +9787534237751 +9787534238024 +9787534238307 +9787534238352 +9787534239410 +9787534239427 +9787534239656 +9787534239816 +9787534240713 +9787534240980 +9787534240997 +9787534241093 +9787534241116 +9787534241147 +9787534241543 +9787534241550 +9787534241567 +9787534242007 +9787534242236 +9787534242540 +9787534242564 +9787534242694 +9787534242779 +9787534242786 +9787534242793 +9787534242847 +9787534242854 +9787534242885 +9787534243134 +9787534244278 +9787534244285 +9787534244445 +9787534244452 +9787534244513 +9787534244599 +9787534244964 +9787534245367 +9787534245374 +9787534245404 +9787534245800 +9787534245824 +9787534245831 +9787534246098 +9787534246296 +9787534246425 +9787534246937 +9787534247033 +9787534247118 +9787534247279 +9787534247347 +9787534247675 +9787534248061 +9787534249044 +9787534249204 +9787534249631 +9787534249860 +9787534249938 +9787534250088 +9787534250095 +9787534250101 +9787534250118 +9787534250125 +9787534250132 +9787534250156 +9787534250170 +9787534250217 +9787534250224 +9787534250255 +9787534250262 +9787534250293 +9787534250316 +9787534250385 +9787534250392 +9787534250705 +9787534250941 +9787534251184 +9787534251641 +9787534251733 +9787534251771 +9787534251788 +9787534251795 +9787534252075 +9787534252495 +9787534252518 +9787534252525 +9787534252983 +9787534253027 +9787534253058 +9787534253188 +9787534253348 +9787534253355 +9787534253393 +9787534253553 +9787534253591 +9787534253607 +9787534253614 +9787534253683 +9787534253850 +9787534253881 +9787534253966 +9787534253997 +9787534254000 +9787534254055 +9787534254062 +9787534254932 +9787534254963 +9787534255168 +9787534255199 +9787534255205 +9787534255311 +9787534255359 +9787534255380 +9787534255472 +9787534255595 +9787534255649 +9787534256004 +9787534256080 +9787534256103 +9787534256219 +9787534256530 +9787534256561 +9787534256578 +9787534256608 +9787534256875 +9787534256936 +9787534257087 +9787534257094 +9787534257117 +9787534257124 +9787534257193 +9787534257681 +9787534257711 +9787534257728 +9787534257889 +9787534258039 +9787534258060 +9787534258077 +9787534258497 +9787534258657 +9787534258688 +9787534258701 +9787534258985 +9787534259050 +9787534259104 +9787534259111 +9787534259166 +9787534259326 +9787534259357 +9787534259395 +9787534259487 +9787534259500 +9787534259630 +9787534259654 +9787534259708 +9787534259715 +9787534259739 +9787534259784 +9787534260216 +9787534260261 +9787534260285 +9787534260315 +9787534260612 +9787534260643 +9787534260650 +9787534260667 +9787534261275 +9787534261282 +9787534261404 +9787534261442 +9787534261565 +9787534261596 +9787534261633 +9787534261640 +9787534261695 +9787534261763 +9787534261947 +9787534261954 +9787534262067 +9787534262166 +9787534262630 +9787534262869 +9787534262876 +9787534262951 +9787534263132 +9787534263644 +9787534263736 +9787534263804 +9787534263866 +9787534263910 +9787534263941 +9787534264047 +9787534264061 +9787534264153 +9787534264399 +9787534264450 +9787534264467 +9787534264474 +9787534264672 +9787534265099 +9787534265273 +9787534265556 +9787534266003 +9787534266027 +9787534266041 +9787534266072 +9787534266157 +9787534266195 +9787534266225 +9787534266287 +9787534266324 +9787534266331 +9787534266362 +9787534266430 +9787534266454 +9787534266560 +9787534266638 +9787534266881 +9787534267031 +9787534267048 +9787534267093 +9787534267130 +9787534267154 +9787534267161 +9787534267185 +9787534267208 +9787534267581 +9787534267758 +9787534267871 +9787534267888 +9787534268021 +9787534268076 +9787534268342 +9787534268434 +9787534268502 +9787534268557 +9787534268564 +9787534268571 +9787534268595 +9787534268601 +9787534268625 +9787534268694 +9787534268823 +9787534268908 +9787534268922 +9787534268953 +9787534268984 +9787534269059 +9787534269073 +9787534269172 +9787534269189 +9787534269196 +9787534269370 +9787534269424 +9787534269431 +9787534269479 +9787534269554 +9787534269578 +9787534269653 +9787534269769 +9787534269998 +9787534270123 +9787534270130 +9787534270147 +9787534270154 +9787534270482 +9787534270505 +9787534270543 +9787534270987 +9787534271366 +9787534271441 +9787534271458 +9787534271519 +9787534271564 +9787534271571 +9787534271588 +9787534271601 +9787534271656 +9787534271670 +9787534271854 +9787534271908 +9787534271939 +9787534272028 +9787534272301 +9787534272363 +9787534272677 +9787534272707 +9787534272905 +9787534272912 +9787534272929 +9787534272936 +9787534273049 +9787534273100 +9787534273148 +9787534273230 +9787534273247 +9787534273261 +9787534273278 +9787534273322 +9787534273667 +9787534274176 +9787534274190 +9787534274206 +9787534274213 +9787534274220 +9787534274299 +9787534274305 +9787534274312 +9787534274329 +9787534274411 +9787534274442 +9787534274497 +9787534274503 +9787534275098 +9787534275111 +9787534275203 +9787534275234 +9787534275258 +9787534275265 +9787534275586 +9787534275593 +9787534275609 +9787534275616 +9787534275623 +9787534275654 +9787534275760 +9787534275791 +9787534275920 +9787534275937 +9787534276149 +9787534276323 +9787534276354 +9787534276477 +9787534276484 +9787534276651 +9787534276668 +9787534276903 +9787534276910 +9787534276927 +9787534276934 +9787534276989 +9787534276996 +9787534277054 +9787534277139 +9787534277320 +9787534277429 +9787534277443 +9787534277450 +9787534277467 +9787534277610 +9787534277979 +9787534278020 +9787534278211 +9787534278945 +9787534279027 +9787534279119 +9787534279232 +9787534279362 +9787534279553 +9787534279676 +9787534279690 +9787534279720 +9787534279768 +9787534279775 +9787534279805 +9787534279812 +9787534279829 +9787534279850 +9787534279867 +9787534279874 +9787534279881 +9787534279898 +9787534279911 +9787534279928 +9787534280153 +9787534280245 +9787534280252 +9787534280276 +9787534280283 +9787534280412 +9787534280429 +9787534280559 +9787534280658 +9787534280719 +9787534280726 +9787534280979 +9787534281020 +9787534281037 +9787534281389 +9787534281433 +9787534281457 +9787534281532 +9787534281617 +9787534281723 +9787534281761 +9787534281945 +9787534281976 +9787534282072 +9787534282348 +9787534282355 +9787534282690 +9787534283130 +9787534283161 +9787534283178 +9787534283291 +9787534283369 +9787534283406 +9787534283574 +9787534283611 +9787534284137 +9787534284250 +9787534284311 +9787534284410 +9787534284502 +9787534284526 +9787534284632 +9787534284663 +9787534284779 +9787534285042 +9787534285059 +9787534285219 +9787534285288 +9787534285493 +9787534285509 +9787534285516 +9787534285523 +9787534285578 +9787534285691 +9787534286087 +9787534286131 +9787534286346 +9787534286360 +9787534286551 +9787534286568 +9787534286582 +9787534286605 +9787534286629 +9787534286865 +9787534286889 +9787534286902 +9787534286919 +9787534286926 +9787534287077 +9787534287169 +9787534287183 +9787534287237 +9787534287329 +9787534287404 +9787534287466 +9787534287725 +9787534287756 +9787534287831 +9787534287855 +9787534287862 +9787534287886 +9787534287893 +9787534287978 +9787534287985 +9787534287992 +9787534288142 +9787534288333 +9787534288340 +9787534289170 +9787534289200 +9787534289637 +9787534289668 +9787534289675 +9787534289682 +9787534289767 +9787534289774 +9787534289873 +9787534290114 +9787534290169 +9787534290237 +9787534290312 +9787534290336 +9787534290824 +9787534290985 +9787534291029 +9787534291081 +9787534291234 +9787534291371 +9787534291586 +9787534291883 +9787534291890 +9787534292187 +9787534292293 +9787534292385 +9787534292392 +9787534292408 +9787534292460 +9787534292897 +9787534292927 +9787534292972 +9787534293092 +9787534293108 +9787534293115 +9787534293139 +9787534293207 +9787534293252 +9787534293276 +9787534293283 +9787534293290 +9787534293542 +9787534293788 +9787534293887 +9787534293931 +9787534294105 +9787534294211 +9787534294228 +9787534294310 +9787534294365 +9787534294587 +9787534294693 +9787534294723 +9787534295058 +9787534295072 +9787534295102 +9787534295171 +9787534295225 +9787534295256 +9787534295294 +9787534295560 +9787534295652 +9787534295942 +9787534295997 +9787534296116 +9787534296253 +9787534296260 +9787534296345 +9787534296529 +9787534296611 +9787534296628 +9787534296642 +9787534296918 +9787534297205 +9787534297380 +9787534297625 +9787534297724 +9787534297847 +9787534298035 +9787534298097 +9787534298165 +9787534298325 +9787534298493 +9787534298851 +9787534298875 +9787534298882 +9787534299797 +9787534299841 +9787534299919 +9787534299933 +9787534299940 +9787534299964 +9787534300783 +9787534301230 +9787534301377 +9787534302589 +9787534303579 +9787534304545 +9787534304576 +9787534305610 +9787534305627 +9787534305788 +9787534306631 +9787534307331 +9787534307782 +9787534308116 +9787534310522 +9787534310546 +9787534311567 +9787534311574 +9787534312113 +9787534312243 +9787534313134 +9787534313141 +9787534313202 +9787534313226 +9787534313301 +9787534313967 +9787534314315 +9787534314650 +9787534315190 +9787534315329 +9787534315534 +9787534315619 +9787534315893 +9787534316005 +9787534316708 +9787534318887 +9787534319952 +9787534320057 +9787534320125 +9787534320347 +9787534320378 +9787534320521 +9787534320866 +9787534321009 +9787534321559 +9787534321979 +9787534322136 +9787534322174 +9787534322808 +9787534322815 +9787534323270 +9787534323607 +9787534324246 +9787534324406 +9787534324413 +9787534324819 +9787534324901 +9787534325687 +9787534325700 +9787534325755 +9787534326264 +9787534326288 +9787534326325 +9787534326776 +9787534326783 +9787534326912 +9787534326967 +9787534327049 +9787534327124 +9787534327155 +9787534327261 +9787534327278 +9787534327285 +9787534327360 +9787534327995 +9787534328015 +9787534328220 +9787534328312 +9787534328329 +9787534328367 +9787534328664 +9787534328916 +9787534328954 +9787534329340 +9787534330087 +9787534330155 +9787534330483 +9787534330506 +9787534330698 +9787534330704 +9787534330896 +9787534331220 +9787534332128 +9787534332210 +9787534332272 +9787534332364 +9787534332371 +9787534332494 +9787534332647 +9787534332685 +9787534332692 +9787534333293 +9787534333453 +9787534333477 +9787534334122 +9787534334856 +9787534334894 +9787534335129 +9787534335266 +9787534335464 +9787534336041 +9787534336195 +9787534336331 +9787534336447 +9787534336461 +9787534336515 +9787534336669 +9787534336676 +9787534336690 +9787534336713 +9787534336720 +9787534336737 +9787534336959 +9787534337604 +9787534338274 +9787534338373 +9787534338441 +9787534338779 +9787534338786 +9787534339585 +9787534339660 +9787534339714 +9787534339745 +9787534339783 +9787534339820 +9787534341335 +9787534341427 +9787534342387 +9787534342554 +9787534343230 +9787534343247 +9787534343377 +9787534343582 +9787534344138 +9787534344961 +9787534346323 +9787534347870 +9787534348419 +9787534348426 +9787534348433 +9787534348662 +9787534349447 +9787534349454 +9787534351037 +9787534351594 +9787534351686 +9787534351693 +9787534352218 +9787534352430 +9787534353246 +9787534353291 +9787534353321 +9787534353666 +9787534353697 +9787534355141 +9787534355158 +9787534355165 +9787534356384 +9787534356674 +9787534356766 +9787534356780 +9787534357268 +9787534357985 +9787534358104 +9787534358524 +9787534358593 +9787534359453 +9787534359460 +9787534359477 +9787534359767 +9787534359996 +9787534361074 +9787534361364 +9787534361456 +9787534361494 +9787534361685 +9787534361746 +9787534361951 +9787534362149 +9787534362224 +9787534364204 +9787534364228 +9787534364365 +9787534364563 +9787534364990 +9787534365140 +9787534365270 +9787534365522 +9787534365546 +9787534365560 +9787534365577 +9787534365836 +9787534365867 +9787534366321 +9787534368561 +9787534368929 +9787534368950 +9787534368974 +9787534369667 +9787534369766 +9787534369834 +9787534370021 +9787534370120 +9787534370137 +9787534370656 +9787534370700 +9787534370717 +9787534370731 +9787534370762 +9787534370779 +9787534371097 +9787534371493 +9787534371714 +9787534373015 +9787534373206 +9787534373336 +9787534373343 +9787534373626 +9787534373664 +9787534373671 +9787534373725 +9787534373992 +9787534374005 +9787534374586 +9787534374685 +9787534374913 +9787534374937 +9787534374944 +9787534374968 +9787534375002 +9787534375194 +9787534375217 +9787534375408 +9787534376061 +9787534376290 +9787534376993 +9787534377006 +9787534377532 +9787534378119 +9787534378188 +9787534378867 +9787534379024 +9787534379284 +9787534379383 +9787534379390 +9787534379406 +9787534379451 +9787534380303 +9787534380365 +9787534380914 +9787534381133 +9787534381140 +9787534381317 +9787534382987 +9787534383045 +9787534383052 +9787534383540 +9787534383618 +9787534384776 +9787534384882 +9787534385094 +9787534385483 +9787534385544 +9787534386367 +9787534386428 +9787534386992 +9787534387098 +9787534387180 +9787534387876 +9787534389580 +9787534390463 +9787534390807 +9787534390838 +9787534390845 +9787534390869 +9787534391217 +9787534391231 +9787534391576 +9787534391644 +9787534392160 +9787534392405 +9787534393013 +9787534394201 +9787534395123 +9787534395420 +9787534395574 +9787534395581 +9787534395611 +9787534395635 +9787534396342 +9787534396502 +9787534396625 +9787534396748 +9787534397196 +9787534397936 +9787534397943 +9787534399282 +9787534399657 +9787534399794 +9787534400100 +9787534400131 +9787534400148 +9787534400186 +9787534400308 +9787534400421 +9787534400452 +9787534400490 +9787534400551 +9787534400629 +9787534400643 +9787534400889 +9787534401176 +9787534401206 +9787534401213 +9787534401237 +9787534401251 +9787534401282 +9787534401398 +9787534401589 +9787534401664 +9787534401831 +9787534402050 +9787534402203 +9787534402234 +9787534402241 +9787534402289 +9787534402333 +9787534402395 +9787534402616 +9787534402838 +9787534402883 +9787534402982 +9787534402999 +9787534403149 +9787534403156 +9787534403170 +9787534403187 +9787534403231 +9787534403361 +9787534403378 +9787534403408 +9787534403446 +9787534403651 +9787534403682 +9787534403705 +9787534403729 +9787534403736 +9787534403743 +9787534403767 +9787534403774 +9787534403781 +9787534403866 +9787534404085 +9787534404177 +9787534404184 +9787534404733 +9787534404801 +9787534404818 +9787534404979 +9787534404993 +9787534405006 +9787534405082 +9787534405181 +9787534405204 +9787534405211 +9787534405396 +9787534405426 +9787534405631 +9787534405648 +9787534405822 +9787534405853 +9787534406218 +9787534406560 +9787534406584 +9787534406843 +9787534406904 +9787534406911 +9787534406935 +9787534406942 +9787534406959 +9787534406997 +9787534407499 +9787534407635 +9787534407758 +9787534407888 +9787534407895 +9787534407925 +9787534408038 +9787534408076 +9787534408359 +9787534408496 +9787534408809 +9787534408908 +9787534409110 +9787534409127 +9787534409165 +9787534409431 +9787534409554 +9787534409578 +9787534409585 +9787534409592 +9787534409660 +9787534409943 +9787534409950 +9787534409974 +9787534410123 +9787534410369 +9787534410383 +9787534410406 +9787534410567 +9787534410574 +9787534410581 +9787534411175 +9787534411212 +9787534411311 +9787534411465 +9787534411588 +9787534412097 +9787534412400 +9787534412417 +9787534412745 +9787534412875 +9787534413162 +9787534413322 +9787534414107 +9787534414114 +9787534414619 +9787534414626 +9787534415173 +9787534415593 +9787534415982 +9787534416095 +9787534416347 +9787534416415 +9787534416521 +9787534417030 +9787534417085 +9787534419478 +9787534419843 +9787534420283 +9787534420351 +9787534420665 +9787534421235 +9787534422027 +9787534422263 +9787534422553 +9787534423994 +9787534424434 +9787534424441 +9787534425738 +9787534425745 +9787534425776 +9787534425813 +9787534426544 +9787534428005 +9787534428074 +9787534428258 +9787534428265 +9787534429231 +9787534429385 +9787534429439 +9787534429545 +9787534430152 +9787534432170 +9787534433962 +9787534437106 +9787534437786 +9787534438301 +9787534438493 +9787534442230 +9787534444531 +9787534447730 +9787534450686 +9787534452659 +9787534456268 +9787534457074 +9787534458798 +9787534459320 +9787534459641 +9787534460760 +9787534461170 +9787534462085 +9787534463846 +9787534463884 +9787534467264 +9787534472589 +9787534473074 +9787534473371 +9787534473838 +9787534474019 +9787534475498 +9787534476860 +9787534480621 +9787534481710 +9787534482045 +9787534485060 +9787534486548 +9787534486555 +9787534486630 +9787534487484 +9787534489372 +9787534491665 +9787534492341 +9787534493850 +9787534496097 +9787534496158 +9787534497285 +9787534499043 +9787534500053 +9787534500367 +9787534501043 +9787534501074 +9787534501364 +9787534501548 +9787534501654 +9787534502118 +9787534502224 +9787534502828 +9787534502835 +9787534502873 +9787534502972 +9787534503009 +9787534503078 +9787534503276 +9787534503306 +9787534503382 +9787534503726 +9787534504259 +9787534504372 +9787534504952 +9787534505126 +9787534505492 +9787534505522 +9787534506062 +9787534506505 +9787534507618 +9787534508530 +9787534508738 +9787534508745 +9787534508776 +9787534508899 +9787534509681 +9787534509902 +9787534510229 +9787534510809 +9787534510908 +9787534511141 +9787534511370 +9787534511721 +9787534512162 +9787534512322 +9787534512476 +9787534512599 +9787534512667 +9787534512759 +9787534512841 +9787534513220 +9787534513671 +9787534513763 +9787534513800 +9787534513886 +9787534514319 +9787534514395 +9787534514432 +9787534514487 +9787534514494 +9787534514609 +9787534515002 +9787534515279 +9787534515286 +9787534515392 +9787534515422 +9787534516023 +9787534516054 +9787534516061 +9787534516108 +9787534516115 +9787534516146 +9787534516153 +9787534516962 +9787534517273 +9787534517327 +9787534517358 +9787534517754 +9787534517976 +9787534518379 +9787534518447 +9787534518676 +9787534518836 +9787534519161 +9787534519581 +9787534520259 +9787534521300 +9787534521737 +9787534522567 +9787534522581 +9787534522598 +9787534522666 +9787534523458 +9787534523724 +9787534523731 +9787534523748 +9787534523755 +9787534523762 +9787534523786 +9787534523816 +9787534524271 +9787534524370 +9787534525179 +9787534525285 +9787534525308 +9787534525322 +9787534525629 +9787534526725 +9787534526824 +9787534526909 +9787534526930 +9787534527968 +9787534528170 +9787534528279 +9787534528637 +9787534528644 +9787534528651 +9787534528668 +9787534528712 +9787534529092 +9787534529559 +9787534530289 +9787534531507 +9787534531514 +9787534532139 +9787534532184 +9787534532214 +9787534532221 +9787534532252 +9787534532269 +9787534532306 +9787534533273 +9787534533433 +9787534533761 +9787534534485 +9787534534553 +9787534534645 +9787534534751 +9787534534966 +9787534535031 +9787534535109 +9787534535130 +9787534535383 +9787534535390 +9787534535406 +9787534535420 +9787534535437 +9787534535444 +9787534535635 +9787534536007 +9787534536014 +9787534536090 +9787534536182 +9787534536205 +9787534536748 +9787534537820 +9787534537851 +9787534537950 +9787534538544 +9787534538681 +9787534538902 +9787534539688 +9787534540011 +9787534541438 +9787534541551 +9787534541681 +9787534541803 +9787534542268 +9787534542398 +9787534543364 +9787534543913 +9787534545856 +9787534547379 +9787534548215 +9787534549977 +9787534551109 +9787534552281 +9787534553493 +9787534558047 +9787534560712 +9787534563522 +9787534565250 +9787534567865 +9787534568558 +9787534569753 +9787534573675 +9787534574221 +9787534574443 +9787534574702 +9787534576621 +9787534577291 +9787534579769 +9787534579912 +9787534580147 +9787534584220 +9787534585814 +9787534586378 +9787534588105 +9787534591761 +9787534591792 +9787534592652 +9787534593376 +9787534593482 +9787534593659 +9787534594007 +9787534595257 +9787534598890 +9787534600159 +9787534600692 +9787534600791 +9787534600968 +9787534601378 +9787534601606 +9787534602351 +9787534602566 +9787534602573 +9787534602610 +9787534602641 +9787534602658 +9787534602696 +9787534602764 +9787534603211 +9787534603808 +9787534604218 +9787534607509 +9787534607820 +9787534607943 +9787534607998 +9787534609091 +9787534609251 +9787534609879 +9787534610172 +9787534610394 +9787534610868 +9787534610943 +9787534611735 +9787534611995 +9787534612015 +9787534612060 +9787534612305 +9787534612312 +9787534612343 +9787534612367 +9787534612602 +9787534613623 +9787534613630 +9787534614477 +9787534614484 +9787534614514 +9787534614828 +9787534615559 +9787534615733 +9787534616136 +9787534616273 +9787534616754 +9787534617591 +9787534617607 +9787534617638 +9787534618758 +9787534618789 +9787534619618 +9787534620003 +9787534620157 +9787534620553 +9787534620676 +9787534621314 +9787534621468 +9787534621857 +9787534621864 +9787534622113 +9787534623080 +9787534624247 +9787534624582 +9787534624919 +9787534625077 +9787534625084 +9787534625114 +9787534625770 +9787534626302 +9787534626340 +9787534626425 +9787534626913 +9787534627002 +9787534627033 +9787534627057 +9787534627835 +9787534627873 +9787534627897 +9787534627910 +9787534628009 +9787534628108 +9787534628177 +9787534628276 +9787534628290 +9787534628641 +9787534629174 +9787534630651 +9787534632303 +9787534633157 +9787534633263 +9787534636387 +9787534636424 +9787534636806 +9787534637179 +9787534638619 +9787534638879 +9787534641633 +9787534641664 +9787534642012 +9787534642630 +9787534642883 +9787534642951 +9787534645433 +9787534645525 +9787534645631 +9787534645914 +9787534646485 +9787534647475 +9787534649998 +9787534650000 +9787534650017 +9787534650178 +9787534650192 +9787534650338 +9787534650666 +9787534650680 +9787534650697 +9787534650710 +9787534650772 +9787534650819 +9787534650826 +9787534652868 +9787534653094 +9787534653100 +9787534655746 +9787534656224 +9787534656682 +9787534657085 +9787534657221 +9787534658341 +9787534658457 +9787534658464 +9787534658655 +9787534660306 +9787534662140 +9787534662546 +9787534664304 +9787534664328 +9787534664571 +9787534667169 +9787534667664 +9787534668654 +9787534668708 +9787534668715 +9787534668722 +9787534670947 +9787534672996 +9787534673160 +9787534677830 +9787534679834 +9787534680069 +9787534681851 +9787534682001 +9787534682360 +9787534682384 +9787534682438 +9787534684876 +9787534685620 +9787534685743 +9787534685934 +9787534686733 +9787534686757 +9787534687334 +9787534688744 +9787534689253 +9787534689314 +9787534689437 +9787534689475 +9787534690945 +9787534692956 +9787534693120 +9787534693441 +9787534693717 +9787534693793 +9787534694912 +9787534696756 +9787534697920 +9787534699313 +9787534701221 +9787534701528 +9787534701764 +9787534704161 +9787534704581 +9787534707148 +9787534708305 +9787534708510 +9787534708572 +9787534710100 +9787534710391 +9787534710520 +9787534710681 +9787534711299 +9787534711909 +9787534713927 +9787534713972 +9787534714030 +9787534720505 +9787534720567 +9787534721090 +9787534721540 +9787534721618 +9787534723230 +9787534723452 +9787534723551 +9787534723643 +9787534724978 +9787534725500 +9787534729201 +9787534730320 +9787534730689 +9787534731488 +9787534732959 +9787534732997 +9787534735271 +9787534736520 +9787534737787 +9787534739903 +9787534740183 +9787534740435 +9787534744440 +9787534745324 +9787534750083 +9787534751189 +9787534752667 +9787534754272 +9787534754395 +9787534754418 +9787534758478 +9787534758652 +9787534761782 +9787534761874 +9787534763724 +9787534767159 +9787534768521 +9787534768972 +9787534769108 +9787534771101 +9787534773112 +9787534773570 +9787534774256 +9787534775062 +9787534775079 +9787534775253 +9787534777219 +9787534778247 +9787534778285 +9787534778667 +9787534782466 +9787534787072 +9787534789663 +9787534793790 +9787534794100 +9787534797606 +9787534799709 +9787534800238 +9787534800276 +9787534800306 +9787534800412 +9787534800436 +9787534800610 +9787534800672 +9787534800719 +9787534800757 +9787534800825 +9787534800863 +9787534800870 +9787534800986 +9787534801044 +9787534801099 +9787534801297 +9787534801310 +9787534801372 +9787534801396 +9787534801679 +9787534801808 +9787534801846 +9787534802010 +9787534802058 +9787534802089 +9787534802256 +9787534802386 +9787534802461 +9787534802515 +9787534802539 +9787534802607 +9787534802645 +9787534802720 +9787534802805 +9787534802836 +9787534802881 +9787534803086 +9787534803093 +9787534803109 +9787534803208 +9787534803246 +9787534803635 +9787534803680 +9787534803758 +9787534803857 +9787534803864 +9787534803918 +9787534804342 +9787534804366 +9787534804656 +9787534804915 +9787534804984 +9787534805165 +9787534805301 +9787534805714 +9787534806346 +9787534806353 +9787534806384 +9787534806476 +9787534806483 +9787534806490 +9787534806803 +9787534806834 +9787534807077 +9787534807084 +9787534807183 +9787534807428 +9787534807701 +9787534807794 +9787534808036 +9787534808203 +9787534808357 +9787534808388 +9787534808715 +9787534808807 +9787534808814 +9787534808883 +9787534808944 +9787534809071 +9787534809088 +9787534809224 +9787534809484 +9787534809583 +9787534810091 +9787534810343 +9787534810565 +9787534810695 +9787534810732 +9787534810848 +9787534810930 +9787534811036 +9787534811067 +9787534811166 +9787534811203 +9787534811234 +9787534811272 +9787534811333 +9787534811357 +9787534811432 +9787534811449 +9787534811494 +9787534811500 +9787534811562 +9787534811586 +9787534811647 +9787534811715 +9787534811777 +9787534811791 +9787534812118 +9787534812217 +9787534812255 +9787534812330 +9787534812385 +9787534812491 +9787534812507 +9787534812538 +9787534812552 +9787534812576 +9787534812590 +9787534812637 +9787534812699 +9787534812705 +9787534812729 +9787534812835 +9787534812866 +9787534812965 +9787534812989 +9787534813016 +9787534813030 +9787534813139 +9787534813146 +9787534813177 +9787534813252 +9787534813306 +9787534813320 +9787534813344 +9787534813351 +9787534813375 +9787534813443 +9787534813474 +9787534813481 +9787534813528 +9787534813535 +9787534813641 +9787534813665 +9787534813870 +9787534814204 +9787534814471 +9787534814495 +9787534814525 +9787534814556 +9787534814952 +9787534815256 +9787534815928 +9787534816222 +9787534816239 +9787534816390 +9787534816796 +9787534817052 +9787534817076 +9787534817113 +9787534817243 +9787534817267 +9787534817274 +9787534817410 +9787534817595 +9787534817755 +9787534817779 +9787534818066 +9787534818608 +9787534818998 +9787534819162 +9787534819452 +9787534819490 +9787534819537 +9787534819841 +9787534819902 +9787534820137 +9787534820267 +9787534820632 +9787534820878 +9787534821264 +9787534821455 +9787534821691 +9787534822773 +9787534823091 +9787534823367 +9787534824487 +9787534824807 +9787534825118 +9787534825651 +9787534825750 +9787534826146 +9787534826719 +9787534826818 +9787534827464 +9787534827600 +9787534827655 +9787534828027 +9787534828812 +9787534829116 +9787534830334 +9787534830396 +9787534830556 +9787534830716 +9787534831027 +9787534831263 +9787534831287 +9787534831478 +9787534831683 +9787534832543 +9787534833441 +9787534833748 +9787534833847 +9787534834127 +9787534834196 +9787534835049 +9787534835483 +9787534835681 +9787534836145 +9787534836619 +9787534836787 +9787534837142 +9787534837579 +9787534838095 +9787534838408 +9787534839085 +9787534839153 +9787534839504 +9787534839689 +9787534839962 +9787534841125 +9787534841460 +9787534841521 +9787534841538 +9787534841569 +9787534841750 +9787534842856 +9787534842900 +9787534843471 +9787534844300 +9787534844621 +9787534844669 +9787534844836 +9787534846175 +9787534846410 +9787534846526 +9787534846625 +9787534846632 +9787534846786 +9787534846915 +9787534847158 +9787534847226 +9787534847929 +9787534847967 +9787534848193 +9787534848209 +9787534848551 +9787534848582 +9787534848988 +9787534849053 +9787534849312 +9787534849954 +9787534850004 +9787534850097 +9787534850349 +9787534850974 +9787534851117 +9787534851179 +9787534852169 +9787534855528 +9787534857225 +9787534858383 +9787534866111 +9787534866920 +9787534872259 +9787534872303 +9787534872327 +9787534872587 +9787534877261 +9787534877872 +9787534879364 +9787534879869 +9787534879968 +9787534880766 +9787534880841 +9787534882180 +9787534882265 +9787534884481 +9787534886843 +9787534887161 +9787534889462 +9787534890758 +9787534890932 +9787534896446 +9787534896538 +9787534896576 +9787534898259 +9787534900020 +9787534900167 +9787534900693 +9787534900884 +9787534901003 +9787534901089 +9787534901416 +9787534902901 +9787534903274 +9787534903403 +9787534903779 +9787534904127 +9787534904325 +9787534904417 +9787534904431 +9787534905520 +9787534907395 +9787534907494 +9787534908293 +9787534909122 +9787534909283 +9787534910906 +9787534911231 +9787534911309 +9787534911514 +9787534914560 +9787534915642 +9787534915659 +9787534918353 +9787534918452 +9787534918759 +9787534919343 +9787534920127 +9787534920585 +9787534920615 +9787534921766 +9787534922534 +9787534923517 +9787534923593 +9787534925634 +9787534925658 +9787534925931 +9787534926013 +9787534926914 +9787534927416 +9787534927560 +9787534930287 +9787534930690 +9787534930782 +9787534931130 +9787534933004 +9787534933448 +9787534935398 +9787534939136 +9787534940309 +9787534943959 +9787534945465 +9787534946332 +9787534947575 +9787534951343 +9787534952425 +9787534953897 +9787534955099 +9787534955150 +9787534956935 +9787534960147 +9787534962073 +9787534962097 +9787534962127 +9787534963575 +9787534963582 +9787534966316 +9787534967993 +9787534968051 +9787534972225 +9787534972232 +9787534972591 +9787534979668 +9787534980558 +9787534980930 +9787534981852 +9787534981876 +9787534981890 +9787534981951 +9787534985294 +9787534987779 +9787534992674 +9787534992681 +9787534995668 +9787534995873 +9787534996283 +9787534996979 +9787534997280 +9787534998508 +9787535000330 +9787535000347 +9787535000378 +9787535000408 +9787535003225 +9787535005519 +9787535006196 +9787535006295 +9787535006424 +9787535006622 +9787535007117 +9787535007384 +9787535007414 +9787535007582 +9787535008060 +9787535008244 +9787535009753 +9787535013071 +9787535014061 +9787535014948 +9787535015396 +9787535015457 +9787535015723 +9787535017703 +9787535018663 +9787535019059 +9787535020062 +9787535020635 +9787535021397 +9787535021731 +9787535022677 +9787535022875 +9787535025791 +9787535025999 +9787535026941 +9787535027757 +9787535030528 +9787535032041 +9787535034380 +9787535035929 +9787535038067 +9787535040695 +9787535041388 +9787535042521 +9787535044747 +9787535044884 +9787535046192 +9787535046307 +9787535047977 +9787535050083 +9787535050229 +9787535050861 +9787535051196 +9787535051875 +9787535053022 +9787535055231 +9787535055248 +9787535055460 +9787535055859 +9787535055903 +9787535058614 +9787535058805 +9787535059017 +9787535059024 +9787535059031 +9787535062222 +9787535063564 +9787535064127 +9787535064707 +9787535064738 +9787535065025 +9787535065414 +9787535066794 +9787535067975 +9787535068446 +9787535069863 +9787535069894 +9787535072191 +9787535072948 +9787535078650 +9787535079107 +9787535079114 +9787535079121 +9787535081377 +9787535081759 +9787535082756 +9787535082763 +9787535082787 +9787535082794 +9787535082800 +9787535085696 +9787535085702 +9787535085719 +9787535086174 +9787535087041 +9787535087607 +9787535088208 +9787535091550 +9787535100559 +9787535101709 +9787535101778 +9787535102775 +9787535103611 +9787535103895 +9787535104052 +9787535104137 +9787535104434 +9787535104748 +9787535105035 +9787535105325 +9787535105493 +9787535105868 +9787535107114 +9787535108425 +9787535108432 +9787535110879 +9787535110886 +9787535111852 +9787535114396 +9787535114426 +9787535115126 +9787535116093 +9787535116383 +9787535117083 +9787535118486 +9787535118882 +9787535119261 +9787535119292 +9787535119490 +9787535119971 +9787535120366 +9787535123015 +9787535123428 +9787535123626 +9787535124043 +9787535124258 +9787535124265 +9787535124937 +9787535124951 +9787535125026 +9787535125040 +9787535125255 +9787535125484 +9787535125774 +9787535125828 +9787535126207 +9787535126214 +9787535126436 +9787535126719 +9787535126863 +9787535127006 +9787535127853 +9787535128256 +9787535128539 +9787535129093 +9787535129383 +9787535129451 +9787535129642 +9787535129772 +9787535130501 +9787535131461 +9787535131720 +9787535132055 +9787535132154 +9787535132260 +9787535132888 +9787535132895 +9787535133151 +9787535133304 +9787535133359 +9787535133632 +9787535135186 +9787535136213 +9787535136343 +9787535139061 +9787535139733 +9787535139849 +9787535139917 +9787535142412 +9787535143532 +9787535143570 +9787535151445 +9787535154484 +9787535154613 +9787535154712 +9787535154774 +9787535154798 +9787535154804 +9787535154880 +9787535154996 +9787535155016 +9787535155153 +9787535159403 +9787535160515 +9787535164360 +9787535164377 +9787535165817 +9787535176943 +9787535181435 +9787535181466 +9787535181954 +9787535189547 +9787535190017 +9787535192929 +9787535192936 +9787535195937 +9787535199362 +9787535199560 +9787535200013 +9787535200150 +9787535200266 +9787535200853 +9787535200877 +9787535200884 +9787535201010 +9787535201027 +9787535201485 +9787535201652 +9787535202239 +9787535202444 +9787535202499 +9787535202642 +9787535202833 +9787535203328 +9787535203823 +9787535204400 +9787535204639 +9787535205582 +9787535205827 +9787535205872 +9787535206374 +9787535206923 +9787535207371 +9787535209146 +9787535210579 +9787535210715 +9787535210951 +9787535211101 +9787535211248 +9787535215802 +9787535216038 +9787535216458 +9787535216496 +9787535216816 +9787535217707 +9787535217967 +9787535218414 +9787535219688 +9787535219763 +9787535221728 +9787535222039 +9787535222480 +9787535223159 +9787535223265 +9787535223661 +9787535223920 +9787535225337 +9787535225436 +9787535226426 +9787535226761 +9787535226938 +9787535226952 +9787535227171 +9787535227294 +9787535229540 +9787535232373 +9787535233127 +9787535233417 +9787535235893 +9787535236043 +9787535237231 +9787535238696 +9787535239006 +9787535248060 +9787535248411 +9787535248671 +9787535249333 +9787535249746 +9787535250735 +9787535251039 +9787535251046 +9787535251947 +9787535252562 +9787535253392 +9787535253743 +9787535253750 +9787535253781 +9787535255068 +9787535255235 +9787535255341 +9787535255501 +9787535255549 +9787535258854 +9787535260925 +9787535262332 +9787535262608 +9787535263995 +9787535265425 +9787535266804 +9787535267894 +9787535268181 +9787535268716 +9787535269096 +9787535269102 +9787535269133 +9787535270290 +9787535270306 +9787535270313 +9787535270726 +9787535271631 +9787535271846 +9787535272393 +9787535274366 +9787535274427 +9787535275158 +9787535281654 +9787535285225 +9787535289414 +9787535290588 +9787535291752 +9787535292094 +9787535292124 +9787535292490 +9787535293367 +9787535295729 +9787535297044 +9787535299666 +9787535300362 +9787535304223 +9787535307644 +9787535309532 +9787535310965 +9787535310996 +9787535311092 +9787535312129 +9787535312488 +9787535312754 +9787535314123 +9787535314246 +9787535314277 +9787535315021 +9787535315342 +9787535315465 +9787535315991 +9787535317575 +9787535317667 +9787535317872 +9787535318664 +9787535318725 +9787535321978 +9787535322029 +9787535322081 +9787535322173 +9787535324092 +9787535324108 +9787535324252 +9787535326478 +9787535326706 +9787535327468 +9787535327499 +9787535330765 +9787535330857 +9787535331243 +9787535331489 +9787535331847 +9787535331885 +9787535332400 +9787535334299 +9787535334657 +9787535335340 +9787535336965 +9787535338679 +9787535340306 +9787535340726 +9787535344090 +9787535348050 +9787535349620 +9787535351692 +9787535351753 +9787535351838 +9787535352088 +9787535352293 +9787535354082 +9787535354884 +9787535355089 +9787535355232 +9787535357410 +9787535357830 +9787535358172 +9787535358233 +9787535358264 +9787535358288 +9787535358431 +9787535359100 +9787535359988 +9787535360632 +9787535362674 +9787535363039 +9787535363220 +9787535363268 +9787535363466 +9787535363695 +9787535364296 +9787535364364 +9787535364753 +9787535364791 +9787535364845 +9787535364852 +9787535364876 +9787535364982 +9787535366153 +9787535366580 +9787535366658 +9787535367624 +9787535367679 +9787535368065 +9787535368799 +9787535368805 +9787535369932 +9787535369956 +9787535371188 +9787535372697 +9787535373717 +9787535374868 +9787535374875 +9787535376275 +9787535377357 +9787535377364 +9787535378323 +9787535378804 +9787535379627 +9787535380029 +9787535380531 +9787535380579 +9787535380593 +9787535381231 +9787535381392 +9787535382108 +9787535382290 +9787535382627 +9787535382634 +9787535383358 +9787535383587 +9787535383600 +9787535385505 +9787535385529 +9787535385550 +9787535385581 +9787535385628 +9787535385659 +9787535385703 +9787535385727 +9787535385741 +9787535386342 +9787535387066 +9787535387608 +9787535387653 +9787535388056 +9787535388339 +9787535388353 +9787535388360 +9787535388650 +9787535390196 +9787535390202 +9787535390844 +9787535391117 +9787535391834 +9787535392053 +9787535392145 +9787535392305 +9787535392312 +9787535392800 +9787535393708 +9787535393838 +9787535394194 +9787535394231 +9787535394279 +9787535394453 +9787535394477 +9787535394484 +9787535397089 +9787535397096 +9787535397478 +9787535397485 +9787535397645 +9787535397751 +9787535399014 +9787535399052 +9787535399069 +9787535399212 +9787535400079 +9787535400185 +9787535400253 +9787535400352 +9787535400598 +9787535400611 +9787535400673 +9787535400758 +9787535400864 +9787535400994 +9787535401083 +9787535401151 +9787535401168 +9787535401342 +9787535401427 +9787535401564 +9787535401656 +9787535401939 +9787535402219 +9787535402240 +9787535402493 +9787535403490 +9787535403568 +9787535403667 +9787535403728 +9787535403889 +9787535403995 +9787535404039 +9787535404091 +9787535404367 +9787535404565 +9787535404619 +9787535404688 +9787535405456 +9787535405500 +9787535405906 +9787535405982 +9787535406071 +9787535406088 +9787535406293 +9787535406422 +9787535406613 +9787535406705 +9787535406910 +9787535407023 +9787535407177 +9787535407351 +9787535407559 +9787535407566 +9787535407610 +9787535407924 +9787535407986 +9787535408082 +9787535408259 +9787535408310 +9787535408327 +9787535408341 +9787535408402 +9787535408433 +9787535408440 +9787535408662 +9787535408754 +9787535409027 +9787535409065 +9787535409409 +9787535409935 +9787535409966 +9787535410689 +9787535411006 +9787535411013 +9787535411150 +9787535411181 +9787535411211 +9787535411228 +9787535411242 +9787535411303 +9787535411433 +9787535411457 +9787535412041 +9787535412119 +9787535412140 +9787535412492 +9787535412515 +9787535412683 +9787535412836 +9787535412874 +9787535412904 +9787535413079 +9787535413109 +9787535413413 +9787535413420 +9787535413819 +9787535413956 +9787535414038 +9787535414045 +9787535414434 +9787535414564 +9787535414595 +9787535414656 +9787535414687 +9787535414830 +9787535414854 +9787535414915 +9787535415318 +9787535415622 +9787535415868 +9787535416087 +9787535416490 +9787535417312 +9787535417640 +9787535417749 +9787535419248 +9787535419446 +9787535419675 +9787535420206 +9787535420572 +9787535420879 +9787535420930 +9787535420978 +9787535421432 +9787535421760 +9787535422248 +9787535422460 +9787535422736 +9787535422781 +9787535422804 +9787535423061 +9787535423436 +9787535423443 +9787535423986 +9787535424297 +9787535424464 +9787535424587 +9787535424594 +9787535424914 +9787535425331 +9787535425744 +9787535426284 +9787535427670 +9787535427687 +9787535428103 +9787535430250 +9787535431349 +9787535431721 +9787535431752 +9787535432759 +9787535432971 +9787535433985 +9787535435224 +9787535435804 +9787535436047 +9787535436528 +9787535436917 +9787535437648 +9787535437723 +9787535438546 +9787535439499 +9787535440358 +9787535440471 +9787535441034 +9787535441249 +9787535441263 +9787535441843 +9787535441973 +9787535442062 +9787535442116 +9787535443250 +9787535443359 +9787535444301 +9787535446916 +9787535446954 +9787535447036 +9787535447388 +9787535447982 +9787535448019 +9787535448156 +9787535448163 +9787535448378 +9787535449313 +9787535449320 +9787535451064 +9787535451415 +9787535453181 +9787535458605 +9787535458834 +9787535460936 +9787535460998 +9787535462084 +9787535465917 +9787535466594 +9787535466853 +9787535469236 +9787535477187 +9787535478177 +9787535479808 +9787535484680 +9787535485809 +9787535486271 +9787535486288 +9787535486295 +9787535486301 +9787535486325 +9787535489104 +9787535490131 +9787535498717 +9787535499370 +9787535502759 +9787535504654 +9787535505149 +9787535505378 +9787535505590 +9787535506887 +9787535507860 +9787535508201 +9787535509161 +9787535510464 +9787535510952 +9787535510969 +9787535511898 +9787535511966 +9787535513175 +9787535513779 +9787535515452 +9787535515629 +9787535515643 +9787535515650 +9787535515797 +9787535515834 +9787535516725 +9787535518644 +9787535518743 +9787535519894 +9787535520678 +9787535522719 +9787535522726 +9787535524133 +9787535524584 +9787535525208 +9787535525666 +9787535525673 +9787535525857 +9787535526212 +9787535526311 +9787535527349 +9787535527417 +9787535528766 +9787535528957 +9787535530455 +9787535530516 +9787535533395 +9787535533975 +9787535535092 +9787535535436 +9787535536617 +9787535537355 +9787535537416 +9787535537966 +9787535538581 +9787535540447 +9787535541642 +9787535541673 +9787535541703 +9787535541758 +9787535541802 +9787535541925 +9787535545077 +9787535546340 +9787535546937 +9787535547262 +9787535550101 +9787535551078 +9787535551115 +9787535551504 +9787535551863 +9787535552037 +9787535552341 +9787535553577 +9787535554765 +9787535556516 +9787535561121 +9787535564467 +9787535564726 +9787535566317 +9787535567413 +9787535567420 +9787535567451 +9787535572578 +9787535576439 +9787535578440 +9787535579379 +9787535579409 +9787535594204 +9787535594655 +9787535596178 +9787535600073 +9787535600080 +9787535600370 +9787535601001 +9787535601148 +9787535601353 +9787535601438 +9787535601742 +9787535602114 +9787535602121 +9787535602312 +9787535602428 +9787535602466 +9787535602640 +9787535603241 +9787535603289 +9787535603357 +9787535603395 +9787535603593 +9787535603876 +9787535603951 +9787535603968 +9787535604040 +9787535604125 +9787535604231 +9787535604354 +9787535604682 +9787535604781 +9787535605030 +9787535605221 +9787535605252 +9787535605443 +9787535606105 +9787535606501 +9787535606570 +9787535606587 +9787535606594 +9787535606907 +9787535606983 +9787535607034 +9787535607089 +9787535607157 +9787535607270 +9787535607379 +9787535608017 +9787535608079 +9787535608253 +9787535608406 +9787535609250 +9787535609410 +9787535609564 +9787535609632 +9787535609717 +9787535610256 +9787535610324 +9787535610737 +9787535610904 +9787535611048 +9787535611055 +9787535611109 +9787535611116 +9787535611130 +9787535611147 +9787535611154 +9787535611161 +9787535611178 +9787535611581 +9787535611970 +9787535612007 +9787535612588 +9787535612649 +9787535612823 +9787535613677 +9787535613738 +9787535613769 +9787535614001 +9787535614278 +9787535614360 +9787535614407 +9787535614421 +9787535614520 +9787535614643 +9787535614667 +9787535614674 +9787535614711 +9787535614780 +9787535614797 +9787535614971 +9787535615381 +9787535615541 +9787535615794 +9787535615909 +9787535615961 +9787535616340 +9787535616357 +9787535617538 +9787535617682 +9787535618252 +9787535618290 +9787535619204 +9787535619716 +9787535619723 +9787535620217 +9787535620224 +9787535620231 +9787535620569 +9787535621603 +9787535622204 +9787535623140 +9787535623171 +9787535623454 +9787535624314 +9787535624574 +9787535624635 +9787535625359 +9787535625434 +9787535625731 +9787535625854 +9787535625861 +9787535626189 +9787535626318 +9787535626578 +9787535627759 +9787535628053 +9787535628619 +9787535629029 +9787535630728 +9787535633941 +9787535634382 +9787535634580 +9787535634733 +9787535635686 +9787535637215 +9787535637864 +9787535638250 +9787535638373 +9787535638632 +9787535638915 +9787535639233 +9787535641366 +9787535643483 +9787535644237 +9787535644428 +9787535644954 +9787535645005 +9787535645272 +9787535647177 +9787535647252 +9787535647481 +9787535647733 +9787535648112 +9787535648525 +9787535648662 +9787535648846 +9787535649157 +9787535650030 +9787535650917 +9787535651112 +9787535651310 +9787535651808 +9787535651891 +9787535652935 +9787535653208 +9787535653758 +9787535653925 +9787535653956 +9787535654151 +9787535654762 +9787535655615 +9787535656070 +9787535656353 +9787535658050 +9787535658142 +9787535658876 +9787535659354 +9787535660060 +9787535660923 +9787535660961 +9787535660978 +9787535661142 +9787535661166 +9787535661234 +9787535661258 +9787535661470 +9787535661845 +9787535662002 +9787535662071 +9787535662514 +9787535662774 +9787535662859 +9787535663153 +9787535664471 +9787535664907 +9787535664914 +9787535665478 +9787535665560 +9787535665706 +9787535666574 +9787535666680 +9787535667038 +9787535667793 +9787535669919 +9787535670083 +9787535670120 +9787535670762 +9787535670793 +9787535672162 +9787535674753 +9787535675293 +9787535678164 +9787535678256 +9787535678324 +9787535678447 +9787535681058 +9787535681348 +9787535681836 +9787535682697 +9787535682932 +9787535684356 +9787535684363 +9787535684486 +9787535685124 +9787535685704 +9787535685872 +9787535686848 +9787535687203 +9787535687272 +9787535687357 +9787535688538 +9787535688705 +9787535690067 +9787535690258 +9787535690647 +9787535690937 +9787535692290 +9787535692979 +9787535694935 +9787535695253 +9787535695260 +9787535695345 +9787535695352 +9787535695383 +9787535695390 +9787535695789 +9787535695833 +9787535696045 +9787535696915 +9787535697066 +9787535697677 +9787535700261 +9787535700575 +9787535700933 +9787535701022 +9787535701039 +9787535701091 +9787535701138 +9787535701626 +9787535702142 +9787535702265 +9787535703422 +9787535703606 +9787535703736 +9787535703743 +9787535703910 +9787535704016 +9787535704085 +9787535704399 +9787535704542 +9787535704696 +9787535704849 +9787535705778 +9787535706164 +9787535706546 +9787535706645 +9787535706836 +9787535706997 +9787535707048 +9787535707819 +9787535708311 +9787535708335 +9787535708595 +9787535708656 +9787535708687 +9787535709349 +9787535709530 +9787535709554 +9787535710079 +9787535710086 +9787535710321 +9787535710697 +9787535710819 +9787535711090 +9787535711694 +9787535712226 +9787535713421 +9787535714039 +9787535714060 +9787535714428 +9787535714442 +9787535715005 +9787535716514 +9787535717054 +9787535717375 +9787535717658 +9787535718617 +9787535718822 +9787535719126 +9787535719959 +9787535720481 +9787535720856 +9787535720924 +9787535722096 +9787535722102 +9787535722331 +9787535722485 +9787535723215 +9787535723321 +9787535723338 +9787535723734 +9787535723895 +9787535723901 +9787535723918 +9787535725462 +9787535725929 +9787535726292 +9787535727350 +9787535727367 +9787535727978 +9787535728036 +9787535728524 +9787535729279 +9787535729286 +9787535729637 +9787535729668 +9787535730190 +9787535730206 +9787535730770 +9787535731791 +9787535732286 +9787535732767 +9787535734310 +9787535734464 +9787535735331 +9787535737366 +9787535737663 +9787535738431 +9787535738752 +9787535739513 +9787535744258 +9787535744586 +9787535747518 +9787535747655 +9787535748157 +9787535751294 +9787535751768 +9787535752444 +9787535752741 +9787535753038 +9787535753380 +9787535754622 +9787535756787 +9787535757500 +9787535758965 +9787535759795 +9787535760340 +9787535760463 +9787535760494 +9787535760630 +9787535761323 +9787535761958 +9787535761965 +9787535763006 +9787535763532 +9787535764690 +9787535766212 +9787535766663 +9787535768452 +9787535768797 +9787535768995 +9787535769343 +9787535770110 +9787535771322 +9787535771667 +9787535773890 +9787535774668 +9787535774989 +9787535774996 +9787535775481 +9787535777966 +9787535778086 +9787535780645 +9787535780997 +9787535781093 +9787535781697 +9787535782908 +9787535785312 +9787535785718 +9787535788177 +9787535788221 +9787535788368 +9787535788399 +9787535788504 +9787535790828 +9787535790965 +9787535793997 +9787535797438 +9787535799005 +9787535800978 +9787535801173 +9787535801883 +9787535802354 +9787535802798 +9787535802934 +9787535803344 +9787535803696 +9787535803825 +9787535803955 +9787535803979 +9787535804228 +9787535804471 +9787535804891 +9787535806024 +9787535806314 +9787535807151 +9787535807168 +9787535807212 +9787535807403 +9787535807717 +9787535807823 +9787535809582 +9787535811202 +9787535811714 +9787535812148 +9787535812292 +9787535816306 +9787535816368 +9787535816405 +9787535816436 +9787535819345 +9787535820860 +9787535823380 +9787535823663 +9787535825872 +9787535826671 +9787535827098 +9787535827500 +9787535827555 +9787535833464 +9787535834102 +9787535834508 +9787535835116 +9787535835321 +9787535837219 +9787535838216 +9787535838513 +9787535838919 +9787535838933 +9787535838957 +9787535839497 +9787535840349 +9787535841353 +9787535841506 +9787535841735 +9787535841865 +9787535842152 +9787535842398 +9787535842473 +9787535844354 +9787535844866 +9787535845382 +9787535845979 +9787535846020 +9787535846068 +9787535847751 +9787535847928 +9787535847980 +9787535848093 +9787535848291 +9787535849304 +9787535851321 +9787535851697 +9787535851703 +9787535851895 +9787535852625 +9787535855060 +9787535855121 +9787535855138 +9787535856739 +9787535857798 +9787535857958 +9787535857972 +9787535858511 +9787535863362 +9787535864703 +9787535865199 +9787535865335 +9787535865526 +9787535866158 +9787535868299 +9787535869463 +9787535869500 +9787535869753 +9787535871770 +9787535872173 +9787535874429 +9787535876577 +9787535878632 +9787535878663 +9787535878670 +9787535878878 +9787535879110 +9787535880390 +9787535881151 +9787535881915 +9787535881960 +9787535882035 +9787535882240 +9787535882271 +9787535883384 +9787535884015 +9787535884749 +9787535886477 +9787535886774 +9787535889072 +9787535890191 +9787535890788 +9787535892140 +9787535892348 +9787535892485 +9787535893611 +9787535893635 +9787535893680 +9787535894755 +9787535896780 +9787535896797 +9787535897374 +9787535897527 +9787535897558 +9787535897572 +9787535900067 +9787535900296 +9787535900371 +9787535900586 +9787535900951 +9787535901156 +9787535901460 +9787535901477 +9787535901491 +9787535901590 +9787535901613 +9787535902061 +9787535902344 +9787535902429 +9787535902443 +9787535902504 +9787535902511 +9787535903327 +9787535903358 +9787535903617 +9787535903891 +9787535904348 +9787535904355 +9787535904539 +9787535904669 +9787535904812 +9787535904973 +9787535905031 +9787535905215 +9787535905567 +9787535905659 +9787535905741 +9787535905840 +9787535905994 +9787535906076 +9787535906410 +9787535906489 +9787535906502 +9787535906526 +9787535906571 +9787535906670 +9787535906755 +9787535907622 +9787535907967 +9787535908339 +9787535908391 +9787535908698 +9787535908773 +9787535908902 +9787535909039 +9787535909145 +9787535909268 +9787535909312 +9787535909435 +9787535909640 +9787535909800 +9787535909923 +9787535910127 +9787535910202 +9787535910325 +9787535910349 +9787535910387 +9787535910639 +9787535910943 +9787535910974 +9787535911049 +9787535911858 +9787535912053 +9787535912091 +9787535912367 +9787535912602 +9787535912664 +9787535913470 +9787535913968 +9787535914033 +9787535914163 +9787535914194 +9787535914446 +9787535914729 +9787535914835 +9787535914965 +9787535915405 +9787535915733 +9787535915764 +9787535915795 +9787535915986 +9787535916037 +9787535916051 +9787535916310 +9787535916365 +9787535916631 +9787535916815 +9787535916846 +9787535917089 +9787535917584 +9787535917591 +9787535917607 +9787535917621 +9787535917638 +9787535918420 +9787535918499 +9787535919083 +9787535919175 +9787535919311 +9787535919380 +9787535919458 +9787535919717 +9787535919731 +9787535919977 +9787535920386 +9787535920409 +9787535921260 +9787535921499 +9787535921918 +9787535921925 +9787535922045 +9787535922762 +9787535922823 +9787535922939 +9787535923165 +9787535923400 +9787535923431 +9787535923455 +9787535923677 +9787535923769 +9787535923851 +9787535924261 +9787535924353 +9787535924711 +9787535925114 +9787535925305 +9787535925510 +9787535926203 +9787535926227 +9787535926722 +9787535926791 +9787535926821 +9787535927149 +9787535928009 +9787535928207 +9787535928627 +9787535928863 +9787535928870 +9787535930019 +9787535930125 +9787535930309 +9787535930408 +9787535930491 +9787535931030 +9787535931405 +9787535931429 +9787535932945 +9787535933065 +9787535933089 +9787535933133 +9787535933690 +9787535934468 +9787535936172 +9787535936516 +9787535936714 +9787535937490 +9787535938404 +9787535938954 +9787535943309 +9787535944214 +9787535948922 +9787535950918 +9787535951960 +9787535952080 +9787535952912 +9787535952981 +9787535955623 +9787535956644 +9787535956750 +9787535958068 +9787535958297 +9787535958600 +9787535960061 +9787535960580 +9787535965875 +9787535967411 +9787535971272 +9787535972699 +9787535973719 +9787535974761 +9787535975843 +9787535976727 +9787535976949 +9787535977526 +9787535978165 +9787535979070 +9787535979520 +9787535982018 +9787535982247 +9787535984814 +9787536000247 +9787536000490 +9787536000537 +9787536000650 +9787536001145 +9787536001251 +9787536001497 +9787536001596 +9787536001947 +9787536002142 +9787536002289 +9787536002418 +9787536002425 +9787536002548 +9787536003088 +9787536003934 +9787536004023 +9787536004030 +9787536004177 +9787536004245 +9787536004443 +9787536004733 +9787536005457 +9787536005877 +9787536006461 +9787536006515 +9787536006553 +9787536006713 +9787536006737 +9787536006850 +9787536006898 +9787536006997 +9787536007048 +9787536007277 +9787536007390 +9787536007758 +9787536008816 +9787536008854 +9787536009066 +9787536009103 +9787536009455 +9787536009462 +9787536009592 +9787536009790 +9787536009813 +9787536009882 +9787536009950 +9787536009967 +9787536010048 +9787536010079 +9787536010260 +9787536010277 +9787536010291 +9787536010499 +9787536010505 +9787536010758 +9787536010765 +9787536011786 +9787536011878 +9787536012011 +9787536012073 +9787536012608 +9787536012868 +9787536012981 +9787536013070 +9787536013117 +9787536013278 +9787536013285 +9787536013414 +9787536013537 +9787536013674 +9787536013902 +9787536013971 +9787536014039 +9787536014046 +9787536014084 +9787536014091 +9787536014251 +9787536014459 +9787536014497 +9787536014794 +9787536015333 +9787536015562 +9787536015685 +9787536015760 +9787536015784 +9787536015920 +9787536015999 +9787536016002 +9787536016095 +9787536016675 +9787536016699 +9787536016774 +9787536016996 +9787536017252 +9787536017429 +9787536017498 +9787536017634 +9787536017689 +9787536017924 +9787536018075 +9787536018310 +9787536018693 +9787536018761 +9787536019218 +9787536019232 +9787536019522 +9787536019584 +9787536020078 +9787536020221 +9787536020238 +9787536020276 +9787536020603 +9787536020733 +9787536020740 +9787536020863 +9787536020979 +9787536021006 +9787536021198 +9787536021273 +9787536021839 +9787536021945 +9787536022157 +9787536022478 +9787536022492 +9787536022508 +9787536022515 +9787536022522 +9787536022553 +9787536022607 +9787536022652 +9787536022683 +9787536022690 +9787536022720 +9787536022744 +9787536022812 +9787536022843 +9787536022874 +9787536023000 +9787536023178 +9787536023369 +9787536023413 +9787536023451 +9787536023734 +9787536023741 +9787536023765 +9787536023895 +9787536024007 +9787536024014 +9787536024021 +9787536024090 +9787536024113 +9787536024151 +9787536024267 +9787536024489 +9787536024571 +9787536024649 +9787536024670 +9787536024960 +9787536025448 +9787536025837 +9787536025851 +9787536025899 +9787536025950 +9787536025981 +9787536025998 +9787536026049 +9787536026094 +9787536026377 +9787536026476 +9787536026605 +9787536027077 +9787536027206 +9787536027329 +9787536027336 +9787536027343 +9787536027510 +9787536027794 +9787536027800 +9787536027916 +9787536027923 +9787536028203 +9787536028333 +9787536028500 +9787536028593 +9787536028616 +9787536028982 +9787536029071 +9787536029576 +9787536029606 +9787536030107 +9787536030282 +9787536030435 +9787536030602 +9787536031180 +9787536031241 +9787536031562 +9787536031692 +9787536031852 +9787536032118 +9787536032415 +9787536032545 +9787536032552 +9787536033139 +9787536033320 +9787536033405 +9787536033801 +9787536034150 +9787536034372 +9787536034402 +9787536034419 +9787536034624 +9787536034778 +9787536034822 +9787536035157 +9787536035850 +9787536035867 +9787536035874 +9787536035928 +9787536036536 +9787536036772 +9787536036826 +9787536036970 +9787536037090 +9787536037434 +9787536037458 +9787536037847 +9787536038486 +9787536038653 +9787536039070 +9787536039148 +9787536039551 +9787536040847 +9787536041059 +9787536041240 +9787536041271 +9787536041486 +9787536041707 +9787536042087 +9787536042117 +9787536042667 +9787536042933 +9787536042964 +9787536044180 +9787536044463 +9787536044487 +9787536045248 +9787536045545 +9787536046023 +9787536046351 +9787536046375 +9787536047129 +9787536047242 +9787536048492 +9787536049390 +9787536049697 +9787536051591 +9787536053083 +9787536053823 +9787536054714 +9787536055247 +9787536056183 +9787536056244 +9787536056626 +9787536056718 +9787536056848 +9787536059030 +9787536059085 +9787536060326 +9787536060623 +9787536060746 +9787536060791 +9787536060814 +9787536061996 +9787536062023 +9787536062597 +9787536062771 +9787536064508 +9787536064607 +9787536064676 +9787536066274 +9787536066571 +9787536066786 +9787536067202 +9787536067905 +9787536068032 +9787536068162 +9787536069206 +9787536071339 +9787536072015 +9787536073241 +9787536073654 +9787536073906 +9787536077454 +9787536078291 +9787536078413 +9787536082113 +9787536086517 +9787536088252 +9787536088344 +9787536090217 +9787536090569 +9787536092709 +9787536093515 +9787536094130 +9787536096295 +9787536096769 +9787536097605 +9787536098473 +9787536098749 +9787536099197 +9787536099906 +9787536100404 +9787536100947 +9787536101166 +9787536101272 +9787536102705 +9787536102842 +9787536102859 +9787536103207 +9787536103290 +9787536104495 +9787536104723 +9787536104914 +9787536105195 +9787536105454 +9787536105775 +9787536106130 +9787536106253 +9787536106796 +9787536106970 +9787536107281 +9787536107298 +9787536107779 +9787536108172 +9787536108325 +9787536108547 +9787536108875 +9787536108905 +9787536109520 +9787536110069 +9787536110274 +9787536110755 +9787536110830 +9787536111516 +9787536111592 +9787536111899 +9787536112346 +9787536112773 +9787536113268 +9787536113411 +9787536113619 +9787536113879 +9787536113985 +9787536114234 +9787536114302 +9787536114395 +9787536114500 +9787536114630 +9787536115019 +9787536115651 +9787536115859 +9787536116153 +9787536116399 +9787536116634 +9787536117037 +9787536117389 +9787536117709 +9787536117853 +9787536118324 +9787536118621 +9787536118645 +9787536118812 +9787536119000 +9787536120143 +9787536120167 +9787536120334 +9787536120518 +9787536120716 +9787536120846 +9787536120945 +9787536122260 +9787536122956 +9787536123205 +9787536123267 +9787536123502 +9787536123816 +9787536123946 +9787536124059 +9787536125568 +9787536125872 +9787536126176 +9787536127609 +9787536129290 +9787536130449 +9787536131446 +9787536132863 +9787536133563 +9787536134034 +9787536135420 +9787536143395 +9787536143838 +9787536147614 +9787536147645 +9787536149496 +9787536150140 +9787536152991 +9787536159990 +9787536161382 +9787536162303 +9787536165496 +9787536165724 +9787536167896 +9787536167995 +9787536171114 +9787536172524 +9787536173613 +9787536174160 +9787536174221 +9787536174405 +9787536176720 +9787536176737 +9787536176799 +9787536200203 +9787536200258 +9787536200999 +9787536201309 +9787536201514 +9787536201620 +9787536201644 +9787536201859 +9787536204287 +9787536204751 +9787536205499 +9787536206212 +9787536206236 +9787536206298 +9787536206571 +9787536206595 +9787536206946 +9787536207653 +9787536207844 +9787536208551 +9787536208681 +9787536209176 +9787536209671 +9787536209695 +9787536209756 +9787536210059 +9787536210295 +9787536210769 +9787536211216 +9787536211551 +9787536211759 +9787536211872 +9787536211902 +9787536212169 +9787536213067 +9787536213210 +9787536213265 +9787536213401 +9787536213517 +9787536213586 +9787536214057 +9787536214088 +9787536214613 +9787536214699 +9787536215375 +9787536215399 +9787536215641 +9787536215900 +9787536216044 +9787536216150 +9787536216198 +9787536216709 +9787536217171 +9787536217270 +9787536218055 +9787536218512 +9787536218994 +9787536219434 +9787536219809 +9787536220027 +9787536220157 +9787536220522 +9787536221826 +9787536221840 +9787536221925 +9787536222090 +9787536222137 +9787536222793 +9787536223028 +9787536223059 +9787536223622 +9787536224063 +9787536224209 +9787536224216 +9787536224674 +9787536225176 +9787536225275 +9787536225718 +9787536226418 +9787536226609 +9787536227378 +9787536227415 +9787536227583 +9787536227903 +9787536228009 +9787536228207 +9787536228344 +9787536228788 +9787536229358 +9787536229594 +9787536229990 +9787536230606 +9787536230897 +9787536230941 +9787536230996 +9787536231474 +9787536231603 +9787536232082 +9787536232112 +9787536233126 +9787536233324 +9787536233454 +9787536233935 +9787536235656 +9787536236257 +9787536236509 +9787536236769 +9787536237933 +9787536238312 +9787536238404 +9787536238534 +9787536238640 +9787536238893 +9787536238923 +9787536239210 +9787536239319 +9787536239333 +9787536239357 +9787536240124 +9787536240278 +9787536240452 +9787536240780 +9787536241657 +9787536242081 +9787536242463 +9787536242685 +9787536242852 +9787536243231 +9787536243675 +9787536243743 +9787536244283 +9787536244634 +9787536245402 +9787536245464 +9787536245563 +9787536245648 +9787536245792 +9787536246188 +9787536246584 +9787536246829 +9787536247161 +9787536248243 +9787536248328 +9787536248403 +9787536248700 +9787536248816 +9787536249288 +9787536249608 +9787536249646 +9787536250130 +9787536250260 +9787536250413 +9787536250659 +9787536250857 +9787536250987 +9787536251724 +9787536252288 +9787536252714 +9787536253346 +9787536254060 +9787536254800 +9787536255388 +9787536255586 +9787536256040 +9787536256064 +9787536258785 +9787536258808 +9787536261266 +9787536261624 +9787536262904 +9787536264342 +9787536265011 +9787536268951 +9787536268975 +9787536268982 +9787536268999 +9787536270190 +9787536271098 +9787536272033 +9787536275218 +9787536275607 +9787536276000 +9787536277663 +9787536277946 +9787536278189 +9787536278288 +9787536280175 +9787536280946 +9787536301030 +9787536301702 +9787536301719 +9787536301740 +9787536301993 +9787536302112 +9787536302884 +9787536302914 +9787536303744 +9787536304154 +9787536304529 +9787536305199 +9787536305441 +9787536305854 +9787536305885 +9787536305892 +9787536305984 +9787536306189 +9787536306554 +9787536306561 +9787536306943 +9787536307346 +9787536307506 +9787536307735 +9787536307827 +9787536308497 +9787536308602 +9787536308671 +9787536308831 +9787536308893 +9787536309142 +9787536309920 +9787536310070 +9787536310254 +9787536310452 +9787536310513 +9787536310681 +9787536311312 +9787536311336 +9787536311350 +9787536311664 +9787536311862 +9787536312029 +9787536312128 +9787536312364 +9787536312463 +9787536312647 +9787536312913 +9787536313040 +9787536313132 +9787536315389 +9787536315976 +9787536316591 +9787536317475 +9787536317529 +9787536317871 +9787536318649 +9787536319264 +9787536319486 +9787536320253 +9787536320314 +9787536321229 +9787536321366 +9787536321625 +9787536321649 +9787536322462 +9787536323049 +9787536323247 +9787536323834 +9787536324756 +9787536324930 +9787536325371 +9787536325593 +9787536326477 +9787536326521 +9787536326576 +9787536327047 +9787536327085 +9787536327092 +9787536327115 +9787536327238 +9787536327733 +9787536327894 +9787536328044 +9787536328204 +9787536328211 +9787536328365 +9787536328525 +9787536328587 +9787536328815 +9787536329041 +9787536329072 +9787536329119 +9787536329201 +9787536329270 +9787536329300 +9787536329614 +9787536329645 +9787536329683 +9787536329690 +9787536329737 +9787536329744 +9787536329782 +9787536329805 +9787536329812 +9787536329911 +9787536329959 +9787536330030 +9787536330085 +9787536330252 +9787536330290 +9787536330542 +9787536330559 +9787536330672 +9787536330689 +9787536330801 +9787536330900 +9787536330955 +9787536330962 +9787536331006 +9787536331228 +9787536331273 +9787536331389 +9787536331549 +9787536331594 +9787536331624 +9787536331631 +9787536331815 +9787536331822 +9787536331853 +9787536332119 +9787536332133 +9787536332201 +9787536332225 +9787536332553 +9787536332560 +9787536332744 +9787536333314 +9787536333345 +9787536333390 +9787536333406 +9787536333475 +9787536333994 +9787536334632 +9787536337329 +9787536338371 +9787536341395 +9787536341937 +9787536341944 +9787536342347 +9787536342675 +9787536346666 +9787536347199 +9787536354890 +9787536356986 +9787536357686 +9787536358515 +9787536358751 +9787536360082 +9787536361980 +9787536362529 +9787536363809 +9787536363885 +9787536364691 +9787536364868 +9787536364950 +9787536365421 +9787536365513 +9787536366763 +9787536366794 +9787536367005 +9787536367562 +9787536367586 +9787536368927 +9787536369955 +9787536374713 +9787536377684 +9787536400146 +9787536400368 +9787536401433 +9787536401662 +9787536401778 +9787536401914 +9787536402157 +9787536402164 +9787536402256 +9787536402973 +9787536403017 +9787536403390 +9787536403451 +9787536403475 +9787536404588 +9787536404809 +9787536404830 +9787536404878 +9787536405110 +9787536405172 +9787536405219 +9787536405233 +9787536405240 +9787536405516 +9787536405677 +9787536406117 +9787536406162 +9787536406186 +9787536406346 +9787536406483 +9787536406605 +9787536408029 +9787536408036 +9787536408890 +9787536409019 +9787536409101 +9787536409170 +9787536409521 +9787536410022 +9787536411555 +9787536411777 +9787536412194 +9787536412200 +9787536412217 +9787536412439 +9787536412668 +9787536412927 +9787536413160 +9787536413375 +9787536413627 +9787536413726 +9787536413764 +9787536414501 +9787536415027 +9787536415041 +9787536415928 +9787536415959 +9787536416253 +9787536417151 +9787536417908 +9787536417915 +9787536417939 +9787536417946 +9787536417953 +9787536417960 +9787536417977 +9787536418486 +9787536418790 +9787536419162 +9787536419414 +9787536419681 +9787536420205 +9787536420304 +9787536420342 +9787536420427 +9787536420434 +9787536420830 +9787536421202 +9787536421547 +9787536421592 +9787536421707 +9787536421875 +9787536422216 +9787536422414 +9787536422773 +9787536423190 +9787536423237 +9787536423244 +9787536423480 +9787536424142 +9787536424531 +9787536424760 +9787536425088 +9787536425255 +9787536425323 +9787536425385 +9787536425552 +9787536425828 +9787536425897 +9787536426023 +9787536426276 +9787536426757 +9787536427075 +9787536427501 +9787536428119 +9787536428416 +9787536428720 +9787536428737 +9787536429321 +9787536429567 +9787536430037 +9787536430372 +9787536430709 +9787536430761 +9787536430792 +9787536430938 +9787536430952 +9787536431089 +9787536431126 +9787536431683 +9787536431775 +9787536432017 +9787536432062 +9787536432109 +9787536432499 +9787536433380 +9787536433496 +9787536434424 +9787536434677 +9787536434721 +9787536435063 +9787536436176 +9787536436312 +9787536436367 +9787536436954 +9787536437937 +9787536438439 +9787536438538 +9787536438798 +9787536439092 +9787536439399 +9787536440005 +9787536440166 +9787536441347 +9787536441408 +9787536442184 +9787536442917 +9787536443082 +9787536443198 +9787536443242 +9787536443372 +9787536443501 +9787536444171 +9787536444607 +9787536444997 +9787536445147 +9787536446755 +9787536447806 +9787536447967 +9787536448391 +9787536448520 +9787536448650 +9787536449008 +9787536449466 +9787536449893 +9787536450462 +9787536450547 +9787536450653 +9787536450745 +9787536451254 +9787536452428 +9787536453227 +9787536454705 +9787536455160 +9787536455283 +9787536455399 +9787536456419 +9787536456464 +9787536458864 +9787536460621 +9787536461345 +9787536462533 +9787536463127 +9787536465008 +9787536465336 +9787536468405 +9787536469723 +9787536469839 +9787536469983 +9787536470491 +9787536470774 +9787536471924 +9787536472037 +9787536473133 +9787536473638 +9787536475113 +9787536476868 +9787536477056 +9787536477223 +9787536477278 +9787536477520 +9787536478855 +9787536478862 +9787536479388 +9787536479838 +9787536479845 +9787536479913 +9787536479944 +9787536480063 +9787536480070 +9787536480179 +9787536480209 +9787536480223 +9787536480315 +9787536481787 +9787536482258 +9787536484603 +9787536484931 +9787536485358 +9787536487413 +9787536488854 +9787536491557 +9787536492059 +9787536494084 +9787536494299 +9787536494619 +9787536496002 +9787536496842 +9787536498532 +9787536498808 +9787536499126 +9787536501119 +9787536506367 +9787536510005 +9787536512795 +9787536513198 +9787536513884 +9787536515482 +9787536516496 +9787536519633 +9787536520738 +9787536523951 +9787536526099 +9787536526174 +9787536526907 +9787536528338 +9787536529311 +9787536531130 +9787536531307 +9787536533813 +9787536534582 +9787536534605 +9787536534612 +9787536535596 +9787536535640 +9787536535657 +9787536535688 +9787536536074 +9787536536661 +9787536536678 +9787536536685 +9787536539204 +9787536540095 +9787536542174 +9787536542655 +9787536544239 +9787536544260 +9787536545373 +9787536545380 +9787536545762 +9787536545779 +9787536546424 +9787536546592 +9787536546806 +9787536546882 +9787536546912 +9787536547896 +9787536548886 +9787536551008 +9787536552661 +9787536553552 +9787536553996 +9787536554009 +9787536554559 +9787536554566 +9787536554986 +9787536556591 +9787536557017 +9787536558625 +9787536561090 +9787536561359 +9787536562431 +9787536562806 +9787536563476 +9787536563490 +9787536565388 +9787536565401 +9787536565425 +9787536565876 +9787536566064 +9787536566613 +9787536567283 +9787536568716 +9787536572393 +9787536573536 +9787536578937 +9787536578968 +9787536580299 +9787536581302 +9787536582620 +9787536582637 +9787536582651 +9787536584112 +9787536586765 +9787536587946 +9787536588578 +9787536588592 +9787536589452 +9787536590403 +9787536590649 +9787536590670 +9787536590823 +9787536591547 +9787536592285 +9787536592438 +9787536592735 +9787536592766 +9787536593237 +9787536593282 +9787536593534 +9787536593541 +9787536593565 +9787536593978 +9787536593985 +9787536594012 +9787536594050 +9787536594180 +9787536594906 +9787536594944 +9787536596412 +9787536596719 +9787536597075 +9787536597464 +9787536597525 +9787536598744 +9787536599284 +9787536600003 +9787536600065 +9787536600218 +9787536600492 +9787536600522 +9787536600553 +9787536600591 +9787536600836 +9787536600843 +9787536600959 +9787536601017 +9787536601093 +9787536601116 +9787536601123 +9787536601376 +9787536601468 +9787536601871 +9787536602069 +9787536602137 +9787536602212 +9787536602304 +9787536602496 +9787536602540 +9787536602861 +9787536602892 +9787536602908 +9787536603042 +9787536603301 +9787536603509 +9787536603684 +9787536603738 +9787536604377 +9787536604452 +9787536604636 +9787536604957 +9787536604964 +9787536604988 +9787536604995 +9787536605039 +9787536605206 +9787536605237 +9787536605244 +9787536605275 +9787536605558 +9787536605756 +9787536606197 +9787536606449 +9787536607170 +9787536608146 +9787536608443 +9787536608498 +9787536608580 +9787536608863 +9787536608955 +9787536609952 +9787536610224 +9787536610255 +9787536610262 +9787536611306 +9787536611504 +9787536611511 +9787536611726 +9787536612150 +9787536613003 +9787536613034 +9787536613058 +9787536613065 +9787536613690 +9787536613744 +9787536613812 +9787536613829 +9787536613836 +9787536613997 +9787536614284 +9787536614451 +9787536615069 +9787536615311 +9787536615748 +9787536616172 +9787536616233 +9787536616356 +9787536616394 +9787536616639 +9787536616912 +9787536617667 +9787536617766 +9787536617995 +9787536618015 +9787536618510 +9787536618800 +9787536619180 +9787536619272 +9787536619395 +9787536619449 +9787536619494 +9787536619708 +9787536619777 +9787536619821 +9787536621442 +9787536621459 +9787536621503 +9787536621589 +9787536621695 +9787536622463 +9787536622500 +9787536623668 +9787536623767 +9787536624528 +9787536625228 +9787536625235 +9787536625242 +9787536625341 +9787536626232 +9787536626317 +9787536626843 +9787536627260 +9787536627338 +9787536627598 +9787536629486 +9787536629813 +9787536630734 +9787536630840 +9787536630857 +9787536631397 +9787536631670 +9787536631762 +9787536631823 +9787536631885 +9787536631908 +9787536631953 +9787536632028 +9787536632110 +9787536632172 +9787536632196 +9787536632219 +9787536632646 +9787536632677 +9787536632691 +9787536632721 +9787536633049 +9787536633148 +9787536633346 +9787536633957 +9787536634282 +9787536634381 +9787536635609 +9787536635715 +9787536635791 +9787536635920 +9787536635951 +9787536636309 +9787536636323 +9787536636385 +9787536636453 +9787536637382 +9787536637429 +9787536637634 +9787536638242 +9787536638518 +9787536638754 +9787536638846 +9787536638853 +9787536638860 +9787536638877 +9787536639218 +9787536639836 +9787536639867 +9787536639973 +9787536640085 +9787536640108 +9787536640429 +9787536640658 +9787536641037 +9787536643383 +9787536643772 +9787536644373 +9787536644571 +9787536644694 +9787536645981 +9787536646834 +9787536646926 +9787536647329 +9787536648265 +9787536648777 +9787536649477 +9787536649804 +9787536649811 +9787536649828 +9787536649859 +9787536650022 +9787536650985 +9787536651005 +9787536651173 +9787536651333 +9787536651371 +9787536651852 +9787536652118 +9787536653559 +9787536653603 +9787536653672 +9787536653801 +9787536653948 +9787536655638 +9787536656840 +9787536657229 +9787536657267 +9787536658349 +9787536659148 +9787536659759 +9787536660137 +9787536663015 +9787536663022 +9787536666146 +9787536666573 +9787536668034 +9787536668140 +9787536668744 +9787536670150 +9787536670808 +9787536671614 +9787536672901 +9787536673014 +9787536673069 +9787536673809 +9787536674394 +9787536674646 +9787536675476 +9787536675636 +9787536675766 +9787536675919 +9787536675995 +9787536676954 +9787536677074 +9787536677944 +9787536678323 +9787536679252 +9787536679665 +9787536681354 +9787536681484 +9787536681491 +9787536681866 +9787536682757 +9787536684669 +9787536685062 +9787536685079 +9787536685710 +9787536685734 +9787536686175 +9787536686236 +9787536686748 +9787536690394 +9787536690431 +9787536690448 +9787536690752 +9787536690776 +9787536691445 +9787536691957 +9787536692145 +9787536692787 +9787536692848 +9787536693135 +9787536694064 +9787536694095 +9787536694682 +9787536694743 +9787536694972 +9787536695955 +9787536696495 +9787536696969 +9787536697157 +9787536697447 +9787536697591 +9787536697676 +9787536698789 +9787536699366 +9787536699823 +9787536701373 +9787536701793 +9787536704084 +9787536705968 +9787536710801 +9787536712379 +9787536713253 +9787536714397 +9787536714861 +9787536715011 +9787536715189 +9787536715240 +9787536715271 +9787536716186 +9787536716766 +9787536716933 +9787536717435 +9787536717619 +9787536718036 +9787536718562 +9787536719156 +9787536719514 +9787536719545 +9787536719569 +9787536719576 +9787536719989 +9787536720138 +9787536720329 +9787536722132 +9787536722231 +9787536723115 +9787536723238 +9787536723290 +9787536723498 +9787536723573 +9787536724730 +9787536725737 +9787536726192 +9787536726635 +9787536726833 +9787536727137 +9787536728905 +9787536729155 +9787536729452 +9787536731349 +9787536731424 +9787536732216 +9787536732261 +9787536732339 +9787536732391 +9787536733787 +9787536735408 +9787536735545 +9787536735743 +9787536736078 +9787536737006 +9787536737754 +9787536738584 +9787536738676 +9787536739406 +9787536739901 +9787536740082 +9787536740280 +9787536740501 +9787536741188 +9787536742390 +9787536742826 +9787536743243 +9787536743502 +9787536743854 +9787536744301 +9787536746398 +9787536746626 +9787536746671 +9787536746923 +9787536747814 +9787536747906 +9787536748439 +9787536748743 +9787536749696 +9787536750012 +9787536750104 +9787536751569 +9787536751606 +9787536751910 +9787536752238 +9787536752283 +9787536752306 +9787536753068 +9787536753334 +9787536753983 +9787536754126 +9787536754225 +9787536754461 +9787536756038 +9787536757004 +9787536757387 +9787536757554 +9787536758179 +9787536758223 +9787536758773 +9787536758797 +9787536758827 +9787536758858 +9787536758865 +9787536758889 +9787536758896 +9787536758926 +9787536759442 +9787536759626 +9787536760363 +9787536762008 +9787536762053 +9787536762329 +9787536763067 +9787536763340 +9787536763722 +9787536763746 +9787536764071 +9787536765023 +9787536765399 +9787536771390 +9787536771871 +9787536773660 +9787536775213 +9787536775602 +9787536775657 +9787536778146 +9787536780323 +9787536788671 +9787536788718 +9787536789258 +9787536793170 +9787536800069 +9787536800144 +9787536800700 +9787536800717 +9787536800823 +9787536800885 +9787536801912 +9787536802476 +9787536802834 +9787536802872 +9787536803626 +9787536803718 +9787536803787 +9787536804210 +9787536804708 +9787536805262 +9787536806467 +9787536806474 +9787536806559 +9787536806696 +9787536806726 +9787536806740 +9787536806870 +9787536807020 +9787536807174 +9787536807198 +9787536807938 +9787536807945 +9787536808621 +9787536809291 +9787536809376 +9787536809758 +9787536809789 +9787536810068 +9787536810198 +9787536810235 +9787536810785 +9787536810969 +9787536811027 +9787536811188 +9787536811331 +9787536811423 +9787536811447 +9787536811478 +9787536811515 +9787536811904 +9787536813809 +9787536813878 +9787536815872 +9787536816077 +9787536816787 +9787536817067 +9787536817159 +9787536817463 +9787536817494 +9787536817708 +9787536817913 +9787536818071 +9787536818873 +9787536821361 +9787536822252 +9787536823358 +9787536823938 +9787536824140 +9787536824287 +9787536825017 +9787536827349 +9787536827554 +9787536828070 +9787536828261 +9787536828735 +9787536829152 +9787536831018 +9787536831117 +9787536831421 +9787536832435 +9787536833029 +9787536833555 +9787536834415 +9787536836440 +9787536838871 +9787536839144 +9787536839953 +9787536841246 +9787536841420 +9787536842946 +9787536845541 +9787536900288 +9787536900318 +9787536900516 +9787536900547 +9787536900622 +9787536900745 +9787536900752 +9787536900950 +9787536901438 +9787536901704 +9787536902060 +9787536902213 +9787536902237 +9787536902930 +9787536904057 +9787536905184 +9787536906112 +9787536906280 +9787536906365 +9787536906846 +9787536906891 +9787536907348 +9787536908154 +9787536908192 +9787536908277 +9787536908314 +9787536908338 +9787536908987 +9787536909045 +9787536909144 +9787536909663 +9787536909854 +9787536910461 +9787536913547 +9787536914513 +9787536916074 +9787536917095 +9787536917484 +9787536917590 +9787536918597 +9787536919556 +9787536921986 +9787536922730 +9787536923270 +9787536923379 +9787536923973 +9787536924291 +9787536924505 +9787536925397 +9787536926059 +9787536926103 +9787536926110 +9787536926325 +9787536926332 +9787536926356 +9787536926561 +9787536926677 +9787536927865 +9787536929838 +9787536931916 +9787536931954 +9787536932357 +9787536932920 +9787536933293 +9787536933743 +9787536935969 +9787536936225 +9787536936416 +9787536936805 +9787536937604 +9787536937734 +9787536937758 +9787536937765 +9787536938687 +9787536938977 +9787536942042 +9787536943315 +9787536943322 +9787536943339 +9787536943353 +9787536943742 +9787536944749 +9787536945340 +9787536945692 +9787536946316 +9787536948204 +9787536948235 +9787536949041 +9787536949058 +9787536949539 +9787536950184 +9787536950979 +9787536951037 +9787536951921 +9787536953277 +9787536953529 +9787536953673 +9787536954083 +9787536955905 +9787536956193 +9787536956841 +9787536956896 +9787536957039 +9787536957381 +9787536957411 +9787536959408 +9787536959798 +9787536960107 +9787536961760 +9787536961890 +9787536961913 +9787536962361 +9787536963177 +9787536966499 +9787536966826 +9787536970335 +9787536970342 +9787536970472 +9787536970595 +9787536970991 +9787536972230 +9787536972674 +9787536972681 +9787536972698 +9787536972704 +9787536972711 +9787536972728 +9787536972759 +9787536972766 +9787536972773 +9787536974166 +9787536975231 +9787536977068 +9787536978461 +9787536979383 +9787536979581 +9787536980310 +9787536980747 +9787536980822 +9787536980846 +9787536981171 +9787536981423 +9787536981492 +9787536981737 +9787536981751 +9787536982628 +9787536983908 +9787536984745 +9787536984875 +9787536985629 +9787536986404 +9787536986480 +9787536986602 +9787536987593 +9787536992177 +9787537063715 +9787537069427 +9787537107617 +9787537112277 +9787537112406 +9787537112598 +9787537112628 +9787537113182 +9787537116145 +9787537117173 +9787537117937 +9787537118965 +9787537120395 +9787537120630 +9787537120654 +9787537120661 +9787537120678 +9787537120692 +9787537120708 +9787537120753 +9787537120999 +9787537121958 +9787537121965 +9787537122207 +9787537124430 +9787537124829 +9787537124928 +9787537124966 +9787537126854 +9787537126977 +9787537127059 +9787537127226 +9787537127301 +9787537127363 +9787537127899 +9787537129022 +9787537129725 +9787537129947 +9787537130424 +9787537130462 +9787537130981 +9787537131902 +9787537132374 +9787537132725 +9787537132770 +9787537132831 +9787537133203 +9787537133241 +9787537133562 +9787537133838 +9787537133975 +9787537134712 +9787537134842 +9787537135269 +9787537135856 +9787537135948 +9787537136662 +9787537136853 +9787537137140 +9787537138543 +9787537141154 +9787537141161 +9787537143172 +9787537143714 +9787537144087 +9787537144094 +9787537144605 +9787537146036 +9787537147729 +9787537148108 +9787537154390 +9787537156615 +9787537158473 +9787537158480 +9787537158497 +9787537158503 +9787537158596 +9787537158640 +9787537158909 +9787537161732 +9787537162623 +9787537163170 +9787537163187 +9787537163538 +9787537163552 +9787537165334 +9787537165396 +9787537166133 +9787537170512 +9787537172950 +9787537173025 +9787537177047 +9787537177054 +9787537178761 +9787537178778 +9787537178822 +9787537178839 +9787537185448 +9787537185455 +9787537185462 +9787537191142 +9787537192446 +9787537193115 +9787537193160 +9787537193177 +9787537194938 +9787537197854 +9787537197922 +9787537199025 +9787537199032 +9787537199087 +9787537199094 +9787537199100 +9787537211222 +9787537212014 +9787537212137 +9787537214476 +9787537220026 +9787537222150 +9787537228329 +9787537231275 +9787537231725 +9787537235167 +9787537235174 +9787537235303 +9787537236072 +9787537236423 +9787537236935 +9787537249188 +9787537250665 +9787537253772 +9787537255042 +9787537255493 +9787537255509 +9787537255516 +9787537255547 +9787537255578 +9787537255899 +9787537255905 +9787537256100 +9787537256483 +9787537258029 +9787537258401 +9787537259033 +9787537261609 +9787537267779 +9787537309615 +9787537309769 +9787537309844 +9787537309899 +9787537310147 +9787537310727 +9787537312158 +9787537314640 +9787537314657 +9787537314671 +9787537322027 +9787537330794 +9787537402187 +9787537402217 +9787537402378 +9787537403597 +9787537403603 +9787537403610 +9787537403795 +9787537403894 +9787537403900 +9787537403931 +9787537405898 +9787537406697 +9787537414944 +9787537500029 +9787537500036 +9787537500074 +9787537500364 +9787537500388 +9787537500913 +9787537500951 +9787537501101 +9787537501118 +9787537501149 +9787537501286 +9787537501514 +9787537502283 +9787537502726 +9787537502887 +9787537503600 +9787537504089 +9787537504096 +9787537504201 +9787537504232 +9787537504744 +9787537504751 +9787537504898 +9787537505062 +9787537505963 +9787537506038 +9787537506168 +9787537506205 +9787537506397 +9787537506656 +9787537506861 +9787537506953 +9787537507295 +9787537507387 +9787537507530 +9787537507639 +9787537507875 +9787537508186 +9787537508476 +9787537509015 +9787537509305 +9787537509923 +9787537509930 +9787537509978 +9787537510219 +9787537510431 +9787537510837 +9787537511469 +9787537511933 +9787537512848 +9787537512855 +9787537512930 +9787537513364 +9787537513531 +9787537513623 +9787537513814 +9787537513869 +9787537513876 +9787537513937 +9787537513951 +9787537514460 +9787537514736 +9787537514750 +9787537515160 +9787537515535 +9787537515610 +9787537515627 +9787537516594 +9787537517164 +9787537517416 +9787537517768 +9787537518192 +9787537518536 +9787537518963 +9787537519144 +9787537519168 +9787537519182 +9787537519786 +9787537519861 +9787537519878 +9787537519892 +9787537520041 +9787537520058 +9787537520478 +9787537521543 +9787537524919 +9787537525015 +9787537525152 +9787537525176 +9787537525572 +9787537526470 +9787537526593 +9787537526722 +9787537527064 +9787537529013 +9787537531566 +9787537532709 +9787537533522 +9787537534253 +9787537535335 +9787537535748 +9787537535755 +9787537536035 +9787537536356 +9787537537155 +9787537538589 +9787537538619 +9787537538657 +9787537538671 +9787537538688 +9787537540049 +9787537543897 +9787537544016 +9787537551137 +9787537551151 +9787537551168 +9787537551274 +9787537551298 +9787537551342 +9787537553025 +9787537553056 +9787537555579 +9787537555746 +9787537557672 +9787537558402 +9787537558730 +9787537558921 +9787537559157 +9787537559492 +9787537561853 +9787537564793 +9787537564885 +9787537565516 +9787537566766 +9787537566933 +9787537567244 +9787537567794 +9787537568517 +9787537570893 +9787537571067 +9787537572897 +9787537573504 +9787537573986 +9787537574112 +9787537574204 +9787537574693 +9787537576062 +9787537590402 +9787537591065 +9787537592239 +9787537594905 +9787537594943 +9787537595377 +9787537595391 +9787537596718 +9787537596947 +9787537596961 +9787537597449 +9787537598880 +9787537599214 +9787537602488 +9787537602860 +9787537605625 +9787537605649 +9787537606899 +9787537606929 +9787537607438 +9787537608312 +9787537608466 +9787537608961 +9787537610711 +9787537611398 +9787537612784 +9787537613019 +9787537614108 +9787537614498 +9787537614610 +9787537614665 +9787537615372 +9787537616119 +9787537617451 +9787537624848 +9787537624879 +9787537625197 +9787537625678 +9787537627009 +9787537627795 +9787537627801 +9787537629751 +9787537629775 +9787537632386 +9787537632409 +9787537632447 +9787537632584 +9787537632966 +9787537633413 +9787537635509 +9787537640879 +9787537640893 +9787537641012 +9787537641074 +9787537641227 +9787537643658 +9787537643764 +9787537643771 +9787537643801 +9787537643825 +9787537648936 +9787537649049 +9787537649612 +9787537649773 +9787537649988 +9787537650052 +9787537650113 +9787537650120 +9787537650311 +9787537650649 +9787537651127 +9787537651165 +9787537651424 +9787537651660 +9787537653237 +9787537654500 +9787537659192 +9787537659208 +9787537659277 +9787537659284 +9787537660679 +9787537660891 +9787537660914 +9787537660976 +9787537665001 +9787537665049 +9787537665056 +9787537668071 +9787537668354 +9787537668620 +9787537669139 +9787537669146 +9787537669375 +9787537669429 +9787537669498 +9787537670487 +9787537670944 +9787537671149 +9787537671170 +9787537671347 +9787537672511 +9787537673570 +9787537673594 +9787537674508 +9787537674515 +9787537674522 +9787537674546 +9787537675956 +9787537676502 +9787537677677 +9787537677776 +9787537677837 +9787537677851 +9787537678018 +9787537678254 +9787537679527 +9787537679541 +9787537679695 +9787537679756 +9787537681216 +9787537681261 +9787537684774 +9787537684781 +9787537684798 +9787537686570 +9787537686600 +9787537686624 +9787537694629 +9787537695725 +9787537700061 +9787537700085 +9787537700108 +9787537700245 +9787537700252 +9787537700511 +9787537700610 +9787537700757 +9787537700795 +9787537701068 +9787537701167 +9787537701471 +9787537701501 +9787537701600 +9787537701709 +9787537702027 +9787537702133 +9787537702232 +9787537702379 +9787537702546 +9787537702584 +9787537702669 +9787537702836 +9787537702898 +9787537703055 +9787537703406 +9787537703420 +9787537703505 +9787537704007 +9787537704137 +9787537704212 +9787537704458 +9787537704489 +9787537704533 +9787537704618 +9787537704663 +9787537704687 +9787537704786 +9787537705271 +9787537705622 +9787537705783 +9787537705974 +9787537706032 +9787537706346 +9787537706391 +9787537706780 +9787537706841 +9787537706933 +9787537706988 +9787537707138 +9787537707633 +9787537707831 +9787537708067 +9787537708081 +9787537708494 +9787537708692 +9787537709088 +9787537709279 +9787537709422 +9787537710022 +9787537710190 +9787537710213 +9787537710268 +9787537710305 +9787537710787 +9787537710893 +9787537711005 +9787537711180 +9787537711463 +9787537711593 +9787537711616 +9787537711678 +9787537711760 +9787537711968 +9787537712187 +9787537712286 +9787537712699 +9787537712736 +9787537712842 +9787537713191 +9787537713559 +9787537713603 +9787537713627 +9787537713672 +9787537713931 +9787537714310 +9787537714419 +9787537714440 +9787537714471 +9787537714563 +9787537714570 +9787537714594 +9787537714600 +9787537714617 +9787537714938 +9787537715058 +9787537715355 +9787537715553 +9787537715935 +9787537716529 +9787537716673 +9787537717168 +9787537717199 +9787537717281 +9787537718233 +9787537718615 +9787537718639 +9787537718646 +9787537719070 +9787537719155 +9787537719223 +9787537719469 +9787537719674 +9787537720021 +9787537720045 +9787537720816 +9787537721332 +9787537721363 +9787537723015 +9787537723077 +9787537724104 +9787537724272 +9787537724388 +9787537724623 +9787537725200 +9787537726399 +9787537726429 +9787537726641 +9787537728348 +9787537730419 +9787537731324 +9787537733045 +9787537733830 +9787537735018 +9787537735674 +9787537736145 +9787537736787 +9787537737241 +9787537737432 +9787537738439 +9787537739573 +9787537740722 +9787537742450 +9787537743105 +9787537743150 +9787537743457 +9787537744348 +9787537745352 +9787537746144 +9787537747028 +9787537747622 +9787537747929 +9787537748216 +9787537748339 +9787537749213 +9787537750059 +9787537750790 +9787537753937 +9787537753944 +9787537756228 +9787537758673 +9787537758758 +9787537760027 +9787537761468 +9787537762472 +9787537763066 +9787537763097 +9787537763561 +9787537763738 +9787537763745 +9787537763752 +9787537763769 +9787537763806 +9787537763905 +9787537763981 +9787537764322 +9787537800013 +9787537800020 +9787537800051 +9787537800068 +9787537800082 +9787537800129 +9787537800136 +9787537800143 +9787537800211 +9787537800303 +9787537800600 +9787537800709 +9787537800730 +9787537800969 +9787537801096 +9787537801157 +9787537801171 +9787537801201 +9787537801522 +9787537801652 +9787537802048 +9787537802130 +9787537802178 +9787537802185 +9787537802314 +9787537802352 +9787537802567 +9787537802666 +9787537802796 +9787537802802 +9787537802819 +9787537803182 +9787537803557 +9787537803816 +9787537804264 +9787537804684 +9787537804769 +9787537805384 +9787537805810 +9787537805827 +9787537806176 +9787537806305 +9787537806367 +9787537806404 +9787537806527 +9787537806725 +9787537807036 +9787537807623 +9787537807654 +9787537807838 +9787537808200 +9787537808736 +9787537808767 +9787537808941 +9787537809054 +9787537809160 +9787537809191 +9787537809542 +9787537809580 +9787537810074 +9787537810173 +9787537810227 +9787537810449 +9787537810524 +9787537810531 +9787537810555 +9787537810722 +9787537810814 +9787537810906 +9787537810920 +9787537810975 +9787537811019 +9787537811040 +9787537811149 +9787537811408 +9787537811576 +9787537811675 +9787537811682 +9787537811811 +9787537811996 +9787537812009 +9787537812757 +9787537812894 +9787537813112 +9787537813136 +9787537813242 +9787537813297 +9787537813402 +9787537813433 +9787537813600 +9787537813723 +9787537813815 +9787537813822 +9787537813839 +9787537813945 +9787537814027 +9787537814041 +9787537814058 +9787537814065 +9787537814201 +9787537814461 +9787537814539 +9787537814577 +9787537814720 +9787537814843 +9787537815017 +9787537815246 +9787537815338 +9787537815499 +9787537815680 +9787537815826 +9787537815857 +9787537816281 +9787537817165 +9787537817318 +9787537817387 +9787537818094 +9787537818124 +9787537818162 +9787537818735 +9787537819473 +9787537819480 +9787537819596 +9787537819619 +9787537819626 +9787537819831 +9787537820035 +9787537820226 +9787537820417 +9787537820486 +9787537820554 +9787537820929 +9787537821094 +9787537821148 +9787537821643 +9787537821681 +9787537821728 +9787537821780 +9787537822282 +9787537822312 +9787537822480 +9787537823029 +9787537823142 +9787537823418 +9787537823579 +9787537823678 +9787537823685 +9787537825306 +9787537825511 +9787537826129 +9787537826174 +9787537826877 +9787537827096 +9787537827812 +9787537827966 +9787537828079 +9787537828512 +9787537828680 +9787537829076 +9787537829380 +9787537829458 +9787537829854 +9787537829977 +9787537830195 +9787537830997 +9787537831772 +9787537832328 +9787537832489 +9787537833103 +9787537834148 +9787537834278 +9787537835244 +9787537835831 +9787537836166 +9787537836210 +9787537836241 +9787537837071 +9787537837408 +9787537837835 +9787537838290 +9787537838535 +9787537838542 +9787537838771 +9787537838955 +9787537839044 +9787537839129 +9787537839723 +9787537840798 +9787537843201 +9787537843676 +9787537845106 +9787537851121 +9787537852784 +9787537852876 +9787537853934 +9787537859998 +9787537863957 +9787537865807 +9787537865845 +9787537867733 +9787537868518 +9787537869539 +9787537869577 +9787537869782 +9787537872102 +9787537872362 +9787537878807 +9787537885089 +9787537887236 +9787537903073 +9787537903523 +9787537913706 +9787537922579 +9787537925273 +9787537925822 +9787537926331 +9787537928724 +9787537931809 +9787537933339 +9787537933551 +9787537934923 +9787537935678 +9787537936453 +9787537936798 +9787537938341 +9787537939744 +9787537939812 +9787537941921 +9787537948234 +9787537948241 +9787537949170 +9787537953597 +9787537953818 +9787537954075 +9787537954082 +9787537954099 +9787537955751 +9787537957861 +9787537974912 +9787537976008 +9787537988971 +9787538001686 +9787538003437 +9787538004137 +9787538004144 +9787538004830 +9787538006179 +9787538006308 +9787538006520 +9787538006629 +9787538008203 +9787538008326 +9787538008937 +9787538009576 +9787538009705 +9787538011012 +9787538011401 +9787538011425 +9787538011449 +9787538011555 +9787538011586 +9787538012491 +9787538013351 +9787538013788 +9787538014464 +9787538014488 +9787538014907 +9787538015751 +9787538017052 +9787538017410 +9787538017823 +9787538018028 +9787538018080 +9787538018295 +9787538019520 +9787538020571 +9787538020649 +9787538020694 +9787538020915 +9787538021646 +9787538021837 +9787538022025 +9787538022148 +9787538022155 +9787538022940 +9787538023190 +9787538023275 +9787538023299 +9787538023305 +9787538023343 +9787538023411 +9787538023435 +9787538023800 +9787538024180 +9787538024258 +9787538024500 +9787538024517 +9787538024739 +9787538025750 +9787538026702 +9787538028188 +9787538028362 +9787538031331 +9787538031591 +9787538032505 +9787538033663 +9787538033755 +9787538100389 +9787538100457 +9787538100648 +9787538100778 +9787538100990 +9787538101133 +9787538101546 +9787538101706 +9787538102024 +9787538102406 +9787538102475 +9787538102741 +9787538103496 +9787538104073 +9787538104530 +9787538104561 +9787538105858 +9787538106442 +9787538107500 +9787538107708 +9787538107715 +9787538108057 +9787538108880 +9787538109214 +9787538109535 +9787538110418 +9787538110609 +9787538111347 +9787538111439 +9787538111569 +9787538111637 +9787538111897 +9787538112313 +9787538113280 +9787538113303 +9787538113440 +9787538113488 +9787538113631 +9787538114010 +9787538114126 +9787538114232 +9787538114874 +9787538115413 +9787538115598 +9787538115741 +9787538116090 +9787538116113 +9787538118681 +9787538118872 +9787538119022 +9787538119800 +9787538120196 +9787538120226 +9787538120493 +9787538120509 +9787538122220 +9787538122725 +9787538122862 +9787538123128 +9787538124705 +9787538124828 +9787538125085 +9787538125290 +9787538125566 +9787538125603 +9787538125627 +9787538125849 +9787538125856 +9787538126310 +9787538126334 +9787538126341 +9787538126358 +9787538126402 +9787538126587 +9787538126662 +9787538126990 +9787538127034 +9787538127171 +9787538127959 +9787538127980 +9787538127997 +9787538128109 +9787538128413 +9787538128949 +9787538129052 +9787538129175 +9787538129625 +9787538129670 +9787538129908 +9787538129922 +9787538130607 +9787538131345 +9787538131505 +9787538131727 +9787538132137 +9787538132182 +9787538132403 +9787538132601 +9787538133097 +9787538133332 +9787538133523 +9787538133998 +9787538134445 +9787538134988 +9787538135718 +9787538135831 +9787538136173 +9787538136210 +9787538136401 +9787538138009 +9787538138283 +9787538139464 +9787538140033 +9787538140255 +9787538141351 +9787538141603 +9787538141610 +9787538142068 +9787538142808 +9787538143836 +9787538144208 +9787538144949 +9787538144994 +9787538146950 +9787538148459 +9787538149265 +9787538152586 +9787538152982 +9787538153200 +9787538153378 +9787538154016 +9787538154290 +9787538154375 +9787538154825 +9787538156522 +9787538160444 +9787538166538 +9787538166750 +9787538172294 +9787538178531 +9787538179941 +9787538180206 +9787538181623 +9787538184372 +9787538185621 +9787538185775 +9787538189902 +9787538195125 +9787538198539 +9787538200164 +9787538201987 +9787538202083 +9787538203103 +9787538203226 +9787538204100 +9787538204490 +9787538204926 +9787538205268 +9787538206388 +9787538207354 +9787538207781 +9787538207873 +9787538207897 +9787538209280 +9787538210149 +9787538210385 +9787538210576 +9787538211177 +9787538212112 +9787538212259 +9787538212334 +9787538214086 +9787538214369 +9787538214376 +9787538214406 +9787538214758 +9787538214925 +9787538215243 +9787538215373 +9787538215427 +9787538216004 +9787538216202 +9787538216707 +9787538216875 +9787538217063 +9787538217155 +9787538217735 +9787538217971 +9787538218701 +9787538218763 +9787538221183 +9787538223996 +9787538235999 +9787538236866 +9787538236873 +9787538236880 +9787538236903 +9787538236927 +9787538236934 +9787538237610 +9787538237764 +9787538238815 +9787538239812 +9787538240290 +9787538242614 +9787538242621 +9787538242638 +9787538242980 +9787538245271 +9787538245301 +9787538245325 +9787538245363 +9787538245455 +9787538246834 +9787538247602 +9787538247671 +9787538247794 +9787538247893 +9787538247985 +9787538247992 +9787538248012 +9787538248364 +9787538248685 +9787538249163 +9787538250107 +9787538250121 +9787538250138 +9787538250237 +9787538250251 +9787538250282 +9787538250299 +9787538250510 +9787538250534 +9787538250589 +9787538250909 +9787538250985 +9787538251173 +9787538251302 +9787538252477 +9787538252996 +9787538253146 +9787538253160 +9787538253184 +9787538253191 +9787538253214 +9787538253580 +9787538254051 +9787538254082 +9787538254914 +9787538255300 +9787538255331 +9787538256192 +9787538256291 +9787538256505 +9787538256673 +9787538256796 +9787538257083 +9787538258400 +9787538258943 +9787538259247 +9787538259254 +9787538259308 +9787538259544 +9787538260977 +9787538261547 +9787538262407 +9787538262537 +9787538262759 +9787538264357 +9787538264524 +9787538264562 +9787538264593 +9787538265088 +9787538265170 +9787538265309 +9787538265750 +9787538265927 +9787538265934 +9787538266825 +9787538266832 +9787538267105 +9787538267136 +9787538272024 +9787538272697 +9787538273694 +9787538273816 +9787538275575 +9787538275896 +9787538277357 +9787538277821 +9787538278323 +9787538278521 +9787538278576 +9787538279962 +9787538280616 +9787538280661 +9787538282160 +9787538282900 +9787538286236 +9787538286793 +9787538287387 +9787538287394 +9787538287660 +9787538288124 +9787538290646 +9787538290721 +9787538291360 +9787538292060 +9787538292336 +9787538292350 +9787538293128 +9787538293166 +9787538293500 +9787538293715 +9787538293760 +9787538294354 +9787538294507 +9787538294651 +9787538294729 +9787538294743 +9787538303292 +9787538305708 +9787538305869 +9787538306972 +9787538306989 +9787538306996 +9787538307269 +9787538307863 +9787538307887 +9787538308167 +9787538309294 +9787538309331 +9787538309577 +9787538310979 +9787538313031 +9787538313659 +9787538316131 +9787538316896 +9787538318746 +9787538318760 +9787538318944 +9787538319095 +9787538319750 +9787538320268 +9787538321005 +9787538321203 +9787538322118 +9787538323962 +9787538325867 +9787538326437 +9787538327342 +9787538327434 +9787538329216 +9787538329230 +9787538331530 +9787538331578 +9787538334500 +9787538334517 +9787538337495 +9787538337648 +9787538340389 +9787538340501 +9787538341706 +9787538342970 +9787538343557 +9787538343687 +9787538346046 +9787538346909 +9787538348606 +9787538354362 +9787538357639 +9787538365757 +9787538366174 +9787538370249 +9787538377033 +9787538378092 +9787538379099 +9787538379167 +9787538379303 +9787538387599 +9787538387650 +9787538388268 +9787538389548 +9787538390889 +9787538393132 +9787538393187 +9787538395754 +9787538399813 +9787538400014 +9787538400113 +9787538400533 +9787538400847 +9787538400991 +9787538401141 +9787538401226 +9787538401332 +9787538401400 +9787538401837 +9787538401967 +9787538403008 +9787538403121 +9787538403206 +9787538403336 +9787538403374 +9787538403466 +9787538403763 +9787538403978 +9787538404456 +9787538404555 +9787538404616 +9787538405446 +9787538407136 +9787538407396 +9787538407709 +9787538408034 +9787538408638 +9787538409550 +9787538409574 +9787538409949 +9787538410709 +9787538410716 +9787538410723 +9787538410778 +9787538410785 +9787538410808 +9787538410815 +9787538410822 +9787538410945 +9787538411348 +9787538411560 +9787538411843 +9787538412147 +9787538412154 +9787538413069 +9787538413175 +9787538413205 +9787538414295 +9787538414486 +9787538414622 +9787538415445 +9787538415469 +9787538415513 +9787538415537 +9787538415650 +9787538416268 +9787538416756 +9787538416763 +9787538416794 +9787538416947 +9787538417562 +9787538417838 +9787538418675 +9787538419092 +9787538419221 +9787538419559 +9787538419795 +9787538419863 +9787538419962 +9787538420449 +9787538420692 +9787538420753 +9787538421507 +9787538421576 +9787538421644 +9787538421705 +9787538421859 +9787538421958 +9787538422047 +9787538422696 +9787538423082 +9787538423365 +9787538424591 +9787538424768 +9787538425642 +9787538425789 +9787538426632 +9787538426687 +9787538426779 +9787538426991 +9787538427042 +9787538429879 +9787538430219 +9787538430738 +9787538430837 +9787538432039 +9787538432060 +9787538432152 +9787538433050 +9787538433494 +9787538434583 +9787538436075 +9787538436402 +9787538436587 +9787538437157 +9787538438208 +9787538439038 +9787538439090 +9787538440201 +9787538440287 +9787538440638 +9787538441383 +9787538441499 +9787538441697 +9787538442052 +9787538442182 +9787538442205 +9787538442779 +9787538444834 +9787538447156 +9787538447392 +9787538448030 +9787538449662 +9787538454765 +9787538454970 +9787538455236 +9787538455458 +9787538455762 +9787538456851 +9787538458817 +9787538460216 +9787538461503 +9787538461732 +9787538462548 +9787538463033 +9787538463828 +9787538463996 +9787538464801 +9787538465303 +9787538466300 +9787538466713 +9787538467376 +9787538467628 +9787538471038 +9787538472639 +9787538473964 +9787538474190 +9787538475296 +9787538477672 +9787538484564 +9787538486919 +9787538487039 +9787538487831 +9787538488623 +9787538490107 +9787538495324 +9787538497120 +9787538498653 +9787538500059 +9787538500363 +9787538500370 +9787538500929 +9787538501605 +9787538501667 +9787538501681 +9787538501766 +9787538501780 +9787538501797 +9787538501919 +9787538502015 +9787538502237 +9787538502251 +9787538502282 +9787538503630 +9787538503937 +9787538504040 +9787538505207 +9787538505603 +9787538505665 +9787538506051 +9787538506082 +9787538506716 +9787538507690 +9787538508093 +9787538508109 +9787538508611 +9787538509120 +9787538509977 +9787538510331 +9787538510454 +9787538510683 +9787538510911 +9787538510973 +9787538510980 +9787538511109 +9787538511185 +9787538511307 +9787538511314 +9787538511338 +9787538512076 +9787538512281 +9787538513134 +9787538513493 +9787538514292 +9787538514308 +9787538514407 +9787538515206 +9787538515404 +9787538517163 +9787538517651 +9787538517668 +9787538517866 +9787538517941 +9787538518160 +9787538518221 +9787538518245 +9787538518276 +9787538518290 +9787538518405 +9787538518924 +9787538518931 +9787538518948 +9787538519754 +9787538520071 +9787538520200 +9787538520248 +9787538520255 +9787538520538 +9787538520583 +9787538520729 +9787538520897 +9787538521139 +9787538521146 +9787538521184 +9787538521351 +9787538521405 +9787538521559 +9787538521863 +9787538521948 +9787538522150 +9787538522167 +9787538523485 +9787538524062 +9787538524147 +9787538524178 +9787538524291 +9787538524307 +9787538524499 +9787538524628 +9787538524925 +9787538525373 +9787538525588 +9787538526462 +9787538526486 +9787538526936 +9787538526967 +9787538527018 +9787538527063 +9787538527100 +9787538527186 +9787538527193 +9787538527247 +9787538527377 +9787538527933 +9787538528442 +9787538529890 +9787538529913 +9787538530179 +9787538530629 +9787538531237 +9787538531855 +9787538532197 +9787538532753 +9787538533439 +9787538533668 +9787538533767 +9787538533774 +9787538533781 +9787538533798 +9787538534160 +9787538534221 +9787538535044 +9787538535051 +9787538536461 +9787538536911 +9787538537383 +9787538537765 +9787538538861 +9787538539530 +9787538540451 +9787538541687 +9787538542325 +9787538542356 +9787538542417 +9787538542493 +9787538542752 +9787538542868 +9787538543810 +9787538544060 +9787538545395 +9787538548587 +9787538548624 +9787538548877 +9787538548907 +9787538549096 +9787538550337 +9787538551402 +9787538551532 +9787538552621 +9787538552652 +9787538552812 +9787538552850 +9787538552898 +9787538553222 +9787538554229 +9787538554236 +9787538554243 +9787538554281 +9787538554533 +9787538555738 +9787538558128 +9787538558746 +9787538558876 +9787538562088 +9787538562101 +9787538562422 +9787538564150 +9787538564310 +9787538565430 +9787538565447 +9787538565454 +9787538565485 +9787538565508 +9787538565560 +9787538565621 +9787538565645 +9787538566062 +9787538566116 +9787538567595 +9787538567601 +9787538567717 +9787538568875 +9787538568929 +9787538569155 +9787538569803 +9787538570397 +9787538570984 +9787538571523 +9787538571554 +9787538571981 +9787538571998 +9787538573336 +9787538573732 +9787538575309 +9787538575354 +9787538575507 +9787538575514 +9787538575545 +9787538575569 +9787538575873 +9787538575927 +9787538575958 +9787538576702 +9787538577426 +9787538577662 +9787538577723 +9787538579055 +9787538579352 +9787538579673 +9787538579871 +9787538581683 +9787538581713 +9787538581836 +9787538583717 +9787538583755 +9787538584547 +9787538585650 +9787538586053 +9787538586473 +9787538586480 +9787538586633 +9787538587050 +9787538588118 +9787538589023 +9787538589177 +9787538589696 +9787538590654 +9787538591279 +9787538591804 +9787538591927 +9787538592375 +9787538592412 +9787538592436 +9787538592528 +9787538596939 +9787538596946 +9787538600148 +9787538600490 +9787538601053 +9787538601299 +9787538601305 +9787538601565 +9787538601909 +9787538601923 +9787538601954 +9787538601978 +9787538602517 +9787538602654 +9787538602968 +9787538603491 +9787538603521 +9787538603958 +9787538603972 +9787538603989 +9787538604009 +9787538604016 +9787538604054 +9787538604467 +9787538604658 +9787538604689 +9787538604962 +9787538605044 +9787538605563 +9787538605723 +9787538605815 +9787538605822 +9787538605969 +9787538606171 +9787538606188 +9787538606409 +9787538606430 +9787538606546 +9787538606683 +9787538606690 +9787538606713 +9787538607697 +9787538607710 +9787538607963 +9787538608007 +9787538608137 +9787538608298 +9787538608304 +9787538608328 +9787538608670 +9787538608762 +9787538608977 +9787538609578 +9787538609660 +9787538609820 +9787538609905 +9787538609950 +9787538609967 +9787538609974 +9787538610673 +9787538610857 +9787538612554 +9787538612578 +9787538612813 +9787538613001 +9787538613094 +9787538613797 +9787538613858 +9787538614237 +9787538614459 +9787538614695 +9787538614848 +9787538614879 +9787538615067 +9787538615081 +9787538615135 +9787538615586 +9787538615715 +9787538616026 +9787538616392 +9787538616637 +9787538617030 +9787538617061 +9787538617078 +9787538617085 +9787538617207 +9787538617641 +9787538618082 +9787538618167 +9787538618716 +9787538618723 +9787538619072 +9787538619355 +9787538619362 +9787538619386 +9787538619393 +9787538619409 +9787538619515 +9787538619959 +9787538620405 +9787538620443 +9787538620818 +9787538620924 +9787538621464 +9787538621693 +9787538622737 +9787538622850 +9787538623093 +9787538623307 +9787538624267 +9787538624281 +9787538624694 +9787538626148 +9787538628197 +9787538630077 +9787538631562 +9787538632095 +9787538633450 +9787538633689 +9787538633771 +9787538633894 +9787538636772 +9787538638233 +9787538638882 +9787538640700 +9787538643381 +9787538643510 +9787538643534 +9787538644050 +9787538644449 +9787538645644 +9787538647167 +9787538647723 +9787538648898 +9787538648997 +9787538649758 +9787538649765 +9787538649826 +9787538649901 +9787538649925 +9787538650174 +9787538650198 +9787538650402 +9787538652611 +9787538653212 +9787538654011 +9787538654592 +9787538655483 +9787538656008 +9787538656695 +9787538657982 +9787538658125 +9787538658675 +9787538658781 +9787538659429 +9787538659894 +9787538661545 +9787538662757 +9787538662818 +9787538663310 +9787538663792 +9787538663990 +9787538664539 +9787538664546 +9787538664706 +9787538665451 +9787538665468 +9787538665970 +9787538667981 +9787538668834 +9787538670035 +9787538670653 +9787538670783 +9787538670806 +9787538671155 +9787538671179 +9787538671186 +9787538671490 +9787538671742 +9787538672237 +9787538673067 +9787538673074 +9787538673081 +9787538673098 +9787538673258 +9787538673432 +9787538673579 +9787538673739 +9787538673814 +9787538675023 +9787538676143 +9787538677492 +9787538678192 +9787538679946 +9787538680621 +9787538682090 +9787538682199 +9787538684810 +9787538685084 +9787538685091 +9787538685923 +9787538686364 +9787538686685 +9787538687743 +9787538687774 +9787538687798 +9787538687804 +9787538687811 +9787538687835 +9787538687910 +9787538688009 +9787538688030 +9787538688054 +9787538688528 +9787538689273 +9787538689396 +9787538689426 +9787538689853 +9787538689945 +9787538690279 +9787538690385 +9787538690569 +9787538690682 +9787538694772 +9787538696783 +9787538697186 +9787538697810 +9787538698749 +9787538699067 +9787538700039 +9787538700343 +9787538700404 +9787538700527 +9787538700534 +9787538700862 +9787538701227 +9787538701357 +9787538701692 +9787538701982 +9787538702033 +9787538702040 +9787538702194 +9787538702361 +9787538702507 +9787538703252 +9787538703412 +9787538703511 +9787538703573 +9787538703627 +9787538703689 +9787538703795 +9787538703887 +9787538704211 +9787538704532 +9787538704594 +9787538704624 +9787538704808 +9787538705096 +9787538705102 +9787538705485 +9787538705669 +9787538705676 +9787538706048 +9787538706109 +9787538706185 +9787538706215 +9787538706239 +9787538706468 +9787538706512 +9787538706550 +9787538706574 +9787538706611 +9787538706635 +9787538706697 +9787538706703 +9787538706727 +9787538706888 +9787538706918 +9787538706956 +9787538706987 +9787538707083 +9787538707403 +9787538707441 +9787538707847 +9787538707991 +9787538708028 +9787538708127 +9787538708202 +9787538708240 +9787538708264 +9787538708356 +9787538708387 +9787538708400 +9787538708486 +9787538708493 +9787538708684 +9787538708752 +9787538708776 +9787538708806 +9787538708820 +9787538708905 +9787538708943 +9787538709018 +9787538709131 +9787538709247 +9787538709292 +9787538709315 +9787538709322 +9787538709353 +9787538709414 +9787538709421 +9787538709445 +9787538709582 +9787538709599 +9787538709605 +9787538709612 +9787538709643 +9787538709650 +9787538709728 +9787538709766 +9787538709988 +9787538710007 +9787538710014 +9787538710045 +9787538710052 +9787538710069 +9787538710076 +9787538710090 +9787538710106 +9787538710229 +9787538710274 +9787538710328 +9787538710427 +9787538710434 +9787538710458 +9787538710489 +9787538710595 +9787538710694 +9787538710786 +9787538710809 +9787538710816 +9787538711073 +9787538711110 +9787538711134 +9787538711158 +9787538711202 +9787538711271 +9787538711332 +9787538711349 +9787538711363 +9787538711394 +9787538711417 +9787538711523 +9787538711530 +9787538711547 +9787538711615 +9787538712018 +9787538712056 +9787538712117 +9787538712155 +9787538712315 +9787538712377 +9787538712414 +9787538712445 +9787538712575 +9787538712704 +9787538712919 +9787538712933 +9787538712957 +9787538712964 +9787538712971 +9787538712995 +9787538713190 +9787538713275 +9787538713343 +9787538713381 +9787538713435 +9787538713541 +9787538713565 +9787538713596 +9787538713640 +9787538713695 +9787538713763 +9787538713947 +9787538713985 +9787538714012 +9787538714104 +9787538714128 +9787538714340 +9787538714371 +9787538714425 +9787538714463 +9787538714685 +9787538714883 +9787538714913 +9787538714920 +9787538714968 +9787538714975 +9787538714999 +9787538715163 +9787538715200 +9787538715224 +9787538715279 +9787538715293 +9787538715309 +9787538715323 +9787538715330 +9787538715729 +9787538715842 +9787538715903 +9787538715910 +9787538715965 +9787538716047 +9787538716054 +9787538716092 +9787538716139 +9787538716184 +9787538716221 +9787538716276 +9787538716313 +9787538716375 +9787538716566 +9787538716658 +9787538716672 +9787538716757 +9787538716764 +9787538716931 +9787538716962 +9787538717181 +9787538717204 +9787538717242 +9787538717297 +9787538717365 +9787538717372 +9787538717419 +9787538717471 +9787538717518 +9787538717525 +9787538717549 +9787538717563 +9787538717587 +9787538717594 +9787538717662 +9787538717693 +9787538717730 +9787538717747 +9787538717761 +9787538717785 +9787538717877 +9787538718188 +9787538718218 +9787538718232 +9787538718522 +9787538718539 +9787538718560 +9787538718645 +9787538718652 +9787538718775 +9787538718874 +9787538719031 +9787538719208 +9787538719789 +9787538719833 +9787538719901 +9787538719918 +9787538719963 +9787538720518 +9787538720563 +9787538721034 +9787538721119 +9787538721294 +9787538721881 +9787538722116 +9787538725742 +9787538726152 +9787538726374 +9787538726398 +9787538726688 +9787538726701 +9787538726923 +9787538727302 +9787538727333 +9787538727340 +9787538731231 +9787538731408 +9787538732986 +9787538733372 +9787538734782 +9787538734799 +9787538736533 +9787538736564 +9787538736960 +9787538738636 +9787538738681 +9787538740097 +9787538740998 +9787538742152 +9787538743944 +9787538746501 +9787538746525 +9787538746532 +9787538747454 +9787538747898 +9787538748673 +9787538748734 +9787538748741 +9787538751680 +9787538752304 +9787538753165 +9787538754919 +9787538754988 +9787538755091 +9787538757514 +9787538757712 +9787538758580 +9787538758993 +9787538759341 +9787538760255 +9787538760958 +9787538761030 +9787538761306 +9787538762877 +9787538763331 +9787538763461 +9787538763645 +9787538763997 +9787538764031 +9787538764055 +9787538764499 +9787538765328 +9787538766578 +9787538766592 +9787538766608 +9787538766615 +9787538766622 +9787538766875 +9787538767797 +9787538770773 +9787538770872 +9787538771206 +9787538772272 +9787538772333 +9787538772678 +9787538772685 +9787538774672 +9787538774702 +9787538775112 +9787538775570 +9787538777031 +9787538777178 +9787538777772 +9787538777932 +9787538780079 +9787538780109 +9787538800111 +9787538800333 +9787538800357 +9787538800401 +9787538801736 +9787538802436 +9787538803112 +9787538803488 +9787538803730 +9787538803907 +9787538805321 +9787538806335 +9787538806786 +9787538807240 +9787538808063 +9787538809091 +9787538809138 +9787538809275 +9787538812398 +9787538812800 +9787538812817 +9787538813050 +9787538813616 +9787538815214 +9787538815603 +9787538815924 +9787538816921 +9787538817522 +9787538817911 +9787538818864 +9787538819038 +9787538819250 +9787538819496 +9787538819533 +9787538820850 +9787538820867 +9787538820881 +9787538821116 +9787538823165 +9787538823721 +9787538824056 +9787538824841 +9787538826531 +9787538826883 +9787538826944 +9787538827149 +9787538827354 +9787538827774 +9787538828443 +9787538829259 +9787538829815 +9787538829877 +9787538830262 +9787538831184 +9787538831856 +9787538832181 +9787538832211 +9787538832990 +9787538833010 +9787538833751 +9787538834000 +9787538834147 +9787538834970 +9787538835915 +9787538837278 +9787538837612 +9787538837759 +9787538839456 +9787538839951 +9787538843187 +9787538844900 +9787538847710 +9787538849516 +9787538850727 +9787538850802 +9787538851182 +9787538853551 +9787538853735 +9787538853742 +9787538855340 +9787538855395 +9787538859645 +9787538860450 +9787538862331 +9787538862393 +9787538864618 +9787538865240 +9787538865707 +9787538868531 +9787538869774 +9787538870848 +9787538871746 +9787538871869 +9787538873061 +9787538873382 +9787538873399 +9787538874808 +9787538875102 +9787538875225 +9787538875386 +9787538875898 +9787538876109 +9787538876413 +9787538876772 +9787538876857 +9787538877571 +9787538879278 +9787538879735 +9787538882940 +9787538884395 +9787538884814 +9787538885057 +9787538885347 +9787538885446 +9787538885668 +9787538889888 +9787538891522 +9787538891591 +9787538893809 +9787538900224 +9787538900231 +9787538900415 +9787538900613 +9787538900705 +9787538900804 +9787538902426 +9787538902433 +9787538902648 +9787538903072 +9787538903492 +9787538903713 +9787538904437 +9787538905632 +9787538906073 +9787538909395 +9787538910292 +9787538914863 +9787538918236 +9787539000107 +9787539000145 +9787539000640 +9787539001029 +9787539001098 +9787539001227 +9787539001302 +9787539001432 +9787539001593 +9787539001821 +9787539001999 +9787539002101 +9787539002422 +9787539002750 +9787539003245 +9787539003436 +9787539004181 +9787539004594 +9787539004914 +9787539005638 +9787539005744 +9787539005805 +9787539005850 +9787539006123 +9787539006161 +9787539006406 +9787539006659 +9787539006673 +9787539006833 +9787539006857 +9787539007557 +9787539007595 +9787539007618 +9787539007908 +9787539007984 +9787539008097 +9787539008240 +9787539008301 +9787539009339 +9787539009476 +9787539009490 +9787539009537 +9787539009964 +9787539010007 +9787539010076 +9787539010182 +9787539010281 +9787539010335 +9787539011097 +9787539011141 +9787539011233 +9787539011639 +9787539011684 +9787539011707 +9787539011783 +9787539012209 +9787539012339 +9787539012742 +9787539012865 +9787539013268 +9787539013886 +9787539013992 +9787539014012 +9787539014371 +9787539014623 +9787539015354 +9787539016672 +9787539016887 +9787539016917 +9787539017549 +9787539018188 +9787539018201 +9787539018218 +9787539018805 +9787539018911 +9787539019994 +9787539020136 +9787539020754 +9787539021232 +9787539021614 +9787539021645 +9787539022017 +9787539026763 +9787539026831 +9787539028620 +9787539033297 +9787539033389 +9787539034799 +9787539036489 +9787539037066 +9787539040004 +9787539040011 +9787539042633 +9787539043197 +9787539044736 +9787539046419 +9787539046464 +9787539048109 +9787539048154 +9787539049038 +9787539049410 +9787539049663 +9787539050041 +9787539050089 +9787539051918 +9787539052564 +9787539053325 +9787539054278 +9787539054667 +9787539066035 +9787539067490 +9787539071770 +9787539073170 +9787539074641 +9787539075181 +9787539075204 +9787539075952 +9787539077499 +9787539080963 +9787539082233 +9787539082295 +9787539083032 +9787539083100 +9787539083513 +9787539085043 +9787539085715 +9787539085753 +9787539085760 +9787539086910 +9787539089102 +9787539090573 +9787539090924 +9787539092874 +9787539094229 +9787539094380 +9787539095875 +9787539101347 +9787539101859 +9787539104089 +9787539105208 +9787539106366 +9787539107462 +9787539108025 +9787539109985 +9787539111193 +9787539111612 +9787539111742 +9787539112367 +9787539112657 +9787539113098 +9787539113128 +9787539113227 +9787539114828 +9787539116327 +9787539116570 +9787539116853 +9787539117430 +9787539117652 +9787539117768 +9787539120003 +9787539120652 +9787539121444 +9787539121550 +9787539121604 +9787539121758 +9787539121796 +9787539121802 +9787539121918 +9787539122939 +9787539125336 +9787539125787 +9787539126814 +9787539126968 +9787539127675 +9787539128160 +9787539128276 +9787539128283 +9787539128528 +9787539128719 +9787539128788 +9787539129334 +9787539130057 +9787539130514 +9787539132143 +9787539133232 +9787539133300 +9787539134994 +9787539135298 +9787539135618 +9787539136547 +9787539136554 +9787539136806 +9787539137070 +9787539137193 +9787539137346 +9787539137513 +9787539137926 +9787539137971 +9787539138008 +9787539138480 +9787539138831 +9787539138916 +9787539139951 +9787539140971 +9787539141206 +9787539141268 +9787539142548 +9787539142937 +9787539143170 +9787539143200 +9787539143668 +9787539144467 +9787539146331 +9787539146348 +9787539146355 +9787539147482 +9787539147499 +9787539147659 +9787539148052 +9787539148182 +9787539148243 +9787539148298 +9787539148304 +9787539148311 +9787539148328 +9787539148335 +9787539148618 +9787539148625 +9787539148632 +9787539148649 +9787539149226 +9787539150437 +9787539150598 +9787539150802 +9787539151397 +9787539151434 +9787539151441 +9787539152158 +9787539152882 +9787539155029 +9787539155128 +9787539155333 +9787539155821 +9787539155845 +9787539156019 +9787539156316 +9787539156552 +9787539156606 +9787539156668 +9787539156675 +9787539157788 +9787539158198 +9787539158518 +9787539158549 +9787539158709 +9787539158938 +9787539159959 +9787539160351 +9787539160559 +9787539160900 +9787539161037 +9787539161501 +9787539161761 +9787539162034 +9787539162041 +9787539162065 +9787539162485 +9787539163048 +9787539163055 +9787539164823 +9787539165035 +9787539165103 +9787539166568 +9787539167138 +9787539167602 +9787539167633 +9787539167688 +9787539167985 +9787539168890 +9787539170183 +9787539170251 +9787539170299 +9787539170749 +9787539170985 +9787539171302 +9787539173825 +9787539174228 +9787539175652 +9787539175928 +9787539175973 +9787539176925 +9787539176994 +9787539177830 +9787539177939 +9787539177960 +9787539178011 +9787539178523 +9787539178714 +9787539179384 +9787539179407 +9787539179476 +9787539179520 +9787539180649 +9787539181110 +9787539181370 +9787539181561 +9787539181608 +9787539181677 +9787539182513 +9787539182902 +9787539182926 +9787539182933 +9787539183138 +9787539183886 +9787539184388 +9787539184395 +9787539185033 +9787539185040 +9787539185699 +9787539185729 +9787539185804 +9787539186542 +9787539187389 +9787539187761 +9787539187778 +9787539187808 +9787539187815 +9787539187839 +9787539187846 +9787539187907 +9787539187921 +9787539187969 +9787539187983 +9787539188348 +9787539188416 +9787539188638 +9787539188652 +9787539188898 +9787539189093 +9787539189710 +9787539189734 +9787539189932 +9787539190051 +9787539190518 +9787539190556 +9787539190679 +9787539190990 +9787539191041 +9787539191140 +9787539191201 +9787539191607 +9787539192116 +9787539192512 +9787539193823 +9787539193960 +9787539193984 +9787539194028 +9787539194448 +9787539194622 +9787539196350 +9787539196442 +9787539196633 +9787539196862 +9787539197456 +9787539197579 +9787539197593 +9787539197654 +9787539197760 +9787539197821 +9787539197838 +9787539198125 +9787539198309 +9787539198316 +9787539199375 +9787539199405 +9787539199795 +9787539200699 +9787539202297 +9787539202303 +9787539202310 +9787539202327 +9787539202334 +9787539203966 +9787539205243 +9787539205625 +9787539207032 +9787539208114 +9787539208282 +9787539208411 +9787539208466 +9787539208633 +9787539209838 +9787539211091 +9787539211107 +9787539211572 +9787539211794 +9787539211848 +9787539213484 +9787539215174 +9787539219233 +9787539219240 +9787539219257 +9787539222950 +9787539222998 +9787539225562 +9787539227153 +9787539227283 +9787539227931 +9787539232508 +9787539234892 +9787539236193 +9787539239262 +9787539243894 +9787539246765 +9787539247151 +9787539249032 +9787539249957 +9787539253022 +9787539253275 +9787539256047 +9787539256085 +9787539257853 +9787539260105 +9787539264134 +9787539265612 +9787539268866 +9787539269382 +9787539270425 +9787539271194 +9787539279121 +9787539279169 +9787539283494 +9787539283555 +9787539287584 +9787539289151 +9787539292595 +9787539294025 +9787539294056 +9787539294353 +9787539294575 +9787539295060 +9787539295077 +9787539297293 +9787539297859 +9787539300016 +9787539300047 +9787539300313 +9787539300344 +9787539300375 +9787539301693 +9787539302072 +9787539302263 +9787539302652 +9787539303000 +9787539305172 +9787539305424 +9787539305431 +9787539306285 +9787539307343 +9787539307626 +9787539307701 +9787539308654 +9787539308678 +9787539308784 +9787539309651 +9787539309798 +9787539310480 +9787539310886 +9787539311173 +9787539311302 +9787539311418 +9787539311890 +9787539312194 +9787539312309 +9787539313528 +9787539314860 +9787539314891 +9787539315416 +9787539315621 +9787539315928 +9787539315935 +9787539315942 +9787539315966 +9787539315973 +9787539316109 +9787539316376 +9787539316550 +9787539316901 +9787539317052 +9787539317083 +9787539317137 +9787539317151 +9787539317175 +9787539317182 +9787539317250 +9787539319216 +9787539320953 +9787539321417 +9787539321448 +9787539321585 +9787539322377 +9787539322759 +9787539324227 +9787539324937 +9787539325354 +9787539325651 +9787539326771 +9787539326962 +9787539327075 +9787539327297 +9787539327662 +9787539328225 +9787539328263 +9787539328836 +9787539329314 +9787539329796 +9787539330051 +9787539331621 +9787539332222 +9787539334608 +9787539337203 +9787539337982 +9787539338934 +9787539339023 +9787539339313 +9787539343921 +9787539344270 +9787539345475 +9787539400440 +9787539400617 +9787539400891 +9787539400907 +9787539401379 +9787539402239 +9787539402338 +9787539403144 +9787539403304 +9787539403434 +9787539403496 +9787539404288 +9787539404967 +9787539405100 +9787539405919 +9787539406206 +9787539406831 +9787539407043 +9787539407159 +9787539407302 +9787539407319 +9787539407340 +9787539407494 +9787539407746 +9787539407906 +9787539407937 +9787539408293 +9787539408651 +9787539408675 +9787539409016 +9787539409122 +9787539409375 +9787539409504 +9787539409603 +9787539409726 +9787539409832 +9787539409948 +9787539410043 +9787539410302 +9787539410371 +9787539410548 +9787539410616 +9787539410791 +9787539410913 +9787539410951 +9787539411149 +9787539411187 +9787539411316 +9787539411767 +9787539412009 +9787539412030 +9787539412047 +9787539412580 +9787539413280 +9787539413419 +9787539413518 +9787539413587 +9787539413594 +9787539413631 +9787539413884 +9787539414256 +9787539415178 +9787539415222 +9787539415352 +9787539415369 +9787539416281 +9787539416533 +9787539416939 +9787539416960 +9787539417394 +9787539417400 +9787539418056 +9787539418087 +9787539418117 +9787539418346 +9787539419268 +9787539420042 +9787539420233 +9787539420493 +9787539420875 +9787539421650 +9787539421773 +9787539421902 +9787539424606 +9787539425122 +9787539427003 +9787539430843 +9787539430850 +9787539431529 +9787539431994 +9787539432090 +9787539433912 +9787539436814 +9787539437750 +9787539438818 +9787539439501 +9787539440910 +9787539443331 +9787539444093 +9787539444581 +9787539444604 +9787539444611 +9787539444628 +9787539444642 +9787539444673 +9787539444697 +9787539445687 +9787539447506 +9787539448336 +9787539450773 +9787539454610 +9787539456201 +9787539456713 +9787539456720 +9787539458182 +9787539465494 +9787539467450 +9787539472096 +9787539473086 +9787539474625 +9787539474861 +9787539474878 +9787539476629 +9787539476698 +9787539477244 +9787539477879 +9787539477923 +9787539479729 +9787539480985 +9787539483405 +9787539484495 +9787539493305 +9787539495095 +9787539495118 +9787539495156 +9787539495309 +9787539500232 +9787539500621 +9787539500928 +9787539502267 +9787539505206 +9787539505435 +9787539505732 +9787539507286 +9787539507590 +9787539508764 +9787539509952 +9787539510545 +9787539511160 +9787539511863 +9787539513102 +9787539513386 +9787539514512 +9787539514970 +9787539517056 +9787539518428 +9787539518732 +9787539518992 +9787539519401 +9787539520025 +9787539523231 +9787539524566 +9787539524573 +9787539525501 +9787539526508 +9787539532134 +9787539532769 +9787539534442 +9787539536484 +9787539536699 +9787539537344 +9787539537368 +9787539538785 +9787539538792 +9787539539683 +9787539540269 +9787539540283 +9787539540641 +9787539541617 +9787539543017 +9787539544403 +9787539546469 +9787539546728 +9787539546803 +9787539547909 +9787539548845 +9787539548890 +9787539548913 +9787539549569 +9787539549576 +9787539549835 +9787539549859 +9787539550367 +9787539550411 +9787539551104 +9787539553504 +9787539553597 +9787539553849 +9787539554747 +9787539554761 +9787539555324 +9787539555348 +9787539555485 +9787539555683 +9787539559520 +9787539561196 +9787539561202 +9787539561226 +9787539561233 +9787539561240 +9787539563190 +9787539563671 +9787539564517 +9787539565873 +9787539568034 +9787539568492 +9787539569970 +9787539570051 +9787539571973 +9787539572086 +9787539572093 +9787539573977 +9787539574004 +9787539574035 +9787539574882 +9787539574936 +9787539575346 +9787539576749 +9787539577524 +9787539578668 +9787539578743 +9787539579788 +9787539580326 +9787539581309 +9787539581316 +9787539581460 +9787539581484 +9787539582702 +9787539583150 +9787539583969 +9787539584119 +9787539585925 +9787539600109 +9787539600147 +9787539600246 +9787539600864 +9787539600963 +9787539601106 +9787539601199 +9787539601687 +9787539602356 +9787539602585 +9787539602653 +9787539602660 +9787539603193 +9787539603575 +9787539603629 +9787539603636 +9787539603711 +9787539603735 +9787539604046 +9787539604053 +9787539604770 +9787539605890 +9787539606095 +9787539606255 +9787539606392 +9787539606415 +9787539606521 +9787539606958 +9787539607122 +9787539607221 +9787539607290 +9787539607597 +9787539607771 +9787539607825 +9787539607832 +9787539607849 +9787539607856 +9787539607870 +9787539608327 +9787539608358 +9787539608549 +9787539608570 +9787539608594 +9787539608648 +9787539609492 +9787539609584 +9787539610436 +9787539611099 +9787539611556 +9787539611730 +9787539611891 +9787539612157 +9787539612256 +9787539612263 +9787539612270 +9787539612294 +9787539612317 +9787539612362 +9787539612416 +9787539612522 +9787539612768 +9787539612829 +9787539612898 +9787539612980 +9787539613079 +9787539613147 +9787539613154 +9787539613161 +9787539613178 +9787539613352 +9787539613376 +9787539613420 +9787539613642 +9787539613673 +9787539613680 +9787539613710 +9787539613741 +9787539613864 +9787539613895 +9787539613949 +9787539613963 +9787539614106 +9787539614229 +9787539614236 +9787539614328 +9787539614380 +9787539614410 +9787539614618 +9787539614632 +9787539614717 +9787539614731 +9787539614755 +9787539614809 +9787539614830 +9787539614885 +9787539614984 +9787539615158 +9787539615226 +9787539615318 +9787539615394 +9787539615400 +9787539615523 +9787539615561 +9787539615967 +9787539616193 +9787539616261 +9787539616285 +9787539616353 +9787539617107 +9787539617138 +9787539617176 +9787539617411 +9787539617428 +9787539617442 +9787539617527 +9787539617619 +9787539617633 +9787539617640 +9787539617657 +9787539618111 +9787539618173 +9787539618340 +9787539618364 +9787539618401 +9787539618517 +9787539618531 +9787539618562 +9787539618579 +9787539618586 +9787539618623 +9787539618838 +9787539618920 +9787539618951 +9787539618975 +9787539618999 +9787539619040 +9787539619149 +9787539619156 +9787539619439 +9787539619484 +9787539619569 +9787539620688 +9787539621999 +9787539624679 +9787539625300 +9787539626208 +9787539626468 +9787539627960 +9787539627977 +9787539628349 +9787539635019 +9787539635569 +9787539636610 +9787539640754 +9787539640938 +9787539641652 +9787539642086 +9787539642468 +9787539642703 +9787539643731 +9787539643977 +9787539645056 +9787539645087 +9787539645117 +9787539647197 +9787539647517 +9787539648255 +9787539648521 +9787539648705 +9787539649054 +9787539649863 +9787539650999 +9787539655178 +9787539657387 +9787539658513 +9787539659534 +9787539661681 +9787539661780 +9787539663357 +9787539667072 +9787539668031 +9787539668277 +9787539670591 +9787539676098 +9787539677422 +9787539677934 +9787539679419 +9787539680491 +9787539680682 +9787539680712 +9787539681054 +9787539681689 +9787539682600 +9787539683300 +9787539683638 +9787539701455 +9787539703022 +9787539703480 +9787539711584 +9787539711959 +9787539712864 +9787539713748 +9787539716954 +9787539719177 +9787539719849 +9787539720456 +9787539721705 +9787539721729 +9787539721736 +9787539722580 +9787539722610 +9787539722627 +9787539729336 +9787539732213 +9787539732558 +9787539732589 +9787539733210 +9787539735467 +9787539735795 +9787539736259 +9787539736969 +9787539737959 +9787539741055 +9787539744070 +9787539744100 +9787539744179 +9787539744186 +9787539746708 +9787539747224 +9787539747736 +9787539749792 +9787539750385 +9787539750415 +9787539750422 +9787539750446 +9787539750545 +9787539750583 +9787539750903 +9787539752273 +9787539752310 +9787539752488 +9787539753393 +9787539753720 +9787539754611 +9787539755809 +9787539756202 +9787539756721 +9787539758732 +9787539758862 +9787539759555 +9787539759678 +9787539760476 +9787539764016 +9787539764030 +9787539764306 +9787539764795 +9787539764801 +9787539764825 +9787539766041 +9787539766287 +9787539766355 +9787539768328 +9787539768625 +9787539768892 +9787539769301 +9787539771762 +9787539771885 +9787539771915 +9787539773322 +9787539773889 +9787539774152 +9787539774534 +9787539775005 +9787539775616 +9787539776064 +9787539778488 +9787539778648 +9787539778853 +9787539778891 +9787539779737 +9787539779843 +9787539779850 +9787539779966 +9787539780634 +9787539780832 +9787539780849 +9787539780856 +9787539780955 +9787539781228 +9787539781532 +9787539781778 +9787539781907 +9787539782133 +9787539783147 +9787539786117 +9787539786254 +9787539786261 +9787539786285 +9787539787015 +9787539787022 +9787539787114 +9787539787121 +9787539787282 +9787539788098 +9787539788111 +9787539788128 +9787539788517 +9787539789798 +9787539790497 +9787539791760 +9787539791883 +9787539791906 +9787539792644 +9787539793542 +9787539793672 +9787539793764 +9787539793795 +9787539793948 +9787539794228 +9787539794808 +9787539794877 +9787539795164 +9787539795560 +9787539795997 +9787539796031 +9787539796611 +9787539798158 +9787539799438 +9787539799452 +9787539799506 +9787539799841 +9787539799858 +9787539800011 +9787539800028 +9787539800059 +9787539800608 +9787539800639 +9787539800745 +9787539800950 +9787539800981 +9787539801230 +9787539801414 +9787539801490 +9787539801612 +9787539801803 +9787539802152 +9787539802213 +9787539802282 +9787539802886 +9787539803173 +9787539803548 +9787539804033 +9787539804057 +9787539804163 +9787539804217 +9787539804231 +9787539804859 +9787539805443 +9787539805702 +9787539806754 +9787539807201 +9787539807270 +9787539807355 +9787539807409 +9787539807416 +9787539807430 +9787539807898 +9787539808253 +9787539808338 +9787539808369 +9787539808642 +9787539808758 +9787539808765 +9787539808796 +9787539808819 +9787539808970 +9787539809243 +9787539809465 +9787539809489 +9787539809588 +9787539809625 +9787539810034 +9787539810058 +9787539810065 +9787539810652 +9787539811024 +9787539811406 +9787539812076 +9787539813783 +9787539815350 +9787539815480 +9787539816227 +9787539819549 +9787539819617 +9787539819631 +9787539820835 +9787539820866 +9787539820958 +9787539821139 +9787539821290 +9787539822167 +9787539822365 +9787539822822 +9787539823935 +9787539825540 +9787539825915 +9787539826035 +9787539827162 +9787539830469 +9787539831688 +9787539833330 +9787539834115 +9787539834146 +9787539834498 +9787539836553 +9787539836577 +9787539837963 +9787539838489 +9787539838601 +9787539838878 +9787539839271 +9787539839981 +9787539840987 +9787539843513 +9787539845920 +9787539847955 +9787539848723 +9787539849195 +9787539852454 +9787539853703 +9787539854830 +9787539854854 +9787539854861 +9787539855332 +9787539859767 +9787539859774 +9787539861944 +9787539862583 +9787539862637 +9787539870755 +9787539875620 +9787539876306 +9787539877167 +9787539877624 +9787539877808 +9787539878355 +9787539878713 +9787539878942 +9787539878966 +9787539878997 +9787539881744 +9787539881768 +9787539881775 +9787539881911 +9787539884127 +9787539885650 +9787539885728 +9787539886725 +9787539886879 +9787539886886 +9787539887906 +9787539887968 +9787539888033 +9787539888132 +9787539888163 +9787539888781 +9787539889122 +9787539890838 +9787539893389 +9787539894454 +9787539894621 +9787539894676 +9787539895116 +9787539895314 +9787539896274 +9787539898261 +9787539898292 +9787539900032 +9787539900049 +9787539900148 +9787539900155 +9787539900476 +9787539900520 +9787539900551 +9787539900568 +9787539900704 +9787539900780 +9787539900865 +9787539901114 +9787539901145 +9787539901275 +9787539901343 +9787539901350 +9787539901442 +9787539901558 +9787539901695 +9787539901831 +9787539901893 +9787539902043 +9787539902111 +9787539902340 +9787539902593 +9787539902739 +9787539902753 +9787539902821 +9787539903101 +9787539903217 +9787539903293 +9787539903330 +9787539903415 +9787539903422 +9787539903439 +9787539903446 +9787539903668 +9787539903705 +9787539903774 +9787539903873 +9787539903880 +9787539903903 +9787539903927 +9787539904146 +9787539904214 +9787539904429 +9787539904436 +9787539904443 +9787539904450 +9787539904511 +9787539904580 +9787539904634 +9787539904863 +9787539905051 +9787539905280 +9787539905365 +9787539905372 +9787539905396 +9787539905419 +9787539905426 +9787539905518 +9787539905525 +9787539905532 +9787539905594 +9787539905617 +9787539905693 +9787539905983 +9787539905990 +9787539906027 +9787539906119 +9787539906218 +9787539906386 +9787539906393 +9787539906409 +9787539906416 +9787539906430 +9787539906454 +9787539906461 +9787539906492 +9787539906508 +9787539906584 +9787539906591 +9787539906607 +9787539906973 +9787539906980 +9787539906997 +9787539907253 +9787539907277 +9787539907291 +9787539907482 +9787539907499 +9787539907505 +9787539907598 +9787539907611 +9787539907628 +9787539907659 +9787539907741 +9787539907819 +9787539907871 +9787539907888 +9787539907901 +9787539908007 +9787539908045 +9787539908069 +9787539908076 +9787539908168 +9787539908175 +9787539908212 +9787539908236 +9787539908250 +9787539908267 +9787539908281 +9787539908410 +9787539908427 +9787539908441 +9787539908465 +9787539908489 +9787539908496 +9787539908571 +9787539908618 +9787539908687 +9787539908717 +9787539908823 +9787539908861 +9787539909158 +9787539909189 +9787539909257 +9787539909271 +9787539909288 +9787539909295 +9787539909301 +9787539909394 +9787539909400 +9787539909417 +9787539909448 +9787539909462 +9787539909479 +9787539909530 +9787539909547 +9787539909554 +9787539909578 +9787539909585 +9787539909592 +9787539909622 +9787539909714 +9787539909738 +9787539909769 +9787539909820 +9787539909837 +9787539909851 +9787539909950 +9787539909967 +9787539910055 +9787539910062 +9787539910086 +9787539910093 +9787539910109 +9787539910116 +9787539910185 +9787539910314 +9787539910406 +9787539910420 +9787539910437 +9787539910444 +9787539910468 +9787539910499 +9787539910666 +9787539910673 +9787539910796 +9787539910925 +9787539911007 +9787539911014 +9787539911083 +9787539911090 +9787539911243 +9787539911489 +9787539911496 +9787539911502 +9787539911519 +9787539911526 +9787539911618 +9787539911687 +9787539911755 +9787539912073 +9787539912141 +9787539912233 +9787539912363 +9787539912370 +9787539912387 +9787539912417 +9787539912455 +9787539912509 +9787539912523 +9787539912547 +9787539912585 +9787539912769 +9787539912790 +9787539912844 +9787539912868 +9787539912899 +9787539912905 +9787539912912 +9787539913018 +9787539913049 +9787539913070 +9787539913339 +9787539913445 +9787539913667 +9787539913735 +9787539913902 +9787539913971 +9787539914039 +9787539914046 +9787539914053 +9787539914060 +9787539914312 +9787539914398 +9787539914497 +9787539914626 +9787539914640 +9787539914671 +9787539914688 +9787539914725 +9787539915128 +9787539915135 +9787539915142 +9787539915210 +9787539915227 +9787539915326 +9787539915395 +9787539915487 +9787539915692 +9787539916262 +9787539916552 +9787539916675 +9787539916712 +9787539916842 +9787539916859 +9787539916934 +9787539917269 +9787539917405 +9787539917634 +9787539917702 +9787539917726 +9787539917887 +9787539917917 +9787539917962 +9787539918136 +9787539918150 +9787539918334 +9787539918341 +9787539918365 +9787539918426 +9787539918525 +9787539918532 +9787539918631 +9787539918655 +9787539918846 +9787539919027 +9787539919188 +9787539919515 +9787539919652 +9787539919881 +9787539919997 +9787539920252 +9787539920375 +9787539920566 +9787539920603 +9787539920917 +9787539921129 +9787539921815 +9787539922157 +9787539922249 +9787539922423 +9787539922447 +9787539922560 +9787539922638 +9787539922843 +9787539922867 +9787539922881 +9787539922911 +9787539922997 +9787539923109 +9787539923161 +9787539923604 +9787539923871 +9787539923963 +9787539924373 +9787539924434 +9787539924519 +9787539924670 +9787539924816 +9787539924847 +9787539925264 +9787539925325 +9787539925356 +9787539925424 +9787539925493 +9787539925509 +9787539925516 +9787539925523 +9787539925547 +9787539925585 +9787539925981 +9787539926223 +9787539926254 +9787539926261 +9787539926469 +9787539926490 +9787539926544 +9787539926636 +9787539926667 +9787539926704 +9787539926889 +9787539926971 +9787539926995 +9787539927114 +9787539927145 +9787539927206 +9787539927220 +9787539927374 +9787539927404 +9787539927503 +9787539928654 +9787539928739 +9787539928784 +9787539928913 +9787539928968 +9787539929118 +9787539929156 +9787539929538 +9787539929897 +9787539929903 +9787539929927 +9787539930077 +9787539931487 +9787539931524 +9787539931579 +9787539931586 +9787539931593 +9787539931623 +9787539931692 +9787539931852 +9787539932033 +9787539932163 +9787539932767 +9787539934419 +9787539934440 +9787539934587 +9787539934624 +9787539935157 +9787539935232 +9787539935249 +9787539935355 +9787539935522 +9787539935805 +9787539935843 +9787539936109 +9787539936383 +9787539936673 +9787539937007 +9787539937267 +9787539937304 +9787539937311 +9787539937533 +9787539937618 +9787539937625 +9787539937687 +9787539937717 +9787539937748 +9787539937960 +9787539938257 +9787539938783 +9787539939018 +9787539939391 +9787539939582 +9787539939612 +9787539939803 +9787539939827 +9787539939957 +9787539940175 +9787539940250 +9787539940298 +9787539940434 +9787539940458 +9787539940977 +9787539940984 +9787539941066 +9787539941585 +9787539941738 +9787539941776 +9787539941936 +9787539941943 +9787539942278 +9787539942346 +9787539942568 +9787539942926 +9787539943022 +9787539943190 +9787539943589 +9787539944814 +9787539944975 +9787539944999 +9787539945019 +9787539945071 +9787539945088 +9787539945149 +9787539945170 +9787539945316 +9787539945330 +9787539945675 +9787539946085 +9787539947068 +9787539947129 +9787539947259 +9787539947280 +9787539949062 +9787539949109 +9787539949154 +9787539949178 +9787539949444 +9787539949703 +9787539950280 +9787539950471 +9787539950488 +9787539950723 +9787539950730 +9787539950747 +9787539950778 +9787539950792 +9787539950808 +9787539950839 +9787539951546 +9787539951584 +9787539951621 +9787539951683 +9787539951775 +9787539951829 +9787539952017 +9787539952079 +9787539952239 +9787539952581 +9787539952680 +9787539952949 +9787539952970 +9787539954288 +9787539954684 +9787539954752 +9787539954783 +9787539955018 +9787539955056 +9787539955230 +9787539956466 +9787539956855 +9787539957012 +9787539957494 +9787539957500 +9787539958002 +9787539959085 +9787539959184 +9787539959481 +9787539959795 +9787539959856 +9787539960456 +9787539960548 +9787539960555 +9787539960920 +9787539961217 +9787539961880 +9787539961897 +9787539962177 +9787539963150 +9787539963242 +9787539963334 +9787539963358 +9787539963518 +9787539964317 +9787539964942 +9787539964973 +9787539965178 +9787539965352 +9787539965406 +9787539965475 +9787539967905 +9787539968032 +9787539968056 +9787539968902 +9787539969206 +9787539969404 +9787539969640 +9787539970585 +9787539970622 +9787539970721 +9787539970912 +9787539971025 +9787539971599 +9787539971735 +9787539971766 +9787539971964 +9787539972367 +9787539972374 +9787539973463 +9787539973999 +9787539974088 +9787539974156 +9787539975610 +9787539976174 +9787539976242 +9787539976822 +9787539976884 +9787539977140 +9787539978109 +9787539978567 +9787539979076 +9787539979687 +9787539980003 +9787539980010 +9787539980805 +9787539981109 +9787539981673 +9787539981710 +9787539981727 +9787539982625 +9787539983240 +9787539983318 +9787539983424 +9787539984322 +9787539984667 +9787539984964 +9787539986401 +9787539988511 +9787539988542 +9787539988993 +9787539989037 +9787539989099 +9787539989679 +9787539989693 +9787539989846 +9787539990613 +9787539991078 +9787539991146 +9787539991801 +9787539991825 +9787539994260 +9787539994550 +9787539995267 +9787539996356 +9787539996950 +9787539997902 +9787539998640 +9787539998770 +9787539999128 +9787540000080 +9787540000301 +9787540000387 +9787540000448 +9787540000493 +9787540000516 +9787540000585 +9787540000592 +9787540000608 +9787540000707 +9787540001070 +9787540001292 +9787540002039 +9787540012359 +9787540019013 +9787540100056 +9787540100087 +9787540100100 +9787540100131 +9787540100155 +9787540100575 +9787540100636 +9787540100735 +9787540100841 +9787540100995 +9787540101039 +9787540101244 +9787540101251 +9787540101282 +9787540102074 +9787540102272 +9787540102562 +9787540102746 +9787540103682 +9787540103835 +9787540104238 +9787540104375 +9787540104870 +9787540105310 +9787540106430 +9787540106805 +9787540106812 +9787540106966 +9787540107031 +9787540107208 +9787540107383 +9787540107567 +9787540108359 +9787540108380 +9787540108748 +9787540108755 +9787540109011 +9787540109424 +9787540109615 +9787540109875 +9787540110246 +9787540110611 +9787540110741 +9787540110758 +9787540111403 +9787540112264 +9787540112448 +9787540113032 +9787540113315 +9787540114688 +9787540114718 +9787540115067 +9787540115838 +9787540115975 +9787540116002 +9787540117023 +9787540117443 +9787540117726 +9787540117894 +9787540118075 +9787540118242 +9787540118662 +9787540118792 +9787540119478 +9787540119911 +9787540119942 +9787540119959 +9787540120375 +9787540120740 +9787540121433 +9787540121532 +9787540121587 +9787540122188 +9787540122195 +9787540122225 +9787540122232 +9787540122249 +9787540122331 +9787540122386 +9787540122638 +9787540122744 +9787540122829 +9787540122836 +9787540122843 +9787540122867 +9787540122898 +9787540122966 +9787540123086 +9787540123383 +9787540123505 +9787540124410 +9787540124731 +9787540124830 +9787540125165 +9787540125172 +9787540125189 +9787540126674 +9787540127251 +9787540127275 +9787540127534 +9787540127763 +9787540127954 +9787540128005 +9787540129293 +9787540129330 +9787540129514 +9787540132026 +9787540137236 +9787540143411 +9787540143435 +9787540143978 +9787540143992 +9787540144388 +9787540144456 +9787540145149 +9787540146832 +9787540147280 +9787540147549 +9787540147969 +9787540148379 +9787540148928 +9787540149826 +9787540150341 +9787540150389 +9787540150402 +9787540152307 +9787540152383 +9787540152611 +9787540153298 +9787540153861 +9787540153878 +9787540153892 +9787540154103 +9787540154813 +9787540154875 +9787540154936 +9787540155285 +9787540155827 +9787540155865 +9787540156046 +9787540157104 +9787540162085 +9787540162092 +9787540162146 +9787540162382 +9787540162511 +9787540162641 +9787540163105 +9787540163143 +9787540163488 +9787540163921 +9787540163938 +9787540164591 +9787540165147 +9787540165154 +9787540165277 +9787540165291 +9787540166168 +9787540166199 +9787540166557 +9787540167356 +9787540167370 +9787540167387 +9787540167400 +9787540167585 +9787540167615 +9787540167981 +9787540169183 +9787540200084 +9787540200183 +9787540200244 +9787540200312 +9787540200367 +9787540200398 +9787540200480 +9787540200510 +9787540200657 +9787540200725 +9787540200756 +9787540200770 +9787540200794 +9787540200886 +9787540200909 +9787540201098 +9787540201104 +9787540201111 +9787540201326 +9787540201487 +9787540201555 +9787540201562 +9787540201708 +9787540201807 +9787540201814 +9787540201869 +9787540201906 +9787540201937 +9787540201982 +9787540202002 +9787540202033 +9787540202217 +9787540202255 +9787540202347 +9787540202422 +9787540202545 +9787540202644 +9787540202804 +9787540202835 +9787540203115 +9787540203146 +9787540203269 +9787540203443 +9787540203450 +9787540203580 +9787540203658 +9787540203795 +9787540203825 +9787540203863 +9787540203887 +9787540203948 +9787540203962 +9787540204136 +9787540204198 +9787540204273 +9787540204334 +9787540204464 +9787540204471 +9787540204600 +9787540204761 +9787540204907 +9787540204914 +9787540205195 +9787540205324 +9787540205393 +9787540205577 +9787540205584 +9787540205591 +9787540205638 +9787540205737 +9787540205805 +9787540205904 +9787540205911 +9787540205935 +9787540206116 +9787540206192 +9787540206239 +9787540206307 +9787540206352 +9787540206581 +9787540206697 +9787540206734 +9787540206796 +9787540206895 +9787540206932 +9787540207045 +9787540207083 +9787540207113 +9787540207120 +9787540207243 +9787540207274 +9787540207342 +9787540207410 +9787540207427 +9787540207458 +9787540207526 +9787540207557 +9787540207564 +9787540207656 +9787540207878 +9787540207991 +9787540208066 +9787540208257 +9787540208387 +9787540208394 +9787540208493 +9787540208578 +9787540209247 +9787540209315 +9787540209322 +9787540209407 +9787540209476 +9787540210465 +9787540210588 +9787540210595 +9787540210625 +9787540210816 +9787540210946 +9787540211042 +9787540211196 +9787540211356 +9787540211523 +9787540211561 +9787540211677 +9787540211820 +9787540211844 +9787540212001 +9787540212247 +9787540212490 +9787540212612 +9787540212735 +9787540212773 +9787540213015 +9787540213039 +9787540213176 +9787540213220 +9787540213459 +9787540213466 +9787540214265 +9787540215033 +9787540215187 +9787540215200 +9787540215545 +9787540215590 +9787540215637 +9787540215644 +9787540216023 +9787540216139 +9787540216153 +9787540216238 +9787540216375 +9787540216696 +9787540217006 +9787540217105 +9787540217280 +9787540217419 +9787540218102 +9787540218362 +9787540218522 +9787540218669 +9787540218799 +9787540218959 +9787540219017 +9787540219222 +9787540219727 +9787540219789 +9787540219819 +9787540219840 +9787540219932 +9787540220068 +9787540220105 +9787540220129 +9787540220150 +9787540220228 +9787540220242 +9787540220495 +9787540220938 +9787540221089 +9787540221171 +9787540222000 +9787540222376 +9787540222512 +9787540222710 +9787540222796 +9787540222833 +9787540222918 +9787540223137 +9787540223229 +9787540223342 +9787540223557 +9787540224042 +9787540224264 +9787540224394 +9787540224530 +9787540224585 +9787540224615 +9787540224776 +9787540224806 +9787540224929 +9787540225872 +9787540225889 +9787540225919 +9787540226251 +9787540226374 +9787540226534 +9787540227371 +9787540228613 +9787540228835 +9787540228859 +9787540228941 +9787540229207 +9787540229566 +9787540229962 +9787540230760 +9787540230791 +9787540231538 +9787540232672 +9787540232849 +9787540233075 +9787540233242 +9787540235833 +9787540235888 +9787540235987 +9787540236533 +9787540237172 +9787540241667 +9787540241780 +9787540241971 +9787540241988 +9787540242022 +9787540244446 +9787540244484 +9787540244699 +9787540245153 +9787540245177 +9787540245368 +9787540245832 +9787540245887 +9787540250409 +9787540250744 +9787540250829 +9787540253035 +9787540254643 +9787540254728 +9787540254780 +9787540255053 +9787540257934 +9787540260644 +9787540261290 +9787540261825 +9787540264420 +9787540264475 +9787540265120 +9787540267759 +9787540268053 +9787540268145 +9787540268343 +9787540268626 +9787540269173 +9787540269319 +9787540269395 +9787540272814 +9787540273309 +9787540275211 +9787540278861 +9787540300012 +9787540300029 +9787540300067 +9787540300128 +9787540300142 +9787540300173 +9787540300197 +9787540300227 +9787540300241 +9787540300258 +9787540300302 +9787540300340 +9787540300388 +9787540300616 +9787540300746 +9787540301415 +9787540301453 +9787540301620 +9787540301958 +9787540301972 +9787540302030 +9787540302122 +9787540303655 +9787540306144 +9787540307189 +9787540309107 +9787540309985 +9787540310776 +9787540310998 +9787540311179 +9787540314545 +9787540314910 +9787540319168 +9787540321734 +9787540322373 +9787540322977 +9787540325077 +9787540326470 +9787540327934 +9787540337896 +9787540338633 +9787540341848 +9787540343415 +9787540343965 +9787540344818 +9787540344887 +9787540345204 +9787540346225 +9787540355005 +9787540356538 +9787540356590 +9787540360900 +9787540361570 +9787540364038 +9787540364090 +9787540364571 +9787540364588 +9787540365974 +9787540366230 +9787540367923 +9787540370251 +9787540370275 +9787540370305 +9787540371449 +9787540371562 +9787540372293 +9787540372408 +9787540372903 +9787540374020 +9787540374044 +9787540374341 +9787540374402 +9787540374426 +9787540374914 +9787540375300 +9787540375317 +9787540375355 +9787540375935 +9787540376000 +9787540376116 +9787540376222 +9787540376260 +9787540376413 +9787540376574 +9787540377090 +9787540377298 +9787540377304 +9787540377328 +9787540377342 +9787540377465 +9787540377496 +9787540377724 +9787540378011 +9787540378028 +9787540378035 +9787540378196 +9787540378226 +9787540378578 +9787540378592 +9787540378707 +9787540380212 +9787540381516 +9787540381523 +9787540381608 +9787540382100 +9787540382704 +9787540400095 +9787540400132 +9787540400187 +9787540400194 +9787540400231 +9787540400439 +9787540400620 +9787540400644 +9787540400965 +9787540400989 +9787540401009 +9787540401092 +9787540401412 +9787540401436 +9787540401450 +9787540401580 +9787540402044 +9787540402235 +9787540402396 +9787540402716 +9787540402822 +9787540402846 +9787540402860 +9787540402907 +9787540402952 +9787540403027 +9787540403157 +9787540403249 +9787540403287 +9787540403997 +9787540404017 +9787540404079 +9787540404277 +9787540404291 +9787540404321 +9787540404604 +9787540404611 +9787540404628 +9787540405014 +9787540405021 +9787540405045 +9787540405076 +9787540405236 +9787540405366 +9787540405465 +9787540406103 +9787540406141 +9787540406158 +9787540406271 +9787540406622 +9787540406646 +9787540406677 +9787540406783 +9787540406899 +9787540406950 +9787540407070 +9787540407087 +9787540407100 +9787540407131 +9787540407179 +9787540407254 +9787540407261 +9787540407278 +9787540407285 +9787540407292 +9787540407308 +9787540407797 +9787540408008 +9787540408237 +9787540408268 +9787540408282 +9787540408541 +9787540408589 +9787540408657 +9787540408664 +9787540408701 +9787540408770 +9787540408800 +9787540408855 +9787540408985 +9787540408992 +9787540409036 +9787540409067 +9787540409074 +9787540409081 +9787540409258 +9787540409265 +9787540409364 +9787540409494 +9787540409586 +9787540409692 +9787540410056 +9787540410292 +9787540410315 +9787540410681 +9787540410728 +9787540410766 +9787540410827 +9787540410926 +9787540410957 +9787540411039 +9787540411077 +9787540411084 +9787540411091 +9787540411114 +9787540411121 +9787540411138 +9787540411169 +9787540411183 +9787540411190 +9787540411206 +9787540411237 +9787540411244 +9787540411251 +9787540411268 +9787540411305 +9787540411350 +9787540411367 +9787540411374 +9787540411404 +9787540411428 +9787540411817 +9787540411824 +9787540411879 +9787540411893 +9787540412135 +9787540412159 +9787540412180 +9787540412227 +9787540412258 +9787540412289 +9787540412333 +9787540412371 +9787540412388 +9787540412395 +9787540412784 +9787540412791 +9787540412876 +9787540413088 +9787540413224 +9787540413309 +9787540413415 +9787540413422 +9787540413538 +9787540413569 +9787540413613 +9787540413637 +9787540413682 +9787540413705 +9787540413958 +9787540414092 +9787540414276 +9787540414887 +9787540415020 +9787540415075 +9787540415372 +9787540415754 +9787540416164 +9787540416171 +9787540416188 +9787540416249 +9787540416294 +9787540416331 +9787540416348 +9787540416355 +9787540416362 +9787540416393 +9787540416423 +9787540416584 +9787540416607 +9787540416799 +9787540417109 +9787540417536 +9787540417543 +9787540417604 +9787540417796 +9787540417833 +9787540417857 +9787540417864 +9787540418038 +9787540418137 +9787540418182 +9787540418236 +9787540418380 +9787540418410 +9787540418496 +9787540418540 +9787540418595 +9787540418663 +9787540418779 +9787540418885 +9787540419141 +9787540419158 +9787540419219 +9787540419394 +9787540419448 +9787540419615 +9787540419653 +9787540419738 +9787540419752 +9787540420321 +9787540420475 +9787540420789 +9787540421274 +9787540421465 +9787540421526 +9787540421625 +9787540421731 +9787540421762 +9787540421823 +9787540422028 +9787540422172 +9787540422202 +9787540422332 +9787540422349 +9787540422387 +9787540422462 +9787540422530 +9787540422615 +9787540422783 +9787540422820 +9787540422837 +9787540422943 +9787540422950 +9787540422967 +9787540423001 +9787540423445 +9787540423636 +9787540423643 +9787540423735 +9787540423742 +9787540423797 +9787540423896 +9787540424220 +9787540424244 +9787540424541 +9787540425418 +9787540425432 +9787540425630 +9787540425791 +9787540425906 +9787540426859 +9787540427009 +9787540427016 +9787540427184 +9787540427924 +9787540427962 +9787540427979 +9787540427993 +9787540428112 +9787540428181 +9787540428860 +9787540428945 +9787540429065 +9787540429393 +9787540429492 +9787540429584 +9787540429614 +9787540429683 +9787540429713 +9787540429737 +9787540429829 +9787540429966 +9787540429973 +9787540430313 +9787540431150 +9787540431808 +9787540431822 +9787540431877 +9787540432911 +9787540433376 +9787540433741 +9787540434229 +9787540434762 +9787540435035 +9787540436278 +9787540436483 +9787540437701 +9787540439170 +9787540444365 +9787540445188 +9787540445546 +9787540448172 +9787540448189 +9787540448288 +9787540448936 +9787540449070 +9787540449193 +9787540450113 +9787540450489 +9787540451752 +9787540452841 +9787540453459 +9787540455774 +9787540458690 +9787540465988 +9787540466817 +9787540467555 +9787540467739 +9787540468446 +9787540469450 +9787540470357 +9787540470586 +9787540474652 +9787540474904 +9787540479671 +9787540488291 +9787540491062 +9787540491321 +9787540491949 +9787540493363 +9787540494155 +9787540495794 +9787540496487 +9787540497354 +9787540497897 +9787540500078 +9787540500399 +9787540501600 +9787540502591 +9787540503994 +9787540504212 +9787540505271 +9787540505431 +9787540507206 +9787540510220 +9787540510237 +9787540510251 +9787540510831 +9787540510848 +9787540511814 +9787540512972 +9787540513689 +9787540515614 +9787540516055 +9787540516451 +9787540516468 +9787540516628 +9787540517670 +9787540518134 +9787540518554 +9787540518639 +9787540518752 +9787540519124 +9787540519810 +9787540520113 +9787540520762 +9787540521370 +9787540521493 +9787540521981 +9787540522001 +9787540522308 +9787540522414 +9787540526252 +9787540527013 +9787540527600 +9787540533342 +9787540535049 +9787540538699 +9787540539566 +9787540540241 +9787540540685 +9787540540852 +9787540541163 +9787540541675 +9787540541774 +9787540544256 +9787540545024 +9787540545116 +9787540545833 +9787540546540 +9787540546779 +9787540546816 +9787540549657 +9787540554330 +9787540556143 +9787540558888 +9787540559564 +9787540559915 +9787540560515 +9787540565138 +9787540567361 +9787540572938 +9787540574000 +9787540580995 +9787540581206 +9787540583040 +9787540584344 +9787540585341 +9787540585389 +9787540585402 +9787540587697 +9787540587703 +9787540588021 +9787540588069 +9787540588083 +9787540588090 +9787540588113 +9787540588540 +9787540588588 +9787540588625 +9787540589707 +9787540590055 +9787540592646 +9787540593674 +9787540596255 +9787540596842 +9787540597764 +9787540599362 +9787540599980 +9787540603472 +9787540603885 +9787540608484 +9787540612726 +9787540613204 +9787540613693 +9787540615291 +9787540619275 +9787540625658 +9787540628000 +9787540628727 +9787540630041 +9787540632038 +9787540632175 +9787540634292 +9787540634377 +9787540635633 +9787540636791 +9787540637262 +9787540637835 +9787540637842 +9787540637927 +9787540639792 +9787540640088 +9787540640118 +9787540640217 +9787540640255 +9787540640279 +9787540641139 +9787540641511 +9787540641535 +9787540641573 +9787540641702 +9787540641887 +9787540644093 +9787540645519 +9787540645601 +9787540649357 +9787540650032 +9787540652500 +9787540653323 +9787540656980 +9787540657109 +9787540658878 +9787540658991 +9787540667528 +9787540669546 +9787540670610 +9787540676025 +9787540677015 +9787540677268 +9787540680275 +9787540680282 +9787540682644 +9787540682651 +9787540682675 +9787540683245 +9787540683801 +9787540685157 +9787540691240 +9787540691585 +9787540691639 +9787540691882 +9787540692032 +9787540692049 +9787540692063 +9787540692193 +9787540692285 +9787540692315 +9787540692360 +9787540692506 +9787540694142 +9787540695705 +9787540695996 +9787540696009 +9787540696030 +9787540696337 +9787540696658 +9787540696665 +9787540696955 +9787540698454 +9787540698485 +9787540700010 +9787540700034 +9787540700096 +9787540700102 +9787540700201 +9787540700218 +9787540700263 +9787540700270 +9787540700362 +9787540700409 +9787540700539 +9787540700577 +9787540700713 +9787540700768 +9787540700799 +9787540700850 +9787540700867 +9787540700898 +9787540701369 +9787540701413 +9787540701420 +9787540701581 +9787540701604 +9787540701628 +9787540701697 +9787540701796 +9787540701932 +9787540701956 +9787540701970 +9787540702113 +9787540702236 +9787540702250 +9787540702564 +9787540702595 +9787540702632 +9787540702731 +9787540702748 +9787540702908 +9787540702922 +9787540703240 +9787540703288 +9787540703394 +9787540703462 +9787540703486 +9787540703516 +9787540703578 +9787540703677 +9787540703745 +9787540703769 +9787540703844 +9787540703943 +9787540704247 +9787540704544 +9787540704995 +9787540705442 +9787540705534 +9787540705701 +9787540706258 +9787540706418 +9787540706500 +9787540706777 +9787540706807 +9787540706920 +9787540706937 +9787540706951 +9787540707026 +9787540707200 +9787540707330 +9787540707743 +9787540708511 +9787540708825 +9787540708979 +9787540708993 +9787540709020 +9787540709860 +9787540710316 +9787540710347 +9787540710767 +9787540711047 +9787540711054 +9787540711757 +9787540711849 +9787540711993 +9787540712051 +9787540712235 +9787540712778 +9787540712792 +9787540712891 +9787540712914 +9787540713058 +9787540713140 +9787540713843 +9787540714031 +9787540714611 +9787540714758 +9787540714802 +9787540715021 +9787540715601 +9787540715625 +9787540715809 +9787540715830 +9787540715878 +9787540715915 +9787540715922 +9787540715939 +9787540716233 +9787540716271 +9787540716349 +9787540716455 +9787540716776 +9787540716806 +9787540717018 +9787540717032 +9787540717148 +9787540717209 +9787540717230 +9787540717254 +9787540717261 +9787540717346 +9787540717605 +9787540718091 +9787540718237 +9787540718312 +9787540718343 +9787540719005 +9787540719340 +9787540719654 +9787540719821 +9787540719951 +9787540720285 +9787540720483 +9787540720612 +9787540720964 +9787540720971 +9787540721336 +9787540721381 +9787540721435 +9787540721459 +9787540721923 +9787540721978 +9787540722036 +9787540722128 +9787540722470 +9787540722531 +9787540722586 +9787540722647 +9787540722692 +9787540723453 +9787540723873 +9787540723880 +9787540723989 +9787540724054 +9787540724290 +9787540724535 +9787540724733 +9787540725105 +9787540725228 +9787540725402 +9787540725464 +9787540725563 +9787540725600 +9787540725846 +9787540726027 +9787540726133 +9787540726157 +9787540726416 +9787540726447 +9787540726546 +9787540726577 +9787540726614 +9787540726744 +9787540726867 +9787540727383 +9787540727611 +9787540727697 +9787540727703 +9787540727819 +9787540727826 +9787540727918 +9787540728212 +9787540728236 +9787540728441 +9787540728557 +9787540728793 +9787540729011 +9787540729028 +9787540729271 +9787540729417 +9787540729776 +9787540730925 +9787540731519 +9787540732530 +9787540732905 +9787540732967 +9787540733087 +9787540733360 +9787540734053 +9787540734060 +9787540734213 +9787540735685 +9787540736835 +9787540736873 +9787540738068 +9787540738143 +9787540738174 +9787540738198 +9787540739102 +9787540739782 +9787540739997 +9787540743079 +9787540745509 +9787540746179 +9787540746223 +9787540748302 +9787540748760 +9787540748777 +9787540749057 +9787540749590 +9787540751883 +9787540752125 +9787540752491 +9787540753054 +9787540754150 +9787540756048 +9787540756116 +9787540756239 +9787540757328 +9787540758363 +9787540758714 +9787540758974 +9787540759315 +9787540759346 +9787540759742 +9787540760519 +9787540760694 +9787540766580 +9787540769420 +9787540769635 +9787540770280 +9787540770389 +9787540770716 +9787540770723 +9787540772314 +9787540772321 +9787540773335 +9787540773977 +9787540774011 +9787540775834 +9787540775889 +9787540776312 +9787540776411 +9787540777661 +9787540777753 +9787540778668 +9787540779115 +9787540779313 +9787540781118 +9787540782276 +9787540785413 +9787540785451 +9787540786250 +9787540786342 +9787540786434 +9787540787875 +9787540787967 +9787540790035 +9787540790943 +9787540791872 +9787540794606 +9787540794699 +9787540794712 +9787540794750 +9787540794774 +9787540794781 +9787540796716 +9787540797294 +9787540797676 +9787540797683 +9787540797706 +9787540798482 +9787540798901 +9787540799724 +9787540799731 +9787540799755 +9787540799762 +9787540799953 +9787540800123 +9787540801311 +9787540802165 +9787540803780 +9787540803858 +9787540806286 +9787540813215 +9787540818630 +9787540818708 +9787540823221 +9787540826567 +9787540826949 +9787540829520 +9787540829551 +9787540830434 +9787540831103 +9787540832261 +9787540832889 +9787540833381 +9787540834432 +9787540835026 +9787540837297 +9787540837808 +9787540838973 +9787540839444 +9787540840020 +9787540842475 +9787540842482 +9787540842499 +9787540842505 +9787540844295 +9787540851637 +9787540851651 +9787540851668 +9787540852535 +9787540853051 +9787540853266 +9787540853464 +9787540855406 +9787540858780 +9787540860912 +9787540860943 +9787540860950 +9787540861223 +9787540861230 +9787540861643 +9787540862350 +9787540862725 +9787540862909 +9787540864927 +9787540866594 +9787540867553 +9787540867577 +9787540869304 +9787540869977 +9787540873035 +9787540873073 +9787540873103 +9787540873134 +9787540873226 +9787540873288 +9787540873493 +9787540873592 +9787540873639 +9787540873936 +9787540873974 +9787540874704 +9787540875282 +9787540875305 +9787540875312 +9787540876340 +9787540876593 +9787540876609 +9787540876623 +9787540876951 +9787540877156 +9787540877163 +9787540877866 +9787540878481 +9787540878689 +9787540883638 +9787540883669 +9787540883768 +9787540884994 +9787540885502 +9787540885717 +9787540888305 +9787540888312 +9787540890193 +9787540891152 +9787540893354 +9787540893378 +9787540893484 +9787540893538 +9787540893545 +9787540893552 +9787540893606 +9787540893972 +9787540894030 +9787540894085 +9787540896324 +9787540896331 +9787540896638 +9787540896645 +9787540896652 +9787540896676 +9787540896713 +9787540896720 +9787540896782 +9787540896829 +9787540897116 +9787540897154 +9787540897192 +9787540900113 +9787540900403 +9787540900984 +9787540901370 +9787540901479 +9787540901561 +9787540901615 +9787540902452 +9787540902698 +9787540902803 +9787540903008 +9787540904579 +9787540905095 +9787540905668 +9787540907778 +9787540908492 +9787540909567 +9787540909604 +9787540910303 +9787540910532 +9787540911966 +9787540912284 +9787540916633 +9787540916749 +9787540917340 +9787540917432 +9787540918163 +9787540918576 +9787540918903 +9787540919443 +9787540921415 +9787540921460 +9787540921569 +9787540921576 +9787540922023 +9787540922221 +9787540923044 +9787540923129 +9787540923259 +9787540923815 +9787540925468 +9787540925727 +9787540925895 +9787540925901 +9787540926601 +9787540927295 +9787540927325 +9787540927370 +9787540928353 +9787540928469 +9787540929220 +9787540930301 +9787540930592 +9787540930820 +9787540930967 +9787540932206 +9787540932213 +9787540932565 +9787540934057 +9787540934279 +9787540935580 +9787540935832 +9787540937539 +9787540937645 +9787540937874 +9787540940102 +9787540940119 +9787540940614 +9787540940621 +9787540941543 +9787540941604 +9787540941895 +9787540942687 +9787540943011 +9787540943080 +9787540943196 +9787540943271 +9787540943356 +9787540944049 +9787540944483 +9787540944827 +9787540945374 +9787540946371 +9787540946470 +9787540947019 +9787540947057 +9787540947156 +9787540947248 +9787540947415 +9787540948252 +9787540949228 +9787540949358 +9787540949471 +9787540949785 +9787540949822 +9787540949990 +9787540951092 +9787540951177 +9787540951269 +9787540951498 +9787540951528 +9787540951566 +9787540951795 +9787540952976 +9787540953003 +9787540954482 +9787540954987 +9787540955038 +9787540955755 +9787540956219 +9787540956370 +9787540956691 +9787540956707 +9787540957179 +9787540957476 +9787540958343 +9787540961794 +9787540962340 +9787540965105 +9787540965600 +9787540973858 +9787540975517 +9787540976880 +9787540978068 +9787540978235 +9787540978532 +9787540979027 +9787540979713 +9787540980283 +9787540980603 +9787540981013 +9787540981068 +9787540981204 +9787540982386 +9787540982782 +9787540983420 +9787540985356 +9787540987091 +9787540988890 +9787540989149 +9787540989668 +9787540990510 +9787540990862 +9787540991838 +9787540993917 +9787540999087 +9787540999544 +9787541000089 +9787541000270 +9787541000324 +9787541000331 +9787541000355 +9787541000560 +9787541000577 +9787541000584 +9787541000638 +9787541000881 +9787541000928 +9787541001154 +9787541001161 +9787541001178 +9787541001222 +9787541001239 +9787541001338 +9787541001956 +9787541002250 +9787541002410 +9787541002533 +9787541002571 +9787541002755 +9787541002779 +9787541002854 +9787541002922 +9787541003462 +9787541003493 +9787541003509 +9787541003813 +9787541004070 +9787541004162 +9787541004353 +9787541004766 +9787541004858 +9787541005800 +9787541006715 +9787541007989 +9787541008054 +9787541008276 +9787541008283 +9787541008290 +9787541008337 +9787541009181 +9787541010125 +9787541010606 +9787541010910 +9787541011108 +9787541011450 +9787541011511 +9787541011580 +9787541011719 +9787541011917 +9787541011931 +9787541011948 +9787541012303 +9787541012341 +9787541012648 +9787541012792 +9787541013027 +9787541013164 +9787541013317 +9787541014062 +9787541014239 +9787541014369 +9787541014604 +9787541015199 +9787541015298 +9787541015700 +9787541015755 +9787541016745 +9787541016776 +9787541017605 +9787541018800 +9787541018954 +9787541022838 +9787541023248 +9787541023484 +9787541023491 +9787541023613 +9787541024214 +9787541024665 +9787541025563 +9787541026270 +9787541026935 +9787541027208 +9787541027499 +9787541027819 +9787541027932 +9787541029097 +9787541029783 +9787541030734 +9787541031106 +9787541031267 +9787541031281 +9787541032080 +9787541032790 +9787541033247 +9787541033391 +9787541034800 +9787541034831 +9787541036019 +9787541036422 +9787541036736 +9787541036996 +9787541038068 +9787541038419 +9787541038563 +9787541039447 +9787541039669 +9787541040368 +9787541041464 +9787541041983 +9787541042102 +9787541042201 +9787541042416 +9787541042652 +9787541043284 +9787541043901 +9787541044755 +9787541044786 +9787541045363 +9787541045936 +9787541046520 +9787541046636 +9787541047862 +9787541048364 +9787541049842 +9787541049958 +9787541050039 +9787541051159 +9787541052231 +9787541052934 +9787541055751 +9787541056390 +9787541056499 +9787541057168 +9787541057229 +9787541057908 +9787541058486 +9787541059636 +9787541060465 +9787541060977 +9787541061431 +9787541061974 +9787541063633 +9787541066337 +9787541067341 +9787541067471 +9787541071812 +9787541072826 +9787541075209 +9787541075308 +9787541075773 +9787541081736 +9787541081743 +9787541082931 +9787541083297 +9787541084126 +9787541084393 +9787541084775 +9787541085697 +9787541085925 +9787541086779 +9787541086922 +9787541087837 +9787541088711 +9787541089220 +9787541089763 +9787541090257 +9787541090301 +9787541090585 +9787541091254 +9787541091957 +9787541092022 +9787541092039 +9787541092046 +9787541092961 +9787541093104 +9787541093876 +9787541094903 +9787541095269 +9787541095405 +9787541095740 +9787541095955 +9787541096051 +9787541096068 +9787541096075 +9787541096082 +9787541096143 +9787541096167 +9787541096235 +9787541096242 +9787541096266 +9787541096389 +9787541096396 +9787541096754 +9787541097249 +9787541097430 +9787541097768 +9787541098499 +9787541098550 +9787541098697 +9787541098864 +9787541098932 +9787541098949 +9787541099991 +9787541100024 +9787541100093 +9787541100321 +9787541100444 +9787541100529 +9787541100840 +9787541101076 +9787541101366 +9787541101403 +9787541101496 +9787541101786 +9787541101793 +9787541101830 +9787541102264 +9787541102486 +9787541102769 +9787541102776 +9787541102806 +9787541102882 +9787541103117 +9787541103667 +9787541104015 +9787541104039 +9787541104459 +9787541104732 +9787541104824 +9787541105616 +9787541105777 +9787541106927 +9787541106958 +9787541107078 +9787541107085 +9787541107467 +9787541107719 +9787541107849 +9787541107887 +9787541108310 +9787541108440 +9787541108464 +9787541108587 +9787541108594 +9787541108686 +9787541108709 +9787541109126 +9787541109164 +9787541109201 +9787541109324 +9787541109331 +9787541109348 +9787541109423 +9787541109591 +9787541109614 +9787541110153 +9787541110337 +9787541110993 +9787541111129 +9787541111631 +9787541111693 +9787541111723 +9787541111815 +9787541111846 +9787541111853 +9787541111938 +9787541111945 +9787541111990 +9787541112027 +9787541112133 +9787541112331 +9787541112348 +9787541112409 +9787541112423 +9787541112522 +9787541112560 +9787541112591 +9787541112645 +9787541112690 +9787541112799 +9787541112812 +9787541113079 +9787541113185 +9787541113406 +9787541113529 +9787541113857 +9787541113864 +9787541113932 +9787541113956 +9787541114021 +9787541114038 +9787541114076 +9787541114090 +9787541114144 +9787541114243 +9787541114250 +9787541114373 +9787541114410 +9787541114496 +9787541114533 +9787541114601 +9787541114632 +9787541114854 +9787541115172 +9787541115202 +9787541115301 +9787541115394 +9787541115608 +9787541116056 +9787541116094 +9787541116100 +9787541116131 +9787541116339 +9787541116360 +9787541116612 +9787541116803 +9787541116810 +9787541116841 +9787541116872 +9787541116902 +9787541116919 +9787541116926 +9787541116933 +9787541117244 +9787541117404 +9787541117565 +9787541117695 +9787541117701 +9787541117725 +9787541117800 +9787541118012 +9787541118098 +9787541118104 +9787541118418 +9787541118692 +9787541118739 +9787541119125 +9787541119194 +9787541119200 +9787541119460 +9787541119545 +9787541119651 +9787541119675 +9787541120183 +9787541120824 +9787541120831 +9787541121852 +9787541123009 +9787541123023 +9787541123221 +9787541124822 +9787541124921 +9787541126185 +9787541126529 +9787541131257 +9787541132124 +9787541132704 +9787541132711 +9787541132735 +9787541132964 +9787541134586 +9787541135545 +9787541135927 +9787541136900 +9787541138676 +9787541139161 +9787541139284 +9787541140068 +9787541140433 +9787541140631 +9787541141744 +9787541142215 +9787541143854 +9787541144332 +9787541149177 +9787541150456 +9787541152382 +9787541153280 +9787541155819 +9787541156854 +9787541156953 +9787541159206 +9787541159237 +9787541159381 +9787541159640 +9787541160493 +9787541160875 +9787541161124 +9787541162459 +9787541163197 +9787541164613 +9787541164972 +9787541164989 +9787541165474 +9787541166129 +9787541166525 +9787541167003 +9787541167379 +9787541167744 +9787541167782 +9787541167829 +9787541168321 +9787541168529 +9787541168659 +9787541168666 +9787541169359 +9787541169465 +9787541169700 +9787541169793 +9787541169861 +9787541169908 +9787541169922 +9787541170379 +9787541170515 +9787541170614 +9787541171178 +9787541171185 +9787541171215 +9787541171253 +9787541171321 +9787541171611 +9787541171826 +9787541172120 +9787541172243 +9787541172342 +9787541172359 +9787541172717 +9787541172724 +9787541172915 +9787541173189 +9787541173196 +9787541200595 +9787541201073 +9787541203077 +9787541204968 +9787541205316 +9787541205774 +9787541206016 +9787541206139 +9787541206863 +9787541207075 +9787541207327 +9787541207945 +9787541208119 +9787541208447 +9787541208614 +9787541208690 +9787541208911 +9787541209048 +9787541209420 +9787541209673 +9787541209772 +9787541209949 +9787541209970 +9787541210037 +9787541210754 +9787541211034 +9787541211249 +9787541211270 +9787541211430 +9787541212659 +9787541213281 +9787541213854 +9787541213878 +9787541215445 +9787541215735 +9787541215742 +9787541215803 +9787541216114 +9787541218835 +9787541219092 +9787541219849 +9787541219979 +9787541220173 +9787541220302 +9787541220340 +9787541220845 +9787541220944 +9787541221088 +9787541221217 +9787541222023 +9787541222412 +9787541222894 +9787541223143 +9787541229299 +9787541229367 +9787541300509 +9787541300707 +9787541403651 +9787541409424 +9787541409431 +9787541410444 +9787541410659 +9787541411991 +9787541412028 +9787541412189 +9787541412646 +9787541413735 +9787541414336 +9787541414510 +9787541414930 +9787541415036 +9787541416187 +9787541416576 +9787541416583 +9787541416613 +9787541416620 +9787541416644 +9787541416668 +9787541416989 +9787541416996 +9787541418549 +9787541419584 +9787541420115 +9787541424922 +9787541427497 +9787541427718 +9787541430916 +9787541433450 +9787541433559 +9787541441844 +9787541443121 +9787541443176 +9787541443732 +9787541444319 +9787541444326 +9787541444999 +9787541445057 +9787541445972 +9787541446955 +9787541447075 +9787541448003 +9787541449727 +9787541450648 +9787541450662 +9787541450679 +9787541450686 +9787541450693 +9787541455681 +9787541457623 +9787541460432 +9787541463143 +9787541464188 +9787541464546 +9787541464553 +9787541464812 +9787541464867 +9787541465321 +9787541467592 +9787541467684 +9787541468001 +9787541468322 +9787541469909 +9787541470356 +9787541471063 +9787541471117 +9787541477898 +9787541479021 +9787541483486 +9787541483509 +9787541484001 +9787541485152 +9787541485169 +9787541489013 +9787541489044 +9787541489075 +9787541489877 +9787541490521 +9787541491849 +9787541492211 +9787541497148 +9787541497346 +9787541498817 +9787541498930 +9787541499425 +9787541499814 +9787541500657 +9787541502620 +9787541502835 +9787541503818 +9787541504679 +9787541504921 +9787541505928 +9787541509056 +9787541513190 +9787541514302 +9787541518980 +9787541519109 +9787541519239 +9787541520624 +9787541522116 +9787541522239 +9787541523595 +9787541528088 +9787541529191 +9787541530456 +9787541531668 +9787541533136 +9787541533259 +9787541534928 +9787541535345 +9787541536045 +9787541536946 +9787541539268 +9787541539558 +9787541540745 +9787541540752 +9787541540790 +9787541540806 +9787541542213 +9787541543531 +9787541547386 +9787541547416 +9787541547430 +9787541547478 +9787541547744 +9787541551086 +9787541551208 +9787541551246 +9787541551338 +9787541553752 +9787541556906 +9787541557545 +9787541558177 +9787541558191 +9787541558207 +9787541558238 +9787541559419 +9787541560378 +9787541561092 +9787541561351 +9787541561368 +9787541562150 +9787541566233 +9787541566479 +9787541570360 +9787541575723 +9787541578731 +9787541584749 +9787541587924 +9787541598937 +9787541600142 +9787541600388 +9787541602443 +9787541603013 +9787541603617 +9787541605512 +9787541605529 +9787541605574 +9787541605598 +9787541605628 +9787541607233 +9787541608032 +9787541608087 +9787541608476 +9787541609022 +9787541609206 +9787541609763 +9787541609848 +9787541609954 +9787541610813 +9787541611124 +9787541612015 +9787541612534 +9787541612831 +9787541613616 +9787541613838 +9787541613968 +9787541614088 +9787541614217 +9787541614330 +9787541614569 +9787541614880 +9787541615191 +9787541615405 +9787541616570 +9787541617348 +9787541617614 +9787541617621 +9787541617850 +9787541618307 +9787541620737 +9787541621260 +9787541621567 +9787541621734 +9787541622403 +9787541623295 +9787541623813 +9787541624094 +9787541625640 +9787541625695 +9787541626968 +9787541627279 +9787541628351 +9787541630064 +9787541630682 +9787541631511 +9787541634079 +9787541634567 +9787541634857 +9787541635687 +9787541639647 +9787541641572 +9787541641817 +9787541642302 +9787541642678 +9787541642920 +9787541643972 +9787541644351 +9787541647246 +9787541648649 +9787541648755 +9787541649011 +9787541652967 +9787541658303 +9787541659324 +9787541666247 +9787541667954 +9787541667978 +9787541667985 +9787541669408 +9787541670220 +9787541670350 +9787541672187 +9787541674525 +9787541676468 +9787541679667 +9787541680038 +9787541680694 +9787541680755 +9787541681349 +9787541681561 +9787541685422 +9787541686191 +9787541686474 +9787541687006 +9787541687099 +9787541687235 +9787541687815 +9787541688157 +9787541689765 +9787541692062 +9787541692314 +9787541700170 +9787541700668 +9787541700743 +9787541702013 +9787541702143 +9787541702167 +9787541703096 +9787541704123 +9787541704291 +9787541710575 +9787541713880 +9787541714382 +9787541719318 +9787541719684 +9787541719844 +9787541720079 +9787541721540 +9787541721557 +9787541721687 +9787541721717 +9787541722790 +9787541722813 +9787541723599 +9787541728648 +9787541729706 +9787541735288 +9787541736742 +9787541738616 +9787541739019 +9787541739262 +9787541739705 +9787541739996 +9787541740220 +9787541741838 +9787541743047 +9787541744457 +9787541745034 +9787541745256 +9787541745393 +9787541745843 +9787541746222 +9787541746420 +9787541748165 +9787541751882 +9787541752308 +9787541752339 +9787541753602 +9787541753619 +9787541754630 +9787541755620 +9787541755880 +9787541755965 +9787541757488 +9787541757495 +9787541757501 +9787541757518 +9787541757532 +9787541757556 +9787541757648 +9787541757716 +9787541757792 +9787541759116 +9787541759178 +9787541759185 +9787541759192 +9787541759727 +9787541759888 +9787541760150 +9787541760402 +9787541760426 +9787541760433 +9787541760594 +9787541762543 +9787541764929 +9787541766244 +9787541766299 +9787541767548 +9787541767807 +9787541768095 +9787541768118 +9787541768200 +9787541768316 +9787541768347 +9787541768774 +9787541769511 +9787541769658 +9787541771484 +9787541771750 +9787541772030 +9787541773334 +9787541773969 +9787541773983 +9787541774799 +9787541775949 +9787541778377 +9787541800399 +9787541800801 +9787541801433 +9787541801570 +9787541801716 +9787541801976 +9787541802393 +9787541802980 +9787541803444 +9787541803925 +9787541804281 +9787541804380 +9787541804595 +9787541804991 +9787541805059 +9787541805066 +9787541805462 +9787541805493 +9787541805615 +9787541805684 +9787541805738 +9787541805936 +9787541806162 +9787541806223 +9787541806261 +9787541806278 +9787541806605 +9787541806780 +9787541806841 +9787541806865 +9787541807268 +9787541807589 +9787541807626 +9787541807862 +9787541807978 +9787541808128 +9787541808487 +9787541808616 +9787541809361 +9787541809521 +9787541809644 +9787541809651 +9787541809750 +9787541810077 +9787541810411 +9787541810718 +9787541810725 +9787541810732 +9787541810848 +9787541810930 +9787541810978 +9787541811050 +9787541811463 +9787541811487 +9787541811548 +9787541811654 +9787541811708 +9787541811715 +9787541811777 +9787541811838 +9787541811876 +9787541811968 +9787541812101 +9787541812118 +9787541812132 +9787541812163 +9787541812330 +9787541812347 +9787541812606 +9787541812705 +9787541812729 +9787541812774 +9787541812910 +9787541813252 +9787541813368 +9787541813528 +9787541813597 +9787541813627 +9787541813795 +9787541813832 +9787541813948 +9787541813993 +9787541814143 +9787541814204 +9787541814235 +9787541814334 +9787541814747 +9787541814754 +9787541814815 +9787541814976 +9787541814983 +9787541815034 +9787541815102 +9787541815133 +9787541815232 +9787541815249 +9787541815324 +9787541815348 +9787541815355 +9787541815461 +9787541815478 +9787541815508 +9787541815522 +9787541815683 +9787541815812 +9787541815829 +9787541815973 +9787541816017 +9787541816215 +9787541816321 +9787541816567 +9787541816673 +9787541816864 +9787541816949 +9787541817380 +9787541817434 +9787541817496 +9787541817526 +9787541817625 +9787541817830 +9787541818028 +9787541818066 +9787541818110 +9787541818271 +9787541818295 +9787541818523 +9787541818530 +9787541818554 +9787541818684 +9787541818691 +9787541818745 +9787541818844 +9787541818950 +9787541819063 +9787541819247 +9787541819377 +9787541819407 +9787541819414 +9787541819421 +9787541819483 +9787541819612 +9787541819681 +9787541819742 +9787541819834 +9787541819889 +9787541820083 +9787541820274 +9787541820502 +9787541820779 +9787541820854 +9787541821400 +9787541821462 +9787541821608 +9787541821851 +9787541821943 +9787541822063 +9787541822377 +9787541822476 +9787541822643 +9787541822834 +9787541822988 +9787541823046 +9787541823107 +9787541823275 +9787541823435 +9787541823442 +9787541823619 +9787541823695 +9787541823787 +9787541823848 +9787541824128 +9787541824180 +9787541824197 +9787541824227 +9787541824241 +9787541824333 +9787541825576 +9787541826887 +9787541827983 +9787541828089 +9787541830570 +9787541831133 +9787541833922 +9787541836732 +9787541836770 +9787541837128 +9787541837340 +9787541839252 +9787541840968 +9787541841033 +9787541842245 +9787541844218 +9787541844232 +9787541844317 +9787541845130 +9787541845949 +9787541845956 +9787541846236 +9787541846243 +9787541900235 +9787541900259 +9787541900686 +9787541906718 +9787541908309 +9787541908323 +9787541909368 +9787541910463 +9787541911187 +9787541914508 +9787541916762 +9787541917288 +9787541917363 +9787541921650 +9787541922657 +9787541924224 +9787541924514 +9787541926358 +9787541926389 +9787541927843 +9787541929298 +9787541931048 +9787541932076 +9787541933486 +9787541934353 +9787541934681 +9787541936791 +9787541942259 +9787541943706 +9787541944925 +9787541945397 +9787541945618 +9787541945953 +9787541949517 +9787541951244 +9787541957390 +9787541959318 +9787541961632 +9787541961854 +9787541962226 +9787541962295 +9787541963650 +9787541966217 +9787541968433 +9787541969942 +9787541969997 +9787541973963 +9787541974304 +9787541974311 +9787541974502 +9787541976384 +9787541977848 +9787541978708 +9787541978746 +9787541979255 +9787541979347 +9787541980251 +9787541980275 +9787541980527 +9787541981180 +9787541982958 +9787541982965 +9787541983085 +9787541983719 +9787541983733 +9787541986826 +9787541988509 +9787541990106 +9787541990137 +9787541990359 +9787541991547 +9787541992742 +9787541993817 +9787541994098 +9787541994517 +9787541994562 +9787541995217 +9787541995729 +9787541996016 +9787541997969 +9787541998751 +9787542001313 +9787542002679 +9787542005281 +9787542006165 +9787542006455 +9787542008169 +9787542008374 +9787542009432 +9787542009678 +9787542010988 +9787542010995 +9787542011060 +9787542012203 +9787542012234 +9787542012272 +9787542013729 +9787542013743 +9787542015341 +9787542015983 +9787542016126 +9787542016195 +9787542017659 +9787542018090 +9787542018687 +9787542018823 +9787542020154 +9787542020444 +9787542020567 +9787542020628 +9787542021335 +9787542022790 +9787542023506 +9787542023520 +9787542024473 +9787542029126 +9787542039132 +9787542100306 +9787542100375 +9787542100870 +9787542100887 +9787542101198 +9787542101587 +9787542101730 +9787542102034 +9787542102478 +9787542103482 +9787542103970 +9787542104175 +9787542104229 +9787542104595 +9787542104816 +9787542104830 +9787542104847 +9787542105073 +9787542105172 +9787542105417 +9787542105806 +9787542105820 +9787542106278 +9787542106308 +9787542107251 +9787542107282 +9787542107800 +9787542107817 +9787542108456 +9787542108821 +9787542108920 +9787542110633 +9787542110985 +9787542111012 +9787542111272 +9787542111982 +9787542112057 +9787542112460 +9787542112484 +9787542113009 +9787542113641 +9787542113771 +9787542113924 +9787542114372 +9787542114433 +9787542114440 +9787542114723 +9787542114785 +9787542116277 +9787542117090 +9787542117472 +9787542118479 +9787542118776 +9787542118905 +9787542119063 +9787542119469 +9787542119544 +9787542119780 +9787542120335 +9787542120687 +9787542120700 +9787542122780 +9787542122865 +9787542123381 +9787542123572 +9787542123589 +9787542124371 +9787542125019 +9787542126313 +9787542126429 +9787542126511 +9787542128409 +9787542134738 +9787542156341 +9787542156594 +9787542157201 +9787542160003 +9787542160010 +9787542160096 +9787542161840 +9787542164544 +9787542165756 +9787542202376 +9787542202611 +9787542202758 +9787542203601 +9787542204349 +9787542204738 +9787542205018 +9787542205148 +9787542205261 +9787542206206 +9787542209283 +9787542210081 +9787542210098 +9787542210722 +9787542213037 +9787542216236 +9787542216281 +9787542219831 +9787542228376 +9787542228390 +9787542228468 +9787542228475 +9787542228482 +9787542228499 +9787542228567 +9787542232045 +9787542232397 +9787542232410 +9787542232540 +9787542232588 +9787542237989 +9787542238061 +9787542239310 +9787542241931 +9787542243126 +9787542243690 +9787542244208 +9787542244888 +9787542245021 +9787542246073 +9787542246226 +9787542246240 +9787542247223 +9787542247230 +9787542247865 +9787542248589 +9787542248596 +9787542248602 +9787542250803 +9787542251077 +9787542251831 +9787542254023 +9787542254450 +9787542254955 +9787542255075 +9787542255402 +9787542257017 +9787542258625 +9787542258632 +9787542261878 +9787542266279 +9787542267634 +9787542267641 +9787542267658 +9787542267665 +9787542267672 +9787542267696 +9787542267702 +9787542267719 +9787542268068 +9787542268846 +9787542272164 +9787542272720 +9787542273666 +9787542275004 +9787542276032 +9787542276063 +9787542276070 +9787542301635 +9787542303714 +9787542308498 +9787542309419 +9787542310194 +9787542310941 +9787542311443 +9787542315212 +9787542316905 +9787542316936 +9787542317025 +9787542324634 +9787542329554 +9787542334282 +9787542339034 +9787542339072 +9787542339096 +9787542342737 +9787542346667 +9787542347220 +9787542349439 +9787542350121 +9787542350138 +9787542350640 +9787542350909 +9787542351807 +9787542351814 +9787542353740 +9787542355393 +9787542356116 +9787542356529 +9787542357595 +9787542357601 +9787542358509 +9787542361899 +9787542400000 +9787542400116 +9787542400437 +9787542401007 +9787542401892 +9787542402929 +9787542403032 +9787542403537 +9787542405135 +9787542405739 +9787542405869 +9787542406446 +9787542409553 +9787542411259 +9787542411679 +9787542411693 +9787542411747 +9787542412843 +9787542414601 +9787542415189 +9787542416568 +9787542416575 +9787542417275 +9787542418173 +9787542419071 +9787542419699 +9787542419873 +9787542420497 +9787542421548 +9787542423313 +9787542425263 +9787542425812 +9787542427311 +9787542428271 +9787542428561 +9787542429230 +9787542429391 +9787542429407 +9787542429414 +9787542429742 +9787542430748 +9787542430755 +9787542430779 +9787542430786 +9787542432407 +9787542432421 +9787542502629 +9787542502636 +9787542502681 +9787542502896 +9787542503220 +9787542503268 +9787542503435 +9787542503442 +9787542504203 +9787542504326 +9787542504388 +9787542504395 +9787542504418 +9787542504746 +9787542504906 +9787542505064 +9787542505071 +9787542505477 +9787542505491 +9787542505675 +9787542505705 +9787542505880 +9787542506238 +9787542506832 +9787542506870 +9787542600172 +9787542600240 +9787542600257 +9787542600417 +9787542600431 +9787542600448 +9787542600455 +9787542600462 +9787542600479 +9787542600615 +9787542600783 +9787542600790 +9787542600806 +9787542600820 +9787542600905 +9787542600943 +9787542600998 +9787542601056 +9787542601209 +9787542601322 +9787542602060 +9787542602107 +9787542602244 +9787542602312 +9787542602510 +9787542603067 +9787542603135 +9787542603159 +9787542603272 +9787542603579 +9787542603661 +9787542604194 +9787542604255 +9787542604316 +9787542604415 +9787542604446 +9787542604453 +9787542604521 +9787542604552 +9787542604569 +9787542604637 +9787542604910 +9787542605009 +9787542605238 +9787542605252 +9787542605276 +9787542605412 +9787542605542 +9787542605566 +9787542605740 +9787542606068 +9787542606082 +9787542606099 +9787542606280 +9787542606310 +9787542606426 +9787542606549 +9787542606655 +9787542606914 +9787542606969 +9787542607362 +9787542607478 +9787542607485 +9787542607553 +9787542607614 +9787542607768 +9787542607997 +9787542608000 +9787542608109 +9787542608192 +9787542608277 +9787542608376 +9787542608512 +9787542608611 +9787542608666 +9787542608895 +9787542608987 +9787542609076 +9787542609120 +9787542609151 +9787542609281 +9787542609359 +9787542609403 +9787542609496 +9787542610270 +9787542610560 +9787542610607 +9787542610942 +9787542611024 +9787542611307 +9787542611420 +9787542611505 +9787542611727 +9787542612281 +9787542612311 +9787542612595 +9787542612663 +9787542612717 +9787542612755 +9787542612779 +9787542613233 +9787542613509 +9787542613837 +9787542613844 +9787542613974 +9787542614131 +9787542614209 +9787542614308 +9787542614704 +9787542614711 +9787542614995 +9787542616142 +9787542616203 +9787542616746 +9787542616838 +9787542617477 +9787542617729 +9787542618566 +9787542618856 +9787542618863 +9787542619167 +9787542619426 +9787542619600 +9787542620125 +9787542620224 +9787542621108 +9787542621290 +9787542621580 +9787542621627 +9787542622891 +9787542623133 +9787542623249 +9787542623270 +9787542624239 +9787542624260 +9787542624376 +9787542624598 +9787542624789 +9787542625113 +9787542625977 +9787542626240 +9787542626837 +9787542627261 +9787542627971 +9787542628435 +9787542631336 +9787542631459 +9787542634962 +9787542635198 +9787542635891 +9787542636249 +9787542636300 +9787542636454 +9787542636607 +9787542636836 +9787542637697 +9787542638618 +9787542638977 +9787542639356 +9787542641007 +9787542641052 +9787542642622 +9787542643223 +9787542643445 +9787542643476 +9787542644596 +9787542645456 +9787542649201 +9787542650092 +9787542650436 +9787542650863 +9787542650924 +9787542651044 +9787542651327 +9787542651907 +9787542651921 +9787542652683 +9787542653178 +9787542654618 +9787542656742 +9787542658661 +9787542660145 +9787542660695 +9787542661142 +9787542661982 +9787542662491 +9787542662804 +9787542663016 +9787542664617 +9787542665638 +9787542666017 +9787542666697 +9787542666956 +9787542667786 +9787542668707 +9787542669124 +9787542670373 +9787542670823 +9787542673916 +9787542674500 +9787542674746 +9787542675040 +9787542676870 +9787542677488 +9787542677884 +9787542677907 +9787542678195 +9787542679567 +9787542680327 +9787542680426 +9787542680846 +9787542680921 +9787542681195 +9787542681676 +9787542682048 +9787542682086 +9787542682154 +9787542682697 +9787542683007 +9787542683328 +9787542683342 +9787542683489 +9787542683694 +9787542683977 +9787542684066 +9787542684097 +9787542684288 +9787542684585 +9787542684752 +9787542684851 +9787542685025 +9787542685049 +9787542685124 +9787542685308 +9787542685315 +9787542685322 +9787542685476 +9787542685483 +9787542685544 +9787542685629 +9787542685704 +9787542685780 +9787542686138 +9787542686206 +9787542686213 +9787542686329 +9787542686404 +9787542686466 +9787542686824 +9787542687050 +9787542687111 +9787542687166 +9787542687388 +9787542687562 +9787542687579 +9787542687739 +9787542687883 +9787542687913 +9787542688187 +9787542688231 +9787542688330 +9787542688507 +9787542700551 +9787542700766 +9787542701268 +9787542701596 +9787542701640 +9787542701848 +9787542701923 +9787542701947 +9787542702043 +9787542702159 +9787542702234 +9787542702388 +9787542702975 +9787542703057 +9787542704986 +9787542705105 +9787542705730 +9787542705761 +9787542705853 +9787542706041 +9787542706478 +9787542707123 +9787542707161 +9787542707192 +9787542707246 +9787542707451 +9787542707611 +9787542708304 +9787542708434 +9787542708687 +9787542708731 +9787542708793 +9787542710000 +9787542710079 +9787542710246 +9787542710345 +9787542710796 +9787542710819 +9787542712455 +9787542713209 +9787542713223 +9787542713438 +9787542714275 +9787542715562 +9787542715807 +9787542715845 +9787542715890 +9787542716606 +9787542717917 +9787542720924 +9787542722614 +9787542722713 +9787542724236 +9787542724397 +9787542724427 +9787542724649 +9787542724755 +9787542725783 +9787542727763 +9787542730411 +9787542731128 +9787542733924 +9787542734327 +9787542734365 +9787542735966 +9787542737212 +9787542737359 +9787542740755 +9787542741943 +9787542742186 +9787542742193 +9787542742322 +9787542743640 +9787542744081 +9787542744562 +9787542744784 +9787542745804 +9787542746016 +9787542746757 +9787542747198 +9787542749246 +9787542749406 +9787542751096 +9787542752031 +9787542752291 +9787542752321 +9787542752338 +9787542752345 +9787542752352 +9787542752369 +9787542752390 +9787542752406 +9787542752420 +9787542752444 +9787542752468 +9787542752512 +9787542753021 +9787542753137 +9787542753380 +9787542753588 +9787542753748 +9787542755162 +9787542755391 +9787542756169 +9787542756398 +9787542756930 +9787542757425 +9787542757432 +9787542757449 +9787542757456 +9787542757517 +9787542757524 +9787542757531 +9787542757999 +9787542758675 +9787542758897 +9787542759030 +9787542759344 +9787542759368 +9787542759375 +9787542759429 +9787542759931 +9787542759948 +9787542760050 +9787542760074 +9787542760289 +9787542760302 +9787542760319 +9787542760869 +9787542760975 +9787542761873 +9787542761903 +9787542762870 +9787542763389 +9787542763709 +9787542764201 +9787542765451 +9787542765468 +9787542765505 +9787542765512 +9787542766250 +9787542767370 +9787542767738 +9787542768254 +9787542768278 +9787542769565 +9787542769695 +9787542769817 +9787542770851 +9787542770868 +9787542771230 +9787542771476 +9787542771612 +9787542771698 +9787542771735 +9787542771841 +9787542771889 +9787542772336 +9787542773111 +9787542773302 +9787542773869 +9787542774385 +9787542774545 +9787542775665 +9787542776037 +9787542776853 +9787542777300 +9787542778277 +9787542779465 +9787542779601 +9787542780270 +9787542780522 +9787542781086 +9787542784360 +9787542784766 +9787542787132 +9787542800206 +9787542800800 +9787542800862 +9787542801128 +9787542802064 +9787542802071 +9787542802088 +9787542803030 +9787542803245 +9787542803252 +9787542803573 +9787542803757 +9787542803863 +9787542803894 +9787542804433 +9787542805041 +9787542805171 +9787542805393 +9787542806215 +9787542806253 +9787542806260 +9787542806741 +9787542806949 +9787542807212 +9787542807229 +9787542807595 +9787542807632 +9787542808417 +9787542808448 +9787542808820 +9787542809056 +9787542809131 +9787542809391 +9787542809834 +9787542810625 +9787542810854 +9787542811110 +9787542811837 +9787542811844 +9787542813831 +9787542814135 +9787542814548 +9787542815781 +9787542816054 +9787542817327 +9787542817563 +9787542817976 +9787542818621 +9787542818799 +9787542818812 +9787542819208 +9787542819215 +9787542819758 +9787542822321 +9787542822512 +9787542823212 +9787542823328 +9787542823656 +9787542824554 +9787542825797 +9787542826534 +9787542827104 +9787542827364 +9787542828583 +9787542828590 +9787542828866 +9787542828910 +9787542829771 +9787542830166 +9787542830340 +9787542833044 +9787542833372 +9787542833464 +9787542833488 +9787542833501 +9787542833518 +9787542835277 +9787542839909 +9787542840233 +9787542840578 +9787542844019 +9787542846570 +9787542847744 +9787542849267 +9787542849953 +9787542855282 +9787542864451 +9787542865816 +9787542867827 +9787542867834 +9787542867841 +9787542867872 +9787542867889 +9787542872869 +9787542873255 +9787542873705 +9787542874115 +9787542874658 +9787542876997 +9787542877680 +9787542879646 +9787542879691 +9787542880017 +9787542882820 +9787542882844 +9787542882905 +9787542883278 +9787542883469 +9787542883483 +9787542900425 +9787542900449 +9787542900753 +9787542900784 +9787542903037 +9787542904102 +9787542904119 +9787542904362 +9787542905833 +9787542908544 +9787542910448 +9787542914361 +9787542915771 +9787542932426 +9787542933942 +9787542937261 +9787542937759 +9787542940513 +9787542951281 +9787542951304 +9787542956651 +9787542960351 +9787542961426 +9787542964151 +9787542964489 +9787542966209 +9787542967558 +9787542967565 +9787542967657 +9787542967855 +9787542968500 +9787542968531 +9787542969064 +9787542969101 +9787542969491 +9787542970152 +9787542971128 +9787542974327 +9787542974365 +9787542974471 +9787542975089 +9787542976154 +9787542976765 +9787542976918 +9787542976932 +9787542977182 +9787542977212 +9787542977649 +9787542977663 +9787542978547 +9787542978660 +9787542978684 +9787542978837 +9787543000377 +9787543000827 +9787543001718 +9787543002067 +9787543002289 +9787543002876 +9787543003347 +9787543003705 +9787543003712 +9787543003958 +9787543003965 +9787543004061 +9787543004320 +9787543004573 +9787543004757 +9787543006119 +9787543006416 +9787543006706 +9787543006973 +9787543008205 +9787543008427 +9787543008878 +9787543009660 +9787543010499 +9787543011168 +9787543012318 +9787543012608 +9787543012622 +9787543012912 +9787543012929 +9787543013001 +9787543013605 +9787543013698 +9787543013919 +9787543014077 +9787543014442 +9787543014510 +9787543014978 +9787543015203 +9787543015425 +9787543015548 +9787543015807 +9787543016606 +9787543016682 +9787543016897 +9787543017177 +9787543017498 +9787543018020 +9787543018396 +9787543019133 +9787543019676 +9787543019898 +9787543020597 +9787543020702 +9787543021570 +9787543022140 +9787543022478 +9787543023543 +9787543023666 +9787543023710 +9787543023772 +9787543024212 +9787543024229 +9787543025851 +9787543026469 +9787543028555 +9787543030220 +9787543031432 +9787543031678 +9787543031838 +9787543032026 +9787543032033 +9787543032675 +9787543032910 +9787543033337 +9787543034495 +9787543034532 +9787543034730 +9787543035591 +9787543036406 +9787543036895 +9787543036994 +9787543037403 +9787543037731 +9787543037861 +9787543038059 +9787543038356 +9787543038721 +9787543038783 +9787543039957 +9787543039964 +9787543040656 +9787543041097 +9787543042483 +9787543042735 +9787543044562 +9787543044814 +9787543045484 +9787543045576 +9787543046832 +9787543046948 +9787543048959 +9787543049321 +9787543049581 +9787543049833 +9787543050907 +9787543052086 +9787543052604 +9787543052765 +9787543052994 +9787543053441 +9787543056251 +9787543056756 +9787543057333 +9787543062863 +9787543063181 +9787543064669 +9787543065567 +9787543065581 +9787543065758 +9787543066748 +9787543066915 +9787543067189 +9787543069770 +9787543071698 +9787543074118 +9787543074705 +9787543079038 +9787543085282 +9787543087712 +9787543088092 +9787543088979 +9787543090101 +9787543090118 +9787543090125 +9787543090378 +9787543090569 +9787543092464 +9787543093737 +9787543094147 +9787543094406 +9787543095557 +9787543095687 +9787543095700 +9787543095717 +9787543095724 +9787543096417 +9787543096844 +9787543096998 +9787543097698 +9787543099890 +9787543100237 +9787543100282 +9787543100763 +9787543100961 +9787543101074 +9787543101203 +9787543101500 +9787543101623 +9787543101869 +9787543101937 +9787543102156 +9787543102583 +9787543200005 +9787543200012 +9787543200036 +9787543200050 +9787543200067 +9787543200074 +9787543200081 +9787543200142 +9787543200159 +9787543200272 +9787543200289 +9787543200517 +9787543200524 +9787543200548 +9787543200579 +9787543200722 +9787543200807 +9787543201088 +9787543201484 +9787543201767 +9787543201835 +9787543201880 +9787543201958 +9787543201989 +9787543202016 +9787543202054 +9787543202108 +9787543202153 +9787543202238 +9787543202368 +9787543202603 +9787543202764 +9787543202856 +9787543202894 +9787543203006 +9787543203013 +9787543203044 +9787543203174 +9787543203464 +9787543203488 +9787543203686 +9787543203716 +9787543203877 +9787543203990 +9787543204010 +9787543204102 +9787543204645 +9787543204720 +9787543205192 +9787543205512 +9787543205826 +9787543206168 +9787543206212 +9787543206366 +9787543206748 +9787543207073 +9787543207097 +9787543207356 +9787543208179 +9787543208407 +9787543208773 +9787543209336 +9787543209770 +9787543210295 +9787543210653 +9787543211018 +9787543211216 +9787543212084 +9787543212169 +9787543212787 +9787543218017 +9787543218468 +9787543220591 +9787543220737 +9787543221611 +9787543222694 +9787543223417 +9787543228658 +9787543235410 +9787543235670 +9787543235939 +9787543235946 +9787543236066 +9787543236073 +9787543236417 +9787543237049 +9787543300309 +9787543300644 +9787543301146 +9787543301184 +9787543301221 +9787543301238 +9787543301658 +9787543302525 +9787543302594 +9787543302655 +9787543303140 +9787543303171 +9787543303379 +9787543303867 +9787543304208 +9787543305083 +9787543305311 +9787543305427 +9787543306288 +9787543306400 +9787543306486 +9787543306578 +9787543306820 +9787543307339 +9787543307346 +9787543307728 +9787543307841 +9787543307889 +9787543308015 +9787543309265 +9787543311206 +9787543311398 +9787543312333 +9787543312418 +9787543312623 +9787543313019 +9787543313668 +9787543313972 +9787543314221 +9787543315020 +9787543318939 +9787543319448 +9787543320024 +9787543320864 +9787543320949 +9787543321380 +9787543322363 +9787543323063 +9787543323254 +9787543323360 +9787543324824 +9787543327115 +9787543331044 +9787543336773 +9787543340251 +9787543340596 +9787543340800 +9787543340916 +9787543340985 +9787543341166 +9787543342712 +9787543344365 +9787543344464 +9787543344969 +9787543345690 +9787543346154 +9787543400016 +9787543400788 +9787543400863 +9787543400894 +9787543402171 +9787543402881 +9787543402935 +9787543402942 +9787543402959 +9787543402980 +9787543403161 +9787543403628 +9787543403987 +9787543405417 +9787543405516 +9787543405738 +9787543405783 +9787543405790 +9787543405806 +9787543406193 +9787543406360 +9787543406513 +9787543407503 +9787543407602 +9787543408609 +9787543408814 +9787543408906 +9787543409675 +9787543411883 +9787543415379 +9787543416208 +9787543416277 +9787543416758 +9787543417106 +9787543417861 +9787543418073 +9787543418554 +9787543421219 +9787543421288 +9787543421462 +9787543421622 +9787543422049 +9787543422315 +9787543423091 +9787543423268 +9787543423374 +9787543423398 +9787543423442 +9787543423459 +9787543423497 +9787543424128 +9787543424142 +9787543424166 +9787543424227 +9787543424678 +9787543425019 +9787543425347 +9787543425484 +9787543425521 +9787543425538 +9787543425613 +9787543425705 +9787543425873 +9787543427112 +9787543427167 +9787543427198 +9787543427228 +9787543427440 +9787543427549 +9787543427693 +9787543427716 +9787543427730 +9787543428393 +9787543428430 +9787543428447 +9787543428768 +9787543429048 +9787543429093 +9787543429123 +9787543429765 +9787543429796 +9787543430105 +9787543430792 +9787543430914 +9787543430921 +9787543431348 +9787543431768 +9787543432000 +9787543432239 +9787543432543 +9787543432604 +9787543433076 +9787543433663 +9787543434479 +9787543435124 +9787543435551 +9787543435711 +9787543435735 +9787543435742 +9787543435780 +9787543435834 +9787543435841 +9787543436022 +9787543436244 +9787543436268 +9787543436664 +9787543436770 +9787543437456 +9787543437470 +9787543437548 +9787543437746 +9787543438392 +9787543438477 +9787543438545 +9787543438651 +9787543438668 +9787543438729 +9787543438910 +9787543439252 +9787543439542 +9787543439603 +9787543439696 +9787543440067 +9787543440432 +9787543440463 +9787543440579 +9787543441378 +9787543441408 +9787543441552 +9787543441903 +9787543442030 +9787543442368 +9787543442634 +9787543442931 +9787543443426 +9787543443488 +9787543443587 +9787543443884 +9787543443914 +9787543444478 +9787543445031 +9787543445895 +9787543445925 +9787543445949 +9787543445994 +9787543446090 +9787543446120 +9787543446144 +9787543446212 +9787543446267 +9787543446489 +9787543446496 +9787543448001 +9787543448025 +9787543448179 +9787543448711 +9787543448742 +9787543448810 +9787543448841 +9787543449169 +9787543449695 +9787543449732 +9787543449770 +9787543450424 +9787543450431 +9787543450523 +9787543450530 +9787543450615 +9787543451261 +9787543451308 +9787543451643 +9787543452725 +9787543453081 +9787543453111 +9787543453784 +9787543453791 +9787543453845 +9787543453883 +9787543454224 +9787543454262 +9787543456310 +9787543458949 +9787543459014 +9787543459793 +9787543463134 +9787543466678 +9787543466715 +9787543466722 +9787543466821 +9787543466845 +9787543466852 +9787543467828 +9787543467897 +9787543468818 +9787543471238 +9787543471245 +9787543472235 +9787543472792 +9787543473195 +9787543474345 +9787543474383 +9787543474406 +9787543474918 +9787543475007 +9787543475304 +9787543475311 +9787543475762 +9787543475779 +9787543475786 +9787543475861 +9787543476929 +9787543477582 +9787543478923 +9787543479067 +9787543479517 +9787543480124 +9787543480131 +9787543484061 +9787543485488 +9787543485563 +9787543486669 +9787543489905 +9787543495388 +9787543495449 +9787543495463 +9787543495524 +9787543496996 +9787543498075 +9787543498167 +9787543498396 +9787543498853 +9787543499133 +9787543500228 +9787543500433 +9787543500808 +9787543501171 +9787543502420 +9787543502437 +9787543505957 +9787543507654 +9787543507692 +9787543507708 +9787543508187 +9787543511927 +9787543513532 +9787543515048 +9787543515574 +9787543517301 +9787543517547 +9787543518810 +9787543520011 +9787543520028 +9787543520349 +9787543520608 +9787543520806 +9787543520813 +9787543522107 +9787543522114 +9787543522183 +9787543522251 +9787543522275 +9787543522336 +9787543522350 +9787543522398 +9787543523111 +9787543523999 +9787543524019 +9787543524064 +9787543524095 +9787543524132 +9787543524323 +9787543524422 +9787543524439 +9787543525153 +9787543525290 +9787543525375 +9787543525511 +9787543525559 +9787543525573 +9787543527010 +9787543527232 +9787543527249 +9787543527256 +9787543527263 +9787543527300 +9787543527317 +9787543527867 +9787543527904 +9787543528185 +9787543528406 +9787543528437 +9787543528901 +9787543528949 +9787543528956 +9787543528963 +9787543528970 +9787543528987 +9787543529052 +9787543529809 +9787543530737 +9787543531338 +9787543531574 +9787543531918 +9787543534070 +9787543534117 +9787543539792 +9787543546394 +9787543547070 +9787543547537 +9787543548077 +9787543566446 +9787543572393 +9787543577978 +9787543578005 +9787543578029 +9787543578050 +9787543578067 +9787543578098 +9787543578289 +9787543578500 +9787543578791 +9787543582545 +9787543583177 +9787543583443 +9787543585010 +9787543589070 +9787543589797 +9787543590175 +9787543591127 +9787543594753 +9787543601000 +9787543601048 +9787543601543 +9787543602106 +9787543602137 +9787543602229 +9787543602236 +9787543602243 +9787543602809 +9787543603172 +9787543603264 +9787543605060 +9787543605169 +9787543605367 +9787543605381 +9787543605398 +9787543605985 +9787543606531 +9787543607415 +9787543607422 +9787543607484 +9787543608009 +9787543608498 +9787543608634 +9787543608795 +9787543608818 +9787543608825 +9787543609129 +9787543609570 +9787543609723 +9787543611764 +9787543611986 +9787543612198 +9787543612228 +9787543612310 +9787543612334 +9787543612501 +9787543613416 +9787543613522 +9787543613669 +9787543613881 +9787543614505 +9787543614598 +9787543614642 +9787543614758 +9787543615571 +9787543615779 +9787543615847 +9787543615915 +9787543616417 +9787543616707 +9787543616776 +9787543616806 +9787543616929 +9787543617155 +9787543617308 +9787543617377 +9787543617681 +9787543617834 +9787543617872 +9787543618633 +9787543619289 +9787543619531 +9787543620582 +9787543620834 +9787543621220 +9787543621640 +9787543621725 +9787543621770 +9787543622043 +9787543622050 +9787543622067 +9787543622142 +9787543623002 +9787543623279 +9787543623378 +9787543624108 +9787543624955 +9787543625396 +9787543626447 +9787543626478 +9787543627697 +9787543627758 +9787543630086 +9787543630321 +9787543631069 +9787543631922 +9787543633117 +9787543633230 +9787543633360 +9787543633711 +9787543634077 +9787543636750 +9787543636781 +9787543636972 +9787543637658 +9787543640962 +9787543641471 +9787543641891 +9787543642959 +9787543643154 +9787543644885 +9787543645448 +9787543645455 +9787543645608 +9787543645752 +9787543645943 +9787543646919 +9787543647787 +9787543648326 +9787543649118 +9787543649644 +9787543650701 +9787543652286 +9787543653276 +9787543654341 +9787543656475 +9787543657618 +9787543658103 +9787543659179 +9787543659704 +9787543662926 +9787543663190 +9787543663848 +9787543664005 +9787543664302 +9787543664784 +9787543666771 +9787543667242 +9787543667549 +9787543668782 +9787543669772 +9787543670167 +9787543670853 +9787543671898 +9787543672697 +9787543674479 +9787543675360 +9787543675766 +9787543676138 +9787543676244 +9787543676497 +9787543678323 +9787543678606 +9787543678910 +9787543681842 +9787543682016 +9787543683617 +9787543684850 +9787543684942 +9787543685314 +9787543686212 +9787543686229 +9787543686243 +9787543686410 +9787543686427 +9787543686441 +9787543689008 +9787543691704 +9787543691735 +9787543691742 +9787543691902 +9787543692008 +9787543692619 +9787543693036 +9787543695450 +9787543695900 +9787543695931 +9787543696815 +9787543697607 +9787543698017 +9787543698116 +9787543698598 +9787543699144 +9787543699847 +9787543710634 +9787543711617 +9787543714380 +9787543725607 +9787543727175 +9787543729612 +9787543729926 +9787543731639 +9787543732803 +9787543741201 +9787543741782 +9787543741812 +9787543744196 +9787543744493 +9787543747050 +9787543747296 +9787543747715 +9787543759107 +9787543765832 +9787543777217 +9787543777866 +9787543787704 +9787543798793 +9787543798984 +9787543800052 +9787543800267 +9787543800335 +9787543800595 +9787543800632 +9787543800854 +9787543801271 +9787543801516 +9787543801622 +9787543801745 +9787543802087 +9787543802353 +9787543802919 +9787543802964 +9787543803046 +9787543803091 +9787543803541 +9787543803930 +9787543804111 +9787543804135 +9787543804357 +9787543805033 +9787543805347 +9787543805651 +9787543806009 +9787543806221 +9787543806290 +9787543806344 +9787543806580 +9787543806641 +9787543806658 +9787543806870 +9787543806894 +9787543807228 +9787543807624 +9787543807839 +9787543808546 +9787543809222 +9787543809352 +9787543809802 +9787543809857 +9787543809871 +9787543809888 +9787543809895 +9787543809901 +9787543809925 +9787543809956 +9787543810174 +9787543810785 +9787543811553 +9787543811751 +9787543812000 +9787543812246 +9787543812277 +9787543812475 +9787543812673 +9787543812970 +9787543813113 +9787543813137 +9787543813168 +9787543813250 +9787543813588 +9787543813779 +9787543813939 +9787543814196 +9787543814844 +9787543815698 +9787543815735 +9787543815780 +9787543815872 +9787543816015 +9787543816237 +9787543816244 +9787543816275 +9787543816282 +9787543816398 +9787543816411 +9787543816473 +9787543816497 +9787543816619 +9787543816954 +9787543816985 +9787543817005 +9787543817012 +9787543817654 +9787543818118 +9787543818187 +9787543818385 +9787543818682 +9787543818750 +9787543819023 +9787543819320 +9787543819412 +9787543819498 +9787543819986 +9787543820029 +9787543820098 +9787543820623 +9787543820883 +9787543821262 +9787543821279 +9787543821354 +9787543821439 +9787543821446 +9787543821477 +9787543821514 +9787543821521 +9787543821606 +9787543821651 +9787543822092 +9787543822290 +9787543823020 +9787543823181 +9787543823488 +9787543823754 +9787543824065 +9787543824256 +9787543824324 +9787543824607 +9787543824638 +9787543825635 +9787543825826 +9787543825833 +9787543825871 +9787543826830 +9787543827233 +9787543827516 +9787543827707 +9787543827738 +9787543828049 +9787543828513 +9787543828834 +9787543828971 +9787543829961 +9787543830509 +9787543831049 +9787543831261 +9787543831919 +9787543832060 +9787543832688 +9787543834637 +9787543835184 +9787543835207 +9787543835375 +9787543836976 +9787543837072 +9787543837089 +9787543838024 +9787543838291 +9787543839274 +9787543839526 +9787543840119 +9787543840454 +9787543840737 +9787543840881 +9787543842199 +9787543842519 +9787543842649 +9787543843349 +9787543843677 +9787543843776 +9787543843882 +9787543844063 +9787543844698 +9787543844780 +9787543844933 +9787543845435 +9787543845442 +9787543847941 +9787543848207 +9787543848320 +9787543849259 +9787543849686 +9787543852624 +9787543852648 +9787543853386 +9787543853980 +9787543854581 +9787543855762 +9787543857865 +9787543857889 +9787543859869 +9787543862340 +9787543862463 +9787543863125 +9787543865334 +9787543865402 +9787543865679 +9787543866201 +9787543866546 +9787543867109 +9787543868830 +9787543870444 +9787543870918 +9787543871571 +9787543871762 +9787543871946 +9787543872066 +9787543872752 +9787543872905 +9787543873360 +9787543873421 +9787543873650 +9787543875166 +9787543875272 +9787543875685 +9787543875838 +9787543875852 +9787543875869 +9787543875876 +9787543875951 +9787543875968 +9787543876019 +9787543876101 +9787543876118 +9787543876156 +9787543876873 +9787543877429 +9787543878105 +9787543879003 +9787543880580 +9787543881051 +9787543881549 +9787543882294 +9787543884014 +9787543885479 +9787543887633 +9787543887800 +9787543888395 +9787543888418 +9787543888494 +9787543889538 +9787543890831 +9787543891074 +9787543891111 +9787543891258 +9787543891265 +9787543891289 +9787543891401 +9787543891708 +9787543892064 +9787543892323 +9787543893528 +9787543893726 +9787543893887 +9787543894082 +9787543894358 +9787543894532 +9787543896109 +9787543896178 +9787543896635 +9787543896925 +9787543897007 +9787543897137 +9787543897441 +9787543897526 +9787543897687 +9787543898073 +9787543898110 +9787543898431 +9787543899094 +9787543899568 +9787543899582 +9787543899636 +9787543899643 +9787543899711 +9787543899902 +9787543900684 +9787543901452 +9787543901476 +9787543902190 +9787543902497 +9787543904811 +9787543905146 +9787543905726 +9787543906792 +9787543908901 +9787543909601 +9787543909786 +9787543909977 +9787543909984 +9787543910003 +9787543910348 +9787543910720 +9787543911567 +9787543911598 +9787543911789 +9787543911888 +9787543912014 +9787543912069 +9787543912113 +9787543912168 +9787543912205 +9787543912311 +9787543912380 +9787543912687 +9787543912915 +9787543913684 +9787543913837 +9787543914537 +9787543915411 +9787543915886 +9787543916173 +9787543916586 +9787543916982 +9787543918016 +9787543918030 +9787543918801 +9787543919143 +9787543919679 +9787543919921 +9787543920422 +9787543921016 +9787543924840 +9787543926554 +9787543926677 +9787543926837 +9787543927469 +9787543927513 +9787543927896 +9787543928961 +9787543929258 +9787543931770 +9787543931893 +9787543932432 +9787543932456 +9787543934252 +9787543937383 +9787543940208 +9787543940246 +9787543941496 +9787543943063 +9787543943414 +9787543952010 +9787543952690 +9787543953130 +9787543955660 +9787543958173 +9787543958579 +9787543959170 +9787543959248 +9787543959293 +9787543959927 +9787543960442 +9787543961388 +9787543963177 +9787543963603 +9787543964891 +9787543964921 +9787543965126 +9787543965461 +9787543967878 +9787543969346 +9787543969360 +9787543969810 +9787543970182 +9787543971677 +9787543971929 +9787543977464 +9787543981003 +9787543981768 +9787543982215 +9787543982444 +9787543983540 +9787543988026 +9787543988521 +9787543989344 +9787543990029 +9787543990036 +9787543990135 +9787543990166 +9787543991040 +9787543991286 +9787543991750 +9787543993266 +9787544000246 +9787544001182 +9787544001212 +9787544001908 +9787544002530 +9787544004718 +9787544005197 +9787544005517 +9787544005814 +9787544007498 +9787544007580 +9787544007702 +9787544007719 +9787544007764 +9787544007993 +9787544008082 +9787544008099 +9787544008105 +9787544009041 +9787544009317 +9787544009645 +9787544009652 +9787544009997 +9787544010481 +9787544010856 +9787544010948 +9787544011013 +9787544011228 +9787544011648 +9787544011662 +9787544011792 +9787544011907 +9787544012171 +9787544012508 +9787544012539 +9787544012966 +9787544014205 +9787544014250 +9787544014342 +9787544015592 +9787544017220 +9787544017336 +9787544017619 +9787544018005 +9787544018425 +9787544018470 +9787544018548 +9787544018661 +9787544020220 +9787544020398 +9787544020473 +9787544020930 +9787544021814 +9787544021869 +9787544022705 +9787544022903 +9787544024303 +9787544024686 +9787544025904 +9787544027946 +9787544028738 +9787544029148 +9787544030342 +9787544033077 +9787544033923 +9787544034111 +9787544034449 +9787544043687 +9787544045155 +9787544048170 +9787544051460 +9787544055901 +9787544058933 +9787544059275 +9787544059404 +9787544063180 +9787544064507 +9787544074896 +9787544094047 +9787544100847 +9787544101837 +9787544102018 +9787544102049 +9787544102087 +9787544102100 +9787544102278 +9787544102353 +9787544102605 +9787544102766 +9787544102841 +9787544102896 +9787544103046 +9787544103138 +9787544103152 +9787544103190 +9787544103237 +9787544103244 +9787544103343 +9787544103411 +9787544103688 +9787544103794 +9787544103855 +9787544103862 +9787544104036 +9787544104111 +9787544104166 +9787544104203 +9787544104340 +9787544104357 +9787544104401 +9787544104586 +9787544104852 +9787544104869 +9787544104876 +9787544104944 +9787544105453 +9787544105477 +9787544105521 +9787544106214 +9787544106450 +9787544106757 +9787544106764 +9787544106801 +9787544106818 +9787544106900 +9787544106955 +9787544106962 +9787544107075 +9787544107143 +9787544107372 +9787544107433 +9787544107822 +9787544107976 +9787544109109 +9787544109116 +9787544109604 +9787544109710 +9787544110990 +9787544111133 +9787544111287 +9787544111423 +9787544111874 +9787544112147 +9787544113984 +9787544114448 +9787544114936 +9787544116053 +9787544117388 +9787544117623 +9787544119696 +9787544119702 +9787544120074 +9787544120562 +9787544121415 +9787544125949 +9787544126014 +9787544126359 +9787544127370 +9787544127691 +9787544128124 +9787544130677 +9787544132091 +9787544133746 +9787544137775 +9787544142892 +9787544143158 +9787544143233 +9787544144537 +9787544147071 +9787544148108 +9787544149877 +9787544150330 +9787544152280 +9787544152396 +9787544152464 +9787544153980 +9787544156066 +9787544157742 +9787544158169 +9787544158565 +9787544159661 +9787544160391 +9787544160759 +9787544160797 +9787544162180 +9787544162685 +9787544163194 +9787544164535 +9787544169691 +9787544174268 +9787544174275 +9787544185387 +9787544186025 +9787544188630 +9787544188722 +9787544190039 +9787544190046 +9787544190084 +9787544190282 +9787544190374 +9787544190398 +9787544191487 +9787544196710 +9787544196840 +9787544200189 +9787544200318 +9787544200622 +9787544201322 +9787544202657 +9787544202992 +9787544203289 +9787544203296 +9787544204255 +9787544204521 +9787544204828 +9787544205863 +9787544206341 +9787544206358 +9787544206389 +9787544207683 +9787544208291 +9787544208444 +9787544208451 +9787544208468 +9787544208642 +9787544209076 +9787544209083 +9787544209434 +9787544209601 +9787544210720 +9787544210775 +9787544210850 +9787544211017 +9787544211116 +9787544211253 +9787544212113 +9787544212120 +9787544212397 +9787544212991 +9787544213066 +9787544213103 +9787544213110 +9787544213233 +9787544214469 +9787544214568 +9787544215039 +9787544215459 +9787544215893 +9787544215930 +9787544216449 +9787544216500 +9787544216647 +9787544216678 +9787544217057 +9787544217101 +9787544217323 +9787544217491 +9787544217569 +9787544217590 +9787544217606 +9787544218184 +9787544218580 +9787544219433 +9787544220156 +9787544220378 +9787544220583 +9787544221016 +9787544221115 +9787544221399 +9787544221450 +9787544221467 +9787544221580 +9787544221771 +9787544222402 +9787544222532 +9787544223058 +9787544223171 +9787544223607 +9787544223836 +9787544223935 +9787544223980 +9787544224000 +9787544225304 +9787544226127 +9787544226332 +9787544226554 +9787544226851 +9787544226998 +9787544227391 +9787544227438 +9787544227452 +9787544227780 +9787544228343 +9787544228497 +9787544229531 +9787544230155 +9787544230193 +9787544230865 +9787544231794 +9787544232678 +9787544233026 +9787544234177 +9787544234306 +9787544235198 +9787544235624 +9787544235884 +9787544236119 +9787544236232 +9787544236416 +9787544236430 +9787544237048 +9787544237055 +9787544237062 +9787544238786 +9787544239295 +9787544239318 +9787544239349 +9787544240079 +9787544240239 +9787544240659 +9787544240949 +9787544240963 +9787544241243 +9787544241281 +9787544242035 +9787544242356 +9787544243957 +9787544244008 +9787544244787 +9787544245098 +9787544245166 +9787544245364 +9787544245432 +9787544245449 +9787544245531 +9787544245784 +9787544245838 +9787544246996 +9787544247221 +9787544248877 +9787544249348 +9787544249713 +9787544249874 +9787544249966 +9787544250122 +9787544250481 +9787544250542 +9787544250702 +9787544251105 +9787544251174 +9787544251181 +9787544255165 +9787544256049 +9787544256292 +9787544257428 +9787544257763 +9787544257855 +9787544257961 +9787544258302 +9787544258548 +9787544258715 +9787544258753 +9787544258784 +9787544258814 +9787544259293 +9787544259354 +9787544259637 +9787544261593 +9787544261623 +9787544263511 +9787544267021 +9787544267465 +9787544267649 +9787544268110 +9787544268400 +9787544268592 +9787544268905 +9787544269711 +9787544270007 +9787544272308 +9787544272322 +9787544272544 +9787544272919 +9787544272926 +9787544273060 +9787544275200 +9787544275507 +9787544275958 +9787544277266 +9787544279826 +9787544279833 +9787544279901 +9787544280341 +9787544280938 +9787544281287 +9787544281294 +9787544281874 +9787544283007 +9787544287869 +9787544288118 +9787544288620 +9787544288798 +9787544289061 +9787544289214 +9787544289733 +9787544289818 +9787544290500 +9787544290838 +9787544290951 +9787544292795 +9787544295215 +9787544297059 +9787544297097 +9787544297813 +9787544299589 +9787544300148 +9787544300209 +9787544300261 +9787544300285 +9787544300452 +9787544300889 +9787544301428 +9787544301442 +9787544301466 +9787544301732 +9787544301954 +9787544302128 +9787544302135 +9787544302166 +9787544302371 +9787544302470 +9787544302906 +9787544303514 +9787544303613 +9787544303927 +9787544304054 +9787544304122 +9787544304245 +9787544304771 +9787544304795 +9787544304825 +9787544304863 +9787544304917 +9787544305631 +9787544305846 +9787544305969 +9787544306416 +9787544306485 +9787544307109 +9787544309417 +9787544309479 +9787544309516 +9787544309967 +9787544310239 +9787544310291 +9787544310819 +9787544312479 +9787544312578 +9787544313100 +9787544313513 +9787544313698 +9787544313865 +9787544314701 +9787544315920 +9787544316613 +9787544316842 +9787544318198 +9787544318310 +9787544318549 +9787544319478 +9787544319997 +9787544323468 +9787544324755 +9787544325516 +9787544326292 +9787544329071 +9787544331524 +9787544331661 +9787544331708 +9787544332071 +9787544332217 +9787544332231 +9787544333405 +9787544333580 +9787544333863 +9787544334525 +9787544335317 +9787544335355 +9787544337397 +9787544337403 +9787544338011 +9787544341165 +9787544341325 +9787544341592 +9787544342025 +9787544342995 +9787544344562 +9787544347327 +9787544347853 +9787544348621 +9787544349246 +9787544350587 +9787544351997 +9787544352123 +9787544352338 +9787544355407 +9787544355766 +9787544355827 +9787544358415 +9787544360111 +9787544368049 +9787544372336 +9787544372381 +9787544372466 +9787544372497 +9787544372602 +9787544372657 +9787544372732 +9787544372800 +9787544372947 +9787544373746 +9787544373760 +9787544374088 +9787544383394 +9787544385558 +9787544388863 +9787544391443 +9787544401890 +9787544403467 +9787544406352 +9787544407571 +9787544407694 +9787544409865 +9787544412186 +9787544412728 +9787544412780 +9787544412797 +9787544413015 +9787544413640 +9787544413664 +9787544414173 +9787544414401 +9787544416320 +9787544416535 +9787544418539 +9787544420402 +9787544420785 +9787544421829 +9787544422062 +9787544422697 +9787544422772 +9787544424424 +9787544424578 +9787544425889 +9787544427326 +9787544427432 +9787544427456 +9787544427531 +9787544427586 +9787544428095 +9787544428101 +9787544428408 +9787544428545 +9787544429047 +9787544429269 +9787544430647 +9787544431385 +9787544432238 +9787544433457 +9787544433518 +9787544436601 +9787544436731 +9787544436861 +9787544437387 +9787544440790 +9787544441711 +9787544441759 +9787544444828 +9787544444941 +9787544445474 +9787544445672 +9787544447201 +9787544447768 +9787544449465 +9787544450348 +9787544453363 +9787544453370 +9787544453387 +9787544455930 +9787544455978 +9787544455985 +9787544461856 +9787544461894 +9787544462792 +9787544463379 +9787544467902 +9787544468817 +9787544468824 +9787544469142 +9787544469159 +9787544470667 +9787544473583 +9787544474702 +9787544475464 +9787544476423 +9787544476515 +9787544476867 +9787544477451 +9787544477512 +9787544481786 +9787544482721 +9787544483759 +9787544483766 +9787544485401 +9787544486323 +9787544486347 +9787544486859 +9787544487818 +9787544488228 +9787544488235 +9787544488242 +9787544488259 +9787544488273 +9787544490412 +9787544491341 +9787544491358 +9787544491365 +9787544491372 +9787544491389 +9787544491402 +9787544491419 +9787544491860 +9787544492140 +9787544492829 +9787544493093 +9787544493277 +9787544493482 +9787544493536 +9787544494403 +9787544494410 +9787544494427 +9787544494441 +9787544494472 +9787544494502 +9787544495875 +9787544495936 +9787544496056 +9787544496407 +9787544496438 +9787544496537 +9787544496773 +9787544496780 +9787544497541 +9787544498449 +9787544498609 +9787544498630 +9787544498807 +9787544498814 +9787544499095 +9787544499200 +9787544500081 +9787544500333 +9787544502252 +9787544502528 +9787544502535 +9787544504171 +9787544505659 +9787544506076 +9787544506274 +9787544506311 +9787544507103 +9787544509190 +9787544509206 +9787544509213 +9787544509299 +9787544509329 +9787544509428 +9787544509473 +9787544511490 +9787544512497 +9787544512657 +9787544514736 +9787544514910 +9787544514927 +9787544514965 +9787544514996 +9787544515771 +9787544515870 +9787544517768 +9787544517973 +9787544520195 +9787544521338 +9787544524179 +9787544524889 +9787544526005 +9787544526593 +9787544529181 +9787544530170 +9787544530194 +9787544530613 +9787544531184 +9787544532815 +9787544532976 +9787544533966 +9787544534284 +9787544537919 +9787544537940 +9787544541244 +9787544541640 +9787544541664 +9787544542388 +9787544543477 +9787544548502 +9787544548649 +9787544553575 +9787544555203 +9787544555531 +9787544555555 +9787544555586 +9787544555609 +9787544555616 +9787544556248 +9787544556422 +9787544557818 +9787544559454 +9787544559478 +9787544559485 +9787544559515 +9787544559782 +9787544560351 +9787544563512 +9787544563529 +9787544563536 +9787544563925 +9787544563970 +9787544565608 +9787544567275 +9787544569699 +9787544570619 +9787544571104 +9787544571241 +9787544571272 +9787544575171 +9787544575416 +9787544575775 +9787544575782 +9787544576307 +9787544578707 +9787544601641 +9787544603485 +9787544605243 +9787544606646 +9787544606790 +9787544608220 +9787544608633 +9787544609975 +9787544610360 +9787544610780 +9787544611725 +9787544612784 +9787544614153 +9787544618281 +9787544618298 +9787544620505 +9787544620901 +9787544621533 +9787544625159 +9787544625982 +9787544626040 +9787544627108 +9787544631969 +9787544642675 +9787544643351 +9787544644402 +9787544646239 +9787544646673 +9787544649346 +9787544650359 +9787544652858 +9787544658331 +9787544659055 +9787544659420 +9787544660341 +9787544660365 +9787544661812 +9787544661836 +9787544662314 +9787544662321 +9787544663625 +9787544666091 +9787544668200 +9787544670340 +9787544670371 +9787544670531 +9787544671453 +9787544671460 +9787544671613 +9787544671880 +9787544671903 +9787544671958 +9787544671989 +9787544671996 +9787544672979 +9787544674881 +9787544674904 +9787544675093 +9787544675123 +9787544675949 +9787544676151 +9787544676281 +9787544676618 +9787544676656 +9787544676670 +9787544677240 +9787544677271 +9787544677301 +9787544677318 +9787544677349 +9787544678926 +9787544678971 +9787544679008 +9787544680240 +9787544680271 +9787544680288 +9787544680462 +9787544680622 +9787544681339 +9787544681346 +9787544681438 +9787544681636 +9787544682046 +9787544682107 +9787544682114 +9787544682190 +9787544684460 +9787544700122 +9787544700566 +9787544705233 +9787544706292 +9787544707091 +9787544709125 +9787544712941 +9787544717014 +9787544724210 +9787544724449 +9787544724838 +9787544726399 +9787544727259 +9787544727624 +9787544728072 +9787544729482 +9787544730228 +9787544730563 +9787544730754 +9787544732000 +9787544733403 +9787544733991 +9787544734066 +9787544736053 +9787544738828 +9787544740388 +9787544740562 +9787544740845 +9787544741163 +9787544742405 +9787544744836 +9787544745499 +9787544747271 +9787544748827 +9787544756655 +9787544762601 +9787544764162 +9787544765916 +9787544767736 +9787544769730 +9787544770897 +9787544771948 +9787544773638 +9787544774994 +9787544776929 +9787544779029 +9787544780032 +9787544780766 +9787544781237 +9787544781312 +9787544781329 +9787544781695 +9787544782074 +9787544782982 +9787544783484 +9787544783828 +9787544784290 +9787544785334 +9787544785365 +9787544786737 +9787544787284 +9787544787291 +9787544788489 +9787544790949 +9787544792097 +9787544792462 +9787544792523 +9787544792578 +9787544792936 +9787544793834 +9787544794305 +9787544795678 +9787544795814 +9787544795913 +9787544796989 +9787544797351 +9787544797801 +9787544797849 +9787544798570 +9787544798754 +9787544798815 +9787544798822 +9787544798914 +9787544798938 +9787544798976 +9787544799157 +9787544799171 +9787544799287 +9787544799645 +9787544799713 +9787544801379 +9787544801478 +9787544803076 +9787544805391 +9787544805643 +9787544806190 +9787544807265 +9787544808132 +9787544808378 +9787544809023 +9787544810845 +9787544811125 +9787544811255 +9787544813242 +9787544813655 +9787544813822 +9787544814782 +9787544814799 +9787544814805 +9787544814812 +9787544814829 +9787544815642 +9787544816069 +9787544817097 +9787544817523 +9787544817981 +9787544818841 +9787544818872 +9787544819077 +9787544819459 +9787544820370 +9787544820530 +9787544821629 +9787544821643 +9787544823258 +9787544823272 +9787544823302 +9787544823319 +9787544824781 +9787544825115 +9787544825122 +9787544825153 +9787544826211 +9787544826228 +9787544826242 +9787544829076 +9787544829175 +9787544829212 +9787544829236 +9787544831116 +9787544831697 +9787544832274 +9787544832403 +9787544833790 +9787544834957 +9787544835220 +9787544836906 +9787544837675 +9787544837682 +9787544838016 +9787544838412 +9787544838429 +9787544839075 +9787544840019 +9787544840842 +9787544841443 +9787544841474 +9787544841504 +9787544841566 +9787544841757 +9787544841900 +9787544842235 +9787544842457 +9787544842488 +9787544843034 +9787544846691 +9787544847025 +9787544848718 +9787544851312 +9787544851336 +9787544853194 +9787544853248 +9787544855211 +9787544857475 +9787544857529 +9787544860970 +9787544863674 +9787544865920 +9787544866132 +9787544866149 +9787544866170 +9787544867818 +9787544870276 +9787544871211 +9787544874953 +9787544874991 +9787544876070 +9787544876087 +9787544877244 +9787544878234 +9787544878241 +9787544878531 +9787544878777 +9787544878876 +9787544878883 +9787544879583 +9787544880879 +9787544881135 +9787544881494 +9787544882279 +9787544883023 +9787544883412 +9787544884068 +9787544884105 +9787544884457 +9787544884730 +9787544884754 +9787544884976 +9787544885256 +9787544886598 +9787544886857 +9787544886864 +9787544887403 +9787544887410 +9787544887427 +9787544888103 +9787544888387 +9787544888455 +9787544889377 +9787544889872 +9787544890649 +9787544890977 +9787544900584 +9787544901246 +9787544901253 +9787544901260 +9787544902793 +9787544903912 +9787544905312 +9787544906012 +9787544906029 +9787544909518 +9787544910590 +9787544911108 +9787544912907 +9787544916318 +9787544916332 +9787544917537 +9787544920285 +9787544924245 +9787544935920 +9787544973250 +9787544999038 +9787545005684 +9787545007497 +9787545008289 +9787545009309 +9787545009484 +9787545010329 +9787545010459 +9787545011777 +9787545011791 +9787545013337 +9787545015553 +9787545015584 +9787545015898 +9787545015904 +9787545015911 +9787545017038 +9787545017212 +9787545017496 +9787545017922 +9787545026474 +9787545028720 +9787545028874 +9787545028980 +9787545032611 +9787545034486 +9787545035049 +9787545035230 +9787545035322 +9787545035520 +9787545035773 +9787545035780 +9787545036374 +9787545037029 +9787545037081 +9787545038002 +9787545038286 +9787545038422 +9787545040487 +9787545041057 +9787545044362 +9787545044423 +9787545044447 +9787545044461 +9787545044478 +9787545044553 +9787545044669 +9787545046786 +9787545053715 +9787545054101 +9787545054279 +9787545055122 +9787545055375 +9787545058932 +9787545058994 +9787545060560 +9787545061369 +9787545061864 +9787545062311 +9787545062885 +9787545062908 +9787545062922 +9787545064728 +9787545064742 +9787545065688 +9787545065718 +9787545066326 +9787545068160 +9787545068535 +9787545068597 +9787545069457 +9787545069556 +9787545069570 +9787545070057 +9787545070064 +9787545071795 +9787545072853 +9787545072860 +9787545073317 +9787545073836 +9787545074949 +9787545074956 +9787545075380 +9787545075618 +9787545076578 +9787545076622 +9787545077544 +9787545077575 +9787545078435 +9787545079081 +9787545079753 +9787545080384 +9787545080391 +9787545085631 +9787545099881 +9787545100624 +9787545101874 +9787545102239 +9787545102413 +9787545102758 +9787545103243 +9787545103250 +9787545103267 +9787545103342 +9787545106138 +9787545107869 +9787545108446 +9787545109108 +9787545109115 +9787545109276 +9787545109412 +9787545110203 +9787545110234 +9787545110715 +9787545110739 +9787545110777 +9787545110906 +9787545110937 +9787545111446 +9787545112092 +9787545112696 +9787545113563 +9787545113693 +9787545114508 +9787545114539 +9787545115673 +9787545115710 +9787545115789 +9787545117363 +9787545118629 +9787545123074 +9787545128031 +9787545130270 +9787545130508 +9787545131185 +9787545131253 +9787545132304 +9787545133110 +9787545133653 +9787545133684 +9787545134902 +9787545135237 +9787545136869 +9787545137446 +9787545137842 +9787545138597 +9787545138603 +9787545141771 +9787545142655 +9787545147421 +9787545149296 +9787545150810 +9787545153149 +9787545153187 +9787545155822 +9787545158571 +9787545158687 +9787545161403 +9787545168778 +9787545169430 +9787545171938 +9787545172225 +9787545200959 +9787545202205 +9787545203875 +9787545204148 +9787545204551 +9787545204865 +9787545204971 +9787545204988 +9787545205107 +9787545205336 +9787545205435 +9787545205596 +9787545205688 +9787545205718 +9787545205770 +9787545205985 +9787545206326 +9787545207033 +9787545207699 +9787545208368 +9787545208542 +9787545209013 +9787545209433 +9787545210620 +9787545210880 +9787545210910 +9787545211757 +9787545212273 +9787545212723 +9787545212990 +9787545213003 +9787545213812 +9787545214215 +9787545214222 +9787545214802 +9787545214918 +9787545215274 +9787545215328 +9787545215465 +9787545215489 +9787545215823 +9787545215885 +9787545216004 +9787545216301 +9787545217056 +9787545218152 +9787545219364 +9787545219487 +9787545219548 +9787545219654 +9787545219678 +9787545220049 +9787545220056 +9787545220087 +9787545220100 +9787545220117 +9787545220193 +9787545220216 +9787545220261 +9787545220353 +9787545300383 +9787545300796 +9787545300963 +9787545300987 +9787545301090 +9787545301106 +9787545301533 +9787545302479 +9787545302547 +9787545302837 +9787545303698 +9787545303827 +9787545303896 +9787545303902 +9787545304343 +9787545304565 +9787545305975 +9787545305999 +9787545306002 +9787545400441 +9787545401981 +9787545405750 +9787545406221 +9787545408096 +9787545409543 +9787545409598 +9787545409604 +9787545411133 +9787545411263 +9787545415384 +9787545415957 +9787545415988 +9787545416251 +9787545416268 +9787545416275 +9787545416282 +9787545416299 +9787545416305 +9787545418026 +9787545418804 +9787545418958 +9787545420371 +9787545423556 +9787545426908 +9787545429275 +9787545432343 +9787545433166 +9787545433371 +9787545434187 +9787545434873 +9787545435771 +9787545436471 +9787545445404 +9787545449402 +9787545452815 +9787545454215 +9787545454239 +9787545461107 +9787545462180 +9787545462944 +9787545463439 +9787545464993 +9787545465433 +9787545465440 +9787545467253 +9787545467710 +9787545472486 +9787545473209 +9787545473568 +9787545473704 +9787545474220 +9787545475296 +9787545477023 +9787545477887 +9787545478297 +9787545478549 +9787545478587 +9787545478600 +9787545479287 +9787545479300 +9787545479430 +9787545481679 +9787545481686 +9787545482904 +9787545483437 +9787545483635 +9787545483925 +9787545483987 +9787545485004 +9787545485707 +9787545486131 +9787545489538 +9787545489798 +9787545490473 +9787545490534 +9787545490848 +9787545490947 +9787545491678 +9787545492125 +9787545492170 +9787545492538 +9787545492736 +9787545493139 +9787545494136 +9787545494143 +9787545494433 +9787545494440 +9787545494570 +9787545495287 +9787545496222 +9787545496246 +9787545496734 +9787545496826 +9787545501636 +9787545501674 +9787545502657 +9787545504569 +9787545504774 +9787545508239 +9787545508338 +9787545508383 +9787545511680 +9787545511918 +9787545511932 +9787545512137 +9787545512182 +9787545512687 +9787545512748 +9787545513097 +9787545513301 +9787545513349 +9787545513370 +9787545513394 +9787545515138 +9787545515244 +9787545517385 +9787545517798 +9787545517866 +9787545517880 +9787545517897 +9787545518221 +9787545518252 +9787545518283 +9787545518528 +9787545518801 +9787545518825 +9787545518832 +9787545518887 +9787545518917 +9787545521313 +9787545521894 +9787545521900 +9787545521924 +9787545523911 +9787545524949 +9787545525830 +9787545525878 +9787545525922 +9787545525977 +9787545526127 +9787545528015 +9787545528244 +9787545528299 +9787545528473 +9787545528497 +9787545528602 +9787545528619 +9787545528725 +9787545528916 +9787545529494 +9787545529999 +9787545530292 +9787545530582 +9787545530704 +9787545530742 +9787545531039 +9787545531268 +9787545532012 +9787545532456 +9787545533132 +9787545534153 +9787545534177 +9787545534214 +9787545534221 +9787545534337 +9787545534344 +9787545534368 +9787545534405 +9787545534412 +9787545535716 +9787545535723 +9787545536690 +9787545536874 +9787545536881 +9787545536904 +9787545537154 +9787545537185 +9787545537253 +9787545537925 +9787545538403 +9787545538496 +9787545538663 +9787545539431 +9787545539455 +9787545539912 +9787545540499 +9787545540925 +9787545541205 +9787545541342 +9787545541380 +9787545541403 +9787545541892 +9787545541922 +9787545542486 +9787545542547 +9787545542615 +9787545542660 +9787545542684 +9787545542738 +9787545543599 +9787545543612 +9787545544497 +9787545544831 +9787545545654 +9787545545685 +9787545545791 +9787545546262 +9787545546415 +9787545546767 +9787545547405 +9787545547740 +9787545548013 +9787545548020 +9787545548372 +9787545549195 +9787545550450 +9787545550467 +9787545550474 +9787545550481 +9787545551396 +9787545551501 +9787545551754 +9787545551952 +9787545551976 +9787545552034 +9787545552331 +9787545552560 +9787545553475 +9787545553482 +9787545553512 +9787545553536 +9787545553567 +9787545553628 +9787545554618 +9787545554731 +9787545554854 +9787545554977 +9787545555011 +9787545555196 +9787545555516 +9787545555660 +9787545555776 +9787545556032 +9787545556124 +9787545556384 +9787545557183 +9787545557787 +9787545557794 +9787545557800 +9787545557831 +9787545557848 +9787545557862 +9787545558036 +9787545558333 +9787545558470 +9787545558487 +9787545558500 +9787545559149 +9787545559699 +9787545559897 +9787545560022 +9787545560046 +9787545561449 +9787545561661 +9787545561685 +9787545561821 +9787545562118 +9787545562217 +9787545562255 +9787545562552 +9787545562569 +9787545562910 +9787545562927 +9787545562958 +9787545562972 +9787545563009 +9787545563450 +9787545563528 +9787545563559 +9787545563993 +9787545564723 +9787545565010 +9787545565027 +9787545566659 +9787545567359 +9787545568486 +9787545569063 +9787545569391 +9787545569414 +9787545569988 +9787545570144 +9787545570311 +9787545571271 +9787545571394 +9787545571479 +9787545572001 +9787545572643 +9787545573435 +9787545574326 +9787545574876 +9787545575026 +9787545575316 +9787545575637 +9787545575675 +9787545576092 +9787545576191 +9787545576238 +9787545576665 +9787545576788 +9787545576924 +9787545576948 +9787545576955 +9787545576962 +9787545576979 +9787545576993 +9787545577006 +9787545577013 +9787545577020 +9787545577037 +9787545577372 +9787545577662 +9787545577716 +9787545577853 +9787545577877 +9787545577891 +9787545577907 +9787545578010 +9787545578065 +9787545578072 +9787545578942 +9787545578966 +9787545578973 +9787545578980 +9787545578997 +9787545579017 +9787545579024 +9787545579130 +9787545580150 +9787545580228 +9787545580297 +9787545580396 +9787545580907 +9787545581300 +9787545582024 +9787545582178 +9787545582604 +9787545582741 +9787545582772 +9787545582963 +9787545583021 +9787545583137 +9787545583175 +9787545583212 +9787545583502 +9787545583540 +9787545583854 +9787545583861 +9787545583878 +9787545584240 +9787545584370 +9787545584639 +9787545584653 +9787545584691 +9787545584820 +9787545585063 +9787545585070 +9787545585131 +9787545585278 +9787545585308 +9787545585438 +9787545585513 +9787545585629 +9787545585780 +9787545585797 +9787545585926 +9787545585933 +9787545585964 +9787545586046 +9787545586077 +9787545586329 +9787545588644 +9787545589474 +9787545600292 +9787545600827 +9787545601152 +9787545601190 +9787545601213 +9787545601343 +9787545601367 +9787545601466 +9787545602173 +9787545602906 +9787545602937 +9787545604511 +9787545604566 +9787545604573 +9787545605105 +9787545605372 +9787545605389 +9787545605396 +9787545605402 +9787545606249 +9787545607079 +9787545607116 +9787545607260 +9787545607307 +9787545607994 +9787545608014 +9787545608038 +9787545608045 +9787545608144 +9787545608175 +9787545608618 +9787545608649 +9787545608687 +9787545608762 +9787545608786 +9787545608946 +9787545608991 +9787545609011 +9787545609295 +9787545609301 +9787545611120 +9787545611717 +9787545611748 +9787545611762 +9787545612349 +9787545612509 +9787545613001 +9787545613070 +9787545613247 +9787545614435 +9787545614459 +9787545614909 +9787545615678 +9787545618846 +9787545700060 +9787545700381 +9787545700510 +9787545700664 +9787545701258 +9787545701319 +9787545701876 +9787545702217 +9787545702569 +9787545703061 +9787545703115 +9787545703443 +9787545704396 +9787545704525 +9787545704587 +9787545704914 +9787545704952 +9787545705881 +9787545706000 +9787545706345 +9787545706628 +9787545706758 +9787545707427 +9787545707618 +9787545707663 +9787545707694 +9787545707755 +9787545708608 +9787545708806 +9787545708899 +9787545709018 +9787545709193 +9787545709230 +9787545709940 +9787545710489 +9787545710588 +9787545711035 +9787545711059 +9787545711127 +9787545712025 +9787545712032 +9787545712049 +9787545712674 +9787545713817 +9787545715170 +9787545715552 +9787545715583 +9787545715927 +9787545716139 +9787545716542 +9787545719444 +9787545719659 +9787545720686 +9787545722727 +9787545722796 +9787545724134 +9787545724332 +9787545725513 +9787545725988 +9787545727234 +9787545727494 +9787545727555 +9787545727616 +9787545727746 +9787545728538 +9787545728811 +9787545728859 +9787545729542 +9787545729573 +9787545729665 +9787545730708 +9787545732221 +9787545800111 +9787545800234 +9787545801118 +9787545801583 +9787545803228 +9787545803433 +9787545804195 +9787545804256 +9787545805086 +9787545805840 +9787545805888 +9787545806502 +9787545806700 +9787545807172 +9787545807905 +9787545809480 +9787545809657 +9787545809954 +9787545813302 +9787545813982 +9787545814149 +9787545814453 +9787545814903 +9787545815313 +9787545815641 +9787545816273 +9787545816501 +9787545817119 +9787545817348 +9787545817850 +9787545818000 +9787545818154 +9787545818413 +9787545819007 +9787545819267 +9787545819656 +9787545820041 +9787545821086 +9787545822656 +9787545822809 +9787545822885 +9787545823141 +9787545823387 +9787545823653 +9787545823660 +9787545823677 +9787545823707 +9787545823868 +9787545823899 +9787545824087 +9787545824094 +9787545824117 +9787545824148 +9787545824155 +9787545824254 +9787545824339 +9787545824353 +9787545824537 +9787545824797 +9787545900286 +9787545900873 +9787545901504 +9787545901672 +9787545901689 +9787545903386 +9787545904093 +9787545904185 +9787545905298 +9787545905519 +9787545906301 +9787545907957 +9787545908527 +9787545909005 +9787545909012 +9787545909029 +9787545909036 +9787545909074 +9787545909104 +9787545912128 +9787545912609 +9787545914146 +9787545915129 +9787545916027 +9787545918861 +9787545919950 +9787545920192 +9787545922899 +9787545922905 +9787545923643 +9787546000558 +9787546000633 +9787546001203 +9787546001401 +9787546002200 +9787546002354 +9787546003917 +9787546004204 +9787546004433 +9787546004594 +9787546006451 +9787546007229 +9787546007731 +9787546100005 +9787546101231 +9787546101514 +9787546101521 +9787546102597 +9787546102962 +9787546103426 +9787546103440 +9787546105253 +9787546106892 +9787546109145 +9787546110691 +9787546111247 +9787546112183 +9787546112558 +9787546112749 +9787546114996 +9787546115009 +9787546116280 +9787546116754 +9787546117058 +9787546117089 +9787546117508 +9787546117935 +9787546118529 +9787546118567 +9787546119298 +9787546119489 +9787546120003 +9787546121444 +9787546122007 +9787546123097 +9787546123646 +9787546123684 +9787546124933 +9787546125916 +9787546126210 +9787546126319 +9787546126418 +9787546127484 +9787546127514 +9787546127538 +9787546128139 +9787546128610 +9787546130774 +9787546131467 +9787546132037 +9787546132075 +9787546133577 +9787546133904 +9787546134260 +9787546134345 +9787546135670 +9787546136233 +9787546137117 +9787546138763 +9787546139197 +9787546139531 +9787546139593 +9787546140377 +9787546143347 +9787546143422 +9787546143491 +9787546143576 +9787546144351 +9787546144894 +9787546146300 +9787546146355 +9787546146850 +9787546147413 +9787546147437 +9787546148069 +9787546148137 +9787546148144 +9787546148571 +9787546149066 +9787546150017 +9787546151816 +9787546152202 +9787546152684 +9787546153438 +9787546153636 +9787546158792 +9787546160573 +9787546165424 +9787546165431 +9787546166896 +9787546173009 +9787546173016 +9787546174181 +9787546181608 +9787546182865 +9787546193083 +9787546193830 +9787546194707 +9787546195247 +9787546196664 +9787546200224 +9787546200231 +9787546200309 +9787546201122 +9787546201696 +9787546201795 +9787546202273 +9787546202648 +9787546203379 +9787546203645 +9787546203720 +9787546203782 +9787546203997 +9787546204482 +9787546206110 +9787546208640 +9787546208671 +9787546208961 +9787546209135 +9787546209142 +9787546209159 +9787546209258 +9787546209500 +9787546212500 +9787546212616 +9787546212623 +9787546212654 +9787546213651 +9787546213972 +9787546214412 +9787546214566 +9787546214573 +9787546214597 +9787546214696 +9787546214757 +9787546214771 +9787546214801 +9787546215341 +9787546215785 +9787546216157 +9787546216232 +9787546217079 +9787546217284 +9787546217574 +9787546218342 +9787546218786 +9787546220147 +9787546220192 +9787546220291 +9787546220338 +9787546220390 +9787546220413 +9787546220451 +9787546220475 +9787546220529 +9787546220635 +9787546220642 +9787546220673 +9787546220680 +9787546220710 +9787546220727 +9787546220734 +9787546220765 +9787546220857 +9787546221007 +9787546221038 +9787546222578 +9787546222998 +9787546223001 +9787546225562 +9787546228921 +9787546230160 +9787546230214 +9787546231242 +9787546233628 +9787546235165 +9787546237718 +9787546237725 +9787546238067 +9787546238265 +9787546300733 +9787546301877 +9787546301945 +9787546302034 +9787546302041 +9787546302096 +9787546302102 +9787546302157 +9787546302355 +9787546302386 +9787546303307 +9787546303314 +9787546303611 +9787546304281 +9787546306902 +9787546307534 +9787546307589 +9787546309019 +9787546309484 +9787546311111 +9787546311203 +9787546311210 +9787546312781 +9787546313825 +9787546314679 +9787546315621 +9787546316864 +9787546316994 +9787546317205 +9787546317380 +9787546317410 +9787546317472 +9787546317878 +9787546318509 +9787546318592 +9787546318820 +9787546318950 +9787546319490 +9787546319919 +9787546323152 +9787546323275 +9787546323282 +9787546323527 +9787546323589 +9787546323718 +9787546323824 +9787546323947 +9787546324340 +9787546324449 +9787546325873 +9787546326146 +9787546326580 +9787546326610 +9787546326627 +9787546326634 +9787546326788 +9787546326801 +9787546326993 +9787546328089 +9787546328355 +9787546328607 +9787546328645 +9787546329178 +9787546329307 +9787546330211 +9787546331126 +9787546331690 +9787546333892 +9787546334547 +9787546335148 +9787546335346 +9787546336114 +9787546336213 +9787546339535 +9787546340319 +9787546340920 +9787546340937 +9787546341002 +9787546341163 +9787546341590 +9787546344478 +9787546344492 +9787546345901 +9787546345970 +9787546346960 +9787546347530 +9787546347653 +9787546348780 +9787546348896 +9787546349572 +9787546349756 +9787546350080 +9787546350158 +9787546350455 +9787546351421 +9787546351476 +9787546354507 +9787546355719 +9787546356990 +9787546358741 +9787546359847 +9787546367668 +9787546367682 +9787546367705 +9787546367729 +9787546367828 +9787546368429 +9787546368498 +9787546368771 +9787546369129 +9787546369174 +9787546369228 +9787546369662 +9787546370194 +9787546370675 +9787546370750 +9787546370774 +9787546371306 +9787546373713 +9787546374260 +9787546374277 +9787546374413 +9787546374796 +9787546374802 +9787546378640 +9787546378855 +9787546379456 +9787546379616 +9787546379883 +9787546379890 +9787546379975 +9787546380001 +9787546380025 +9787546381251 +9787546381916 +9787546381930 +9787546385365 +9787546385471 +9787546385662 +9787546386065 +9787546386119 +9787546388090 +9787546388502 +9787546388670 +9787546390161 +9787546390291 +9787546390758 +9787546392608 +9787546393810 +9787546394008 +9787546394039 +9787546394473 +9787546396699 +9787546396736 +9787546399904 +9787546399911 +9787546403830 +9787546409191 +9787546410357 +9787546410388 +9787546410944 +9787546413853 +9787546417318 +9787546417325 +9787546418018 +9787546422107 +9787546422343 +9787546424156 +9787546426389 +9787546426549 +9787546428307 +9787546429762 +9787546431758 +9787546432960 +9787546434100 +9787546434322 +9787546434407 +9787546434421 +9787546435312 +9787546435480 +9787546435510 +9787546435602 +9787546435954 +9787546436050 +9787546502359 +9787546502908 +9787546505152 +9787546513188 +9787546521244 +9787546603643 +9787546621111 +9787546621135 +9787546621425 +9787546626147 +9787546626697 +9787546628134 +9787546647722 +9787546647807 +9787546701080 +9787546701356 +9787546702667 +9787546703190 +9787546703244 +9787546800141 +9787546800783 +9787546801148 +9787546801254 +9787546801452 +9787546801841 +9787546802671 +9787546802749 +9787546802909 +9787546803067 +9787546804101 +9787546804408 +9787546806013 +9787546806099 +9787546806242 +9787546807560 +9787546809458 +9787546809540 +9787546812014 +9787546812298 +9787546812342 +9787546812618 +9787546817941 +9787546818351 +9787546822921 +9787546823539 +9787546823584 +9787546824819 +9787546826219 +9787546901473 +9787546901756 +9787546902654 +9787546903002 +9787546903187 +9787546903231 +9787546903347 +9787546903378 +9787546903408 +9787546903538 +9787546903620 +9787546907499 +9787546908663 +9787546914077 +9787546915357 +9787546915562 +9787546917665 +9787546919652 +9787546923444 +9787546931449 +9787546939353 +9787546942940 +9787546959214 +9787546959245 +9787546959252 +9787546959290 +9787546959306 +9787546962931 +9787546962955 +9787546969923 +9787546969930 +9787546969985 +9787546983653 +9787546986531 +9787546986555 +9787546987392 +9787546988474 +9787546989907 +9787546989914 +9787546994659 +9787547001820 +9787547002018 +9787547002254 +9787547002377 +9787547002384 +9787547002438 +9787547002445 +9787547002452 +9787547002612 +9787547002728 +9787547002810 +9787547003190 +9787547003206 +9787547004654 +9787547005262 +9787547005385 +9787547005781 +9787547006238 +9787547006368 +9787547006672 +9787547008249 +9787547008331 +9787547008638 +9787547009147 +9787547009536 +9787547010839 +9787547013908 +9787547015025 +9787547015032 +9787547015131 +9787547015209 +9787547015384 +9787547015766 +9787547015834 +9787547016022 +9787547016183 +9787547016459 +9787547016589 +9787547018347 +9787547019788 +9787547019825 +9787547020166 +9787547020173 +9787547020388 +9787547020395 +9787547020401 +9787547020487 +9787547020524 +9787547020593 +9787547020609 +9787547020685 +9787547020791 +9787547021088 +9787547021279 +9787547022115 +9787547022375 +9787547023778 +9787547023822 +9787547026670 +9787547027554 +9787547028025 +9787547028810 +9787547029510 +9787547031551 +9787547032046 +9787547032329 +9787547032732 +9787547033432 +9787547035603 +9787547036082 +9787547037270 +9787547037294 +9787547037546 +9787547037676 +9787547039625 +9787547039649 +9787547042724 +9787547042748 +9787547044230 +9787547044841 +9787547046654 +9787547051351 +9787547051566 +9787547051689 +9787547052396 +9787547052426 +9787547052532 +9787547053324 +9787547055199 +9787547057681 +9787547061701 +9787547062630 +9787547063255 +9787547063460 +9787547063507 +9787547063514 +9787547064184 +9787547064252 +9787547064481 +9787547065310 +9787547065952 +9787547065983 +9787547066331 +9787547066454 +9787547066492 +9787547066584 +9787547067314 +9787547067635 +9787547067987 +9787547102084 +9787547102091 +9787547108567 +9787547108895 +9787547109038 +9787547112342 +9787547117521 +9787547117675 +9787547119839 +9787547120842 +9787547121191 +9787547121627 +9787547122679 +9787547122686 +9787547122693 +9787547122730 +9787547122754 +9787547122761 +9787547122815 +9787547122839 +9787547122846 +9787547122853 +9787547122860 +9787547122877 +9787547122884 +9787547122891 +9787547122914 +9787547122952 +9787547122969 +9787547122976 +9787547123010 +9787547123027 +9787547123041 +9787547123362 +9787547124987 +9787547125441 +9787547126134 +9787547126226 +9787547126233 +9787547126400 +9787547126417 +9787547126479 +9787547126677 +9787547126745 +9787547126929 +9787547128602 +9787547128763 +9787547129982 +9787547130049 +9787547201398 +9787547201855 +9787547201916 +9787547203590 +9787547204870 +9787547205327 +9787547208212 +9787547208403 +9787547209806 +9787547210093 +9787547212707 +9787547214626 +9787547214671 +9787547215968 +9787547216033 +9787547217030 +9787547218457 +9787547218525 +9787547218662 +9787547218693 +9787547219867 +9787547221105 +9787547222386 +9787547222409 +9787547223543 +9787547225059 +9787547227718 +9787547228449 +9787547229224 +9787547232163 +9787547232200 +9787547237915 +9787547238196 +9787547244784 +9787547247587 +9787547255940 +9787547257395 +9787547257951 +9787547260142 +9787547262191 +9787547262405 +9787547264980 +9787547265604 +9787547267080 +9787547267233 +9787547269206 +9787547269831 +9787547270172 +9787547270332 +9787547272435 +9787547273524 +9787547277386 +9787547277393 +9787547277409 +9787547277423 +9787547277430 +9787547279700 +9787547280744 +9787547281987 +9787547285220 +9787547290361 +9787547290378 +9787547290873 +9787547292549 +9787547292594 +9787547292648 +9787547293805 +9787547295106 +9787547301234 +9787547301265 +9787547301494 +9787547301678 +9787547301890 +9787547302705 +9787547303955 +9787547304242 +9787547304563 +9787547305713 +9787547306970 +9787547309117 +9787547309438 +9787547310076 +9787547310403 +9787547311523 +9787547312179 +9787547312209 +9787547312223 +9787547312384 +9787547312476 +9787547312940 +9787547313213 +9787547314005 +9787547315835 +9787547318461 +9787547319147 +9787547319192 +9787547321393 +9787547321706 +9787547322253 +9787547322321 +9787547322451 +9787547322468 +9787547322536 +9787547322826 +9787547322970 +9787547323052 +9787547323243 +9787547323304 +9787547323618 +9787547323670 +9787547323786 +9787547323809 +9787547323960 +9787547324042 +9787547324158 +9787547324219 +9787547324226 +9787547324257 +9787547324264 +9787547324417 +9787547324462 +9787547324721 +9787547324783 +9787547324820 +9787547324837 +9787547324868 +9787547324912 +9787547324943 +9787547324950 +9787547325001 +9787547325063 +9787547325070 +9787547325117 +9787547325209 +9787547325223 +9787547325230 +9787547325254 +9787547325377 +9787547325421 +9787547325490 +9787547325537 +9787547325551 +9787547325568 +9787547325582 +9787547325643 +9787547325681 +9787547325940 +9787547325995 +9787547326015 +9787547326084 +9787547326527 +9787547327074 +9787547327104 +9787547327326 +9787547327456 +9787547400135 +9787547400593 +9787547401187 +9787547401231 +9787547402269 +9787547402658 +9787547403242 +9787547403419 +9787547403488 +9787547403631 +9787547403860 +9787547404195 +9787547404775 +9787547405062 +9787547405086 +9787547405369 +9787547410172 +9787547410530 +9787547410554 +9787547411421 +9787547411506 +9787547414927 +9787547418741 +9787547420539 +9787547420942 +9787547421741 +9787547424469 +9787547424544 +9787547425985 +9787547426173 +9787547427354 +9787547429297 +9787547429426 +9787547430767 +9787547430781 +9787547431672 +9787547432198 +9787547432921 +9787547432969 +9787547433072 +9787547433942 +9787547434383 +9787547435113 +9787547435137 +9787547435335 +9787547435724 +9787547435748 +9787547436363 +9787547436585 +9787547436929 +9787547438466 +9787547438480 +9787547439029 +9787547439593 +9787547440193 +9787547440520 +9787547440827 +9787547441091 +9787547444733 +9787547444962 +9787547446249 +9787547446331 +9787547446775 +9787547447963 +9787547448175 +9787547448793 +9787547449127 +9787547449134 +9787547449370 +9787547449387 +9787547449400 +9787547449417 +9787547449424 +9787547450277 +9787547450963 +9787547452936 +9787547500118 +9787547500668 +9787547501566 +9787547501771 +9787547502327 +9787547502709 +9787547503096 +9787547503539 +9787547503775 +9787547504864 +9787547505151 +9787547507575 +9787547508664 +9787547508756 +9787547511077 +9787547512852 +9787547513668 +9787547513859 +9787547515662 +9787547516744 +9787547517017 +9787547517277 +9787547517512 +9787547517901 +9787547518298 +9787547518441 +9787547518601 +9787547518670 +9787547519752 +9787547519929 +9787547520239 +9787547521281 +9787547521342 +9787547521700 +9787547521755 +9787547521861 +9787547522158 +9787547522172 +9787547522394 +9787547522820 +9787547522875 +9787547523001 +9787547523063 +9787547523414 +9787547523636 +9787547601532 +9787547603475 +9787547604236 +9787547605196 +9787547606667 +9787547608579 +9787547609538 +9787547611135 +9787547611364 +9787547612408 +9787547616048 +9787547617045 +9787547619162 +9787547619261 +9787547619513 +9787547619612 +9787547619971 +9787547620083 +9787547620304 +9787547620366 +9787547620472 +9787547620595 +9787547620649 +9787547620670 +9787547621257 +9787547700136 +9787547700143 +9787547700693 +9787547700839 +9787547700853 +9787547701010 +9787547702642 +9787547702901 +9787547703489 +9787547703823 +9787547704011 +9787547704967 +9787547705308 +9787547705339 +9787547705346 +9787547705919 +9787547706077 +9787547706541 +9787547706602 +9787547706619 +9787547706749 +9787547707111 +9787547707173 +9787547707203 +9787547707326 +9787547707388 +9787547707401 +9787547707838 +9787547709085 +9787547710869 +9787547710876 +9787547710883 +9787547710890 +9787547711095 +9787547712146 +9787547712504 +9787547712627 +9787547712757 +9787547713600 +9787547715963 +9787547716083 +9787547716359 +9787547716502 +9787547716700 +9787547717332 +9787547717684 +9787547717691 +9787547717707 +9787547717714 +9787547717752 +9787547717790 +9787547717806 +9787547717820 +9787547717844 +9787547717851 +9787547718360 +9787547718735 +9787547718759 +9787547718797 +9787547720226 +9787547720585 +9787547721254 +9787547721469 +9787547721636 +9787547721681 +9787547722008 +9787547723654 +9787547724491 +9787547726174 +9787547726501 +9787547726518 +9787547726525 +9787547726754 +9787547727171 +9787547727447 +9787547728574 +9787547729823 +9787547729830 +9787547730379 +9787547731901 +9787547732137 +9787547732397 +9787547732687 +9787547733257 +9787547733400 +9787547734117 +9787547734186 +9787547734674 +9787547734971 +9787547735152 +9787547735367 +9787547735657 +9787547736067 +9787547736203 +9787547736401 +9787547737422 +9787547737972 +9787547738252 +9787547738894 +9787547740453 +9787547740705 +9787547740712 +9787547742495 +9787547742518 +9787547742556 +9787547742808 +9787547742877 +9787547743287 +9787547744109 +9787547744178 +9787547744536 +9787547745199 +9787547745212 +9787547745748 +9787547745830 +9787547746912 +9787547747148 +9787547747155 +9787547747186 +9787547747261 +9787547747384 +9787547747674 +9787547747728 +9787547747803 +9787547747834 +9787547747841 +9787547747872 +9787547748091 +9787547748107 +9787547748527 +9787547748732 +9787547748800 +9787547749593 +9787547749739 +9787547749852 +9787547749876 +9787547749920 +9787547750025 +9787547750117 +9787547750278 +9787547750407 +9787547750469 +9787547750483 +9787547750520 +9787547750612 +9787547750629 +9787547750735 +9787547750827 +9787547751039 +9787547751152 +9787547751459 +9787547751619 +9787547751695 +9787547806111 +9787547806326 +9787547810866 +9787547812587 +9787547814307 +9787547816592 +9787547817209 +9787547817735 +9787547819111 +9787547819678 +9787547819722 +9787547822890 +9787547823446 +9787547823897 +9787547824245 +9787547824320 +9787547824658 +9787547824870 +9787547825235 +9787547825723 +9787547827017 +9787547830833 +9787547830949 +9787547834909 +9787547835760 +9787547837214 +9787547841648 +9787547842942 +9787547843345 +9787547843796 +9787547845134 +9787547845486 +9787547845493 +9787547846544 +9787547848555 +9787547848678 +9787547848876 +9787547851715 +9787547851777 +9787547852101 +9787547852668 +9787547853009 +9787547853429 +9787547855461 +9787547855621 +9787547855904 +9787547857083 +9787547861264 +9787547861523 +9787547861653 +9787547862186 +9787547863183 +9787547863305 +9787547863640 +9787547863831 +9787547864647 +9787547864661 +9787547865705 +9787547865712 +9787547865989 +9787547866634 +9787547866771 +9787547867365 +9787547867747 +9787547867891 +9787547868072 +9787547868133 +9787547868225 +9787547868263 +9787547868485 +9787547868546 +9787547868775 +9787547868782 +9787547869062 +9787547869079 +9787547869277 +9787547869468 +9787547869581 +9787547870389 +9787547870501 +9787547870631 +9787547870839 +9787547871089 +9787547871140 +9787547900703 +9787547900918 +9787547902622 +9787547902714 +9787547902776 +9787547903544 +9787547904244 +9787547904695 +9787547904732 +9787547905067 +9787547905333 +9787547905364 +9787547905982 +9787547906095 +9787547906965 +9787547907382 +9787547907610 +9787547909072 +9787547909157 +9787547909317 +9787547909324 +9787547909607 +9787547909669 +9787547909782 +9787547910108 +9787547912553 +9787547915172 +9787547915356 +9787547916940 +9787547918135 +9787547918272 +9787547918616 +9787547919224 +9787547922491 +9787547922774 +9787547922934 +9787547924037 +9787547924549 +9787547924747 +9787547924754 +9787547924761 +9787547925881 +9787547926628 +9787547926710 +9787547928080 +9787547928172 +9787547928493 +9787547928523 +9787547929384 +9787547929544 +9787547930168 +9787547931226 +9787547931240 +9787547931974 +9787547932520 +9787547932797 +9787547932940 +9787547932971 +9787547933022 +9787547933244 +9787547933404 +9787547933602 +9787547933701 +9787547934173 +9787547934234 +9787547934418 +9787547934500 +9787547934548 +9787547934586 +9787547934609 +9787547934623 +9787547934708 +9787547934753 +9787547934760 +9787547934937 +9787547935057 +9787547935095 +9787547935170 +9787547935231 +9787547935255 +9787547935286 +9787547935392 +9787547935521 +9787547935644 +9787547935729 +9787547935972 +9787547935996 +9787547936009 +9787547936436 +9787548002130 +9787548004820 +9787548005155 +9787548005285 +9787548005612 +9787548006169 +9787548006428 +9787548006435 +9787548007173 +9787548007722 +9787548008163 +9787548008187 +9787548008392 +9787548011972 +9787548012269 +9787548013143 +9787548014416 +9787548014874 +9787548015635 +9787548019466 +9787548019565 +9787548020578 +9787548021070 +9787548022060 +9787548022091 +9787548022121 +9787548023586 +9787548024279 +9787548024712 +9787548024828 +9787548024835 +9787548024842 +9787548024873 +9787548026181 +9787548026198 +9787548026419 +9787548027027 +9787548027072 +9787548027959 +9787548027966 +9787548030386 +9787548031482 +9787548031666 +9787548031673 +9787548031680 +9787548031697 +9787548031703 +9787548034032 +9787548034315 +9787548038634 +9787548038924 +9787548040163 +9787548040293 +9787548040460 +9787548040507 +9787548042013 +9787548043492 +9787548044123 +9787548045519 +9787548045557 +9787548046745 +9787548047322 +9787548048367 +9787548048381 +9787548048541 +9787548051053 +9787548051893 +9787548051909 +9787548051923 +9787548052968 +9787548055136 +9787548055679 +9787548056546 +9787548059080 +9787548059097 +9787548059103 +9787548059110 +9787548059127 +9787548059134 +9787548059141 +9787548059158 +9787548059165 +9787548059172 +9787548059202 +9787548059981 +9787548060949 +9787548061328 +9787548063100 +9787548063483 +9787548063902 +9787548065760 +9787548065944 +9787548068471 +9787548070764 +9787548071303 +9787548072003 +9787548072058 +9787548072850 +9787548073802 +9787548074410 +9787548074434 +9787548075493 +9787548075745 +9787548075820 +9787548078142 +9787548078616 +9787548078661 +9787548083863 +9787548084310 +9787548086567 +9787548087359 +9787548087434 +9787548087458 +9787548087465 +9787548087939 +9787548092117 +9787548092575 +9787548093039 +9787548093978 +9787548094180 +9787548094630 +9787548096931 +9787548098836 +9787548098966 +9787548099413 +9787548100256 +9787548100348 +9787548101598 +9787548101895 +9787548103462 +9787548103707 +9787548104766 +9787548107385 +9787548107408 +9787548107798 +9787548109532 +9787548113119 +9787548113577 +9787548200550 +9787548202226 +9787548202578 +9787548202714 +9787548203605 +9787548204190 +9787548204220 +9787548204602 +9787548206163 +9787548206668 +9787548206958 +9787548207252 +9787548208181 +9787548208785 +9787548211129 +9787548211617 +9787548211945 +9787548212041 +9787548214816 +9787548214892 +9787548215806 +9787548217145 +9787548220671 +9787548223122 +9787548223900 +9787548225782 +9787548230342 +9787548231394 +9787548237112 +9787548239741 +9787548241935 +9787548243526 +9787548243694 +9787548246237 +9787548247074 +9787548248682 +9787548249269 +9787548249399 +9787548249627 +9787548300342 +9787548300601 +9787548301073 +9787548301530 +9787548301554 +9787548301899 +9787548302780 +9787548403180 +9787548404569 +9787548405344 +9787548406990 +9787548407645 +9787548408970 +9787548414094 +9787548414124 +9787548414827 +9787548415794 +9787548415978 +9787548419068 +9787548427599 +9787548427605 +9787548428398 +9787548431787 +9787548433651 +9787548434351 +9787548434368 +9787548434696 +9787548437123 +9787548440192 +9787548441830 +9787548448020 +9787548448723 +9787548449027 +9787548453123 +9787548454984 +9787548455080 +9787548455479 +9787548460954 +9787548461968 +9787548462378 +9787548462569 +9787548462880 +9787548462989 +9787548463009 +9787548463122 +9787548463252 +9787548463702 +9787548463771 +9787548463795 +9787548464006 +9787548465218 +9787548466826 +9787548468097 +9787548469025 +9787548472186 +9787548472926 +9787548473022 +9787548475590 +9787548476450 +9787548476474 +9787548479284 +9787548480112 +9787548480457 +9787548481942 +9787548482031 +9787548482222 +9787548483250 +9787548483687 +9787548601036 +9787548601258 +9787548601340 +9787548601463 +9787548602194 +9787548602316 +9787548603115 +9787548603528 +9787548603719 +9787548603801 +9787548604068 +9787548604303 +9787548604372 +9787548604471 +9787548604754 +9787548604761 +9787548605812 +9787548607656 +9787548607984 +9787548608394 +9787548609469 +9787548611233 +9787548611455 +9787548612209 +9787548613091 +9787548614470 +9787548619291 +9787548619345 +9787548619369 +9787548620129 +9787548620143 +9787548620266 +9787548620303 +9787548620358 +9787548620525 +9787548620648 +9787548620754 +9787548653875 +9787548701620 +9787548701835 +9787548703402 +9787548704225 +9787548707080 +9787548707196 +9787548708223 +9787548709480 +9787548709930 +9787548710066 +9787548716075 +9787548718567 +9787548731931 +9787548734734 +9787548736585 +9787548738329 +9787548739517 +9787548739692 +9787548740735 +9787548740858 +9787548742197 +9787548742678 +9787548743538 +9787548743620 +9787548743699 +9787548743934 +9787548743989 +9787548744191 +9787548744207 +9787548744344 +9787548744573 +9787548744597 +9787548744818 +9787548744832 +9787548744856 +9787548744917 +9787548745099 +9787548745259 +9787548745464 +9787548745600 +9787548745808 +9787548746256 +9787548746461 +9787548746560 +9787548746645 +9787548747338 +9787548747970 +9787548748113 +9787548748359 +9787548748960 +9787548749318 +9787548749820 +9787548750994 +9787548751069 +9787548751083 +9787548751328 +9787548753438 +9787548754138 +9787548755319 +9787548756422 +9787548757801 +9787548759300 +9787548759584 +9787548759867 +9787548760931 +9787548761778 +9787548800323 +9787548801382 +9787548801559 +9787548801696 +9787548802839 +9787548802945 +9787548803591 +9787548804659 +9787548805304 +9787548805380 +9787548805595 +9787548805632 +9787548807254 +9787548807261 +9787548807827 +9787548807865 +9787548807872 +9787548809265 +9787548812340 +9787548812555 +9787548812920 +9787548814320 +9787548814610 +9787548814757 +9787548815259 +9787548816669 +9787548818168 +9787548821496 +9787548823216 +9787548824176 +9787548824961 +9787548825470 +9787548826897 +9787548828594 +9787548828631 +9787548828990 +9787548829300 +9787548829980 +9787548830009 +9787548831396 +9787548831754 +9787548831921 +9787548831938 +9787548831945 +9787548833499 +9787548834397 +9787548836506 +9787548836704 +9787548837770 +9787548839552 +9787548839576 +9787548840749 +9787548841357 +9787548841753 +9787548842057 +9787548842163 +9787548842187 +9787548842248 +9787548842330 +9787548842415 +9787548842477 +9787548842545 +9787548842767 +9787548842972 +9787548843009 +9787548843276 +9787548844198 +9787548846239 +9787548846666 +9787548847021 +9787548848264 +9787548848820 +9787548849155 +9787548850465 +9787548851554 +9787548851790 +9787548851806 +9787548851813 +9787548854500 +9787548855132 +9787548855477 +9787548855880 +9787548855897 +9787548856726 +9787548856733 +9787548856757 +9787548857198 +9787548857754 +9787548858225 +9787548859048 +9787548859406 +9787548859420 +9787548859437 +9787548859444 +9787548859468 +9787548860952 +9787548863496 +9787548865674 +9787548865995 +9787548866664 +9787548866893 +9787548867166 +9787548867678 +9787548867739 +9787548868002 +9787548868187 +9787548868453 +9787548868644 +9787548868958 +9787548874676 +9787548900672 +9787548900726 +9787548901310 +9787548901723 +9787548903314 +9787548903499 +9787548903543 +9787548903635 +9787548904540 +9787548904656 +9787548904731 +9787548905257 +9787548908197 +9787548909255 +9787548911005 +9787548912668 +9787548912897 +9787548913061 +9787548914242 +9787548914860 +9787548915928 +9787548916932 +9787548917021 +9787548917120 +9787548917595 +9787548917861 +9787548918141 +9787548918172 +9787548918400 +9787548918523 +9787548925316 +9787548926856 +9787548928751 +9787548930204 +9787548931058 +9787548931416 +9787548931508 +9787548931836 +9787548931850 +9787548932017 +9787548932079 +9787548932147 +9787548932154 +9787548932420 +9787548933922 +9787548935643 +9787548935957 +9787548936046 +9787548938057 +9787548938835 +9787548939689 +9787548940388 +9787548940593 +9787548941446 +9787548941460 +9787548942368 +9787548943457 +9787548943884 +9787548945833 +9787548945864 +9787548946304 +9787548946328 +9787548947417 +9787548948315 +9787548949282 +9787548949312 +9787548949374 +9787548949381 +9787548949404 +9787548949848 +9787548953210 +9787548953456 +9787548954316 +9787548954378 +9787548954996 +9787548956129 +9787548956136 +9787548956167 +9787548956181 +9787548956204 +9787548956266 +9787548956808 +9787548956815 +9787548957942 +9787548957980 +9787548957997 +9787548958031 +9787548958598 +9787548958994 +9787548959014 +9787548959021 +9787548959434 +9787549001156 +9787549001187 +9787549004409 +9787549006526 +9787549006977 +9787549007950 +9787549008476 +9787549009770 +9787549011575 +9787549012695 +9787549013807 +9787549013906 +9787549014057 +9787549016518 +9787549016594 +9787549018611 +9787549018734 +9787549018741 +9787549018819 +9787549018970 +9787549019625 +9787549020829 +9787549021314 +9787549021529 +9787549021574 +9787549022120 +9787549022175 +9787549022205 +9787549022298 +9787549022328 +9787549024100 +9787549024186 +9787549025022 +9787549025329 +9787549026036 +9787549026258 +9787549027101 +9787549027309 +9787549027330 +9787549027385 +9787549027767 +9787549027774 +9787549028245 +9787549028603 +9787549029570 +9787549030767 +9787549100309 +9787549100804 +9787549102426 +9787549102587 +9787549103782 +9787549105311 +9787549105489 +9787549105496 +9787549105526 +9787549105748 +9787549105762 +9787549105779 +9787549107865 +9787549109173 +9787549109586 +9787549110407 +9787549110995 +9787549112500 +9787549113507 +9787549113736 +9787549113941 +9787549115914 +9787549116379 +9787549117581 +9787549118465 +9787549118892 +9787549119103 +9787549119455 +9787549119523 +9787549119608 +9787549120055 +9787549120253 +9787549120796 +9787549121304 +9787549121755 +9787549123933 +9787549124190 +9787549124947 +9787549125661 +9787549125678 +9787549126811 +9787549128242 +9787549128969 +9787549129133 +9787549129393 +9787549200139 +9787549200757 +9787549202089 +9787549202379 +9787549202744 +9787549203611 +9787549203635 +9787549203642 +9787549203734 +9787549203871 +9787549204328 +9787549204649 +9787549204724 +9787549205264 +9787549205363 +9787549205387 +9787549205981 +9787549206759 +9787549206780 +9787549207848 +9787549208234 +9787549208838 +9787549209941 +9787549210213 +9787549210275 +9787549211296 +9787549211678 +9787549212439 +9787549217441 +9787549217946 +9787549219384 +9787549219391 +9787549219407 +9787549219414 +9787549219421 +9787549221479 +9787549221486 +9787549221516 +9787549222490 +9787549223169 +9787549223336 +9787549226634 +9787549226740 +9787549228348 +9787549229222 +9787549229369 +9787549229376 +9787549229499 +9787549230198 +9787549230204 +9787549230211 +9787549230365 +9787549230389 +9787549231317 +9787549232604 +9787549232741 +9787549234028 +9787549234264 +9787549234455 +9787549234615 +9787549234653 +9787549234677 +9787549234721 +9787549235117 +9787549235131 +9787549235421 +9787549235797 +9787549235803 +9787549237043 +9787549237067 +9787549238019 +9787549238149 +9787549239719 +9787549241668 +9787549241965 +9787549241996 +9787549242276 +9787549242337 +9787549242726 +9787549243068 +9787549243600 +9787549244133 +9787549244140 +9787549244522 +9787549244546 +9787549244560 +9787549245789 +9787549246373 +9787549247394 +9787549247721 +9787549249213 +9787549249817 +9787549252008 +9787549254095 +9787549254590 +9787549255610 +9787549256013 +9787549256150 +9787549257287 +9787549257508 +9787549257744 +9787549258352 +9787549261161 +9787549263080 +9787549263400 +9787549264797 +9787549267064 +9787549269068 +9787549270781 +9787549271726 +9787549273461 +9787549276592 +9787549276615 +9787549276639 +9787549277698 +9787549278534 +9787549278633 +9787549278657 +9787549278879 +9787549279487 +9787549281763 +9787549282708 +9787549282913 +9787549283033 +9787549283057 +9787549283071 +9787549283088 +9787549283309 +9787549283828 +9787549283835 +9787549284085 +9787549284115 +9787549285846 +9787549286171 +9787549287086 +9787549287505 +9787549287680 +9787549288649 +9787549288892 +9787549288915 +9787549289318 +9787549289356 +9787549289554 +9787549291090 +9787549291359 +9787549292776 +9787549294244 +9787549294473 +9787549295128 +9787549295227 +9787549295616 +9787549295678 +9787549295944 +9787549296934 +9787549297276 +9787549297283 +9787549297887 +9787549297894 +9787549298518 +9787549298556 +9787549298563 +9787549298570 +9787549299065 +9787549299409 +9787549300631 +9787549301065 +9787549302734 +9787549305308 +9787549305339 +9787549305827 +9787549307555 +9787549308620 +9787549310043 +9787549313501 +9787549316939 +9787549317042 +9787549319299 +9787549320608 +9787549321735 +9787549327072 +9787549335886 +9787549337484 +9787549338283 +9787549341429 +9787549345045 +9787549346479 +9787549349418 +9787549349432 +9787549349494 +9787549349517 +9787549350063 +9787549352753 +9787549353224 +9787549354153 +9787549358526 +9787549358700 +9787549358786 +9787549358854 +9787549358977 +9787549358991 +9787549359455 +9787549360758 +9787549361519 +9787549364169 +9787549364190 +9787549364473 +9787549366439 +9787549367733 +9787549372461 +9787549372966 +9787549373666 +9787549377831 +9787549377862 +9787549377916 +9787549377978 +9787549377985 +9787549378036 +9787549378043 +9787549378128 +9787549379903 +9787549380350 +9787549380596 +9787549380602 +9787549381616 +9787549381685 +9787549384488 +9787549385560 +9787549385966 +9787549389674 +9787549392278 +9787549392995 +9787549394401 +9787549394456 +9787549394579 +9787549394593 +9787549394722 +9787549394784 +9787549394821 +9787549394906 +9787549394913 +9787549394999 +9787549395002 +9787549395019 +9787549395026 +9787549395033 +9787549395071 +9787549395088 +9787549395125 +9787549395200 +9787549395279 +9787549397129 +9787549397174 +9787549397181 +9787549397389 +9787549399970 +9787549400348 +9787549400447 +9787549401048 +9787549401741 +9787549402755 +9787549402953 +9787549403530 +9787549403745 +9787549404056 +9787549404841 +9787549405640 +9787549405794 +9787549406128 +9787549407118 +9787549408924 +9787549409013 +9787549409211 +9787549410644 +9787549410712 +9787549411979 +9787549412211 +9787549412372 +9787549412549 +9787549413249 +9787549415885 +9787549416813 +9787549417032 +9787549418190 +9787549418206 +9787549418411 +9787549418695 +9787549420865 +9787549421176 +9787549423279 +9787549423705 +9787549423927 +9787549426591 +9787549426614 +9787549428410 +9787549501342 +9787549502776 +9787549504220 +9787549504251 +9787549509881 +9787549510719 +9787549514380 +9787549515905 +9787549516735 +9787549517480 +9787549517640 +9787549517732 +9787549523368 +9787549526093 +9787549528189 +9787549529292 +9787549533787 +9787549533909 +9787549536313 +9787549536610 +9787549543786 +9787549544561 +9787549545070 +9787549548682 +9787549548736 +9787549551637 +9787549558124 +9787549559909 +9787549561094 +9787549561445 +9787549561865 +9787549565276 +9787549566204 +9787549568000 +9787549570225 +9787549573448 +9787549575749 +9787549576272 +9787549578238 +9787549580408 +9787549581863 +9787549583935 +9787549586318 +9787549586356 +9787549586363 +9787549587278 +9787549596379 +9787549601288 +9787549603350 +9787549604494 +9787549604593 +9787549604739 +9787549605163 +9787549605507 +9787549606481 +9787549606498 +9787549606511 +9787549606528 +9787549606870 +9787549607426 +9787549608096 +9787549608430 +9787549610129 +9787549610150 +9787549610198 +9787549611065 +9787549611126 +9787549612215 +9787549612826 +9787549613045 +9787549613977 +9787549614288 +9787549615063 +9787549616053 +9787549616336 +9787549616985 +9787549617081 +9787549618217 +9787549618873 +9787549618910 +9787549620371 +9787549620555 +9787549620692 +9787549621316 +9787549621811 +9787549621835 +9787549621897 +9787549621972 +9787549622542 +9787549622566 +9787549626205 +9787549626953 +9787549628995 +9787549631490 +9787549633340 +9787549635177 +9787549636242 +9787549637171 +9787549638468 +9787549638680 +9787549638956 +9787549639366 +9787549639465 +9787549639557 +9787549639564 +9787549639588 +9787549641109 +9787549641796 +9787549641987 +9787549642120 +9787549642168 +9787549642267 +9787549642489 +9787549642557 +9787549643080 +9787549643448 +9787549643486 +9787549643493 +9787549643516 +9787549643561 +9787549643578 +9787549643752 +9787549643998 +9787549644414 +9787549644834 +9787549644872 +9787549644919 +9787549645091 +9787549645138 +9787549701193 +9787549702039 +9787549702046 +9787549702053 +9787549704026 +9787549705450 +9787549705726 +9787549705849 +9787549706099 +9787549706464 +9787549707645 +9787549714759 +9787549717354 +9787549717934 +9787549718429 +9787549721887 +9787549722075 +9787549724307 +9787549728978 +9787549729241 +9787549730025 +9787549731152 +9787549800797 +9787549801633 +9787549809516 +9787549809851 +9787549809875 +9787549809882 +9787549810086 +9787549810499 +9787549812240 +9787549812837 +9787549813902 +9787549814008 +9787549814039 +9787549814077 +9787549815234 +9787549815814 +9787549817085 +9787549818891 +9787549822096 +9787549822584 +9787549822928 +9787549826971 +9787549827381 +9787549830183 +9787549833047 +9787549833597 +9787549834495 +9787549837205 +9787549838608 +9787549841967 +9787549841981 +9787549844586 +9787549844623 +9787549845149 +9787549846276 +9787549846283 +9787549846658 +9787549848669 +9787549849864 +9787549856107 +9787549857715 +9787549859825 +9787549859849 +9787549861224 +9787549864003 +9787549904471 +9787549905102 +9787549906123 +9787549906321 +9787549907342 +9787549907939 +9787549908011 +9787549909629 +9787549910090 +9787549910113 +9787549911356 +9787549911493 +9787549913756 +9787549915590 +9787549915606 +9787549915873 +9787549915880 +9787549916610 +9787549918058 +9787549919826 +9787549920037 +9787549920846 +9787549921669 +9787549922116 +9787549924721 +9787549927555 +9787549928019 +9787549928071 +9787549929368 +9787549929405 +9787549929412 +9787549929511 +9787549929597 +9787549931569 +9787549933280 +9787549933587 +9787549936052 +9787549936076 +9787549938087 +9787549938308 +9787549939688 +9787549940028 +9787549942305 +9787549948741 +9787549948963 +9787549950560 +9787549952076 +9787549952670 +9787549952847 +9787549953059 +9787549954377 +9787549954643 +9787549955305 +9787549955411 +9787549956081 +9787549957453 +9787549958221 +9787549960262 +9787549960873 +9787549963355 +9787549964024 +9787549965588 +9787549966011 +9787549966165 +9787549966523 +9787549967100 +9787549971510 +9787549971527 +9787549971534 +9787549972098 +9787549974672 +9787549975068 +9787549975341 +9787549975587 +9787549977109 +9787549977345 +9787549978007 +9787549978212 +9787549979714 +9787549980208 +9787549980505 +9787549980529 +9787549980888 +9787549980901 +9787549981472 +9787549981519 +9787549981748 +9787549981830 +9787549981922 +9787549981991 +9787549982622 +9787549983322 +9787549984596 +9787549984602 +9787549986200 +9787549986224 +9787549986781 +9787549987320 +9787549988075 +9787549988914 +9787549989348 +9787549989584 +9787549990207 +9787549991778 +9787549992256 +9787549992430 +9787549992812 +9787549993352 +9787549994588 +9787549995295 +9787549997855 +9787549997862 +9787549997985 +9787549997992 +9787549998012 +9787549998029 +9787549998043 +9787549998180 +9787549998388 +9787549998418 +9787549998425 +9787549998432 +9787549998470 +9787549998494 +9787549999682 +9787550001435 +9787550002470 +9787550003989 +9787550004023 +9787550006775 +9787550008687 +9787550013964 +9787550019164 +9787550020184 +9787550021402 +9787550023901 +9787550033573 +9787550033795 +9787550034082 +9787550034419 +9787550038295 +9787550039100 +9787550040885 +9787550041059 +9787550041349 +9787550041363 +9787550042339 +9787550042834 +9787550045415 +9787550045781 +9787550046221 +9787550046344 +9787550047006 +9787550047655 +9787550048867 +9787550049093 +9787550049291 +9787550049321 +9787550049758 +9787550049833 +9787550049956 +9787550051164 +9787550051423 +9787550051522 +9787550051553 +9787550051942 +9787550051997 +9787550052000 +9787550052017 +9787550052383 +9787550053373 +9787550053380 +9787550054448 +9787550055094 +9787550055162 +9787550056275 +9787550056503 +9787550057449 +9787550057456 +9787550057531 +9787550058620 +9787550060029 +9787550104723 +9787550110595 +9787550124059 +9787550124233 +9787550130234 +9787550131743 +9787550135475 +9787550138421 +9787550144583 +9787550145672 +9787550149410 +9787550152502 +9787550152564 +9787550152571 +9787550155930 +9787550156012 +9787550156456 +9787550156463 +9787550159655 +9787550160248 +9787550160385 +9787550160460 +9787550161252 +9787550161412 +9787550161771 +9787550161870 +9787550162143 +9787550162532 +9787550162556 +9787550163096 +9787550163133 +9787550163188 +9787550164130 +9787550164154 +9787550168459 +9787550172739 +9787550174474 +9787550175563 +9787550175631 +9787550175969 +9787550176430 +9787550176454 +9787550176683 +9787550176782 +9787550178069 +9787550178083 +9787550178816 +9787550180031 +9787550180895 +9787550181069 +9787550181519 +9787550183292 +9787550184084 +9787550184602 +9787550185104 +9787550186569 +9787550187795 +9787550188723 +9787550189898 +9787550190122 +9787550191297 +9787550191594 +9787550194861 +9787550194878 +9787550195899 +9787550197442 +9787550200197 +9787550200241 +9787550200692 +9787550200753 +9787550200791 +9787550200814 +9787550200821 +9787550200937 +9787550201897 +9787550202191 +9787550202443 +9787550202467 +9787550203273 +9787550203297 +9787550203853 +9787550205895 +9787550206670 +9787550206755 +9787550206786 +9787550208582 +9787550209466 +9787550209480 +9787550209503 +9787550209534 +9787550211537 +9787550211742 +9787550214286 +9787550215450 +9787550216983 +9787550219342 +9787550220317 +9787550220430 +9787550221475 +9787550223196 +9787550224636 +9787550228160 +9787550228849 +9787550228856 +9787550231603 +9787550231696 +9787550232839 +9787550233829 +9787550234222 +9787550234352 +9787550234383 +9787550234734 +9787550236554 +9787550237742 +9787550237766 +9787550237889 +9787550238299 +9787550238343 +9787550238435 +9787550240636 +9787550240643 +9787550240698 +9787550242296 +9787550242364 +9787550244214 +9787550245921 +9787550247437 +9787550252677 +9787550252929 +9787550252967 +9787550253025 +9787550253117 +9787550254251 +9787550256699 +9787550259997 +9787550260825 +9787550262355 +9787550262744 +9787550264663 +9787550265387 +9787550266070 +9787550266704 +9787550270152 +9787550271081 +9787550271319 +9787550273306 +9787550275232 +9787550275904 +9787550277960 +9787550278097 +9787550278134 +9787550278141 +9787550278158 +9787550278608 +9787550278820 +9787550280427 +9787550280649 +9787550281554 +9787550283282 +9787550283435 +9787550284449 +9787550286511 +9787550286542 +9787550287617 +9787550287877 +9787550290662 +9787550291171 +9787550295056 +9787550295506 +9787550296916 +9787550297517 +9787550297579 +9787550298583 +9787550299474 +9787550300125 +9787550301474 +9787550301795 +9787550302242 +9787550302792 +9787550305090 +9787550310667 +9787550311091 +9787550312258 +9787550312296 +9787550313385 +9787550313392 +9787550314757 +9787550315976 +9787550316959 +9787550317116 +9787550319424 +9787550320031 +9787550320918 +9787550321168 +9787550321236 +9787550321625 +9787550321847 +9787550322554 +9787550322714 +9787550322929 +9787550323292 +9787550323322 +9787550323537 +9787550324886 +9787550325159 +9787550325647 +9787550325845 +9787550326699 +9787550327559 +9787550327702 +9787550328136 +9787550328167 +9787550329102 +9787550329362 +9787550329393 +9787550329423 +9787550329690 +9787550330337 +9787550330665 +9787550333529 +9787550333550 +9787550333741 +9787550333932 +9787550334526 +9787550334557 +9787550335080 +9787550335202 +9787550404878 +9787550407855 +9787550411821 +9787550412521 +9787550413955 +9787550417663 +9787550428836 +9787550429888 +9787550432093 +9787550433984 +9787550435636 +9787550440852 +9787550444874 +9787550446052 +9787550447417 +9787550447561 +9787550448049 +9787550448223 +9787550449404 +9787550450950 +9787550452145 +9787550452725 +9787550452985 +9787550453395 +9787550453883 +9787550455993 +9787550456228 +9787550456280 +9787550459571 +9787550460140 +9787550460317 +9787550462274 +9787550462601 +9787550463967 +9787550464421 +9787550464674 +9787550464681 +9787550467149 +9787550500853 +9787550501089 +9787550501928 +9787550503694 +9787550503939 +9787550504301 +9787550504318 +9787550508217 +9787550509535 +9787550509542 +9787550509559 +9787550510234 +9787550512726 +9787550512948 +9787550512955 +9787550512993 +9787550513068 +9787550513228 +9787550513280 +9787550513709 +9787550518049 +9787550518056 +9787550518193 +9787550518339 +9787550519305 +9787550520035 +9787550521582 +9787550521711 +9787550521780 +9787550522824 +9787550522893 +9787550601598 +9787550601635 +9787550601642 +9787550602281 +9787550605152 +9787550605497 +9787550608290 +9787550608443 +9787550608559 +9787550609228 +9787550609235 +9787550609662 +9787550610620 +9787550611160 +9787550611191 +9787550611658 +9787550611795 +9787550612518 +9787550612594 +9787550612600 +9787550613225 +9787550613423 +9787550613454 +9787550613638 +9787550613690 +9787550613782 +9787550613799 +9787550613812 +9787550614123 +9787550614222 +9787550614475 +9787550614642 +9787550614659 +9787550615649 +9787550615663 +9787550615748 +9787550615809 +9787550616479 +9787550616516 +9787550617018 +9787550617414 +9787550617421 +9787550617490 +9787550617582 +9787550618602 +9787550618909 +9787550619029 +9787550619173 +9787550620230 +9787550620322 +9787550620681 +9787550620728 +9787550620988 +9787550621220 +9787550621770 +9787550622234 +9787550622692 +9787550622883 +9787550624375 +9787550624955 +9787550625075 +9787550625273 +9787550626089 +9787550626379 +9787550626966 +9787550626997 +9787550627765 +9787550628151 +9787550628403 +9787550628755 +9787550629127 +9787550629905 +9787550630444 +9787550630475 +9787550630772 +9787550630826 +9787550630833 +9787550633643 +9787550633667 +9787550634794 +9787550635135 +9787550635401 +9787550635609 +9787550636354 +9787550636996 +9787550637139 +9787550637412 +9787550637627 +9787550638471 +9787550638655 +9787550638846 +9787550638853 +9787550638921 +9787550639652 +9787550639669 +9787550639874 +9787550639973 +9787550640139 +9787550640337 +9787550640351 +9787550640795 +9787550641044 +9787550641051 +9787550641402 +9787550641754 +9787550642348 +9787550642362 +9787550643093 +9787550643505 +9787550643512 +9787550643932 +9787550644199 +9787550644434 +9787550644786 +9787550644885 +9787550700390 +9787550700420 +9787550700673 +9787550701120 +9787550701519 +9787550701724 +9787550702233 +9787550702295 +9787550702912 +9787550703353 +9787550703377 +9787550703384 +9787550703629 +9787550704428 +9787550705333 +9787550706453 +9787550706989 +9787550707115 +9787550707177 +9787550708709 +9787550709362 +9787550709577 +9787550709669 +9787550709836 +9787550710122 +9787550710290 +9787550710375 +9787550711105 +9787550713079 +9787550713369 +9787550713635 +9787550715790 +9787550715912 +9787550716643 +9787550716827 +9787550717145 +9787550718425 +9787550718500 +9787550718616 +9787550719330 +9787550719385 +9787550722224 +9787550723689 +9787550724099 +9787550724174 +9787550724402 +9787550724822 +9787550724945 +9787550725027 +9787550725416 +9787550726406 +9787550726871 +9787550728271 +9787550728936 +9787550728974 +9787550728981 +9787550729483 +9787550729988 +9787550730496 +9787550730762 +9787550731493 +9787550732001 +9787550732797 +9787550733350 +9787550734623 +9787550734630 +9787550734906 +9787550735705 +9787550736740 +9787550736757 +9787550737075 +9787550737525 +9787550737549 +9787550737761 +9787550737914 +9787550738386 +9787550738539 +9787550738997 +9787550739017 +9787550739024 +9787550739086 +9787550739413 +9787550739857 +9787550739888 +9787550740099 +9787550740112 +9787550740129 +9787550740327 +9787550741218 +9787550741492 +9787550741508 +9787550741614 +9787550741645 +9787550742093 +9787550742109 +9787550743199 +9787550743786 +9787550800892 +9787550801912 +9787550804258 +9787550804548 +9787550804562 +9787550805965 +9787550806399 +9787550807464 +9787550807501 +9787550807587 +9787550810181 +9787550811904 +9787550811911 +9787550811928 +9787550811935 +9787550811942 +9787550811959 +9787550811966 +9787550812611 +9787550814271 +9787550814325 +9787550814332 +9787550814349 +9787550816480 +9787550816695 +9787550818521 +9787550818699 +9787550819412 +9787550819658 +9787550820524 +9787550820906 +9787550820975 +9787550821255 +9787550821415 +9787550827684 +9787550828315 +9787550829626 +9787550830417 +9787550831025 +9787550831186 +9787550831476 +9787550831544 +9787550831629 +9787550831933 +9787550831971 +9787550832145 +9787550832411 +9787550832428 +9787550833524 +9787550833722 +9787550833951 +9787550834408 +9787550834590 +9787550834613 +9787550834729 +9787550834941 +9787550835078 +9787550835580 +9787550835931 +9787550836761 +9787550838109 +9787550838895 +9787550838963 +9787550839014 +9787550839168 +9787550839366 +9787550839793 +9787550840324 +9787550842311 +9787550843011 +9787550843387 +9787550844391 +9787550844407 +9787550844841 +9787550845213 +9787550845237 +9787550845589 +9787550845763 +9787550845794 +9787550845879 +9787550845886 +9787550845978 +9787550846098 +9787550846135 +9787550846326 +9787550846371 +9787550846395 +9787550846548 +9787550846791 +9787550847217 +9787550847224 +9787550847866 +9787550848023 +9787550900714 +9787550908765 +9787550910713 +9787550911710 +9787550914728 +9787550918009 +9787550920804 +9787550924857 +9787550925915 +9787550932371 +9787550932630 +9787550938472 +9787551006132 +9787551007665 +9787551007672 +9787551009720 +9787551009898 +9787551011396 +9787551011952 +9787551011969 +9787551012614 +9787551016810 +9787551018593 +9787551018616 +9787551018982 +9787551019408 +9787551019422 +9787551019880 +9787551020787 +9787551025416 +9787551026475 +9787551028691 +9787551100236 +9787551100397 +9787551100724 +9787551100755 +9787551101455 +9787551102957 +9787551104661 +9787551105040 +9787551105057 +9787551105217 +9787551105293 +9787551105910 +9787551107105 +9787551107686 +9787551108775 +9787551109116 +9787551109406 +9787551109543 +9787551109949 +9787551110822 +9787551110846 +9787551110921 +9787551111065 +9787551111355 +9787551111393 +9787551111515 +9787551113564 +9787551114141 +9787551114233 +9787551117500 +9787551117630 +9787551117975 +9787551117999 +9787551123228 +9787551123778 +9787551125147 +9787551125208 +9787551127271 +9787551128391 +9787551129428 +9787551130080 +9787551135535 +9787551135948 +9787551137300 +9787551138918 +9787551138925 +9787551140935 +9787551141222 +9787551142700 +9787551142748 +9787551142786 +9787551142847 +9787551143332 +9787551143394 +9787551143400 +9787551143516 +9787551144674 +9787551145190 +9787551145435 +9787551145442 +9787551145701 +9787551146364 +9787551146432 +9787551146449 +9787551146883 +9787551147996 +9787551149754 +9787551151818 +9787551153690 +9787551156950 +9787551156998 +9787551157025 +9787551157124 +9787551157421 +9787551158275 +9787551158930 +9787551158954 +9787551159791 +9787551161770 +9787551162029 +9787551162364 +9787551162371 +9787551162517 +9787551163965 +9787551165792 +9787551165976 +9787551167239 +9787551167246 +9787551167963 +9787551168892 +9787551168939 +9787551169967 +9787551170956 +9787551171120 +9787551171373 +9787551171489 +9787551171748 +9787551172158 +9787551172202 +9787551172882 +9787551173674 +9787551174367 +9787551176293 +9787551176637 +9787551176644 +9787551200066 +9787551200172 +9787551200233 +9787551200332 +9787551200448 +9787551200615 +9787551200714 +9787551200882 +9787551200936 +9787551201346 +9787551301657 +9787551302173 +9787551302500 +9787551302999 +9787551303279 +9787551303576 +9787551303699 +9787551303811 +9787551304306 +9787551305259 +9787551305389 +9787551305938 +9787551307222 +9787551308441 +9787551308618 +9787551314213 +9787551316057 +9787551317177 +9787551317221 +9787551318266 +9787551322256 +9787551323352 +9787551324090 +9787551326155 +9787551326216 +9787551326636 +9787551327138 +9787551327947 +9787551328265 +9787551328401 +9787551328487 +9787551328630 +9787551328883 +9787551330138 +9787551400091 +9787551401517 +9787551401777 +9787551406710 +9787551407243 +9787551407984 +9787551409582 +9787551409742 +9787551411073 +9787551411103 +9787551414562 +9787551415804 +9787551416191 +9787551416207 +9787551416399 +9787551418430 +9787551418805 +9787551420501 +9787551424066 +9787551424097 +9787551424110 +9787551424356 +9787551427210 +9787551427364 +9787551428651 +9787551428668 +9787551428705 +9787551429061 +9787551430456 +9787551430531 +9787551431989 +9787551432467 +9787551432733 +9787551434508 +9787551434874 +9787551434881 +9787551434898 +9787551434904 +9787551434928 +9787551435482 +9787551435666 +9787551437653 +9787551437660 +9787551439114 +9787551439350 +9787551439824 +9787551441650 +9787551441728 +9787551442947 +9787551444057 +9787551444552 +9787551446266 +9787551446877 +9787551446990 +9787551447263 +9787551448505 +9787551448833 +9787551449038 +9787551450058 +9787551450089 +9787551450645 +9787551450980 +9787551451000 +9787551451031 +9787551451079 +9787551451130 +9787551451321 +9787551451338 +9787551452380 +9787551452762 +9787551453745 +9787551453981 +9787551454001 +9787551454490 +9787551502481 +9787551503075 +9787551503334 +9787551504782 +9787551504850 +9787551505024 +9787551507769 +9787551508384 +9787551510578 +9787551510585 +9787551510608 +9787551510639 +9787551512428 +9787551519267 +9787551522694 +9787551526227 +9787551526234 +9787551526784 +9787551527019 +9787551527057 +9787551527071 +9787551527088 +9787551527095 +9787551527194 +9787551527231 +9787551527378 +9787551527392 +9787551527408 +9787551527422 +9787551527439 +9787551527446 +9787551535618 +9787551536202 +9787551537629 +9787551537667 +9787551538145 +9787551539975 +9787551540445 +9787551540544 +9787551543088 +9787551543422 +9787551549226 +9787551549349 +9787551553551 +9787551555463 +9787551565721 +9787551571371 +9787551573559 +9787551573597 +9787551575249 +9787551576222 +9787551586887 +9787551586894 +9787551586900 +9787551591812 +9787551598156 +9787551600132 +9787551600798 +9787551601320 +9787551602075 +9787551602136 +9787551603782 +9787551605311 +9787551605724 +9787551606738 +9787551606899 +9787551607353 +9787551607506 +9787551608350 +9787551610483 +9787551614979 +9787551618717 +9787551620314 +9787551625869 +9787551629508 +9787551630047 +9787551701754 +9787551704687 +9787551705448 +9787551705998 +9787551707190 +9787551707640 +9787551708715 +9787551708807 +9787551709071 +9787551709286 +9787551709446 +9787551711746 +9787551711883 +9787551712989 +9787551716109 +9787551716178 +9787551716307 +9787551718691 +9787551719049 +9787551719063 +9787551719384 +9787551720823 +9787551722902 +9787551723725 +9787551724326 +9787551724333 +9787551725491 +9787551726306 +9787551726559 +9787551726610 +9787551727198 +9787551727457 +9787551729185 +9787551729970 +9787551730464 +9787551731003 +9787551731102 +9787551732444 +9787551732659 +9787551732901 +9787551733182 +9787551733199 +9787551733298 +9787551733823 +9787551734004 +9787551735971 +9787551736114 +9787551800297 +9787551800549 +9787551800693 +9787551800747 +9787551800761 +9787551801812 +9787551802048 +9787551802130 +9787551802314 +9787551802581 +9787551802741 +9787551802956 +9787551802963 +9787551803045 +9787551803090 +9787551803250 +9787551803496 +9787551803861 +9787551804196 +9787551804745 +9787551804769 +9787551805186 +9787551805483 +9787551805827 +9787551806145 +9787551806336 +9787551806947 +9787551807333 +9787551807449 +9787551807593 +9787551808309 +9787551808446 +9787551808736 +9787551808903 +9787551808972 +9787551809276 +9787551809597 +9787551811071 +9787551814843 +9787551815246 +9787551815444 +9787551815550 +9787551815789 +9787551816014 +9787551817929 +9787551818360 +9787551819282 +9787551820790 +9787551821711 +9787551823722 +9787551825757 +9787551825863 +9787551825900 +9787551826020 +9787551826037 +9787551826136 +9787551826150 +9787551826181 +9787551826327 +9787551826471 +9787551826655 +9787551828055 +9787551828901 +9787551829021 +9787551829038 +9787551830829 +9787551900775 +9787551901611 +9787551901888 +9787551902960 +9787551904438 +9787551909051 +9787552001044 +9787552001396 +9787552002454 +9787552003147 +9787552006360 +9787552006667 +9787552009842 +9787552015454 +9787552016246 +9787552016314 +9787552018936 +9787552020366 +9787552021158 +9787552021233 +9787552023817 +9787552028874 +9787552029383 +9787552029932 +9787552033007 +9787552033564 +9787552034509 +9787552037975 +9787552039665 +9787552040036 +9787552040432 +9787552040463 +9787552040951 +9787552041804 +9787552041835 +9787552042665 +9787552044010 +9787552044041 +9787552044492 +9787552044614 +9787552045420 +9787552045581 +9787552045772 +9787552045802 +9787552045963 +9787552046076 +9787552046106 +9787552046113 +9787552046151 +9787552046304 +9787552047103 +9787552047226 +9787552047233 +9787552047264 +9787552047387 +9787552047479 +9787552100570 +9787552100969 +9787552101348 +9787552102802 +9787552103540 +9787552104356 +9787552104394 +9787552104431 +9787552104622 +9787552104868 +9787552104905 +9787552105414 +9787552106183 +9787552106459 +9787552106749 +9787552106862 +9787552108835 +9787552111262 +9787552112528 +9787552112689 +9787552113181 +9787552115055 +9787552119183 +9787552119206 +9787552119213 +9787552121995 +9787552122206 +9787552123364 +9787552123425 +9787552123449 +9787552123616 +9787552200546 +9787552203943 +9787552203950 +9787552204186 +9787552204209 +9787552204247 +9787552206227 +9787552206265 +9787552206982 +9787552207514 +9787552207682 +9787552207712 +9787552208047 +9787552208207 +9787552213171 +9787552213317 +9787552213324 +9787552213348 +9787552213379 +9787552213447 +9787552214147 +9787552214154 +9787552216158 +9787552216523 +9787552216592 +9787552217889 +9787552219289 +9787552219296 +9787552219364 +9787552219784 +9787552219845 +9787552220162 +9787552225945 +9787552226065 +9787552229608 +9787552229677 +9787552230703 +9787552230734 +9787552231342 +9787552234251 +9787552234398 +9787552234404 +9787552234985 +9787552235319 +9787552236507 +9787552236552 +9787552238426 +9787552238433 +9787552238440 +9787552238549 +9787552238563 +9787552242928 +9787552243062 +9787552244885 +9787552244892 +9787552244908 +9787552244915 +9787552244922 +9787552244939 +9787552244946 +9787552244953 +9787552244960 +9787552244977 +9787552247145 +9787552248722 +9787552252071 +9787552252316 +9787552253764 +9787552253788 +9787552254945 +9787552254952 +9787552254969 +9787552255287 +9787552255584 +9787552259568 +9787552260274 +9787552260373 +9787552260717 +9787552263329 +9787552264081 +9787552266085 +9787552266351 +9787552268201 +9787552269727 +9787552270105 +9787552270402 +9787552270433 +9787552272864 +9787552272871 +9787552272994 +9787552273007 +9787552275605 +9787552275674 +9787552279344 +9787552282436 +9787552282528 +9787552282542 +9787552282900 +9787552282962 +9787552283143 +9787552284041 +9787552284157 +9787552284324 +9787552284331 +9787552287509 +9787552288391 +9787552288414 +9787552288506 +9787552289671 +9787552289725 +9787552290158 +9787552290172 +9787552290196 +9787552290219 +9787552294132 +9787552294279 +9787552294408 +9787552295818 +9787552295825 +9787552295870 +9787552297362 +9787552297911 +9787552298215 +9787552298482 +9787552298529 +9787552298536 +9787552298567 +9787552298574 +9787552298581 +9787552301588 +9787552302028 +9787552302868 +9787552302875 +9787552303315 +9787552304596 +9787552304619 +9787552305036 +9787552306170 +9787552306224 +9787552306699 +9787552306705 +9787552307801 +9787552307856 +9787552309331 +9787552310986 +9787552311211 +9787552314854 +9787552315769 +9787552320619 +9787552321463 +9787552325881 +9787552325997 +9787552327205 +9787552327298 +9787552328011 +9787552329209 +9787552329346 +9787552329353 +9787552329483 +9787552329780 +9787552329810 +9787552405347 +9787552417036 +9787552425109 +9787552427721 +9787552428179 +9787552428209 +9787552428216 +9787552435795 +9787552435801 +9787552436952 +9787552458244 +9787552460681 +9787552462937 +9787552463019 +9787552465464 +9787552476224 +9787552476958 +9787552478631 +9787552480603 +9787552480702 +9787552480795 +9787552482225 +9787552484526 +9787552487480 +9787552487602 +9787552490091 +9787552490398 +9787552494679 +9787552494686 +9787552494938 +9787552498882 +9787552500042 +9787552501520 +9787552506730 +9787552509038 +9787552509076 +9787552509991 +9787552510140 +9787552510225 +9787552510256 +9787552512120 +9787552512229 +9787552513394 +9787552515336 +9787552517095 +9787552517255 +9787552517378 +9787552529456 +9787552529470 +9787552529777 +9787552530230 +9787552537994 +9787552538281 +9787552539592 +9787552542585 +9787552542790 +9787552542875 +9787552545678 +9787552546804 +9787552547443 +9787552548020 +9787552548198 +9787552549157 +9787552549379 +9787552551631 +9787552552874 +9787552553246 +9787552557947 +9787552561340 +9787552561425 +9787552564273 +9787552566185 +9787552571202 +9787552571998 +9787552572773 +9787552572803 +9787552603798 +9787552603811 +9787552608274 +9787552609592 +9787552609608 +9787552609615 +9787552609622 +9787552610413 +9787552611564 +9787552611991 +9787552612004 +9787552614640 +9787552615203 +9787552615227 +9787552616439 +9787552616576 +9787552617719 +9787552620498 +9787552626117 +9787552627497 +9787552628852 +9787552629781 +9787552630015 +9787552631289 +9787552633559 +9787552634341 +9787552634730 +9787552641134 +9787552642742 +9787552643091 +9787552643121 +9787552643602 +9787552643688 +9787552643893 +9787552644807 +9787552644821 +9787552646399 +9787552646405 +9787552646443 +9787552646481 +9787552646603 +9787552647846 +9787552647884 +9787552648775 +9787552650396 +9787552651713 +9787552651812 +9787552653489 +9787552654639 +9787552700275 +9787552701036 +9787552701456 +9787552701661 +9787552702910 +9787552702972 +9787552703139 +9787552703405 +9787552703542 +9787552703627 +9787552703849 +9787552703917 +9787552705041 +9787552705591 +9787552705805 +9787552705911 +9787552706352 +9787552706611 +9787552706680 +9787552706727 +9787552706857 +9787552707090 +9787552707182 +9787552707298 +9787552707311 +9787552707335 +9787552707397 +9787552707526 +9787552707663 +9787552707670 +9787552707717 +9787552707724 +9787552707984 +9787552708004 +9787552708028 +9787552708073 +9787552708080 +9787552708424 +9787552708431 +9787552708523 +9787552708554 +9787552708837 +9787552708851 +9787552800371 +9787552801897 +9787552802627 +9787552802757 +9787552802771 +9787552802924 +9787552804010 +9787552804188 +9787552807349 +9787552807431 +9787552807899 +9787552808001 +9787552809541 +9787552810271 +9787552810592 +9787552811704 +9787552812206 +9787552812404 +9787552813036 +9787552813067 +9787552813074 +9787552813081 +9787552813098 +9787552813135 +9787552814170 +9787552814187 +9787552814200 +9787552814217 +9787552814897 +9787552814934 +9787552815641 +9787552815832 +9787552815849 +9787552901894 +9787552903140 +9787552905823 +9787552905830 +9787552910247 +9787552910414 +9787552910612 +9787552916560 +9787553000176 +9787553000480 +9787553000916 +9787553001883 +9787553002392 +9787553002644 +9787553004754 +9787553006345 +9787553006741 +9787553007304 +9787553007373 +9787553008486 +9787553008493 +9787553008653 +9787553009414 +9787553009698 +9787553010038 +9787553010281 +9787553010748 +9787553011417 +9787553012155 +9787553012285 +9787553012926 +9787553100463 +9787553101651 +9787553101910 +9787553102788 +9787553103402 +9787553103563 +9787553104027 +9787553104133 +9787553104737 +9787553104799 +9787553104928 +9787553105468 +9787553105550 +9787553105833 +9787553106380 +9787553106427 +9787553106540 +9787553106786 +9787553107103 +9787553107233 +9787553108186 +9787553109152 +9787553109176 +9787553109824 +9787553111315 +9787553111384 +9787553111964 +9787553112381 +9787553114255 +9787553114460 +9787553114606 +9787553114767 +9787553114941 +9787553115993 +9787553116181 +9787553116655 +9787553116822 +9787553118376 +9787553119540 +9787553119564 +9787553120645 +9787553121345 +9787553121635 +9787553121871 +9787553122359 +9787553122373 +9787553122533 +9787553122540 +9787553122762 +9787553122793 +9787553122816 +9787553122830 +9787553123004 +9787553123530 +9787553200637 +9787553201900 +9787553204284 +9787553208091 +9787553208510 +9787553208732 +9787553208992 +9787553209791 +9787553210476 +9787553210674 +9787553211138 +9787553211152 +9787553213200 +9787553213415 +9787553213507 +9787553213538 +9787553213569 +9787553214498 +9787553215310 +9787553301785 +9787553302157 +9787553303406 +9787553303758 +9787553304779 +9787553306438 +9787553306889 +9787553307633 +9787553307695 +9787553307725 +9787553308845 +9787553311036 +9787553311371 +9787553311647 +9787553311821 +9787553312583 +9787553315348 +9787553316499 +9787553318080 +9787553318769 +9787553321615 +9787553321899 +9787553322766 +9787553323008 +9787553324487 +9787553326238 +9787553326351 +9787553328096 +9787553328959 +9787553329406 +9787553329642 +9787553331041 +9787553331225 +9787553332185 +9787553332895 +9787553332918 +9787553333748 +9787553333977 +9787553334899 +9787553336497 +9787553338156 +9787553340166 +9787553340432 +9787553340630 +9787553341491 +9787553343099 +9787553343327 +9787553343518 +9787553343594 +9787553343983 +9787553344263 +9787553346755 +9787553346861 +9787553347110 +9787553347967 +9787553348230 +9787553348490 +9787553349459 +9787553349855 +9787553349862 +9787553349954 +9787553350257 +9787553351025 +9787553351131 +9787553351278 +9787553400730 +9787553400884 +9787553401126 +9787553401287 +9787553401393 +9787553404172 +9787553404189 +9787553404196 +9787553404202 +9787553404424 +9787553404479 +9787553404769 +9787553405605 +9787553405872 +9787553406145 +9787553406183 +9787553406220 +9787553406244 +9787553406411 +9787553406879 +9787553407586 +9787553409900 +9787553410050 +9787553410425 +9787553410944 +9787553411026 +9787553411323 +9787553411347 +9787553411354 +9787553411361 +9787553411392 +9787553411439 +9787553411651 +9787553411910 +9787553412603 +9787553412641 +9787553412689 +9787553414331 +9787553414379 +9787553414409 +9787553414874 +9787553415048 +9787553415680 +9787553416052 +9787553416076 +9787553416182 +9787553416274 +9787553416298 +9787553416489 +9787553417875 +9787553418025 +9787553418346 +9787553418360 +9787553418711 +9787553418957 +9787553419619 +9787553420011 +9787553420813 +9787553421865 +9787553422985 +9787553422992 +9787553425849 +9787553425856 +9787553425870 +9787553425887 +9787553425900 +9787553425962 +9787553425993 +9787553426006 +9787553426068 +9787553426143 +9787553426167 +9787553426181 +9787553426198 +9787553426228 +9787553426266 +9787553426310 +9787553426341 +9787553426358 +9787553426365 +9787553426402 +9787553426419 +9787553426426 +9787553426433 +9787553427737 +9787553429083 +9787553429403 +9787553430669 +9787553430812 +9787553431710 +9787553431888 +9787553432182 +9787553432199 +9787553432243 +9787553432281 +9787553432380 +9787553432403 +9787553432410 +9787553432625 +9787553434995 +9787553435008 +9787553436067 +9787553437064 +9787553437231 +9787553438689 +9787553439266 +9787553439785 +9787553439792 +9787553440040 +9787553440422 +9787553440460 +9787553440583 +9787553440590 +9787553440880 +9787553440903 +9787553441078 +9787553441122 +9787553441832 +9787553441887 +9787553441894 +9787553441917 +9787553441931 +9787553441948 +9787553441986 +9787553442365 +9787553443188 +9787553443201 +9787553443874 +9787553444079 +9787553445434 +9787553447964 +9787553448114 +9787553449234 +9787553450377 +9787553450438 +9787553450636 +9787553453071 +9787553453101 +9787553453873 +9787553453910 +9787553453927 +9787553456515 +9787553456966 +9787553457017 +9787553457024 +9787553457239 +9787553457529 +9787553458731 +9787553460079 +9787553460130 +9787553460673 +9787553461779 +9787553462233 +9787553462721 +9787553462943 +9787553463124 +9787553463421 +9787553464077 +9787553466972 +9787553467573 +9787553467825 +9787553468082 +9787553468099 +9787553468501 +9787553468761 +9787553468839 +9787553469447 +9787553470344 +9787553470351 +9787553470375 +9787553470405 +9787553471549 +9787553471945 +9787553472201 +9787553474663 +9787553475387 +9787553475592 +9787553475820 +9787553476049 +9787553476537 +9787553476834 +9787553477688 +9787553478043 +9787553478708 +9787553479255 +9787553480077 +9787553483276 +9787553483795 +9787553483962 +9787553484549 +9787553484679 +9787553485560 +9787553485638 +9787553485898 +9787553486345 +9787553486451 +9787553492209 +9787553492384 +9787553492414 +9787553493206 +9787553493480 +9787553493497 +9787553494609 +9787553494616 +9787553495774 +9787553495781 +9787553495941 +9787553497594 +9787553498362 +9787553498430 +9787553498461 +9787553500133 +9787553500157 +9787553500256 +9787553501840 +9787553502168 +9787553503097 +9787553504148 +9787553505084 +9787553505183 +9787553505251 +9787553505350 +9787553505466 +9787553505909 +9787553506241 +9787553506586 +9787553507149 +9787553507156 +9787553507248 +9787553507651 +9787553507866 +9787553508191 +9787553508313 +9787553508528 +9787553508726 +9787553509075 +9787553509235 +9787553510187 +9787553510774 +9787553510910 +9787553510934 +9787553511702 +9787553511887 +9787553516943 +9787553517834 +9787553518541 +9787553518992 +9787553519685 +9787553519708 +9787553523132 +9787553524733 +9787553525747 +9787553525815 +9787553525969 +9787553526508 +9787553527024 +9787553527666 +9787553529950 +9787553530321 +9787553530901 +9787553530970 +9787553531014 +9787553531113 +9787553531120 +9787553531519 +9787553531885 +9787553600512 +9787553601724 +9787553603018 +9787553608983 +9787553609225 +9787553610320 +9787553610665 +9787553612478 +9787553613659 +9787553613727 +9787553614274 +9787553615615 +9787553616452 +9787553618531 +9787553618555 +9787553618692 +9787553618708 +9787553620602 +9787553620732 +9787553620749 +9787553621890 +9787553623184 +9787553623788 +9787553624518 +9787553625652 +9787553633558 +9787553639888 +9787553643786 +9787553644318 +9787553648750 +9787553649405 +9787553656113 +9787553660639 +9787553660684 +9787553661018 +9787553661124 +9787553661520 +9787553661858 +9787553662466 +9787553663890 +9787553666822 +9787553668390 +9787553672953 +9787553677859 +9787553684932 +9787553686028 +9787553687209 +9787553687810 +9787553688336 +9787553690025 +9787553692005 +9787553692609 +9787553692746 +9787553692760 +9787553693101 +9787553693385 +9787553694122 +9787553696058 +9787553696577 +9787553696591 +9787553696607 +9787553698359 +9787553698731 +9787553699424 +9787553699486 +9787553699516 +9787553699691 +9787553700113 +9787553700540 +9787553700793 +9787553700809 +9787553703176 +9787553703299 +9787553704401 +9787553706764 +9787553709482 +9787553709659 +9787553710952 +9787553711065 +9787553711089 +9787553711287 +9787553711874 +9787553712598 +9787553713311 +9787553715025 +9787553715308 +9787553719016 +9787553719672 +9787553721811 +9787553722085 +9787553722733 +9787553722740 +9787553724324 +9787553728575 +9787553728605 +9787553729213 +9787553729732 +9787553735351 +9787553735375 +9787553735382 +9787553735436 +9787553735443 +9787553735757 +9787553739533 +9787553745527 +9787553745671 +9787553745909 +9787553746616 +9787553746623 +9787553746685 +9787553748825 +9787553753478 +9787553754161 +9787553754277 +9787553756974 +9787553762982 +9787553765327 +9787553765402 +9787553768694 +9787553771892 +9787553772295 +9787553772363 +9787553772707 +9787553774220 +9787553779225 +9787553786018 +9787553793535 +9787553798349 +9787553799247 +9787553800004 +9787553800127 +9787553800998 +9787553802480 +9787553803173 +9787553803807 +9787553805191 +9787553805399 +9787553806334 +9787553807478 +9787553807652 +9787553808628 +9787553809588 +9787553809939 +9787553810645 +9787553810850 +9787553811222 +9787553811383 +9787553812328 +9787553813394 +9787553814469 +9787553814797 +9787553815220 +9787553816869 +9787553817590 +9787553818160 +9787553818214 +9787553818351 +9787553819006 +9787553819105 +9787553819310 +9787553819426 +9787553819464 +9787553819495 +9787553819525 +9787553819556 +9787553819570 +9787553819600 +9787553819617 +9787553819860 +9787553819921 +9787553820163 +9787553820323 +9787553820330 +9787553820606 +9787553820774 +9787553820811 +9787553820859 +9787553820910 +9787553820958 +9787553820996 +9787553821153 +9787553821337 +9787553821382 +9787553821399 +9787553821405 +9787553821559 +9787553821702 +9787553821757 +9787553821948 +9787553822310 +9787553822662 +9787553822723 +9787553822853 +9787553823034 +9787553823065 +9787553823164 +9787553823461 +9787553903446 +9787553903897 +9787553904283 +9787553904986 +9787553907208 +9787553909141 +9787553909493 +9787553910857 +9787553916798 +9787553919348 +9787553922973 +9787553923123 +9787553923772 +9787553930053 +9787553936314 +9787553936383 +9787553936406 +9787553936413 +9787553936420 +9787553936529 +9787553936628 +9787553936741 +9787553939681 +9787553939704 +9787553944449 +9787553947556 +9787553947563 +9787553947860 +9787553948539 +9787553950884 +9787553951645 +9787553951836 +9787553953199 +9787553954776 +9787553954820 +9787553955018 +9787553955032 +9787553955377 +9787553955384 +9787553955643 +9787553955896 +9787553958057 +9787553959573 +9787553961965 +9787553961996 +9787553962047 +9787553963938 +9787553964751 +9787553968124 +9787553968148 +9787553968155 +9787553968308 +9787553968681 +9787553969367 +9787553969503 +9787553970202 +9787553970219 +9787553971995 +9787553972015 +9787553972190 +9787553972398 +9787553972411 +9787553973418 +9787553973807 +9787553974033 +9787553974194 +9787553974316 +9787553974446 +9787553975306 +9787553975313 +9787553975979 +9787553975986 +9787553976396 +9787553979069 +9787553979090 +9787553979205 +9787553979274 +9787553979601 +9787553979618 +9787553979632 +9787553979656 +9787553980218 +9787553980683 +9787553980690 +9787553980706 +9787553980768 +9787553980775 +9787553980782 +9787553980805 +9787553980812 +9787553980843 +9787553980850 +9787553980874 +9787553981543 +9787553983097 +9787553984056 +9787553984094 +9787553986630 +9787553987323 +9787553987330 +9787553987347 +9787553987446 +9787553987460 +9787553988313 +9787553988337 +9787553988528 +9787553988559 +9787553988573 +9787553988603 +9787553988610 +9787553988627 +9787553988634 +9787553988641 +9787553988696 +9787553988702 +9787553988726 +9787553988733 +9787553988740 +9787553988757 +9787553990804 +9787553990842 +9787553991405 +9787553991924 +9787553991948 +9787553992532 +9787553992754 +9787553992952 +9787553994956 +9787553994970 +9787553996042 +9787553996059 +9787553996233 +9787553996318 +9787553996479 +9787553996714 +9787553996820 +9787553996837 +9787553997155 +9787553997179 +9787553997384 +9787553998077 +9787553998107 +9787553998336 +9787553998374 +9787553998473 +9787553998756 +9787554000212 +9787554000618 +9787554000625 +9787554000786 +9787554001011 +9787554001622 +9787554001691 +9787554001714 +9787554001806 +9787554002117 +9787554002223 +9787554002230 +9787554002971 +9787554002988 +9787554003015 +9787554003411 +9787554003503 +9787554003718 +9787554004593 +9787554005019 +9787554005088 +9787554005118 +9787554005156 +9787554005163 +9787554006542 +9787554006795 +9787554006948 +9787554007488 +9787554009185 +9787554009901 +9787554011409 +9787554011591 +9787554011874 +9787554011973 +9787554013175 +9787554013403 +9787554013489 +9787554013519 +9787554013663 +9787554013670 +9787554013953 +9787554014349 +9787554015209 +9787554015261 +9787554017074 +9787554018378 +9787554018620 +9787554020265 +9787554020395 +9787554021705 +9787554022092 +9787554022139 +9787554022214 +9787554023471 +9787554024089 +9787554024096 +9787554024393 +9787554024836 +9787554025208 +9787554025468 +9787554025598 +9787554025611 +9787554026199 +9787554026229 +9787554026403 +9787554026731 +9787554026830 +9787554027486 +9787554027684 +9787554027691 +9787554028094 +9787554028322 +9787554029398 +9787554029527 +9787554029794 +9787554030592 +9787554030615 +9787554031063 +9787554031148 +9787554031285 +9787554031537 +9787554032299 +9787554032695 +9787554032749 +9787554032817 +9787554032992 +9787554101346 +9787554101902 +9787554102619 +9787554102626 +9787554103005 +9787554103869 +9787554105375 +9787554106785 +9787554107386 +9787554108321 +9787554108611 +9787554109663 +9787554110027 +9787554112229 +9787554112472 +9787554113394 +9787554114070 +9787554119082 +9787554119099 +9787554119105 +9787554119563 +9787554120057 +9787554120439 +9787554122433 +9787554122464 +9787554122686 +9787554124383 +9787554129920 +9787554130766 +9787554131473 +9787554134177 +9787554135488 +9787554140093 +9787554140468 +9787554140840 +9787554140857 +9787554143803 +9787554146576 +9787554146583 +9787554147207 +9787554147405 +9787554148389 +9787554148396 +9787554148440 +9787554148457 +9787554148570 +9787554148594 +9787554148891 +9787554149324 +9787554149898 +9787554149911 +9787554150283 +9787554150405 +9787554150702 +9787554150757 +9787554151730 +9787554151815 +9787554151822 +9787554151853 +9787554153222 +9787554153253 +9787554153581 +9787554153611 +9787554154267 +9787554154366 +9787554154465 +9787554154571 +9787554155042 +9787554155080 +9787554157305 +9787554158173 +9787554158241 +9787554158548 +9787554158715 +9787554158739 +9787554159781 +9787554159804 +9787554159927 +9787554159958 +9787554159965 +9787554160084 +9787554160145 +9787554160237 +9787554160251 +9787554160275 +9787554160305 +9787554160664 +9787554161517 +9787554161951 +9787554161968 +9787554161999 +9787554162002 +9787554162019 +9787554162231 +9787554162262 +9787554162439 +9787554162538 +9787554162873 +9787554164136 +9787554164303 +9787554164310 +9787554164631 +9787554165010 +9787554165027 +9787554165034 +9787554165041 +9787554165065 +9787554165508 +9787554165577 +9787554165904 +9787554167038 +9787554167069 +9787554167243 +9787554167830 +9787554168332 +9787554168646 +9787554168653 +9787554168660 +9787554168721 +9787554168998 +9787554169001 +9787554169209 +9787554169391 +9787554170472 +9787554171462 +9787554172971 +9787554173862 +9787554175095 +9787554175668 +9787554176788 +9787554177563 +9787554177792 +9787554177877 +9787554178447 +9787554178911 +9787554181522 +9787554202166 +9787554202173 +9787554204290 +9787554206324 +9787554209622 +9787554209660 +9787554213643 +9787554223345 +9787554224090 +9787554227619 +9787554230268 +9787554230701 +9787554300312 +9787554300978 +9787554301098 +9787554301487 +9787554301760 +9787554301791 +9787554302248 +9787554303450 +9787554303863 +9787554304181 +9787554307007 +9787554307922 +9787554308158 +9787554310786 +9787554310809 +9787554407950 +9787554409213 +9787554409374 +9787554415870 +9787554416983 +9787554418543 +9787554435472 +9787554440018 +9787554442029 +9787554444481 +9787554444504 +9787554444511 +9787554444528 +9787554444535 +9787554446485 +9787554446508 +9787554446539 +9787554447406 +9787554448007 +9787554448021 +9787554448038 +9787554448045 +9787554448137 +9787554451885 +9787554453384 +9787554454893 +9787554455555 +9787554455562 +9787554455579 +9787554455630 +9787554455654 +9787554455685 +9787554500309 +9787554500316 +9787554500750 +9787554501344 +9787554501351 +9787554504840 +9787554509548 +9787554513972 +9787554514511 +9787554514887 +9787554514900 +9787554515730 +9787554516003 +9787554516331 +9787554516614 +9787554516652 +9787554516898 +9787554518953 +9787554519905 +9787554520581 +9787554522943 +9787554522967 +9787554528983 +9787554529621 +9787554530702 +9787554533451 +9787554533475 +9787554536384 +9787554536483 +9787554540282 +9787554543573 +9787554543634 +9787554543658 +9787554544280 +9787554545799 +9787554545805 +9787554545812 +9787554548097 +9787554551141 +9787554551196 +9787554551240 +9787554551530 +9787554551592 +9787554553725 +9787554553909 +9787554554098 +9787554555408 +9787554555835 +9787554558553 +9787554562383 +9787554562543 +9787554562895 +9787554564387 +9787554564851 +9787554566541 +9787554569788 +9787554570005 +9787554574645 +9787554578865 +9787554579039 +9787554580240 +9787554580615 +9787554582428 +9787554586099 +9787554588413 +9787554589571 +9787554589878 +9787554602676 +9787554603932 +9787554604731 +9787554604861 +9787554605028 +9787554607138 +9787554607954 +9787554609248 +9787554609514 +9787554610848 +9787554610886 +9787554614921 +9787554618165 +9787554619780 +9787554621639 +9787554622056 +9787554622100 +9787554622353 +9787554622575 +9787554623046 +9787554623121 +9787554623213 +9787554623237 +9787554623299 +9787554623381 +9787554623558 +9787554623718 +9787554623947 +9787554624500 +9787554624777 +9787554624890 +9787554625453 +9787554701669 +9787554702864 +9787554702970 +9787554703908 +9787554705179 +9787554705209 +9787554705988 +9787554707067 +9787554707166 +9787554709719 +9787554709788 +9787554710876 +9787554710906 +9787554711071 +9787554711132 +9787554712115 +9787554712160 +9787554712382 +9787554712764 +9787554713419 +9787554713648 +9787554800218 +9787554800225 +9787554800676 +9787554800690 +9787554800713 +9787554800843 +9787554801857 +9787554802144 +9787554802366 +9787554803288 +9787554803660 +9787554803738 +9787554803998 +9787554804834 +9787554804964 +9787554807101 +9787554807118 +9787554807699 +9787554807972 +9787554812013 +9787554813003 +9787554816387 +9787554819548 +9787554821459 +9787554822487 +9787554822807 +9787554823019 +9787554823330 +9787554823767 +9787554823811 +9787554824962 +9787554825143 +9787554825426 +9787554825686 +9787554826294 +9787554826591 +9787554827604 +9787554828151 +9787554829134 +9787554829752 +9787554829813 +9787554829820 +9787554829837 +9787554831229 +9787554833568 +9787554839522 +9787554839720 +9787554839959 +9787554840139 +9787554840603 +9787554840832 +9787554840870 +9787554840986 +9787554841198 +9787554845103 +9787554846087 +9787554846162 +9787554846742 +9787554846858 +9787554846995 +9787554850299 +9787554851470 +9787554855164 +9787554865897 +9787554869239 +9787554869819 +9787554906750 +9787554911662 +9787554913017 +9787554915608 +9787554916001 +9787554918715 +9787554919088 +9787554919897 +9787554920275 +9787554920282 +9787554920497 +9787554920596 +9787554920787 +9787554921319 +9787554921340 +9787554921395 +9787554921920 +9787554922088 +9787554923399 +9787554924143 +9787554924457 +9787554924464 +9787554924471 +9787554924488 +9787554924570 +9787554924754 +9787554925058 +9787554926451 +9787554927656 +9787554928097 +9787554929759 +9787554929780 +9787554929797 +9787554929834 +9787554929841 +9787554931127 +9787554933640 +9787554933688 +9787554934142 +9787554934425 +9787554934593 +9787554934609 +9787554934616 +9787554937747 +9787554941287 +9787554941348 +9787554941362 +9787554943229 +9787554944875 +9787555000471 +9787555003373 +9787555003731 +9787555004424 +9787555007937 +9787555009047 +9787555010098 +9787555011651 +9787555014195 +9787555015239 +9787555015819 +9787555016786 +9787555017936 +9787555019282 +9787555019794 +9787555020776 +9787555022176 +9787555022251 +9787555022640 +9787555024606 +9787555026396 +9787555027652 +9787555031130 +9787555031277 +9787555031895 +9787555032670 +9787555034124 +9787555036005 +9787555038573 +9787555038917 +9787555040897 +9787555100102 +9787555100379 +9787555100584 +9787555101666 +9787555101932 +9787555102588 +9787555102618 +9787555102748 +9787555102816 +9787555103264 +9787555103417 +9787555103615 +9787555103813 +9787555104117 +9787555105343 +9787555106197 +9787555107644 +9787555109129 +9787555109570 +9787555110460 +9787555112440 +9787555112495 +9787555112945 +9787555114086 +9787555114314 +9787555114444 +9787555115335 +9787555117230 +9787555117513 +9787555118152 +9787555119692 +9787555121305 +9787555121671 +9787555122463 +9787555123026 +9787555123361 +9787555200086 +9787555200666 +9787555201502 +9787555201847 +9787555202769 +9787555202905 +9787555203421 +9787555203438 +9787555203490 +9787555203506 +9787555203513 +9787555204060 +9787555204268 +9787555204473 +9787555204794 +9787555207726 +9787555208570 +9787555208761 +9787555208983 +9787555208990 +9787555209478 +9787555210412 +9787555210429 +9787555211037 +9787555211099 +9787555211105 +9787555211815 +9787555211884 +9787555213147 +9787555213253 +9787555213338 +9787555213352 +9787555214205 +9787555214281 +9787555215110 +9787555215271 +9787555217466 +9787555218418 +9787555220374 +9787555220381 +9787555220466 +9787555220756 +9787555220923 +9787555220947 +9787555223511 +9787555225430 +9787555225454 +9787555225829 +9787555226161 +9787555226192 +9787555226284 +9787555226703 +9787555226796 +9787555227120 +9787555228073 +9787555228776 +9787555228783 +9787555228813 +9787555228820 +9787555230281 +9787555230311 +9787555231851 +9787555233923 +9787555236856 +9787555237396 +9787555238096 +9787555239352 +9787555239383 +9787555239840 +9787555242529 +9787555246251 +9787555246268 +9787555246879 +9787555250593 +9787555250647 +9787555252214 +9787555252337 +9787555253297 +9787555254034 +9787555255932 +9787555256724 +9787555257295 +9787555257721 +9787555262909 +9787555263180 +9787555263760 +9787555265542 +9787555265726 +9787555268543 +9787555268819 +9787555269847 +9787555272038 +9787555273691 +9787555273844 +9787555274919 +9787555275664 +9787555275985 +9787555277507 +9787555278122 +9787555279136 +9787555279730 +9787555281580 +9787555281696 +9787555281948 +9787555282167 +9787555282259 +9787555282341 +9787555282396 +9787555282495 +9787555282501 +9787555282648 +9787555282655 +9787555282662 +9787555282679 +9787555283348 +9787555283485 +9787555283546 +9787555283560 +9787555283577 +9787555283904 +9787555284291 +9787555286523 +9787555286615 +9787555287902 +9787555288459 +9787555288497 +9787555288978 +9787555290025 +9787555290834 +9787555291169 +9787555292227 +9787555292241 +9787555292487 +9787555293040 +9787555294009 +9787555294269 +9787555294351 +9787555294665 +9787555295174 +9787555295181 +9787555295198 +9787555295730 +9787555295747 +9787555296102 +9787555296324 +9787555296447 +9787555296478 +9787555296713 +9787555296737 +9787555297291 +9787555297888 +9787555297963 +9787555298267 +9787555298649 +9787555298656 +9787555298663 +9787555298991 +9787555301660 +9787555301691 +9787555301912 +9787555304531 +9787555311393 +9787555322856 +9787555322986 +9787555332343 +9787555344247 +9787555348368 +9787555368496 +9787555370062 +9787555374497 +9787555374510 +9787555381488 +9787555381518 +9787555384748 +9787555397083 +9787555400851 +9787555401391 +9787555401513 +9787555401780 +9787555402619 +9787555403012 +9787555405313 +9787555407188 +9787555407874 +9787555409182 +9787555409274 +9787555409618 +9787555410461 +9787555412083 +9787555414896 +9787555417057 +9787555417194 +9787555417736 +9787555417941 +9787555418009 +9787555418979 +9787555419136 +9787555419143 +9787555419167 +9787555419464 +9787555419891 +9787555420330 +9787555420606 +9787555420781 +9787555420835 +9787555421122 +9787555421313 +9787555421481 +9787555421726 +9787555421757 +9787555421979 +9787555422358 +9787555423058 +9787555423089 +9787555500049 +9787555500322 +9787555500834 +9787555501596 +9787555502074 +9787555502098 +9787555502517 +9787555502784 +9787555505518 +9787555505525 +9787555505891 +9787555505952 +9787555506324 +9787555506591 +9787555506690 +9787555508861 +9787555508885 +9787555509677 +9787555510178 +9787555510543 +9787555511953 +9787555512547 +9787555513094 +9787555513643 +9787555514794 +9787555514978 +9787555515081 +9787555518327 +9787555600022 +9787555600718 +9787555602729 +9787555604723 +9787555606185 +9787555606529 +9787555606734 +9787555606796 +9787555608059 +9787555608851 +9787555609575 +9787555700081 +9787555700432 +9787555700753 +9787555701699 +9787555703396 +9787555706076 +9787555706465 +9787555706694 +9787555706854 +9787555708377 +9787555709411 +9787555709619 +9787555709947 +9787555709954 +9787555710738 +9787555710745 +9787555711384 +9787555711421 +9787555711650 +9787555711841 +9787555712077 +9787555712084 +9787555712213 +9787555712879 +9787555713050 +9787555713173 +9787555713401 +9787555713432 +9787555713500 +9787555713722 +9787555714422 +9787555714446 +9787555714484 +9787555714514 +9787555714521 +9787555714637 +9787555714675 +9787555714699 +9787555714781 +9787555714804 +9787555715047 +9787555715238 +9787555715276 +9787555715290 +9787555715399 +9787555715412 +9787555715924 +9787555716051 +9787555716112 +9787555716129 +9787555716327 +9787555716341 +9787555716754 +9787555716792 +9787555717683 +9787555717980 +9787555718161 +9787555718291 +9787555718345 +9787555718437 +9787555718710 +9787555718758 +9787555718888 +9787555718918 +9787555718987 +9787555719205 +9787555719328 +9787555719342 +9787555719359 +9787555719427 +9787555719489 +9787555719793 +9787555720041 +9787555720171 +9787555720805 +9787555720829 +9787555720843 +9787555720966 +9787555720973 +9787555721154 +9787555721604 +9787555721659 +9787555722052 +9787555722083 +9787555722304 +9787555722397 +9787555722625 +9787555722748 +9787555722892 +9787555723417 +9787555723592 +9787555723998 +9787555726050 +9787555726135 +9787555727262 +9787555727279 +9787555804994 +9787555808343 +9787555808794 +9787555808862 +9787555815099 +9787555900948 +9787555901297 +9787555901440 +9787555903673 +9787555903802 +9787555905745 +9787555907831 +9787555908692 +9787555909101 +9787555909781 +9787555910978 +9787555910985 +9787555912446 +9787555913504 +9787555913511 +9787555913535 +9787555913542 +9787555914181 +9787555914365 +9787555914587 +9787555914815 +9787555914822 +9787555915218 +9787555915621 +9787555915843 +9787555916017 +9787555916314 +9787555916444 +9787555916666 +9787555917168 +9787555917557 +9787555918066 +9787556001569 +9787556001583 +9787556002986 +9787556003655 +9787556004133 +9787556004386 +9787556004447 +9787556004485 +9787556006557 +9787556007400 +9787556007592 +9787556008100 +9787556008452 +9787556008506 +9787556008513 +9787556008520 +9787556008537 +9787556008551 +9787556008568 +9787556009862 +9787556009923 +9787556010035 +9787556010783 +9787556011315 +9787556012077 +9787556012084 +9787556012282 +9787556012558 +9787556012718 +9787556012756 +9787556013647 +9787556013913 +9787556014378 +9787556014965 +9787556015030 +9787556015047 +9787556015054 +9787556015085 +9787556015115 +9787556015382 +9787556015795 +9787556015924 +9787556017188 +9787556017492 +9787556019038 +9787556019045 +9787556019052 +9787556019069 +9787556019076 +9787556019557 +9787556019984 +9787556020010 +9787556020089 +9787556021437 +9787556021956 +9787556023196 +9787556023738 +9787556024544 +9787556025411 +9787556026760 +9787556026975 +9787556027170 +9787556027477 +9787556027484 +9787556027576 +9787556027583 +9787556027880 +9787556028672 +9787556028801 +9787556029747 +9787556031023 +9787556031498 +9787556031672 +9787556034222 +9787556034949 +9787556035533 +9787556036028 +9787556037780 +9787556037827 +9787556038336 +9787556038343 +9787556038350 +9787556038398 +9787556038435 +9787556039630 +9787556040087 +9787556040711 +9787556040841 +9787556041794 +9787556044108 +9787556044320 +9787556046300 +9787556047789 +9787556048137 +9787556048199 +9787556048571 +9787556049288 +9787556049790 +9787556051328 +9787556054350 +9787556054770 +9787556054787 +9787556054794 +9787556055586 +9787556058037 +9787556058044 +9787556060627 +9787556061167 +9787556061174 +9787556061181 +9787556061440 +9787556061976 +9787556062300 +9787556063505 +9787556063512 +9787556063529 +9787556063543 +9787556063550 +9787556063574 +9787556064106 +9787556064670 +9787556067947 +9787556069200 +9787556071401 +9787556072279 +9787556074051 +9787556075683 +9787556077687 +9787556077694 +9787556078592 +9787556079230 +9787556079674 +9787556079681 +9787556079698 +9787556079704 +9787556079711 +9787556079728 +9787556079957 +9787556080175 +9787556081738 +9787556082087 +9787556082902 +9787556083947 +9787556085538 +9787556085569 +9787556085798 +9787556087440 +9787556087723 +9787556089529 +9787556089642 +9787556089666 +9787556089673 +9787556090914 +9787556091973 +9787556092185 +9787556093014 +9787556093830 +9787556094332 +9787556094615 +9787556094691 +9787556094776 +9787556094998 +9787556095254 +9787556095377 +9787556095438 +9787556095933 +9787556096336 +9787556096343 +9787556096541 +9787556100330 +9787556103102 +9787556103683 +9787556104185 +9787556105182 +9787556105199 +9787556105564 +9787556105694 +9787556105960 +9787556106424 +9787556106653 +9787556106660 +9787556109777 +9787556110773 +9787556112111 +9787556113392 +9787556116522 +9787556119004 +9787556119226 +9787556121052 +9787556121892 +9787556122820 +9787556123117 +9787556124909 +9787556124923 +9787556125432 +9787556125449 +9787556125517 +9787556125531 +9787556125708 +9787556126118 +9787556126279 +9787556127108 +9787556128402 +9787556129096 +9787556129195 +9787556129201 +9787556130085 +9787556130634 +9787556130863 +9787556131563 +9787556132096 +9787556132416 +9787556132782 +9787556133017 +9787556133253 +9787556133260 +9787556133352 +9787556133451 +9787556133925 +9787556134021 +9787556134649 +9787556135288 +9787556135394 +9787556135448 +9787556135820 +9787556135974 +9787556136117 +9787556136148 +9787556138128 +9787556202782 +9787556202799 +9787556205882 +9787556206346 +9787556206582 +9787556207039 +9787556207077 +9787556207084 +9787556207107 +9787556207145 +9787556208449 +9787556210046 +9787556210053 +9787556211197 +9787556213030 +9787556213061 +9787556214389 +9787556215256 +9787556217366 +9787556221813 +9787556224241 +9787556224371 +9787556224388 +9787556227358 +9787556228331 +9787556232758 +9787556234165 +9787556235384 +9787556239610 +9787556240821 +9787556240944 +9787556241286 +9787556241309 +9787556242184 +9787556242207 +9787556244140 +9787556244225 +9787556244546 +9787556245284 +9787556247813 +9787556248025 +9787556250523 +9787556251902 +9787556251988 +9787556252725 +9787556253333 +9787556253340 +9787556253609 +9787556254057 +9787556254262 +9787556254675 +9787556256082 +9787556256860 +9787556259373 +9787556261314 +9787556263196 +9787556263417 +9787556264582 +9787556264773 +9787556266128 +9787556267026 +9787556269112 +9787556270392 +9787556270699 +9787556272372 +9787556272716 +9787556273720 +9787556274710 +9787556274826 +9787556275861 +9787556276424 +9787556276608 +9787556276615 +9787556276714 +9787556276875 +9787556277704 +9787556277940 +9787556277988 +9787556278138 +9787556279548 +9787556279555 +9787556279685 +9787556279722 +9787556279852 +9787556281015 +9787556281220 +9787556281237 +9787556282203 +9787556282746 +9787556283590 +9787556283606 +9787556300938 +9787556301287 +9787556301348 +9787556301751 +9787556306916 +9787556307104 +9787556307357 +9787556307432 +9787556307630 +9787556307777 +9787556307876 +9787556308545 +9787556308866 +9787556309184 +9787556309689 +9787556310456 +9787556310821 +9787556400171 +9787556400898 +9787556400904 +9787556400966 +9787556405671 +9787556406531 +9787556407118 +9787556407361 +9787556408498 +9787556410231 +9787556410897 +9787556412198 +9787556415168 +9787556416219 +9787556416530 +9787556416868 +9787556417537 +9787556423248 +9787556423859 +9787556423866 +9787556425693 +9787556428328 +9787556428946 +9787556430932 +9787556432073 +9787556435500 +9787556447060 +9787556450541 +9787556450756 +9787556453023 +9787556454341 +9787556456529 +9787556457649 +9787556457854 +9787556457861 +9787556457991 +9787556463466 +9787556464968 +9787556500505 +9787556500666 +9787556500871 +9787556501991 +9787556502431 +9787556506538 +9787556507412 +9787556508044 +9787556508822 +9787556510689 +9787556511006 +9787556513062 +9787556513871 +9787556514892 +9787556515080 +9787556515158 +9787556515578 +9787556515745 +9787556515974 +9787556515998 +9787556516483 +9787556516964 +9787556517381 +9787556518425 +9787556518432 +9787556520930 +9787556522477 +9787556522965 +9787556523597 +9787556600069 +9787556600373 +9787556600588 +9787556600618 +9787556600625 +9787556600731 +9787556603435 +9787556603473 +9787556603596 +9787556603619 +9787556604104 +9787556604234 +9787556605033 +9787556605101 +9787556605170 +9787556605361 +9787556605880 +9787556605934 +9787556700011 +9787556700097 +9787556700240 +9787556700257 +9787556700356 +9787556700615 +9787556700622 +9787556700899 +9787556701780 +9787556703784 +9787556708505 +9787556708598 +9787556709410 +9787556710201 +9787556711468 +9787556711802 +9787556712854 +9787556800490 +9787556800544 +9787556800988 +9787556801589 +9787556801992 +9787556802005 +9787556802166 +9787556802210 +9787556802340 +9787556802395 +9787556803187 +9787556803569 +9787556804597 +9787556804733 +9787556805051 +9787556805068 +9787556807192 +9787556808717 +9787556808755 +9787556808762 +9787556808809 +9787556809646 +9787556810864 +9787556812370 +9787556813377 +9787556814190 +9787556814671 +9787556815746 +9787556815982 +9787556816675 +9787556817948 +9787556818808 +9787556818822 +9787556818839 +9787556818891 +9787556819256 +9787556819713 +9787556821518 +9787556822829 +9787556822843 +9787556825080 +9787556826476 +9787556829682 +9787556829903 +9787556831982 +9787556832453 +9787556832781 +9787556835539 +9787556836703 +9787556836765 +9787556838516 +9787556839445 +9787556839889 +9787556843749 +9787556844241 +9787556844784 +9787556846443 +9787556846924 +9787556847129 +9787556847297 +9787556847303 +9787556847419 +9787556847440 +9787556847457 +9787556847471 +9787556848362 +9787556848874 +9787556849338 +9787556850396 +9787556851423 +9787556852659 +9787556853533 +9787556854424 +9787556857098 +9787556859542 +9787556860098 +9787556860401 +9787556861354 +9787556861873 +9787556861910 +9787556861927 +9787556861934 +9787556861958 +9787556862078 +9787556862092 +9787556862627 +9787556862818 +9787556862917 +9787556863211 +9787556863235 +9787556864003 +9787556864911 +9787556865031 +9787556865055 +9787556865512 +9787556865536 +9787556865956 +9787556865970 +9787556866007 +9787556868407 +9787556872237 +9787556872640 +9787556872855 +9787556874026 +9787556874781 +9787556874804 +9787556874828 +9787556874835 +9787556874866 +9787556874903 +9787556875382 +9787556876013 +9787556876020 +9787556876211 +9787556876402 +9787556876440 +9787556876457 +9787556877065 +9787556877089 +9787556877348 +9787556877447 +9787556877768 +9787556877812 +9787556877829 +9787556878222 +9787556878291 +9787556878475 +9787556878574 +9787556878598 +9787556878628 +9787556879182 +9787556879397 +9787556879434 +9787556879472 +9787556879595 +9787556879809 +9787556880362 +9787556880508 +9787556880737 +9787556881147 +9787556881154 +9787556882045 +9787556882274 +9787556883035 +9787556883042 +9787556883721 +9787556884001 +9787556884049 +9787556884070 +9787556884100 +9787556884469 +9787556885190 +9787556885886 +9787556886579 +9787556886944 +9787556886975 +9787556887194 +9787556890309 +9787556903146 +9787556905126 +9787556915514 +9787557000868 +9787557004989 +9787557005412 +9787557005481 +9787557005603 +9787557006372 +9787557006464 +9787557006471 +9787557006570 +9787557008017 +9787557008765 +9787557009779 +9787557009854 +9787557010225 +9787557010560 +9787557010577 +9787557010768 +9787557011963 +9787557013721 +9787557015145 +9787557015237 +9787557016586 +9787557017262 +9787557017316 +9787557018313 +9787557018658 +9787557018740 +9787557019990 +9787557020033 +9787557021658 +9787557021665 +9787557021948 +9787557022457 +9787557022525 +9787557022822 +9787557023119 +9787557023447 +9787557024659 +9787557024703 +9787557025151 +9787557025915 +9787557026110 +9787557026868 +9787557026875 +9787557027407 +9787557028527 +9787557028626 +9787557029029 +9787557029432 +9787557029524 +9787557029531 +9787557029715 +9787557029722 +9787557029937 +9787557030148 +9787557030155 +9787557030506 +9787557031480 +9787557031824 +9787557031855 +9787557031985 +9787557032128 +9787557032159 +9787557032678 +9787557032876 +9787557033149 +9787557033262 +9787557033491 +9787557033774 +9787557033989 +9787557034009 +9787557034016 +9787557034221 +9787557034412 +9787557034436 +9787557034559 +9787557034795 +9787557035464 +9787557100254 +9787557201135 +9787557202125 +9787557203221 +9787557204983 +9787557205225 +9787557206048 +9787557206109 +9787557207335 +9787557207878 +9787557208837 +9787557208844 +9787557208905 +9787557208943 +9787557208950 +9787557208967 +9787557208981 +9787557209018 +9787557209810 +9787557210489 +9787557211479 +9787557211721 +9787557211769 +9787557211967 +9787557214142 +9787557214166 +9787557214227 +9787557214678 +9787557304935 +9787557304973 +9787557404611 +9787557405458 +9787557406851 +9787557414221 +9787557415877 +9787557415884 +9787557415891 +9787557416010 +9787557417109 +9787557417796 +9787557417819 +9787557419448 +9787557420376 +9787557421571 +9787557421595 +9787557421618 +9787557421700 +9787557500146 +9787557500191 +9787557500207 +9787557500382 +9787557502164 +9787557502188 +9787557502454 +9787557502553 +9787557502652 +9787557503710 +9787557507794 +9787557509842 +9787557509958 +9787557510107 +9787557510640 +9787557511166 +9787557511197 +9787557511203 +9787557511227 +9787557511241 +9787557511548 +9787557511944 +9787557511951 +9787557512057 +9787557512545 +9787557513306 +9787557515850 +9787557518059 +9787557521424 +9787557521547 +9787557521639 +9787557521646 +9787557522476 +9787557524067 +9787557528232 +9787557528270 +9787557528959 +9787557529222 +9787557529659 +9787557529741 +9787557529819 +9787557529826 +9787557529864 +9787557533502 +9787557533564 +9787557533571 +9787557533588 +9787557533793 +9787557536305 +9787557536664 +9787557536671 +9787557536695 +9787557537883 +9787557538859 +9787557540425 +9787557540852 +9787557540890 +9787557541866 +9787557542511 +9787557544232 +9787557545611 +9787557545659 +9787557545673 +9787557548193 +9787557550448 +9787557550820 +9787557552961 +9787557555269 +9787557555450 +9787557556747 +9787557557324 +9787557561123 +9787557563165 +9787557564186 +9787557564209 +9787557564735 +9787557565237 +9787557565244 +9787557568368 +9787557569990 +9787557570033 +9787557571474 +9787557572006 +9787557575069 +9787557575076 +9787557575182 +9787557575199 +9787557576813 +9787557578107 +9787557579036 +9787557579098 +9787557579104 +9787557581596 +9787557584597 +9787557589868 +9787557592745 +9787557608248 +9787557609122 +9787557613358 +9787557615895 +9787557617059 +9787557617202 +9787557619084 +9787557621728 +9787557622152 +9787557626075 +9787557626631 +9787557629410 +9787557630348 +9787557630546 +9787557632410 +9787557633424 +9787557634346 +9787557638535 +9787557646851 +9787557647452 +9787557654832 +9787557655334 +9787557657338 +9787557659301 +9787557660758 +9787557660765 +9787557660772 +9787557660802 +9787557660826 +9787557663827 +9787557666163 +9787557666200 +9787557666217 +9787557668211 +9787557674823 +9787557675318 +9787557677343 +9787557678685 +9787557683290 +9787557683979 +9787557685508 +9787557686758 +9787557687656 +9787557689254 +9787557691486 +9787557691721 +9787557692728 +9787557693121 +9787557694579 +9787557695309 +9787557695484 +9787557698423 +9787557698645 +9787557699390 +9787557699406 +9787557700065 +9787557701574 +9787557702281 +9787557702502 +9787557702526 +9787557703233 +9787557704698 +9787557706623 +9787557708276 +9787557709679 +9787557710736 +9787557806897 +9787557815417 +9787557817992 +9787557818081 +9787557850555 +9787557875671 +9787557878900 +9787557879396 +9787557881757 +9787557890025 +9787557891794 +9787557893071 +9787557893699 +9787557901172 +9787557902063 +9787557905323 +9787557905330 +9787557906054 +9787557911454 +9787557911560 +9787557912574 +9787557913724 +9787557914745 +9787557915773 +9787558002922 +9787558002953 +9787558004773 +9787558005930 +9787558008719 +9787558009280 +9787558010118 +9787558010910 +9787558013171 +9787558016073 +9787558017841 +9787558020285 +9787558021060 +9787558025389 +9787558027468 +9787558027505 +9787558027512 +9787558027949 +9787558027956 +9787558028717 +9787558029622 +9787558030727 +9787558030741 +9787558032370 +9787558036521 +9787558038365 +9787558039430 +9787558039447 +9787558040863 +9787558042317 +9787558043024 +9787558043505 +9787558043956 +9787558043963 +9787558043987 +9787558043994 +9787558044007 +9787558045493 +9787558046544 +9787558048333 +9787558050916 +9787558051319 +9787558051326 +9787558052170 +9787558052187 +9787558054709 +9787558055669 +9787558056994 +9787558058004 +9787558059636 +9787558059988 +9787558060014 +9787558061028 +9787558062889 +9787558063497 +9787558064852 +9787558065521 +9787558068119 +9787558069468 +9787558070389 +9787558072505 +9787558076626 +9787558076640 +9787558077159 +9787558079283 +9787558079801 +9787558079825 +9787558079832 +9787558079849 +9787558088094 +9787558090936 +9787558092350 +9787558092626 +9787558093593 +9787558093975 +9787558095801 +9787558099687 +9787558102882 +9787558107573 +9787558107740 +9787558108419 +9787558108563 +9787558111112 +9787558112157 +9787558115943 +9787558116490 +9787558118593 +9787558119088 +9787558119118 +9787558119927 +9787558122651 +9787558123245 +9787558124648 +9787558124655 +9787558124662 +9787558125270 +9787558125461 +9787558127168 +9787558128950 +9787558129148 +9787558130731 +9787558130748 +9787558131608 +9787558131707 +9787558135293 +9787558137396 +9787558137730 +9787558137945 +9787558139581 +9787558141126 +9787558142246 +9787558143199 +9787558146060 +9787558146978 +9787558148606 +9787558149887 +9787558151668 +9787558155444 +9787558155468 +9787558155475 +9787558156915 +9787558156984 +9787558158650 +9787558159312 +9787558160042 +9787558161551 +9787558161841 +9787558173479 +9787558173486 +9787558173493 +9787558173509 +9787558173516 +9787558176043 +9787558179600 +9787558183720 +9787558184246 +9787558187698 +9787558187926 +9787558188992 +9787558190070 +9787558191541 +9787558192883 +9787558192913 +9787558193170 +9787558194610 +9787558194726 +9787558195778 +9787558195945 +9787558195990 +9787558196010 +9787558196034 +9787558197062 +9787558197307 +9787558198281 +9787558198496 +9787558198526 +9787558198533 +9787558198601 +9787558199394 +9787558199592 +9787558199646 +9787558202919 +9787558203121 +9787558203138 +9787558205170 +9787558205347 +9787558208911 +9787558209512 +9787558211393 +9787558211911 +9787558211935 +9787558211997 +9787558215902 +9787558218613 +9787558218750 +9787558219689 +9787558219696 +9787558221873 +9787558222009 +9787558222016 +9787558222023 +9787558227219 +9787558227226 +9787558228186 +9787558228193 +9787558229046 +9787558229053 +9787558229275 +9787558229282 +9787558229305 +9787558231247 +9787558231520 +9787558233388 +9787558237522 +9787558238024 +9787558238031 +9787558238048 +9787558238055 +9787558238550 +9787558239700 +9787558239717 +9787558240058 +9787558240898 +9787558241154 +9787558241550 +9787558245152 +9787558245329 +9787558246159 +9787558246180 +9787558246227 +9787558247279 +9787558247323 +9787558248238 +9787558253270 +9787558257056 +9787558260292 +9787558261336 +9787558263842 +9787558263859 +9787558263866 +9787558266331 +9787558268427 +9787558269028 +9787558300080 +9787558301483 +9787558304262 +9787558304576 +9787558307669 +9787558310041 +9787558315220 +9787558315510 +9787558315534 +9787558317668 +9787558321191 +9787558324376 +9787558324802 +9787558324819 +9787558324826 +9787558325977 +9787558328596 +9787558328671 +9787558329210 +9787558329746 +9787558332784 +9787558332838 +9787558334696 +9787558334900 +9787558334955 +9787558335198 +9787558335716 +9787558335891 +9787558336324 +9787558337154 +9787558337406 +9787558338250 +9787558338298 +9787558338311 +9787558338434 +9787558338540 +9787558339035 +9787558340017 +9787558340123 +9787558340284 +9787558340321 +9787558341267 +9787558342387 +9787558342400 +9787558342417 +9787558343131 +9787558343148 +9787558343179 +9787558343186 +9787558343308 +9787558343346 +9787558343575 +9787558344220 +9787558344251 +9787558344978 +9787558345876 +9787558345913 +9787558347337 +9787558401923 +9787558403132 +9787558405372 +9787558408403 +9787558409158 +9787558409851 +9787558410765 +9787558412110 +9787558415937 +9787558417887 +9787558419058 +9787558420726 +9787558421631 +9787558421877 +9787558423758 +9787558424700 +9787558424731 +9787558424915 +9787558425325 +9787558425332 +9787558426803 +9787558427480 +9787558427671 +9787558428135 +9787558429064 +9787558429941 +9787558429958 +9787558430824 +9787558431067 +9787558431074 +9787558431159 +9787558431173 +9787558435720 +9787558509704 +9787558509711 +9787558512056 +9787558512469 +9787558512643 +9787558513329 +9787558514159 +9787558514203 +9787558514289 +9787558514302 +9787558514388 +9787558514531 +9787558515873 +9787558522758 +9787558523687 +9787558525902 +9787558528019 +9787558528033 +9787558528552 +9787558530609 +9787558530838 +9787558532856 +9787558537448 +9787558541223 +9787558547584 +9787558548932 +9787558549205 +9787558550218 +9787558550744 +9787558552113 +9787558552359 +9787558552731 +9787558552977 +9787558553028 +9787558553233 +9787558553257 +9787558553400 +9787558554018 +9787558554032 +9787558554629 +9787558555244 +9787558556340 +9787558556647 +9787558557538 +9787558558979 +9787558559068 +9787558559372 +9787558559457 +9787558561283 +9787558561306 +9787558563515 +9787558567766 +9787558567803 +9787558568275 +9787558572579 +9787558572821 +9787558573606 +9787558573767 +9787558574610 +9787558574641 +9787558575075 +9787558575372 +9787558575426 +9787558576034 +9787558577116 +9787558579394 +9787558579516 +9787558579905 +9787558580246 +9787558582868 +9787558583117 +9787558583155 +9787558583377 +9787558583896 +9787558584015 +9787558584039 +9787558584046 +9787558584183 +9787558584428 +9787558584817 +9787558585012 +9787558585593 +9787558585951 +9787558586033 +9787558586057 +9787558586064 +9787558586217 +9787558586989 +9787558587207 +9787558587733 +9787558588426 +9787558588754 +9787558588853 +9787558590573 +9787558590672 +9787558591860 +9787558593161 +9787558593697 +9787558593703 +9787558594069 +9787558594601 +9787558595295 +9787558596476 +9787558596629 +9787558600241 +9787558601026 +9787558601590 +9787558602290 +9787558603273 +9787558603846 +9787558604171 +9787558604294 +9787558604584 +9787558604799 +9787558606663 +9787558607875 +9787558608216 +9787558610615 +9787558610783 +9787558611957 +9787558612244 +9787558612305 +9787558612725 +9787558613357 +9787558613449 +9787558613616 +9787558614767 +9787558614972 +9787558616037 +9787558616624 +9787558617102 +9787558617546 +9787558617577 +9787558617751 +9787558617874 +9787558618277 +9787558618413 +9787558619366 +9787558619779 +9787558620065 +9787558623851 +9787558624759 +9787558626050 +9787558626395 +9787558626593 +9787558626647 +9787558626661 +9787558627200 +9787558627781 +9787558627897 +9787558628030 +9787558628474 +9787558629044 +9787558629051 +9787558629129 +9787558629594 +9787558629693 +9787558629785 +9787558630224 +9787558630231 +9787558630248 +9787558630422 +9787558630477 +9787558631511 +9787558631542 +9787558709913 +9787558711862 +9787558711893 +9787558713644 +9787558716041 +9787558716065 +9787558716126 +9787558719431 +9787558720475 +9787558720857 +9787558723261 +9787558726415 +9787558727603 +9787558728792 +9787558730023 +9787558730139 +9787558730153 +9787558731273 +9787558733154 +9787558735042 +9787558735646 +9787558737114 +9787558738036 +9787558738203 +9787558738753 +9787558743351 +9787558748585 +9787558749544 +9787558750502 +9787558756771 +9787558757389 +9787558758102 +9787558759277 +9787558759369 +9787558759772 +9787558760181 +9787558760198 +9787558760280 +9787558760297 +9787558760426 +9787558761690 +9787558761898 +9787558762901 +9787558762987 +9787558800030 +9787558802577 +9787558900020 +9787558901157 +9787558901171 +9787558901744 +9787558901966 +9787558901997 +9787558902802 +9787558902819 +9787558903236 +9787558903267 +9787558903380 +9787558904790 +9787558904929 +9787558905070 +9787558905490 +9787558906756 +9787558906862 +9787558906947 +9787558907876 +9787558907920 +9787558908576 +9787558908620 +9787558908644 +9787558909160 +9787558909443 +9787558909832 +9787558911279 +9787558911293 +9787558911743 +9787558911750 +9787558912658 +9787558913297 +9787558913808 +9787558913853 +9787558913860 +9787558914218 +9787558916137 +9787558916335 +9787558916410 +9787558916588 +9787558917646 +9787558917677 +9787558918407 +9787558918674 +9787558918742 +9787558919305 +9787559014610 +9787559016003 +9787559018762 +9787559026521 +9787559027023 +9787559028358 +9787559035318 +9787559035349 +9787559043504 +9787559048721 +9787559052896 +9787559054784 +9787559054838 +9787559058478 +9787559059758 +9787559062246 +9787559062277 +9787559064950 +9787559066701 +9787559070371 +9787559072191 +9787559076007 +9787559078995 +9787559079190 +9787559079572 +9787559080301 +9787559086129 +9787559086273 +9787559086327 +9787559086464 +9787559086884 +9787559089175 +9787559090928 +9787559094452 +9787559094483 +9787559094490 +9787559094551 +9787559094681 +9787559095022 +9787559095039 +9787559095046 +9787559095053 +9787559095077 +9787559095183 +9787559095411 +9787559096685 +9787559096807 +9787559097538 +9787559098849 +9787559100115 +9787559104311 +9787559106155 +9787559107039 +9787559109583 +9787559110282 +9787559110749 +9787559112514 +9787559113139 +9787559113603 +9787559114075 +9787559114426 +9787559115898 +9787559118448 +9787559119438 +9787559120083 +9787559124869 +9787559130662 +9787559130686 +9787559132628 +9787559134004 +9787559135216 +9787559135919 +9787559137128 +9787559139290 +9787559139764 +9787559140753 +9787559201799 +9787559203076 +9787559205933 +9787559300409 +9787559300867 +9787559302090 +9787559303431 +9787559305077 +9787559305848 +9787559306333 +9787559306937 +9787559306951 +9787559308894 +9787559308900 +9787559309570 +9787559309884 +9787559309945 +9787559311450 +9787559312129 +9787559312662 +9787559313553 +9787559314710 +9787559314932 +9787559315151 +9787559316271 +9787559316417 +9787559316714 +9787559318664 +9787559320322 +9787559324993 +9787559325525 +9787559325532 +9787559326492 +9787559326942 +9787559328083 +9787559328144 +9787559330062 +9787559332455 +9787559333032 +9787559334558 +9787559335159 +9787559335173 +9787559336194 +9787559337573 +9787559339232 +9787559339966 +9787559340061 +9787559341242 +9787559342317 +9787559343581 +9787559344199 +9787559344878 +9787559344892 +9787559345233 +9787559345240 +9787559345776 +9787559348739 +9787559349637 +9787559351531 +9787559351753 +9787559352972 +9787559354433 +9787559355522 +9787559355744 +9787559355799 +9787559355911 +9787559356918 +9787559358431 +9787559358646 +9787559358721 +9787559358745 +9787559359254 +9787559359278 +9787559359315 +9787559360069 +9787559360427 +9787559360779 +9787559361493 +9787559362018 +9787559362445 +9787559362476 +9787559362506 +9787559362599 +9787559363459 +9787559365132 +9787559365422 +9787559365453 +9787559365507 +9787559367648 +9787559369918 +9787559369949 +9787559370198 +9787559372048 +9787559372079 +9787559372123 +9787559372758 +9787559372826 +9787559372925 +9787559372932 +9787559372987 +9787559373199 +9787559373335 +9787559373397 +9787559373403 +9787559373595 +9787559373656 +9787559373984 +9787559375254 +9787559375643 +9787559375803 +9787559377043 +9787559377630 +9787559380142 +9787559381538 +9787559382443 +9787559382863 +9787559382900 +9787559382917 +9787559382924 +9787559382931 +9787559382955 +9787559382993 +9787559383099 +9787559383105 +9787559383198 +9787559383235 +9787559383617 +9787559383662 +9787559383693 +9787559383716 +9787559383860 +9787559385383 +9787559388421 +9787559388803 +9787559388902 +9787559391261 +9787559391933 +9787559392107 +9787559392442 +9787559392466 +9787559392510 +9787559392664 +9787559392855 +9787559393104 +9787559393531 +9787559395528 +9787559395832 +9787559396587 +9787559396617 +9787559398789 +9787559399809 +9787559400369 +9787559400512 +9787559402325 +9787559402332 +9787559403360 +9787559403391 +9787559403773 +9787559403919 +9787559404510 +9787559405678 +9787559406545 +9787559408174 +9787559409324 +9787559409362 +9787559410214 +9787559411013 +9787559411051 +9787559411402 +9787559412751 +9787559413574 +9787559415400 +9787559417251 +9787559418272 +9787559419231 +9787559421296 +9787559421388 +9787559423825 +9787559424426 +9787559424563 +9787559429957 +9787559430588 +9787559431028 +9787559431257 +9787559431400 +9787559431455 +9787559432322 +9787559433411 +9787559433541 +9787559435781 +9787559436061 +9787559436962 +9787559437242 +9787559438751 +9787559439444 +9787559440259 +9787559440464 +9787559441591 +9787559443526 +9787559443762 +9787559444257 +9787559444523 +9787559444943 +9787559446022 +9787559447340 +9787559448125 +9787559448149 +9787559448385 +9787559448460 +9787559448590 +9787559449023 +9787559449092 +9787559452573 +9787559453501 +9787559455147 +9787559456007 +9787559457042 +9787559457332 +9787559457394 +9787559457912 +9787559458834 +9787559459220 +9787559459855 +9787559460226 +9787559460233 +9787559460240 +9787559460332 +9787559462596 +9787559463203 +9787559463678 +9787559464279 +9787559464392 +9787559466556 +9787559466723 +9787559466754 +9787559466914 +9787559466938 +9787559466945 +9787559466952 +9787559466976 +9787559467232 +9787559467737 +9787559467744 +9787559468291 +9787559468642 +9787559469571 +9787559470065 +9787559470423 +9787559470737 +9787559470751 +9787559470942 +9787559471246 +9787559472663 +9787559472700 +9787559472908 +9787559473226 +9787559473486 +9787559473776 +9787559473806 +9787559473875 +9787559474094 +9787559474247 +9787559474384 +9787559474421 +9787559474933 +9787559475060 +9787559475114 +9787559475138 +9787559475527 +9787559475893 +9787559476050 +9787559476319 +9787559476500 +9787559476906 +9787559476944 +9787559476968 +9787559476975 +9787559477040 +9787559477101 +9787559477118 +9787559477194 +9787559477743 +9787559477804 +9787559477835 +9787559477989 +9787559478146 +9787559478252 +9787559478290 +9787559478528 +9787559478931 +9787559479150 +9787559479280 +9787559479365 +9787559479464 +9787559479495 +9787559479686 +9787559479723 +9787559479747 +9787559479891 +9787559479990 +9787559480293 +9787559480323 +9787559480354 +9787559480453 +9787559480576 +9787559480897 +9787559480927 +9787559480965 +9787559480972 +9787559480989 +9787559481009 +9787559481016 +9787559481085 +9787559481108 +9787559481443 +9787559481702 +9787559481979 +9787559482020 +9787559482105 +9787559482129 +9787559482310 +9787559482488 +9787559482525 +9787559482945 +9787559484079 +9787559484123 +9787559484451 +9787559484567 +9787559484598 +9787559484888 +9787559484925 +9787559484932 +9787559484987 +9787559485243 +9787559485274 +9787559485281 +9787559485380 +9787559485526 +9787559485656 +9787559485731 +9787559485748 +9787559485755 +9787559486134 +9787559486165 +9787559486509 +9787559486592 +9787559486790 +9787559486813 +9787559487025 +9787559487056 +9787559487193 +9787559487339 +9787559487360 +9787559487384 +9787559487445 +9787559487452 +9787559487490 +9787559487667 +9787559487681 +9787559487711 +9787559488138 +9787559488237 +9787559488381 +9787559488428 +9787559488435 +9787559488442 +9787559488480 +9787559488572 +9787559488626 +9787559488657 +9787559488763 +9787559488831 +9787559488879 +9787559488916 +9787559488961 +9787559489029 +9787559489036 +9787559489067 +9787559489180 +9787559489203 +9787559489258 +9787559489302 +9787559489357 +9787559489470 +9787559489494 +9787559489517 +9787559489593 +9787559489685 +9787559489692 +9787559489876 +9787559489906 +9787559489951 +9787559489999 +9787559490193 +9787559490346 +9787559490414 +9787559490568 +9787559490575 +9787559490674 +9787559490681 +9787559490742 +9787559490940 +9787559490995 +9787559491510 +9787559491664 +9787559491671 +9787559491923 +9787559491930 +9787559492081 +9787559492326 +9787559492333 +9787559492340 +9787559492425 +9787559492517 +9787559492586 +9787559493002 +9787559493170 +9787559493354 +9787559493385 +9787559493521 +9787559493767 +9787559493965 +9787559494030 +9787559494405 +9787559494412 +9787559494849 +9787559495051 +9787559495679 +9787559495853 +9787559497024 +9787559497192 +9787559497536 +9787559498199 +9787559498519 +9787559499455 +9787559500403 +9787559505798 +9787559506047 +9787559506580 +9787559506634 +9787559509826 +9787559514660 +9787559514707 +9787559514714 +9787559514721 +9787559516831 +9787559517012 +9787559517142 +9787559517180 +9787559517197 +9787559521101 +9787559523761 +9787559528490 +9787559531162 +9787559531179 +9787559533708 +9787559533746 +9787559533807 +9787559533982 +9787559534002 +9787559535276 +9787559536181 +9787559540317 +9787559540515 +9787559541567 +9787559541666 +9787559541970 +9787559546098 +9787559548801 +9787559549228 +9787559553294 +9787559554642 +9787559554925 +9787559557247 +9787559563194 +9787559563231 +9787559564078 +9787559566058 +9787559567864 +9787559601513 +9787559601537 +9787559601568 +9787559601599 +9787559601612 +9787559601629 +9787559601636 +9787559601643 +9787559603630 +9787559604460 +9787559607348 +9787559607942 +9787559608529 +9787559611857 +9787559612632 +9787559616197 +9787559621887 +9787559622129 +9787559624840 +9787559625106 +9787559625243 +9787559627025 +9787559627438 +9787559630414 +9787559631404 +9787559633859 +9787559635990 +9787559636003 +9787559636294 +9787559636690 +9787559637000 +9787559638212 +9787559638373 +9787559638731 +9787559639738 +9787559639752 +9787559640727 +9787559640734 +9787559641182 +9787559642714 +9787559642943 +9787559642967 +9787559643933 +9787559644275 +9787559644916 +9787559648310 +9787559648891 +9787559652249 +9787559653093 +9787559654496 +9787559655257 +9787559655585 +9787559655806 +9787559655899 +9787559657954 +9787559658555 +9787559660152 +9787559660183 +9787559660336 +9787559661777 +9787559661883 +9787559662156 +9787559662415 +9787559664150 +9787559664624 +9787559664679 +9787559664686 +9787559665850 +9787559665874 +9787559666574 +9787559667458 +9787559667465 +9787559667533 +9787559667595 +9787559667847 +9787559667892 +9787559668042 +9787559668295 +9787559668738 +9787559669001 +9787559669384 +9787559669735 +9787559669834 +9787559670120 +9787559670366 +9787559670540 +9787559670625 +9787559671165 +9787559671202 +9787559671417 +9787559671530 +9787559671721 +9787559671950 +9787559672230 +9787559672339 +9787559672452 +9787559672520 +9787559672537 +9787559672544 +9787559672643 +9787559672698 +9787559672759 +9787559672841 +9787559672889 +9787559673084 +9787559673190 +9787559673558 +9787559673565 +9787559673732 +9787559673848 +9787559674142 +9787559674159 +9787559674319 +9787559674388 +9787559674418 +9787559674746 +9787559674845 +9787559675019 +9787559675033 +9787559675064 +9787559675095 +9787559675132 +9787559675156 +9787559675170 +9787559675224 +9787559675286 +9787559675354 +9787559675361 +9787559675477 +9787559675637 +9787559675934 +9787559675965 +9787559676153 +9787559676443 +9787559676474 +9787559676566 +9787559676580 +9787559676641 +9787559676665 +9787559676825 +9787559676856 +9787559676894 +9787559677075 +9787559677136 +9787559677280 +9787559677303 +9787559677419 +9787559677433 +9787559677525 +9787559677570 +9787559677730 +9787559677754 +9787559678386 +9787559678393 +9787559678416 +9787559678454 +9787559678584 +9787559678645 +9787559678683 +9787559678713 +9787559678911 +9787559679369 +9787559679437 +9787559679505 +9787559679598 +9787559679604 +9787559679659 +9787559679666 +9787559679680 +9787559679697 +9787559679703 +9787559679727 +9787559679741 +9787559679758 +9787559679765 +9787559679772 +9787559679796 +9787559679871 +9787559679925 +9787559680167 +9787559680198 +9787559680235 +9787559680280 +9787559680341 +9787559680471 +9787559680525 +9787559680648 +9787559680662 +9787559680693 +9787559680723 +9787559680778 +9787559680839 +9787559680952 +9787559680983 +9787559680990 +9787559681058 +9787559681096 +9787559681133 +9787559681201 +9787559681225 +9787559681287 +9787559681416 +9787559681560 +9787559681584 +9787559681591 +9787559681720 +9787559681805 +9787559681850 +9787559681966 +9787559682017 +9787559682031 +9787559682208 +9787559682291 +9787559682321 +9787559682444 +9787559682451 +9787559682550 +9787559682611 +9787559682628 +9787559682796 +9787559682819 +9787559682932 +9787559682987 +9787559683007 +9787559683021 +9787559683137 +9787559683243 +9787559683427 +9787559683540 +9787559683557 +9787559683793 +9787559683861 +9787559683915 +9787559683960 +9787559684004 +9787559684011 +9787559684028 +9787559684127 +9787559684172 +9787559684202 +9787559684240 +9787559684325 +9787559684400 +9787559684462 +9787559684639 +9787559684646 +9787559700056 +9787559700070 +9787559700124 +9787559700445 +9787559700452 +9787559700506 +9787559700520 +9787559701152 +9787559702159 +9787559702982 +9787559703712 +9787559703781 +9787559704313 +9787559704566 +9787559704610 +9787559704627 +9787559705280 +9787559705303 +9787559706607 +9787559707611 +9787559707925 +9787559708793 +9787559708816 +9787559709738 +9787559709851 +9787559710642 +9787559711137 +9787559711281 +9787559711335 +9787559712592 +9787559712608 +9787559712639 +9787559712691 +9787559712738 +9787559713377 +9787559713902 +9787559714084 +9787559714176 +9787559715722 +9787559716026 +9787559716187 +9787559716927 +9787559717993 +9787559718112 +9787559718426 +9787559718433 +9787559718778 +9787559718884 +9787559718891 +9787559718983 +9787559719713 +9787559720610 +9787559720818 +9787559720924 +9787559721068 +9787559721181 +9787559721426 +9787559723031 +9787559723789 +9787559724939 +9787559724977 +9787559726001 +9787559726032 +9787559726230 +9787559726841 +9787559727411 +9787559727497 +9787559728166 +9787559728319 +9787559728920 +9787559728982 +9787559729248 +9787559729637 +9787559729644 +9787559729651 +9787559729668 +9787559730060 +9787559730923 +9787559731135 +9787559731555 +9787559731906 +9787559732071 +9787559732101 +9787559734006 +9787559736260 +9787559736574 +9787559736673 +9787559736918 +9787559737915 +9787559738493 +9787559738530 +9787559738936 +9787559740229 +9787559740243 +9787559740878 +9787559740892 +9787559741592 +9787559741622 +9787559742087 +9787559742100 +9787559800749 +9787559801166 +9787559809339 +9787559809704 +9787559810915 +9787559815972 +9787559815989 +9787559815996 +9787559816009 +9787559816016 +9787559818249 +9787559818393 +9787559818874 +9787559819291 +9787559826091 +9787559826107 +9787559829139 +9787559829207 +9787559830128 +9787559830654 +9787559832955 +9787559833006 +9787559833891 +9787559835031 +9787559835093 +9787559835772 +9787559838216 +9787559838377 +9787559838483 +9787559838834 +9787559839565 +9787559840851 +9787559841407 +9787559841551 +9787559841667 +9787559842893 +9787559843852 +9787559844170 +9787559844286 +9787559848079 +9787559849618 +9787559849632 +9787559849649 +9787559849656 +9787559850164 +9787559852359 +9787559852434 +9787559853325 +9787559855442 +9787559855527 +9787559856371 +9787559857491 +9787559857897 +9787559858177 +9787559859358 +9787559859822 +9787559860019 +9787559860774 +9787559860866 +9787559860873 +9787559861238 +9787559862358 +9787559862808 +9787559863171 +9787559863546 +9787559863652 +9787559864123 +9787559865090 +9787559865106 +9787559865427 +9787559865458 +9787559865656 +9787559865830 +9787559866172 +9787559867193 +9787559867230 +9787559867254 +9787559867322 +9787559867339 +9787559867353 +9787559867933 +9787559868398 +9787559868480 +9787559868558 +9787559868985 +9787559869104 +9787559869227 +9787559869371 +9787559870025 +9787559870292 +9787559870605 +9787559870957 +9787559871251 +9787559871411 +9787559871695 +9787559872081 +9787559872180 +9787559872289 +9787559872364 +9787559872418 +9787559872913 +9787559873125 +9787559873163 +9787559873323 +9787559873330 +9787559873361 +9787559873521 +9787559873750 +9787559873774 +9787559873866 +9787559873880 +9787559873897 +9787559873910 +9787559873927 +9787559873934 +9787559874016 +9787559874115 +9787559874191 +9787559874221 +9787559874283 +9787559874382 +9787559874443 +9787559874467 +9787559874597 +9787559874603 +9787559874733 +9787559874757 +9787559874931 +9787559874955 +9787559874979 +9787559875013 +9787559875020 +9787559875068 +9787559875303 +9787559875341 +9787559875358 +9787559875570 +9787559875662 +9787559875747 +9787559875754 +9787559875853 +9787559876416 +9787559876690 +9787559876874 +9787559876980 +9787559877055 +9787559877314 +9787559877321 +9787559877352 +9787559877666 +9787559877956 +9787559878540 +9787559879103 +9787559879110 +9787559879134 +9787559879172 +9787559879363 +9787559879530 +9787559879653 +9787559879714 +9787559879776 +9787559879783 +9787559879929 +9787559879967 +9787559879981 +9787559880017 +9787559880093 +9787559880116 +9787559881359 +9787559881885 +9787559881977 +9787559882134 +9787559884893 +9787559900005 +9787559901521 +9787559906151 +9787559908360 +9787559909428 +9787559909473 +9787559909503 +9787559909718 +9787559925589 +9787559927392 +9787559927668 +9787559931870 +9787560000374 +9787560001296 +9787560001340 +9787560001616 +9787560001685 +9787560001845 +9787560001876 +9787560001906 +9787560001951 +9787560002095 +9787560002217 +9787560002453 +9787560002613 +9787560002811 +9787560002910 +9787560003290 +9787560003344 +9787560003498 +9787560003573 +9787560004877 +9787560005027 +9787560005447 +9787560005591 +9787560005829 +9787560005874 +9787560005928 +9787560006048 +9787560006123 +9787560006147 +9787560006352 +9787560007106 +9787560007120 +9787560007229 +9787560007298 +9787560007595 +9787560007632 +9787560007656 +9787560007670 +9787560007687 +9787560007762 +9787560007861 +9787560007878 +9787560007939 +9787560008301 +9787560008363 +9787560008424 +9787560008448 +9787560008455 +9787560008462 +9787560008561 +9787560008608 +9787560008615 +9787560008622 +9787560008660 +9787560008783 +9787560008974 +9787560008981 +9787560009001 +9787560009018 +9787560009025 +9787560009056 +9787560009063 +9787560009087 +9787560009100 +9787560009117 +9787560009124 +9787560009773 +9787560009780 +9787560009797 +9787560009810 +9787560009834 +9787560009865 +9787560010038 +9787560010113 +9787560010243 +9787560010328 +9787560010335 +9787560010397 +9787560010571 +9787560010687 +9787560011301 +9787560011530 +9787560012018 +9787560012063 +9787560012100 +9787560012155 +9787560012933 +9787560013626 +9787560013640 +9787560013732 +9787560014210 +9787560014241 +9787560015019 +9787560015774 +9787560016108 +9787560016290 +9787560016566 +9787560016627 +9787560016771 +9787560016818 +9787560016993 +9787560017433 +9787560017464 +9787560017570 +9787560018232 +9787560018348 +9787560019611 +9787560020075 +9787560020891 +9787560021621 +9787560021744 +9787560022727 +9787560025124 +9787560025193 +9787560027753 +9787560028477 +9787560028743 +9787560029962 +9787560030333 +9787560030784 +9787560032603 +9787560033983 +9787560035406 +9787560035871 +9787560036663 +9787560037141 +9787560039145 +9787560039664 +9787560040721 +9787560042039 +9787560043708 +9787560043999 +9787560047980 +9787560049014 +9787560052700 +9787560052939 +9787560053110 +9787560054254 +9787560054896 +9787560055046 +9787560056227 +9787560056784 +9787560056791 +9787560057422 +9787560059730 +9787560061559 +9787560066073 +9787560066189 +9787560067056 +9787560067100 +9787560067896 +9787560069173 +9787560069944 +9787560071534 +9787560072845 +9787560072999 +9787560076188 +9787560078410 +9787560079387 +9787560079752 +9787560081380 +9787560081588 +9787560081625 +9787560082271 +9787560082882 +9787560083186 +9787560083377 +9787560083414 +9787560084336 +9787560085524 +9787560085548 +9787560086125 +9787560086552 +9787560086699 +9787560087092 +9787560087917 +9787560089157 +9787560092607 +9787560095929 +9787560095943 +9787560098081 +9787560098531 +9787560098661 +9787560098746 +9787560100050 +9787560100098 +9787560100258 +9787560100760 +9787560100968 +9787560101149 +9787560101262 +9787560102580 +9787560103327 +9787560103549 +9787560105253 +9787560105611 +9787560105628 +9787560105888 +9787560105949 +9787560106472 +9787560106939 +9787560107974 +9787560109275 +9787560109435 +9787560111384 +9787560113326 +9787560113517 +9787560113692 +9787560114446 +9787560116334 +9787560116426 +9787560116662 +9787560117591 +9787560117713 +9787560118291 +9787560118710 +9787560119496 +9787560119755 +9787560120072 +9787560121277 +9787560121482 +9787560121673 +9787560121840 +9787560122656 +9787560122991 +9787560123011 +9787560123516 +9787560124728 +9787560125305 +9787560125695 +9787560126074 +9787560126432 +9787560128122 +9787560128467 +9787560128504 +9787560128580 +9787560128696 +9787560128832 +9787560128849 +9787560129167 +9787560132020 +9787560133195 +9787560133201 +9787560133324 +9787560140537 +9787560141473 +9787560141558 +9787560142784 +9787560143538 +9787560146324 +9787560148397 +9787560148427 +9787560149912 +9787560150772 +9787560151083 +9787560152851 +9787560154022 +9787560154619 +9787560156583 +9787560156774 +9787560157368 +9787560158839 +9787560163956 +9787560166964 +9787560167893 +9787560171722 +9787560171746 +9787560172200 +9787560175720 +9787560176451 +9787560181295 +9787560187259 +9787560187426 +9787560189659 +9787560191577 +9787560193472 +9787560193519 +9787560194516 +9787560194523 +9787560194547 +9787560195162 +9787560195605 +9787560201177 +9787560201498 +9787560201757 +9787560202471 +9787560203119 +9787560204192 +9787560204451 +9787560204611 +9787560205090 +9787560205526 +9787560205571 +9787560209746 +9787560210070 +9787560210919 +9787560211213 +9787560212630 +9787560217284 +9787560217796 +9787560218403 +9787560219653 +9787560219806 +9787560221014 +9787560221243 +9787560221281 +9787560221298 +9787560222912 +9787560223285 +9787560223322 +9787560223353 +9787560223360 +9787560223735 +9787560223742 +9787560223766 +9787560224831 +9787560225104 +9787560226910 +9787560227276 +9787560227719 +9787560227726 +9787560227757 +9787560227764 +9787560227818 +9787560227832 +9787560229720 +9787560231839 +9787560237923 +9787560243191 +9787560243580 +9787560243795 +9787560245157 +9787560245539 +9787560246543 +9787560248103 +9787560255002 +9787560256214 +9787560257068 +9787560257846 +9787560258164 +9787560259499 +9787560260358 +9787560262772 +9787560268460 +9787560269481 +9787560269498 +9787560269511 +9787560270081 +9787560270531 +9787560274546 +9787560274935 +9787560275314 +9787560277738 +9787560277813 +9787560278339 +9787560279121 +9787560279176 +9787560280011 +9787560280387 +9787560281674 +9787560282930 +9787560283395 +9787560284170 +9787560287058 +9787560287065 +9787560288093 +9787560288628 +9787560289489 +9787560290348 +9787560290669 +9787560293707 +9787560295312 +9787560296715 +9787560297026 +9787560297040 +9787560300092 +9787560302164 +9787560302362 +9787560312200 +9787560314983 +9787560315164 +9787560315317 +9787560315959 +9787560318134 +9787560318219 +9787560318424 +9787560319735 +9787560320250 +9787560326245 +9787560333441 +9787560334301 +9787560334363 +9787560334691 +9787560335810 +9787560336183 +9787560336442 +9787560337920 +9787560339597 +9787560341040 +9787560341729 +9787560342665 +9787560345550 +9787560345567 +9787560347721 +9787560347752 +9787560348032 +9787560348650 +9787560349534 +9787560354460 +9787560355085 +9787560358437 +9787560359540 +9787560360355 +9787560363288 +9787560365152 +9787560365985 +9787560368016 +9787560373263 +9787560373843 +9787560373959 +9787560374048 +9787560375397 +9787560376639 +9787560376820 +9787560377605 +9787560380797 +9787560383453 +9787560387550 +9787560387895 +9787560389011 +9787560389028 +9787560389486 +9787560389745 +9787560390376 +9787560390390 +9787560391984 +9787560392899 +9787560395272 +9787560395357 +9787560395449 +9787560395708 +9787560397856 +9787560399317 +9787560399324 +9787560399676 +9787560399775 +9787560399935 +9787560401737 +9787560402222 +9787560403137 +9787560403984 +9787560404417 +9787560404936 +9787560405124 +9787560405483 +9787560405629 +9787560405643 +9787560405926 +9787560406787 +9787560407906 +9787560408118 +9787560408262 +9787560408743 +9787560408750 +9787560408767 +9787560410036 +9787560410050 +9787560410098 +9787560410555 +9787560411491 +9787560411552 +9787560411958 +9787560412085 +9787560412887 +9787560413242 +9787560413617 +9787560414201 +9787560415000 +9787560416274 +9787560416410 +9787560416885 +9787560417301 +9787560417370 +9787560418025 +9787560418223 +9787560419848 +9787560419855 +9787560419862 +9787560420011 +9787560420486 +9787560421926 +9787560421933 +9787560422534 +9787560423128 +9787560424682 +9787560430584 +9787560430720 +9787560430744 +9787560431086 +9787560431109 +9787560432410 +9787560432526 +9787560432564 +9787560433004 +9787560433264 +9787560434537 +9787560435084 +9787560435114 +9787560435589 +9787560435596 +9787560437552 +9787560437798 +9787560442877 +9787560443522 +9787560445342 +9787560445656 +9787560448305 +9787560448336 +9787560448503 +9787560448657 +9787560448732 +9787560449319 +9787560449326 +9787560449753 +9787560450452 +9787560450971 +9787560451206 +9787560451954 +9787560453644 +9787560453668 +9787560454221 +9787560454702 +9787560454801 +9787560454832 +9787560455037 +9787560455150 +9787560455198 +9787560455242 +9787560455532 +9787560455747 +9787560456034 +9787560456355 +9787560456973 +9787560500096 +9787560500140 +9787560501314 +9787560501802 +9787560501895 +9787560502120 +9787560502168 +9787560502908 +9787560503318 +9787560504735 +9787560505596 +9787560506784 +9787560506791 +9787560506913 +9787560507040 +9787560509419 +9787560509587 +9787560510132 +9787560510378 +9787560511115 +9787560511733 +9787560511764 +9787560511788 +9787560512679 +9787560513171 +9787560513768 +9787560513850 +9787560513935 +9787560514482 +9787560517803 +9787560522838 +9787560523347 +9787560523712 +9787560523743 +9787560523811 +9787560531144 +9787560531984 +9787560532837 +9787560533377 +9787560533421 +9787560534091 +9787560534190 +9787560534244 +9787560535401 +9787560538068 +9787560539812 +9787560540801 +9787560541419 +9787560542515 +9787560542539 +9787560544144 +9787560544267 +9787560550220 +9787560550718 +9787560550916 +9787560553870 +9787560557632 +9787560560434 +9787560560526 +9787560561042 +9787560563244 +9787560565170 +9787560565620 +9787560565637 +9787560565644 +9787560566825 +9787560568225 +9787560569130 +9787560569161 +9787560569178 +9787560570747 +9787560571584 +9787560572987 +9787560573113 +9787560577036 +9787560584720 +9787560589138 +9787560598277 +9787560600680 +9787560603032 +9787560604213 +9787560606231 +9787560609683 +9787560611822 +9787560612188 +9787560613666 +9787560626994 +9787560629292 +9787560633497 +9787560639666 +9787560643243 +9787560643700 +9787560645322 +9787560660332 +9787560664033 +9787560668406 +9787560669694 +9787560670331 +9787560671604 +9787560672717 +9787560672809 +9787560672977 +9787560673035 +9787560673929 +9787560674339 +9787560674780 +9787560675176 +9787560675220 +9787560700014 +9787560700069 +9787560700076 +9787560700236 +9787560700250 +9787560700311 +9787560700397 +9787560700540 +9787560701196 +9787560702148 +9787560702599 +9787560703299 +9787560703626 +9787560703756 +9787560704012 +9787560704050 +9787560704562 +9787560704609 +9787560704838 +9787560705378 +9787560705385 +9787560705392 +9787560705538 +9787560705903 +9787560706726 +9787560706931 +9787560707150 +9787560707365 +9787560711119 +9787560711218 +9787560714073 +9787560714240 +9787560714332 +9787560715513 +9787560716251 +9787560716336 +9787560717869 +9787560717883 +9787560717937 +9787560718071 +9787560718200 +9787560718323 +9787560718774 +9787560719597 +9787560719603 +9787560720593 +9787560720968 +9787560721187 +9787560723747 +9787560724928 +9787560724973 +9787560726717 +9787560729596 +9787560730950 +9787560734439 +9787560736365 +9787560738055 +9787560738253 +9787560741987 +9787560744872 +9787560746432 +9787560746524 +9787560747828 +9787560748139 +9787560748788 +9787560749327 +9787560754505 +9787560755311 +9787560756905 +9787560757186 +9787560757407 +9787560757674 +9787560759043 +9787560760896 +9787560760902 +9787560760964 +9787560763231 +9787560765280 +9787560765419 +9787560766850 +9787560767352 +9787560768281 +9787560768342 +9787560771267 +9787560772417 +9787560775418 +9787560777146 +9787560777160 +9787560777559 +9787560777801 +9787560778013 +9787560781815 +9787560783130 +9787560783420 +9787560786476 +9787560800554 +9787560800783 +9787560800943 +9787560801995 +9787560802480 +9787560802640 +9787560802671 +9787560802756 +9787560803180 +9787560803333 +9787560803487 +9787560804576 +9787560805214 +9787560805344 +9787560805597 +9787560806488 +9787560806846 +9787560806891 +9787560807881 +9787560808017 +9787560808079 +9787560808154 +9787560808871 +9787560809052 +9787560809250 +9787560809564 +9787560811420 +9787560812502 +9787560813271 +9787560813387 +9787560813509 +9787560814308 +9787560816661 +9787560816937 +9787560818085 +9787560818597 +9787560819174 +9787560820149 +9787560820262 +9787560820408 +9787560820644 +9787560821474 +9787560822051 +9787560823805 +9787560824895 +9787560825526 +9787560825823 +9787560826707 +9787560827292 +9787560829135 +9787560829852 +9787560829876 +9787560829883 +9787560829920 +9787560830025 +9787560838427 +9787560840796 +9787560841052 +9787560847009 +9787560847580 +9787560853635 +9787560855615 +9787560855899 +9787560857008 +9787560858869 +9787560859361 +9787560860305 +9787560860503 +9787560862064 +9787560864501 +9787560870625 +9787560870977 +9787560871073 +9787560871486 +9787560871493 +9787560871561 +9787560872599 +9787560872728 +9787560873008 +9787560873060 +9787560873565 +9787560874562 +9787560875187 +9787560875811 +9787560875927 +9787560876900 +9787560877471 +9787560878676 +9787560879277 +9787560879352 +9787560880006 +9787560883106 +9787560883779 +9787560884080 +9787560884868 +9787560885803 +9787560886428 +9787560886534 +9787560886640 +9787560886749 +9787560889917 +9787560890050 +9787560890593 +9787560890609 +9787560890746 +9787560890807 +9787560891392 +9787560893044 +9787560893464 +9787560893679 +9787560893754 +9787560894065 +9787560894263 +9787560894591 +9787560896137 +9787560896298 +9787560898698 +9787560899046 +9787560899299 +9787560899305 +9787560899442 +9787560900452 +9787560900643 +9787560901039 +9787560901329 +9787560901473 +9787560902159 +9787560902227 +9787560902364 +9787560902586 +9787560903453 +9787560904122 +9787560904474 +9787560905907 +9787560906102 +9787560906232 +9787560906645 +9787560908366 +9787560908588 +9787560908946 +9787560909080 +9787560909226 +9787560909318 +9787560910079 +9787560911830 +9787560912295 +9787560912622 +9787560912660 +9787560912950 +9787560914275 +9787560915319 +9787560915814 +9787560916163 +9787560916620 +9787560916835 +9787560917191 +9787560917641 +9787560919218 +9787560919737 +9787560919775 +9787560920078 +9787560920429 +9787560920924 +9787560921433 +9787560923918 +9787560923963 +9787560925059 +9787560926667 +9787560926896 +9787560927688 +9787560928098 +9787560928654 +9787560937267 +9787560944111 +9787560944630 +9787560947945 +9787560948096 +9787560949680 +9787560955490 +9787560964447 +9787560967059 +9787560968353 +9787560968605 +9787560969954 +9787560971919 +9787560973883 +9787560974583 +9787560977959 +9787560979496 +9787560981031 +9787560981246 +9787560983264 +9787560986579 +9787560989952 +9787560994369 +9787560995113 +9787560995366 +9787560995601 +9787560995618 +9787561000649 +9787561001738 +9787561002469 +9787561002810 +9787561002889 +9787561003275 +9787561003473 +9787561004111 +9787561004180 +9787561004883 +9787561005156 +9787561005545 +9787561006870 +9787561008645 +9787561008850 +9787561009550 +9787561010228 +9787561010686 +9787561012161 +9787561012482 +9787561012567 +9787561013304 +9787561014059 +9787561014066 +9787561018170 +9787561018613 +9787561018644 +9787561021231 +9787561021446 +9787561022597 +9787561022610 +9787561023389 +9787561024102 +9787561025055 +9787561031070 +9787561033050 +9787561034712 +9787561035160 +9787561035511 +9787561036273 +9787561038451 +9787561039168 +9787561039335 +9787561040874 +9787561041109 +9787561043011 +9787561044056 +9787561044247 +9787561044728 +9787561046227 +9787561046487 +9787561046685 +9787561050163 +9787561052044 +9787561055496 +9787561056059 +9787561056349 +9787561058480 +9787561059463 +9787561060155 +9787561060261 +9787561062883 +9787561064269 +9787561064481 +9787561065402 +9787561065471 +9787561068137 +9787561069530 +9787561069554 +9787561069585 +9787561069677 +9787561069776 +9787561070017 +9787561070024 +9787561070031 +9787561070338 +9787561071090 +9787561071670 +9787561071700 +9787561071731 +9787561071748 +9787561071885 +9787561071892 +9787561071946 +9787561072011 +9787561072578 +9787561072752 +9787561072844 +9787561074831 +9787561075739 +9787561076149 +9787561076903 +9787561076910 +9787561078921 +9787561084731 +9787561087374 +9787561087435 +9787561088135 +9787561090350 +9787561090718 +9787561091760 +9787561092712 +9787561093269 +9787561095645 +9787561095669 +9787561095676 +9787561096505 +9787561096901 +9787561097359 +9787561105634 +9787561107744 +9787561107799 +9787561110072 +9787561110591 +9787561112656 +9787561112687 +9787561114117 +9787561116739 +9787561118474 +9787561118856 +9787561119457 +9787561119679 +9787561120651 +9787561120668 +9787561122174 +9787561123744 +9787561125038 +9787561127162 +9787561130063 +9787561131268 +9787561133514 +9787561135600 +9787561137567 +9787561142127 +9787561146897 +9787561150818 +9787561150931 +9787561152553 +9787561166352 +9787561166369 +9787561169209 +9787561169223 +9787561169247 +9787561169322 +9787561169728 +9787561170083 +9787561171035 +9787561171646 +9787561176375 +9787561178850 +9787561183168 +9787561190272 +9787561194522 +9787561196380 +9787561197233 +9787561198285 +9787561201091 +9787561201886 +9787561205143 +9787561205662 +9787561205761 +9787561210055 +9787561213285 +9787561214718 +9787561215036 +9787561226049 +9787561230756 +9787561236352 +9787561242643 +9787561247136 +9787561247938 +9787561249314 +9787561253458 +9787561253878 +9787561254219 +9787561254431 +9787561254837 +9787561254844 +9787561255216 +9787561255414 +9787561259467 +9787561262030 +9787561262054 +9787561262498 +9787561264102 +9787561265222 +9787561266694 +9787561266809 +9787561267141 +9787561268292 +9787561270523 +9787561270660 +9787561270714 +9787561272329 +9787561272503 +9787561272701 +9787561273449 +9787561273593 +9787561273616 +9787561276334 +9787561276938 +9787561277393 +9787561277584 +9787561277607 +9787561277720 +9787561278673 +9787561279113 +9787561280003 +9787561280430 +9787561281512 +9787561282670 +9787561283875 +9787561284834 +9787561284940 +9787561286388 +9787561286609 +9787561286678 +9787561288955 +9787561289693 +9787561290033 +9787561300084 +9787561300107 +9787561300558 +9787561300909 +9787561301586 +9787561303719 +9787561304563 +9787561304631 +9787561305270 +9787561309940 +9787561310427 +9787561310489 +9787561311165 +9787561311523 +9787561312292 +9787561314814 +9787561314944 +9787561314951 +9787561315651 +9787561316375 +9787561316900 +9787561316924 +9787561317266 +9787561317488 +9787561317495 +9787561317549 +9787561317655 +9787561318348 +9787561318515 +9787561318843 +9787561318850 +9787561318911 +9787561319130 +9787561319215 +9787561319451 +9787561319659 +9787561320020 +9787561320327 +9787561320341 +9787561320372 +9787561320389 +9787561320402 +9787561320464 +9787561320594 +9787561320617 +9787561320709 +9787561320716 +9787561320723 +9787561320860 +9787561321119 +9787561321720 +9787561321768 +9787561321829 +9787561322512 +9787561322635 +9787561323250 +9787561323274 +9787561323342 +9787561323397 +9787561323557 +9787561323649 +9787561323991 +9787561324165 +9787561324257 +9787561324271 +9787561324394 +9787561324899 +9787561325117 +9787561325209 +9787561325490 +9787561325506 +9787561325513 +9787561325667 +9787561325865 +9787561326077 +9787561327289 +9787561327685 +9787561327777 +9787561327791 +9787561328217 +9787561328354 +9787561329122 +9787561329306 +9787561329405 +9787561329498 +9787561329849 +9787561330111 +9787561330319 +9787561330333 +9787561330449 +9787561330661 +9787561330722 +9787561330784 +9787561330807 +9787561330951 +9787561331095 +9787561331125 +9787561331262 +9787561332443 +9787561332474 +9787561332658 +9787561332702 +9787561333051 +9787561333211 +9787561335901 +9787561336076 +9787561336342 +9787561337608 +9787561337790 +9787561338773 +9787561338803 +9787561339206 +9787561340189 +9787561340585 +9787561340707 +9787561341018 +9787561341230 +9787561342138 +9787561342527 +9787561343418 +9787561344125 +9787561344958 +9787561345078 +9787561345085 +9787561345443 +9787561345580 +9787561347133 +9787561347348 +9787561347614 +9787561348390 +9787561349311 +9787561350218 +9787561351130 +9787561353189 +9787561354131 +9787561354612 +9787561354964 +9787561355138 +9787561355206 +9787561357255 +9787561359617 +9787561359884 +9787561362426 +9787561369593 +9787561371114 +9787561371435 +9787561371657 +9787561375167 +9787561377123 +9787561380840 +9787561382400 +9787561384961 +9787561386200 +9787561387535 +9787561388044 +9787561388341 +9787561388358 +9787561388365 +9787561389461 +9787561390351 +9787561390412 +9787561391143 +9787561391471 +9787561391754 +9787561392898 +9787561393024 +9787561393093 +9787561394175 +9787561394847 +9787561396346 +9787561397190 +9787561398814 +9787561400548 +9787561400661 +9787561400876 +9787561400982 +9787561401781 +9787561401972 +9787561402672 +9787561402993 +9787561404003 +9787561404324 +9787561405635 +9787561405659 +9787561406069 +9787561406205 +9787561406588 +9787561407073 +9787561407349 +9787561407486 +9787561407615 +9787561407660 +9787561407790 +9787561407844 +9787561408131 +9787561408360 +9787561408551 +9787561408773 +9787561409596 +9787561410103 +9787561411148 +9787561411339 +9787561411568 +9787561411841 +9787561411933 +9787561412244 +9787561412251 +9787561412381 +9787561412565 +9787561412749 +9787561413685 +9787561414002 +9787561414293 +9787561414569 +9787561415122 +9787561415146 +9787561415412 +9787561415429 +9787561415467 +9787561415481 +9787561415504 +9787561415542 +9787561415825 +9787561415962 +9787561416587 +9787561416600 +9787561416808 +9787561417126 +9787561417874 +9787561417966 +9787561418031 +9787561418208 +9787561418222 +9787561420614 +9787561420720 +9787561425077 +9787561427699 +9787561427965 +9787561429365 +9787561429631 +9787561429853 +9787561429969 +9787561430002 +9787561430323 +9787561430378 +9787561431030 +9787561432747 +9787561435960 +9787561436936 +9787561437124 +9787561438664 +9787561442685 +9787561444856 +9787561450215 +9787561451687 +9787561452318 +9787561452943 +9787561453667 +9787561454305 +9787561454893 +9787561455920 +9787561456378 +9787561456989 +9787561457566 +9787561460566 +9787561461990 +9787561466933 +9787561467657 +9787561467732 +9787561469088 +9787561470275 +9787561470916 +9787561471807 +9787561473436 +9787561474037 +9787561475300 +9787561478011 +9787561479629 +9787561480007 +9787561480809 +9787561480885 +9787561482582 +9787561482698 +9787561484036 +9787561486740 +9787561487228 +9787561490495 +9787561492239 +9787561492987 +9787561500071 +9787561500378 +9787561501160 +9787561501719 +9787561501900 +9787561502952 +9787561506097 +9787561507261 +9787561509012 +9787561509227 +9787561510001 +9787561510438 +9787561512944 +9787561513354 +9787561514443 +9787561515211 +9787561515228 +9787561516768 +9787561519820 +9787561521625 +9787561521823 +9787561521953 +9787561523247 +9787561525586 +9787561526262 +9787561528143 +9787561529010 +9787561530580 +9787561530733 +9787561531075 +9787561531389 +9787561536124 +9787561537138 +9787561537947 +9787561541531 +9787561543849 +9787561545034 +9787561547205 +9787561548202 +9787561549773 +9787561553169 +9787561554517 +9787561558287 +9787561564233 +9787561564387 +9787561564691 +9787561567470 +9787561569368 +9787561571941 +9787561573815 +9787561574065 +9787561579336 +9787561579824 +9787561579879 +9787561580103 +9787561580554 +9787561581162 +9787561581612 +9787561582237 +9787561582541 +9787561582725 +9787561582794 +9787561582817 +9787561583111 +9787561583128 +9787561583265 +9787561583401 +9787561583685 +9787561584453 +9787561584989 +9787561585191 +9787561585917 +9787561587249 +9787561588956 +9787561590041 +9787561590058 +9787561590874 +9787561591826 +9787561592656 +9787561595176 +9787561595312 +9787561600177 +9787561600214 +9787561600511 +9787561600993 +9787561601006 +9787561601327 +9787561602355 +9787561602515 +9787561602553 +9787561604175 +9787561604267 +9787561605912 +9787561606728 +9787561606735 +9787561607565 +9787561607725 +9787561612286 +9787561613351 +9787561616543 +9787561619186 +9787561619339 +9787561619872 +9787561625637 +9787561627761 +9787561627914 +9787561628997 +9787561635353 +9787561635537 +9787561638712 +9787561700099 +9787561700341 +9787561700549 +9787561700693 +9787561700792 +9787561700839 +9787561700884 +9787561700921 +9787561700952 +9787561701942 +9787561702017 +9787561702376 +9787561702567 +9787561702994 +9787561703274 +9787561703533 +9787561703755 +9787561703823 +9787561704318 +9787561704462 +9787561704486 +9787561704639 +9787561704646 +9787561705063 +9787561705223 +9787561705346 +9787561705476 +9787561706008 +9787561706268 +9787561706329 +9787561706565 +9787561706633 +9787561707081 +9787561707241 +9787561707296 +9787561707319 +9787561707340 +9787561707593 +9787561707739 +9787561708255 +9787561708385 +9787561708569 +9787561708576 +9787561708590 +9787561708637 +9787561709016 +9787561709672 +9787561710258 +9787561710524 +9787561710784 +9787561710821 +9787561710852 +9787561711361 +9787561711408 +9787561711415 +9787561711446 +9787561711484 +9787561711507 +9787561711958 +9787561712245 +9787561712320 +9787561712412 +9787561712696 +9787561712887 +9787561713709 +9787561713785 +9787561713938 +9787561713983 +9787561714607 +9787561714829 +9787561714843 +9787561715055 +9787561715505 +9787561715543 +9787561715567 +9787561716113 +9787561716212 +9787561716250 +9787561716458 +9787561716762 +9787561716809 +9787561716977 +9787561717431 +9787561717486 +9787561717639 +9787561717653 +9787561717776 +9787561717783 +9787561717844 +9787561717899 +9787561718179 +9787561718285 +9787561718339 +9787561718544 +9787561718612 +9787561720097 +9787561720547 +9787561720851 +9787561721186 +9787561721193 +9787561721544 +9787561721551 +9787561721643 +9787561722756 +9787561722817 +9787561722879 +9787561722978 +9787561723166 +9787561723326 +9787561723371 +9787561723487 +9787561723760 +9787561723807 +9787561723937 +9787561724019 +9787561724422 +9787561724538 +9787561724583 +9787561724606 +9787561724705 +9787561724804 +9787561724859 +9787561725511 +9787561727157 +9787561727225 +9787561727836 +9787561728178 +9787561728833 +9787561733547 +9787561734964 +9787561735091 +9787561735985 +9787561736975 +9787561738061 +9787561738108 +9787561738887 +9787561741306 +9787561743690 +9787561744147 +9787561744529 +9787561746165 +9787561746868 +9787561748022 +9787561749210 +9787561750131 +9787561752357 +9787561755464 +9787561755648 +9787561756133 +9787561756409 +9787561757062 +9787561759349 +9787561760277 +9787561761809 +9787561763520 +9787561765487 +9787561766101 +9787561767153 +9787561768464 +9787561771679 +9787561771969 +9787561773451 +9787561775677 +9787561780411 +9787561785560 +9787561786130 +9787561787687 +9787561788400 +9787561788448 +9787561788479 +9787561788486 +9787561788530 +9787561788547 +9787561788936 +9787561789247 +9787561789414 +9787561791523 +9787561795163 +9787561795699 +9787561795972 +9787561797082 +9787561797228 +9787561797402 +9787561797433 +9787561798010 +9787561798065 +9787561798195 +9787561798355 +9787561799024 +9787561799338 +9787561800003 +9787561800089 +9787561800683 +9787561800874 +9787561800942 +9787561800959 +9787561801222 +9787561801529 +9787561801574 +9787561801673 +9787561802427 +9787561802489 +9787561802502 +9787561802731 +9787561802755 +9787561802885 +9787561802984 +9787561802991 +9787561803448 +9787561804056 +9787561804223 +9787561805275 +9787561805497 +9787561807576 +9787561807583 +9787561808054 +9787561808399 +9787561810583 +9787561811597 +9787561812044 +9787561812433 +9787561812686 +9787561813812 +9787561813836 +9787561814024 +9787561815342 +9787561820360 +9787561821411 +9787561821589 +9787561831601 +9787561832707 +9787561841501 +9787561847930 +9787561848463 +9787561849002 +9787561849064 +9787561853764 +9787561858875 +9787561859827 +9787561859896 +9787561861134 +9787561862087 +9787561862339 +9787561862834 +9787561864999 +9787561867099 +9787561867303 +9787561867624 +9787561868386 +9787561869031 +9787561869338 +9787561869369 +9787561876671 +9787561878309 +9787561900116 +9787561900123 +9787561900758 +9787561900833 +9787561901038 +9787561901168 +9787561901571 +9787561901793 +9787561902042 +9787561902356 +9787561902585 +9787561902615 +9787561902714 +9787561902851 +9787561903728 +9787561903766 +9787561903933 +9787561904039 +9787561904107 +9787561904411 +9787561904428 +9787561904664 +9787561904688 +9787561905319 +9787561905937 +9787561906040 +9787561906132 +9787561906231 +9787561906323 +9787561906545 +9787561907283 +9787561907573 +9787561907702 +9787561907733 +9787561907740 +9787561907948 +9787561907993 +9787561908655 +9787561908907 +9787561909379 +9787561909553 +9787561909621 +9787561910085 +9787561910573 +9787561911082 +9787561911891 +9787561912584 +9787561912874 +9787561914960 +9787561916728 +9787561918241 +9787561919194 +9787561919873 +9787561922392 +9787561923153 +9787561923771 +9787561925270 +9787561925409 +9787561927212 +9787561928042 +9787561928431 +9787561931080 +9787561931097 +9787561931172 +9787561931219 +9787561931318 +9787561931561 +9787561931721 +9787561932384 +9787561933213 +9787561933527 +9787561933640 +9787561935170 +9787561935491 +9787561942376 +9787561943045 +9787561943052 +9787561943939 +9787561947722 +9787561947999 +9787561949375 +9787561949382 +9787561950111 +9787561950234 +9787561950807 +9787561951125 +9787561952085 +9787561954256 +9787561954348 +9787561954362 +9787561954805 +9787561955239 +9787561955635 +9787561956489 +9787561956915 +9787561958292 +9787561958445 +9787561961001 +9787561961438 +9787561961766 +9787561962541 +9787561962671 +9787561962916 +9787561963180 +9787561963371 +9787561964651 +9787561965474 +9787561965962 +9787561966051 +9787561966396 +9787561966952 +9787561967430 +9787562001744 +9787562001829 +9787562001874 +9787562002512 +9787562003243 +9787562004417 +9787562005537 +9787562005919 +9787562007746 +9787562007784 +9787562008989 +9787562009054 +9787562009290 +9787562010548 +9787562010586 +9787562012986 +9787562013259 +9787562013532 +9787562013754 +9787562014263 +9787562016236 +9787562016786 +9787562016946 +9787562017646 +9787562017943 +9787562017981 +9787562018261 +9787562018339 +9787562018537 +9787562018599 +9787562018995 +9787562019237 +9787562019312 +9787562019329 +9787562019909 +9787562020929 +9787562021933 +9787562025924 +9787562027195 +9787562027201 +9787562030966 +9787562034544 +9787562034933 +9787562042037 +9787562042303 +9787562045519 +9787562049746 +9787562050964 +9787562055426 +9787562060208 +9787562063599 +9787562066712 +9787562072416 +9787562073550 +9787562078180 +9787562080985 +9787562086161 +9787562088912 +9787562090441 +9787562091721 +9787562091882 +9787562092131 +9787562093008 +9787562093022 +9787562093305 +9787562094869 +9787562096573 +9787562097136 +9787562097358 +9787562098713 +9787562099994 +9787562102359 +9787562102885 +9787562103714 +9787562105619 +9787562109143 +9787562109365 +9787562109518 +9787562110125 +9787562110231 +9787562111504 +9787562111634 +9787562111955 +9787562112051 +9787562112662 +9787562113133 +9787562114062 +9787562114499 +9787562114628 +9787562114680 +9787562115076 +9787562115304 +9787562115748 +9787562116479 +9787562116523 +9787562117360 +9787562117582 +9787562118800 +9787562118817 +9787562119067 +9787562119197 +9787562120445 +9787562120834 +9787562120964 +9787562122326 +9787562122845 +9787562123804 +9787562124245 +9787562124337 +9787562126102 +9787562128380 +9787562128854 +9787562130062 +9787562130307 +9787562132004 +9787562132066 +9787562134190 +9787562135616 +9787562138273 +9787562138471 +9787562138846 +9787562143109 +9787562143956 +9787562144335 +9787562146643 +9787562148692 +9787562149385 +9787562153375 +9787562153580 +9787562156727 +9787562157588 +9787562157670 +9787562157809 +9787562158479 +9787562161455 +9787562166979 +9787562167075 +9787562169390 +9787562171782 +9787562172161 +9787562173274 +9787562173441 +9787562173786 +9787562178767 +9787562179085 +9787562179221 +9787562180401 +9787562181019 +9787562182085 +9787562183099 +9787562186823 +9787562187370 +9787562187431 +9787562188162 +9787562189879 +9787562191315 +9787562192954 +9787562193289 +9787562196648 +9787562196860 +9787562198000 +9787562198024 +9787562199120 +9787562199298 +9787562199601 +9787562201328 +9787562205197 +9787562205814 +9787562206040 +9787562206477 +9787562206996 +9787562207856 +9787562208617 +9787562209027 +9787562209614 +9787562209911 +9787562209928 +9787562211624 +9787562213161 +9787562214694 +9787562215356 +9787562216261 +9787562216421 +9787562216513 +9787562216643 +9787562216988 +9787562217176 +9787562217725 +9787562217848 +9787562218142 +9787562218708 +9787562220305 +9787562220534 +9787562221524 +9787562222507 +9787562224464 +9787562224969 +9787562226116 +9787562227465 +9787562227830 +9787562229216 +9787562230182 +9787562230335 +9787562233008 +9787562233596 +9787562238409 +9787562239130 +9787562239277 +9787562241959 +9787562242024 +9787562247821 +9787562247906 +9787562249283 +9787562249443 +9787562251040 +9787562253594 +9787562257936 +9787562258674 +9787562264767 +9787562267393 +9787562267638 +9787562279259 +9787562279884 +9787562281825 +9787562283638 +9787562283645 +9787562285342 +9787562285687 +9787562287056 +9787562288435 +9787562290124 +9787562290193 +9787562290537 +9787562290971 +9787562292678 +9787562294511 +9787562294641 +9787562294795 +9787562295860 +9787562296089 +9787562297444 +9787562297666 +9787562297802 +9787562298007 +9787562298694 +9787562302506 +9787562302681 +9787562302810 +9787562303329 +9787562303732 +9787562303756 +9787562304241 +9787562304265 +9787562306153 +9787562306832 +9787562306856 +9787562307006 +9787562307785 +9787562307976 +9787562308171 +9787562308201 +9787562308225 +9787562308348 +9787562309048 +9787562309208 +9787562309307 +9787562309383 +9787562310068 +9787562310761 +9787562312277 +9787562312581 +9787562312611 +9787562314974 +9787562316930 +9787562317029 +9787562318460 +9787562318477 +9787562318576 +9787562319146 +9787562319245 +9787562321422 +9787562321804 +9787562330349 +9787562332350 +9787562335177 +9787562336488 +9787562339922 +9787562340850 +9787562340997 +9787562345022 +9787562351269 +9787562353393 +9787562353881 +9787562354055 +9787562355359 +9787562359081 +9787562360933 +9787562364184 +9787562364191 +9787562364795 +9787562367932 +9787562370376 +9787562372899 +9787562373674 +9787562373759 +9787562374176 +9787562374527 +9787562375234 +9787562376392 +9787562400257 +9787562400349 +9787562401742 +9787562402213 +9787562402848 +9787562403388 +9787562403838 +9787562406020 +9787562406402 +9787562406877 +9787562407225 +9787562407744 +9787562409571 +9787562409786 +9787562410096 +9787562410119 +9787562410126 +9787562410294 +9787562410751 +9787562410805 +9787562411284 +9787562411802 +9787562412120 +9787562412366 +9787562414476 +9787562415183 +9787562416890 +9787562422358 +9787562424833 +9787562431916 +9787562432517 +9787562438793 +9787562438939 +9787562439073 +9787562443131 +9787562449591 +9787562450481 +9787562450795 +9787562451419 +9787562451983 +9787562452164 +9787562454465 +9787562455257 +9787562459118 +9787562459484 +9787562460954 +9787562462606 +9787562464242 +9787562464754 +9787562465379 +9787562465775 +9787562466826 +9787562466925 +9787562467472 +9787562467878 +9787562468011 +9787562469841 +9787562470816 +9787562471578 +9787562472131 +9787562474418 +9787562474708 +9787562475637 +9787562477174 +9787562477471 +9787562482000 +9787562482635 +9787562482710 +9787562484141 +9787562485223 +9787562487401 +9787562489184 +9787562493327 +9787562497745 +9787562502913 +9787562504368 +9787562504559 +9787562506041 +9787562506935 +9787562507123 +9787562508816 +9787562511540 +9787562511656 +9787562512349 +9787562513247 +9787562513759 +9787562513773 +9787562515999 +9787562516323 +9787562516484 +9787562516729 +9787562516743 +9787562517993 +9787562518150 +9787562519072 +9787562519713 +9787562524885 +9787562524922 +9787562525356 +9787562525851 +9787562526391 +9787562527695 +9787562528869 +9787562530626 +9787562531012 +9787562532385 +9787562538585 +9787562542339 +9787562542957 +9787562544098 +9787562545668 +9787562546139 +9787562546160 +9787562547228 +9787562548676 +9787562548683 +9787562549109 +9787562549833 +9787562550136 +9787562550464 +9787562550549 +9787562550822 +9787562551171 +9787562551317 +9787562551478 +9787562551614 +9787562552246 +9787562554660 +9787562555674 +9787562558743 +9787562559344 +9787562559405 +9787562561149 +9787562561538 +9787562561668 +9787562600213 +9787562600749 +9787562600794 +9787562600862 +9787562601067 +9787562601173 +9787562601227 +9787562601746 +9787562601845 +9787562601999 +9787562602378 +9787562602408 +9787562603078 +9787562603313 +9787562603818 +9787562603849 +9787562604327 +9787562604365 +9787562604372 +9787562604389 +9787562604471 +9787562604679 +9787562605225 +9787562605522 +9787562605713 +9787562605775 +9787562605782 +9787562605980 +9787562606338 +9787562606420 +9787562606536 +9787562606673 +9787562606802 +9787562606826 +9787562606864 +9787562606932 +9787562606949 +9787562606956 +9787562607120 +9787562607526 +9787562607540 +9787562607571 +9787562607601 +9787562607762 +9787562607908 +9787562608073 +9787562608080 +9787562608356 +9787562608370 +9787562608486 +9787562608493 +9787562608509 +9787562608530 +9787562608554 +9787562608561 +9787562609094 +9787562609100 +9787562609292 +9787562609315 +9787562609377 +9787562609391 +9787562609407 +9787562609674 +9787562609735 +9787562610397 +9787562610403 +9787562610601 +9787562610694 +9787562611479 +9787562612650 +9787562613077 +9787562613497 +9787562613527 +9787562615552 +9787562617136 +9787562617556 +9787562617754 +9787562618966 +9787562620396 +9787562620440 +9787562620952 +9787562621041 +9787562621140 +9787562622178 +9787562622314 +9787562622611 +9787562622635 +9787562622673 +9787562622963 +9787562623304 +9787562623403 +9787562623793 +9787562624233 +9787562624493 +9787562700081 +9787562700142 +9787562700173 +9787562701514 +9787562702108 +9787562702320 +9787562702443 +9787562702559 +9787562702566 +9787562702818 +9787562703280 +9787562703341 +9787562703518 +9787562703624 +9787562704010 +9787562704324 +9787562704850 +9787562704980 +9787562705246 +9787562706076 +9787562706137 +9787562706328 +9787562706410 +9787562800873 +9787562801085 +9787562801566 +9787562803218 +9787562803362 +9787562803393 +9787562803744 +9787562803843 +9787562804512 +9787562805946 +9787562806080 +9787562806134 +9787562806332 +9787562806561 +9787562806608 +9787562806837 +9787562807421 +9787562807575 +9787562808268 +9787562808497 +9787562808787 +9787562808824 +9787562808916 +9787562808947 +9787562809890 +9787562810650 +9787562810674 +9787562810728 +9787562811145 +9787562811404 +9787562812302 +9787562812470 +9787562812562 +9787562812906 +9787562813590 +9787562813651 +9787562815075 +9787562815662 +9787562817956 +9787562818090 +9787562827719 +9787562829430 +9787562830658 +9787562832973 +9787562833987 +9787562836445 +9787562838180 +9787562841838 +9787562842552 +9787562844198 +9787562844983 +9787562844990 +9787562846543 +9787562847076 +9787562847984 +9787562848301 +9787562848356 +9787562848776 +9787562850311 +9787562851066 +9787562851448 +9787562852605 +9787562853589 +9787562853787 +9787562854814 +9787562854890 +9787562855705 +9787562856528 +9787562856603 +9787562856818 +9787562856887 +9787562856900 +9787562858485 +9787562858560 +9787562858782 +9787562858799 +9787562858836 +9787562858997 +9787562859215 +9787562860983 +9787562861317 +9787562861577 +9787562861584 +9787562861591 +9787562861881 +9787562863731 +9787562864561 +9787562865513 +9787562865742 +9787562865940 +9787562867050 +9787562867432 +9787562867920 +9787562868583 +9787562869160 +9787562870852 +9787562870944 +9787562871040 +9787562871613 +9787562872740 +9787562873372 +9787562874560 +9787562875772 +9787562907381 +9787562908197 +9787562908654 +9787562908791 +9787562909460 +9787562921554 +9787562923503 +9787562926689 +9787562930327 +9787562939269 +9787562939641 +9787562944904 +9787562944928 +9787562945840 +9787562945871 +9787562945987 +9787562946519 +9787562946953 +9787562948964 +9787562951674 +9787562952978 +9787562954187 +9787562957423 +9787562960119 +9787562963233 +9787562963585 +9787562963608 +9787562964414 +9787562964568 +9787562964933 +9787562965572 +9787562965664 +9787562966470 +9787562966722 +9787562967293 +9787562968429 +9787562970385 +9787562971290 +9787562973089 +9787563001033 +9787563001866 +9787563002290 +9787563002474 +9787563003778 +9787563004645 +9787563004744 +9787563005154 +9787563005482 +9787563007264 +9787563008322 +9787563009459 +9787563009664 +9787563011612 +9787563013104 +9787563013258 +9787563013272 +9787563014224 +9787563015016 +9787563015368 +9787563016730 +9787563016761 +9787563017546 +9787563020942 +9787563021123 +9787563021468 +9787563022656 +9787563023165 +9787563025459 +9787563026876 +9787563027835 +9787563029228 +9787563034130 +9787563035854 +9787563036233 +9787563036738 +9787563038220 +9787563038602 +9787563039012 +9787563040636 +9787563049240 +9787563050086 +9787563051328 +9787563052622 +9787563052646 +9787563055821 +9787563056811 +9787563060849 +9787563060887 +9787563061556 +9787563063482 +9787563064045 +9787563068197 +9787563068555 +9787563069064 +9787563070268 +9787563071562 +9787563071777 +9787563071883 +9787563073443 +9787563082582 +9787563085484 +9787563086030 +9787563086122 +9787563086252 +9787563086290 +9787563086306 +9787563086313 +9787563086368 +9787563086382 +9787563087365 +9787563088973 +9787563089970 +9787563090518 +9787563093083 +9787563095391 +9787563103669 +9787563103775 +9787563104215 +9787563105168 +9787563105342 +9787563105366 +9787563105571 +9787563105588 +9787563105601 +9787563105625 +9787563105861 +9787563107346 +9787563107582 +9787563108473 +9787563110445 +9787563113057 +9787563115655 +9787563119288 +9787563120710 +9787563125371 +9787563125876 +9787563128297 +9787563131549 +9787563200054 +9787563202096 +9787563206995 +9787563207602 +9787563208111 +9787563209583 +9787563211395 +9787563211739 +9787563212675 +9787563213177 +9787563213375 +9787563214693 +9787563217670 +9787563217991 +9787563219018 +9787563220496 +9787563222988 +9787563224197 +9787563225187 +9787563225651 +9787563226771 +9787563238118 +9787563238316 +9787563239108 +9787563239467 +9787563240968 +9787563241545 +9787563241606 +9787563241620 +9787563241705 +9787563241866 +9787563242634 +9787563244249 +9787563245277 +9787563245703 +9787563246571 +9787563301157 +9787563301652 +9787563301942 +9787563306107 +9787563306350 +9787563307784 +9787563308736 +9787563308774 +9787563309450 +9787563310081 +9787563311743 +9787563312412 +9787563314744 +9787563316915 +9787563317219 +9787563319169 +9787563319602 +9787563319893 +9787563320059 +9787563320196 +9787563320202 +9787563320615 +9787563320776 +9787563321070 +9787563321124 +9787563321377 +9787563321759 +9787563321766 +9787563322329 +9787563322985 +9787563323258 +9787563323296 +9787563323302 +9787563324491 +9787563324736 +9787563325085 +9787563325252 +9787563325344 +9787563325399 +9787563325511 +9787563325580 +9787563326167 +9787563327058 +9787563327386 +9787563329205 +9787563329236 +9787563329595 +9787563329823 +9787563329960 +9787563330744 +9787563331048 +9787563331130 +9787563331604 +9787563331628 +9787563331819 +9787563333783 +9787563334216 +9787563334377 +9787563334384 +9787563334469 +9787563334490 +9787563334605 +9787563335664 +9787563335695 +9787563337026 +9787563337033 +9787563337132 +9787563337262 +9787563338054 +9787563338436 +9787563338450 +9787563338627 +9787563338658 +9787563338702 +9787563338795 +9787563339358 +9787563339631 +9787563342990 +9787563343355 +9787563343454 +9787563343461 +9787563345472 +9787563346738 +9787563351275 +9787563352272 +9787563353200 +9787563353262 +9787563354016 +9787563357178 +9787563357222 +9787563358427 +9787563359769 +9787563360185 +9787563360208 +9787563360352 +9787563360369 +9787563363001 +9787563364244 +9787563364312 +9787563365838 +9787563368853 +9787563369140 +9787563371426 +9787563371464 +9787563382804 +9787563384181 +9787563386055 +9787563389513 +9787563389537 +9787563397495 +9787563400638 +9787563400669 +9787563400690 +9787563400737 +9787563400911 +9787563401376 +9787563401413 +9787563401420 +9787563401437 +9787563401666 +9787563401741 +9787563401772 +9787563401888 +9787563401949 +9787563402120 +9787563402472 +9787563402878 +9787563403424 +9787563403950 +9787563404148 +9787563406326 +9787563407378 +9787563407835 +9787563408313 +9787563408597 +9787563408801 +9787563408986 +9787563408993 +9787563409228 +9787563409563 +9787563409976 +9787563410088 +9787563410354 +9787563410453 +9787563410545 +9787563410668 +9787563410699 +9787563411252 +9787563411498 +9787563411511 +9787563411665 +9787563411825 +9787563412983 +9787563413942 +9787563413980 +9787563414215 +9787563414260 +9787563414413 +9787563414543 +9787563414574 +9787563414604 +9787563414703 +9787563414802 +9787563414826 +9787563414857 +9787563414918 +9787563415045 +9787563415168 +9787563415182 +9787563415588 +9787563415762 +9787563415892 +9787563415922 +9787563415953 +9787563415984 +9787563416028 +9787563416257 +9787563416394 +9787563416912 +9787563417711 +9787563418008 +9787563418329 +9787563419340 +9787563419401 +9787563419746 +9787563419760 +9787563420070 +9787563420131 +9787563420186 +9787563420407 +9787563420469 +9787563420520 +9787563420605 +9787563420643 +9787563420926 +9787563421060 +9787563421336 +9787563421343 +9787563421800 +9787563421817 +9787563421930 +9787563422203 +9787563422302 +9787563422319 +9787563423507 +9787563424511 +9787563424757 +9787563427055 +9787563432851 +9787563436507 +9787563438006 +9787563438532 +9787563444731 +9787563454198 +9787563454389 +9787563462940 +9787563463466 +9787563465637 +9787563467808 +9787563475599 +9787563481163 +9787563487936 +9787563490875 +9787563496181 +9787563500741 +9787563501748 +9787563503148 +9787563503407 +9787563504893 +9787563505333 +9787563508938 +9787563510078 +9787563511471 +9787563517121 +9787563522903 +9787563530472 +9787563530496 +9787563531011 +9787563531943 +9787563532933 +9787563533411 +9787563534289 +9787563536542 +9787563536788 +9787563537570 +9787563537747 +9787563539109 +9787563539864 +9787563541072 +9787563541164 +9787563541249 +9787563541331 +9787563542109 +9787563542192 +9787563542390 +9787563542765 +9787563543038 +9787563546107 +9787563546886 +9787563549504 +9787563551415 +9787563552382 +9787563553525 +9787563555215 +9787563556762 +9787563556861 +9787563557394 +9787563558216 +9787563559206 +9787563559336 +9787563559350 +9787563559367 +9787563559541 +9787563559688 +9787563560844 +9787563560943 +9787563560998 +9787563561438 +9787563561445 +9787563562206 +9787563562442 +9787563562954 +9787563562978 +9787563562992 +9787563563319 +9787563563654 +9787563563999 +9787563565412 +9787563565931 +9787563566204 +9787563566259 +9787563566419 +9787563566631 +9787563566808 +9787563567294 +9787563567331 +9787563567904 +9787563567911 +9787563568291 +9787563568376 +9787563568505 +9787563568765 +9787563569007 +9787563569847 +9787563569977 +9787563570331 +9787563570393 +9787563571406 +9787563571444 +9787563571987 +9787563573035 +9787563573639 +9787563600786 +9787563604753 +9787563605460 +9787563607600 +9787563608270 +9787563608423 +9787563611331 +9787563611553 +9787563612895 +9787563614844 +9787563614981 +9787563617746 +9787563618170 +9787563620258 +9787563621996 +9787563627370 +9787563632251 +9787563636532 +9787563636631 +9787563636754 +9787563641246 +9787563643189 +9787563644001 +9787563644483 +9787563646678 +9787563648504 +9787563650040 +9787563652730 +9787563655540 +9787563656288 +9787563656301 +9787563659784 +9787563661183 +9787563661190 +9787563666997 +9787563668618 +9787563671540 +9787563672189 +9787563672271 +9787563672820 +9787563673032 +9787563674541 +9787563674626 +9787563674831 +9787563677184 +9787563678808 +9787563679584 +9787563679829 +9787563681112 +9787563682027 +9787563700721 +9787563700837 +9787563701438 +9787563702060 +9787563702312 +9787563705399 +9787563705634 +9787563706068 +9787563706075 +9787563706105 +9787563706655 +9787563706846 +9787563707256 +9787563709199 +9787563709526 +9787563709762 +9787563709830 +9787563711529 +9787563712779 +9787563713660 +9787563715633 +9787563718153 +9787563720002 +9787563720392 +9787563720972 +9787563721160 +9787563722068 +9787563723676 +9787563724093 +9787563727483 +9787563728992 +9787563729074 +9787563730988 +9787563733149 +9787563733361 +9787563733385 +9787563735181 +9787563741519 +9787563741892 +9787563744596 +9787563747306 +9787563747412 +9787563800117 +9787563800124 +9787563800476 +9787563800735 +9787563800766 +9787563800902 +9787563800919 +9787563801534 +9787563801749 +9787563802135 +9787563802142 +9787563802289 +9787563803293 +9787563803323 +9787563803521 +9787563803552 +9787563803729 +9787563805662 +9787563806218 +9787563806263 +9787563808175 +9787563808229 +9787563809851 +9787563810000 +9787563817108 +9787563819287 +9787563820894 +9787563822263 +9787563826926 +9787563900176 +9787563900206 +9787563900725 +9787563900800 +9787563901340 +9787563901395 +9787563901661 +9787563901944 +9787563902088 +9787563902422 +9787563902569 +9787563902972 +9787563903078 +9787563903900 +9787563904259 +9787563904433 +9787563904488 +9787563904617 +9787563904679 +9787563904778 +9787563905003 +9787563906666 +9787563906956 +9787563907151 +9787563908288 +9787563908691 +9787563909247 +9787563909254 +9787563909452 +9787563909575 +9787563911158 +9787563911325 +9787563912735 +9787563914517 +9787563915422 +9787563916559 +9787563917099 +9787563918713 +9787563919086 +9787563919901 +9787563923816 +9787563925117 +9787563929917 +9787563930043 +9787563931736 +9787563933280 +9787563934737 +9787563935567 +9787563935970 +9787563936694 +9787563937790 +9787563938452 +9787563942183 +9787563942510 +9787563942947 +9787563952434 +9787563955756 +9787563955893 +9787563956180 +9787563956258 +9787563958375 +9787563963287 +9787563963294 +9787563969159 +9787563974115 +9787563974672 +9787563976249 +9787563978052 +9787563980710 +9787563982202 +9787563983957 +9787563985241 +9787564000264 +9787564000660 +9787564003968 +9787564004828 +9787564007041 +9787564016333 +9787564019303 +9787564020866 +9787564021313 +9787564022006 +9787564022129 +9787564024475 +9787564038120 +9787564038168 +9787564039301 +9787564044114 +9787564047320 +9787564047931 +9787564053628 +9787564054281 +9787564065225 +9787564069148 +9787564071738 +9787564071745 +9787564076221 +9787564079727 +9787564086237 +9787564086244 +9787564091637 +9787564096595 +9787564099022 +9787564100414 +9787564101879 +9787564102081 +9787564102746 +9787564103194 +9787564107802 +9787564111397 +9787564113780 +9787564120498 +9787564124403 +9787564129705 +9787564130022 +9787564130855 +9787564133221 +9787564133498 +9787564137496 +9787564138950 +9787564141967 +9787564142025 +9787564144395 +9787564146030 +9787564147051 +9787564151744 +9787564151751 +9787564152185 +9787564152208 +9787564153106 +9787564154103 +9787564154141 +9787564155865 +9787564159573 +9787564161798 +9787564162726 +9787564171742 +9787564171773 +9787564172411 +9787564173227 +9787564174125 +9787564174842 +9787564174958 +9787564177331 +9787564178642 +9787564179779 +9787564181154 +9787564182359 +9787564186777 +9787564188443 +9787564189112 +9787564189853 +9787564190729 +9787564191948 +9787564192808 +9787564192891 +9787564193850 +9787564193928 +9787564194079 +9787564194499 +9787564194666 +9787564194741 +9787564194826 +9787564195823 +9787564197285 +9787564210786 +9787564218904 +9787564221294 +9787564236427 +9787564236915 +9787564237370 +9787564238520 +9787564239589 +9787564239619 +9787564240004 +9787564242213 +9787564243418 +9787564243715 +9787564243876 +9787564243906 +9787564244361 +9787564244446 +9787564244873 +9787564245054 +9787564245375 +9787564245672 +9787564300753 +9787564318284 +9787564321239 +9787564322793 +9787564328863 +9787564334482 +9787564337070 +9787564339340 +9787564344986 +9787564345006 +9787564346386 +9787564355128 +9787564361365 +9787564368746 +9787564371487 +9787564372682 +9787564374617 +9787564374686 +9787564378943 +9787564380519 +9787564380540 +9787564382247 +9787564382285 +9787564382292 +9787564382476 +9787564382520 +9787564382926 +9787564383381 +9787564383503 +9787564383619 +9787564384036 +9787564385002 +9787564385774 +9787564386016 +9787564391577 +9787564395186 +9787564396794 +9787564396848 +9787564397920 +9787564398255 +9787564398439 +9787564399054 +9787564400279 +9787564402716 +9787564403645 +9787564404918 +9787564405359 +9787564406684 +9787564408497 +9787564410254 +9787564410315 +9787564410490 +9787564410872 +9787564411473 +9787564411626 +9787564411862 +9787564413057 +9787564413385 +9787564413873 +9787564414894 +9787564415716 +9787564415747 +9787564415792 +9787564416706 +9787564416720 +9787564416782 +9787564417178 +9787564417956 +9787564418212 +9787564419530 +9787564419653 +9787564421595 +9787564422936 +9787564423926 +9787564424350 +9787564424701 +9787564426064 +9787564426460 +9787564427047 +9787564427405 +9787564429652 +9787564430214 +9787564430856 +9787564432157 +9787564432249 +9787564432386 +9787564433154 +9787564433284 +9787564433338 +9787564434168 +9787564434670 +9787564434694 +9787564436162 +9787564436315 +9787564436483 +9787564436629 +9787564436988 +9787564437060 +9787564437077 +9787564437114 +9787564438524 +9787564439033 +9787564439057 +9787564439156 +9787564439491 +9787564439514 +9787564439682 +9787564439859 +9787564441487 +9787564442149 +9787564442477 +9787564500160 +9787564506179 +9787564507466 +9787564508838 +9787564516307 +9787564519483 +9787564519681 +9787564523718 +9787564525613 +9787564525743 +9787564526337 +9787564529734 +9787564531270 +9787564531652 +9787564531676 +9787564531812 +9787564532109 +9787564532406 +9787564532451 +9787564533557 +9787564533724 +9787564534257 +9787564535179 +9787564535247 +9787564535261 +9787564535322 +9787564536183 +9787564537180 +9787564537487 +9787564537906 +9787564538149 +9787564538224 +9787564540340 +9787564540609 +9787564542511 +9787564542559 +9787564542603 +9787564542627 +9787564542702 +9787564543563 +9787564543570 +9787564543600 +9787564545406 +9787564545604 +9787564546366 +9787564546441 +9787564546670 +9787564546755 +9787564546847 +9787564546960 +9787564547394 +9787564547400 +9787564547677 +9787564548957 +9787564549787 +9787564550936 +9787564553487 +9787564556075 +9787564557331 +9787564558314 +9787564559960 +9787564559977 +9787564561840 +9787564565619 +9787564565640 +9787564570026 +9787564571313 +9787564573201 +9787564574543 +9787564574574 +9787564575489 +9787564576509 +9787564577544 +9787564577926 +9787564578589 +9787564578787 +9787564578930 +9787564579074 +9787564581541 +9787564581640 +9787564582203 +9787564582975 +9787564583354 +9787564583828 +9787564584436 +9787564584948 +9787564585358 +9787564586966 +9787564588205 +9787564589882 +9787564590444 +9787564595050 +9787564595180 +9787564596484 +9787564596873 +9787564598112 +9787564599645 +9787564599942 +9787564600037 +9787564606282 +9787564607135 +9787564608897 +9787564609498 +9787564611743 +9787564615932 +9787564616359 +9787564616380 +9787564619268 +9787564621131 +9787564624491 +9787564632441 +9787564642044 +9787564645670 +9787564646738 +9787564650155 +9787564650803 +9787564651145 +9787564652135 +9787564655266 +9787564660680 +9787564702243 +9787564704728 +9787564707705 +9787564707736 +9787564707910 +9787564708580 +9787564713683 +9787564714161 +9787564714550 +9787564715113 +9787564716929 +9787564717148 +9787564718305 +9787564719166 +9787564720971 +9787564721350 +9787564723439 +9787564723620 +9787564723934 +9787564726140 +9787564726621 +9787564727413 +9787564727550 +9787564729776 +9787564730376 +9787564731113 +9787564732363 +9787564734411 +9787564737634 +9787564740733 +9787564743260 +9787564743451 +9787564746469 +9787564746896 +9787564747923 +9787564748180 +9787564749149 +9787564751913 +9787564752064 +9787564756406 +9787564756543 +9787564757052 +9787564757229 +9787564757274 +9787564759353 +9787564759629 +9787564762483 +9787564762575 +9787564766344 +9787564766375 +9787564771904 +9787564772444 +9787564774592 +9787564776251 +9787564776268 +9787564776305 +9787564776626 +9787564778736 +9787564778927 +9787564779108 +9787564779306 +9787564779559 +9787564779627 +9787564779702 +9787564779740 +9787564779870 +9787564780081 +9787564780630 +9787564781798 +9787564781897 +9787564782221 +9787564782238 +9787564782344 +9787564782986 +9787564783273 +9787564783624 +9787564783662 +9787564783822 +9787564783945 +9787564784706 +9787564785512 +9787564786274 +9787564788193 +9787564788810 +9787564789640 +9787564790677 +9787564790752 +9787564790950 +9787564791018 +9787564791025 +9787564791582 +9787564792183 +9787564792794 +9787564793517 +9787564794262 +9787564795146 +9787564796464 +9787564796716 +9787564796754 +9787564796815 +9787564796822 +9787564796945 +9787564797027 +9787564797072 +9787564797089 +9787564799472 +9787564799786 +9787564801052 +9787564804572 +9787564806477 +9787564809294 +9787564810603 +9787564810658 +9787564810719 +9787564810726 +9787564811211 +9787564812454 +9787564812546 +9787564812843 +9787564812980 +9787564813017 +9787564813086 +9787564813109 +9787564815561 +9787564815660 +9787564816551 +9787564817398 +9787564817596 +9787564820138 +9787564820152 +9787564821814 +9787564822309 +9787564822439 +9787564822811 +9787564823368 +9787564823801 +9787564824167 +9787564824198 +9787564824280 +9787564824853 +9787564824877 +9787564827830 +9787564828929 +9787564829476 +9787564830946 +9787564831196 +9787564831769 +9787564831783 +9787564833008 +9787564833664 +9787564833800 +9787564834081 +9787564834371 +9787564834678 +9787564834708 +9787564834777 +9787564835545 +9787564835804 +9787564835811 +9787564835880 +9787564836016 +9787564836122 +9787564836221 +9787564836542 +9787564836726 +9787564836894 +9787564837525 +9787564838157 +9787564838164 +9787564838263 +9787564838706 +9787564839116 +9787564839253 +9787564839390 +9787564839550 +9787564841065 +9787564841126 +9787564841249 +9787564841263 +9787564841478 +9787564841997 +9787564842093 +9787564842802 +9787564842925 +9787564844639 +9787564844806 +9787564844875 +9787564845001 +9787564845278 +9787564845681 +9787564846121 +9787564846145 +9787564846268 +9787564847067 +9787564847098 +9787564847784 +9787564847852 +9787564847920 +9787564848286 +9787564848408 +9787564848644 +9787564848903 +9787564848934 +9787564848996 +9787564849016 +9787564849047 +9787564849344 +9787564849351 +9787564849368 +9787564850104 +9787564850302 +9787564851408 +9787564851484 +9787564851491 +9787564851545 +9787564853082 +9787564853129 +9787564853167 +9787564853839 +9787564853860 +9787564853884 +9787564853952 +9787564853969 +9787564854010 +9787564854980 +9787564900236 +9787564901523 +9787564902964 +9787564903381 +9787564903541 +9787564903824 +9787564904098 +9787564904951 +9787564905699 +9787564906047 +9787564908836 +9787564909703 +9787564911027 +9787564911577 +9787564911935 +9787564912901 +9787564912918 +9787564912994 +9787564913083 +9787564916428 +9787564916824 +9787564917470 +9787564917531 +9787564918293 +9787564918811 +9787564918835 +9787564918873 +9787564918965 +9787564919269 +9787564919283 +9787564919573 +9787564919948 +9787564920920 +9787564924089 +9787564924126 +9787564924607 +9787564925710 +9787564926021 +9787564926038 +9787564931285 +9787564931568 +9787564932916 +9787564935702 +9787564936853 +9787564936860 +9787564937218 +9787564937232 +9787564937294 +9787564937485 +9787564940195 +9787564941093 +9787564942458 +9787564942533 +9787564942946 +9787564942953 +9787564943110 +9787564945688 +9787564947149 +9787564947330 +9787564947927 +9787564948702 +9787564948795 +9787564948948 +9787564948993 +9787564949341 +9787564950620 +9787564951092 +9787564951580 +9787564951672 +9787564951689 +9787564951696 +9787564951702 +9787564952907 +9787564952952 +9787564953539 +9787564953614 +9787564953621 +9787564953638 +9787564953737 +9787564956929 +9787564957100 +9787565003226 +9787565004162 +9787565004247 +9787565005022 +9787565005336 +9787565006319 +9787565006432 +9787565007255 +9787565007453 +9787565010095 +9787565011566 +9787565011597 +9787565013744 +9787565019067 +9787565024115 +9787565024276 +9787565028748 +9787565028755 +9787565028830 +9787565029691 +9787565033025 +9787565033575 +9787565034640 +9787565043260 +9787565044687 +9787565047121 +9787565047596 +9787565049262 +9787565049866 +9787565050022 +9787565050732 +9787565053405 +9787565053696 +9787565053832 +9787565055850 +9787565063510 +9787565063725 +9787565063978 +9787565064609 +9787565065194 +9787565068959 +9787565100086 +9787565100543 +9787565100567 +9787565100574 +9787565101250 +9787565103315 +9787565105005 +9787565105135 +9787565105814 +9787565106040 +9787565106637 +9787565107269 +9787565107542 +9787565107566 +9787565107573 +9787565107597 +9787565107603 +9787565107610 +9787565107627 +9787565107634 +9787565107658 +9787565107665 +9787565107672 +9787565107689 +9787565107696 +9787565107702 +9787565107726 +9787565107757 +9787565107764 +9787565107771 +9787565107788 +9787565107801 +9787565107818 +9787565107849 +9787565107863 +9787565107924 +9787565108402 +9787565108495 +9787565108938 +9787565109331 +9787565109843 +9787565110412 +9787565110443 +9787565110450 +9787565110467 +9787565110474 +9787565110498 +9787565110511 +9787565110535 +9787565110542 +9787565110573 +9787565110597 +9787565110603 +9787565110610 +9787565110627 +9787565110634 +9787565110658 +9787565110665 +9787565110696 +9787565110702 +9787565110757 +9787565111402 +9787565111464 +9787565111471 +9787565111501 +9787565111570 +9787565111617 +9787565112010 +9787565112386 +9787565113758 +9787565114564 +9787565115004 +9787565115660 +9787565116193 +9787565116407 +9787565116469 +9787565116728 +9787565116735 +9787565116742 +9787565117183 +9787565117794 +9787565117824 +9787565118777 +9787565119385 +9787565119392 +9787565119408 +9787565119699 +9787565120053 +9787565120060 +9787565120077 +9787565121883 +9787565121982 +9787565122613 +9787565122644 +9787565122705 +9787565125157 +9787565126017 +9787565126079 +9787565126192 +9787565126208 +9787565126222 +9787565126246 +9787565126260 +9787565126314 +9787565126345 +9787565126376 +9787565126406 +9787565126413 +9787565126420 +9787565126437 +9787565126475 +9787565126482 +9787565126499 +9787565126505 +9787565126512 +9787565126529 +9787565126857 +9787565126918 +9787565126932 +9787565127212 +9787565127564 +9787565127588 +9787565127762 +9787565130854 +9787565131073 +9787565131165 +9787565131189 +9787565131196 +9787565131226 +9787565131240 +9787565131257 +9787565131264 +9787565131271 +9787565131295 +9787565131332 +9787565131356 +9787565131363 +9787565131370 +9787565131653 +9787565131714 +9787565131738 +9787565131745 +9787565131752 +9787565132476 +9787565132506 +9787565133299 +9787565134531 +9787565134548 +9787565134708 +9787565134807 +9787565134920 +9787565135002 +9787565135057 +9787565135323 +9787565136023 +9787565136054 +9787565136443 +9787565136535 +9787565136566 +9787565137709 +9787565137792 +9787565137945 +9787565138096 +9787565138249 +9787565139130 +9787565139222 +9787565139437 +9787565139451 +9787565140037 +9787565140389 +9787565140402 +9787565140433 +9787565141195 +9787565141256 +9787565141331 +9787565142048 +9787565142406 +9787565142666 +9787565142949 +9787565143519 +9787565143724 +9787565143762 +9787565144363 +9787565144424 +9787565144509 +9787565145537 +9787565146305 +9787565146701 +9787565147715 +9787565148231 +9787565148330 +9787565149658 +9787565149924 +9787565150500 +9787565150609 +9787565150661 +9787565152337 +9787565152528 +9787565152764 +9787565153181 +9787565153549 +9787565153556 +9787565154911 +9787565154928 +9787565155772 +9787565155826 +9787565156755 +9787565157967 +9787565157974 +9787565158513 +9787565158537 +9787565158759 +9787565159923 +9787565160011 +9787565160615 +9787565160653 +9787565160691 +9787565160844 +9787565160875 +9787565161988 +9787565170072 +9787565200748 +9787565204296 +9787565223532 +9787565231490 +9787565233470 +9787565233951 +9787565302206 +9787565305351 +9787565308253 +9787565309946 +9787565310256 +9787565310553 +9787565310966 +9787565314933 +9787565317743 +9787565318696 +9787565319686 +9787565322068 +9787565322280 +9787565326424 +9787565327902 +9787565331862 +9787565331985 +9787565333057 +9787565335709 +9787565336003 +9787565336539 +9787565337673 +9787565338991 +9787565424519 +9787565433139 +9787565446313 +9787565447945 +9787565449802 +9787565451249 +9787565451638 +9787565452604 +9787565453205 +9787565453328 +9787565453656 +9787565453786 +9787565454059 +9787565454769 +9787565454813 +9787565454929 +9787565455124 +9787565455223 +9787565455421 +9787565455513 +9787565505096 +9787565516221 +9787565528804 +9787565600241 +9787565603143 +9787565603723 +9787565604058 +9787565604836 +9787565605161 +9787565605949 +9787565606304 +9787565606519 +9787565606670 +9787565612299 +9787565615177 +9787565617706 +9787565618383 +9787565620393 +9787565621437 +9787565625299 +9787565625961 +9787565626142 +9787565627996 +9787565628009 +9787565628412 +9787565628528 +9787565628559 +9787565629525 +9787565632464 +9787565633317 +9787565633324 +9787565633331 +9787565633348 +9787565635489 +9787565635502 +9787565635540 +9787565635601 +9787565636363 +9787565636462 +9787565636479 +9787565636486 +9787565636509 +9787565636554 +9787565636578 +9787565636646 +9787565636714 +9787565637261 +9787565637285 +9787565637964 +9787565638237 +9787565638879 +9787565641060 +9787565642098 +9787565642944 +9787565643583 +9787565645099 +9787565645235 +9787565645440 +9787565645457 +9787565646607 +9787565646638 +9787565647017 +9787565647024 +9787565647079 +9787565647758 +9787565650772 +9787565651878 +9787565651984 +9787565653797 +9787565653988 +9787565656309 +9787565656408 +9787565656477 +9787565656583 +9787565656590 +9787565656774 +9787565656804 +9787565656859 +9787565657337 +9787565657351 +9787565657580 +9787565657733 +9787565657917 +9787565658068 +9787565658259 +9787565658273 +9787565659614 +9787565659621 +9787565660153 +9787565660443 +9787565660467 +9787565660474 +9787565660528 +9787565660672 +9787565660702 +9787565660894 +9787565661259 +9787565661877 +9787565661891 +9787565662294 +9787565662836 +9787565663611 +9787565664137 +9787565664298 +9787565664687 +9787565664779 +9787565664830 +9787565665141 +9787565665257 +9787565665264 +9787565665271 +9787565665288 +9787565665899 +9787565666360 +9787565666933 +9787565667756 +9787565667992 +9787565668050 +9787565668555 +9787565668869 +9787565669118 +9787565669262 +9787565669347 +9787565669361 +9787565669453 +9787565670398 +9787565670817 +9787565670930 +9787565671180 +9787565671449 +9787565672187 +9787565672484 +9787565672927 +9787565673511 +9787565673818 +9787565675263 +9787565675300 +9787565675652 +9787565676369 +9787565676604 +9787565676635 +9787565677557 +9787565677601 +9787565677816 +9787565678776 +9787565678875 +9787565679636 +9787565679940 +9787565680120 +9787565680199 +9787565681059 +9787565681585 +9787565681639 +9787565681684 +9787565681851 +9787565681950 +9787565682346 +9787565682353 +9787565682360 +9787565682377 +9787565683176 +9787565683305 +9787565683688 +9787565683961 +9787565683978 +9787565683985 +9787565684203 +9787565685828 +9787565701955 +9787565702358 +9787565706189 +9787565710940 +9787565720673 +9787565720710 +9787565721342 +9787565721953 +9787565723896 +9787565723902 +9787565725920 +9787565727528 +9787565727795 +9787565728280 +9787565730115 +9787565730160 +9787565734168 +9787565734250 +9787565734403 +9787565734496 +9787565734502 +9787565734540 +9787565735424 +9787565735592 +9787565735820 +9787565735837 +9787565736957 +9787565737817 +9787565738227 +9787565738463 +9787565800887 +9787565801198 +9787565803024 +9787565804724 +9787565804908 +9787565804939 +9787565804946 +9787565805158 +9787565805431 +9787565806575 +9787565807046 +9787565807053 +9787565807220 +9787565807459 +9787565808364 +9787565808418 +9787565808456 +9787565809613 +9787565809682 +9787565809798 +9787565810237 +9787565810602 +9787565810930 +9787565811012 +9787565811074 +9787565811241 +9787565811272 +9787565811647 +9787565812675 +9787565813559 +9787565814150 +9787565814266 +9787565814389 +9787565814518 +9787565814556 +9787565814716 +9787565817403 +9787565817687 +9787565817779 +9787565818516 +9787565819551 +9787565819810 +9787565820854 +9787565822117 +9787565822988 +9787565824128 +9787565826221 +9787565829024 +9787565830914 +9787565830945 +9787565830952 +9787565830969 +9787565830983 +9787565830990 +9787565831065 +9787565831621 +9787565832888 +9787565834431 +9787565834899 +9787565836107 +9787565836237 +9787565836824 +9787565839078 +9787565839696 +9787565839993 +9787565840067 +9787565842375 +9787565843174 +9787565843181 +9787565843204 +9787565844577 +9787565844751 +9787565845758 +9787565846267 +9787565846328 +9787565846540 +9787565847202 +9787565847752 +9787565848018 +9787565849305 +9787565849527 +9787565850936 +9787565900617 +9787565905087 +9787565905841 +9787565905940 +9787565906152 +9787565907111 +9787565908422 +9787565911729 +9787565912559 +9787565913853 +9787565915918 +9787565917950 +9787565921469 +9787565925153 +9787565926334 +9787565926891 +9787565927294 +9787565928673 +9787565928741 +9787565929953 +9787565930003 +9787565930621 +9787565931178 +9787565931291 +9787565931338 +9787565932267 +9787566000118 +9787566000521 +9787566001245 +9787566002273 +9787566003713 +9787566006677 +9787566012456 +9787566013804 +9787566015402 +9787566016003 +9787566016034 +9787566018335 +9787566018359 +9787566018526 +9787566021809 +9787566023384 +9787566024046 +9787566024510 +9787566100757 +9787566104847 +9787566106100 +9787566106681 +9787566107411 +9787566108210 +9787566114808 +9787566115133 +9787566116178 +9787566116529 +9787566117977 +9787566118493 +9787566118943 +9787566120052 +9787566120410 +9787566124494 +9787566125590 +9787566126979 +9787566127006 +9787566127440 +9787566128102 +9787566128607 +9787566129246 +9787566129284 +9787566129895 +9787566130938 +9787566130952 +9787566131218 +9787566131324 +9787566131461 +9787566131607 +9787566131669 +9787566131676 +9787566131805 +9787566132758 +9787566133182 +9787566133946 +9787566134509 +9787566135247 +9787566135896 +9787566137166 +9787566138255 +9787566138330 +9787566138354 +9787566138446 +9787566139283 +9787566139467 +9787566139955 +9787566140142 +9787566140395 +9787566142672 +9787566142818 +9787566143037 +9787566143525 +9787566143662 +9787566145031 +9787566202291 +9787566202338 +9787566209900 +9787566302588 +9787566305039 +9787566305800 +9787566308238 +9787566308276 +9787566308955 +9787566309174 +9787566313942 +9787566314215 +9787566325990 +9787566400826 +9787566401809 +9787566408259 +9787566408266 +9787566422484 +9787566424136 +9787566425027 +9787566425034 +9787566425041 +9787566426123 +9787566426215 +9787566426222 +9787566426253 +9787566426604 +9787566426697 +9787566428110 +9787566428134 +9787566428677 +9787566500168 +9787566501639 +9787566502315 +9787566502322 +9787566502339 +9787566502346 +9787566502353 +9787566502377 +9787566502414 +9787566502452 +9787566502629 +9787566503817 +9787566504036 +9787566505170 +9787566505811 +9787566506283 +9787566507839 +9787566509147 +9787566510037 +9787566518347 +9787566522382 +9787566523938 +9787566600127 +9787566600349 +9787566600417 +9787566600455 +9787566601728 +9787566602534 +9787566603968 +9787566604750 +9787566604798 +9787566605405 +9787566605436 +9787566606396 +9787566607676 +9787566607850 +9787566612038 +9787566612649 +9787566615435 +9787566617880 +9787566618931 +9787566622464 +9787566622792 +9787566622914 +9787566701824 +9787566707000 +9787566707246 +9787566711250 +9787566713148 +9787566714350 +9787566714497 +9787566716040 +9787566716347 +9787566716408 +9787566716415 +9787566717900 +9787566718259 +9787566718488 +9787566719140 +9787566719928 +9787566719973 +9787566720184 +9787566720252 +9787566720405 +9787566721129 +9787566721365 +9787566722843 +9787566723031 +9787566723086 +9787566723109 +9787566723239 +9787566724281 +9787566724458 +9787566725080 +9787566725622 +9787566725752 +9787566725776 +9787566727091 +9787566728043 +9787566730152 +9787566730497 +9787566730626 +9787566730831 +9787566730978 +9787566730992 +9787566733344 +9787566733375 +9787566733887 +9787566733948 +9787566736444 +9787566737366 +9787566739872 +9787566800077 +9787566801678 +9787566801685 +9787566804143 +9787566805041 +9787566815033 +9787566815576 +9787566817846 +9787566818782 +9787566820839 +9787566821447 +9787566824387 +9787566825780 +9787566829849 +9787566830791 +9787566831675 +9787566831835 +9787566831903 +9787566833433 +9787566836571 +9787566837776 +9787566837813 +9787566838179 +9787566839893 +9787566840158 +9787566900449 +9787566902849 +9787566910134 +9787566910622 +9787566917201 +9787566919984 +9787566920454 +9787566922212 +9787566922809 +9787566922847 +9787566922861 +9787566922908 +9787566923547 +9787566923608 +9787566923851 +9787566923905 +9787566924452 +9787567000780 +9787567004238 +9787567004252 +9787567007567 +9787567012738 +9787567014435 +9787567015104 +9787567019096 +9787567021686 +9787567024052 +9787567024397 +9787567025868 +9787567025981 +9787567026087 +9787567026650 +9787567027930 +9787567028791 +9787567029828 +9787567030244 +9787567030619 +9787567031357 +9787567032309 +9787567036048 +9787567036093 +9787567038912 +9787567107533 +9787567109261 +9787567114937 +9787567115255 +9787567117648 +9787567122383 +9787567125186 +9787567125575 +9787567127166 +9787567127173 +9787567128736 +9787567130906 +9787567131132 +9787567131460 +9787567131569 +9787567134065 +9787567134478 +9787567134485 +9787567134706 +9787567135734 +9787567137349 +9787567137363 +9787567137370 +9787567138452 +9787567138551 +9787567138575 +9787567138759 +9787567139770 +9787567139800 +9787567139992 +9787567143548 +9787567144026 +9787567145696 +9787567145764 +9787567147935 +9787567149762 +9787567150751 +9787567151031 +9787567151567 +9787567152717 +9787567201774 +9787567202795 +9787567205864 +9787567210004 +9787567211124 +9787567212039 +9787567215252 +9787567228108 +9787567229587 +9787567230422 +9787567230897 +9787567231023 +9787567234208 +9787567234284 +9787567234499 +9787567234543 +9787567235052 +9787567235076 +9787567235687 +9787567235786 +9787567235854 +9787567236509 +9787567236578 +9787567237100 +9787567237124 +9787567237209 +9787567237735 +9787567237919 +9787567238107 +9787567238794 +9787567240520 +9787567241428 +9787567243767 +9787567244139 +9787567244276 +9787567245860 +9787567246249 +9787567246461 +9787567248922 +9787567251113 +9787567252554 +9787567252561 +9787567252578 +9787567300118 +9787567300606 +9787567300897 +9787567302037 +9787567302785 +9787567302891 +9787567303188 +9787567303614 +9787567304871 +9787567305267 +9787567305434 +9787567306264 +9787567306455 +9787567406674 +9787567408630 +9787567411524 +9787567411937 +9787567412040 +9787567412514 +9787567414259 +9787567422063 +9787567423848 +9787567429413 +9787567431348 +9787567500228 +9787567500730 +9787567500747 +9787567501577 +9787567501584 +9787567502222 +9787567503328 +9787567504110 +9787567506381 +9787567506398 +9787567506404 +9787567506411 +9787567507562 +9787567508217 +9787567508224 +9787567508767 +9787567519718 +9787567519725 +9787567520561 +9787567521278 +9787567522442 +9787567522930 +9787567527218 +9787567531338 +9787567532298 +9787567532960 +9787567537668 +9787567542747 +9787567543003 +9787567544017 +9787567545823 +9787567549357 +9787567550407 +9787567555297 +9787567555518 +9787567560260 +9787567565487 +9787567566941 +9787567567344 +9787567571341 +9787567571440 +9787567573130 +9787567573857 +9787567574403 +9787567575622 +9787567576049 +9787567576193 +9787567576872 +9787567577503 +9787567578371 +9787567579323 +9787567579767 +9787567582828 +9787567584600 +9787567585584 +9787567585850 +9787567587724 +9787567587748 +9787567589599 +9787567590649 +9787567593077 +9787567594210 +9787567594227 +9787567594562 +9787567596023 +9787567597266 +9787567597662 +9787567601031 +9787567610934 +9787567610941 +9787567616141 +9787567617117 +9787567622647 +9787567627543 +9787567629974 +9787567630802 +9787567634954 +9787567635791 +9787567637153 +9787567638297 +9787567641785 +9787567641846 +9787567641853 +9787567641884 +9787567641938 +9787567641945 +9787567642386 +9787567642881 +9787567642904 +9787567642911 +9787567642935 +9787567643307 +9787567644069 +9787567644243 +9787567644915 +9787567645684 +9787567645707 +9787567646063 +9787567649736 +9787567651166 +9787567651289 +9787567652989 +9787567653412 +9787567654129 +9787567656222 +9787567656987 +9787567657793 +9787567657823 +9787567665965 +9787567666009 +9787567666979 +9787567667174 +9787567667730 +9787567667839 +9787567667846 +9787567670310 +9787567701403 +9787567706903 +9787567710856 +9787567711617 +9787567721098 +9787567723498 +9787567723504 +9787567723610 +9787567724785 +9787567725478 +9787567727984 +9787567730267 +9787567730342 +9787567730830 +9787567733268 +9787567733305 +9787567739857 +9787567742529 +9787567742604 +9787567753754 +9787567753808 +9787567755840 +9787567764422 +9787567765139 +9787567768963 +9787567777460 +9787567778634 +9787567778962 +9787567780088 +9787567781580 +9787567783911 +9787567785960 +9787567794764 +9787567796577 +9787567798199 +9787567799448 +9787567799592 +9787567800687 +9787567801080 +9787567802094 +9787567803657 +9787567803794 +9787567809086 +9787567809147 +9787567810600 +9787567813595 +9787567813724 +9787567814035 +9787567815490 +9787567900929 +9787567902893 +9787567905313 +9787567905450 +9787567905580 +9787567905610 +9787567906082 +9787567912526 +9787567912991 +9787567915183 +9787567915503 +9787567915978 +9787567916180 +9787567916890 +9787567917293 +9787567917491 +9787567917583 +9787567918078 +9787567920583 +9787567921030 +9787567921375 +9787567921634 +9787567922389 +9787567924307 +9787567924857 +9787567924956 +9787567925656 +9787568000833 +9787568003087 +9787568004237 +9787568004435 +9787568004633 +9787568011020 +9787568011037 +9787568011365 +9787568015905 +9787568018784 +9787568020138 +9787568021517 +9787568021739 +9787568021746 +9787568021876 +9787568022415 +9787568025850 +9787568031332 +9787568035019 +9787568038386 +9787568039314 +9787568040914 +9787568041188 +9787568041973 +9787568044691 +9787568045285 +9787568046213 +9787568047272 +9787568047821 +9787568048514 +9787568050289 +9787568050753 +9787568050760 +9787568050807 +9787568053846 +9787568054362 +9787568058032 +9787568059138 +9787568063722 +9787568067553 +9787568069427 +9787568072601 +9787568073486 +9787568073967 +9787568074957 +9787568076159 +9787568082020 +9787568083218 +9787568087025 +9787568088572 +9787568093200 +9787568093446 +9787568093637 +9787568093644 +9787568097239 +9787568097642 +9787568099073 +9787568099097 +9787568101585 +9787568101592 +9787568106955 +9787568107099 +9787568109567 +9787568109604 +9787568116367 +9787568121163 +9787568121927 +9787568122863 +9787568122870 +9787568123211 +9787568130943 +9787568130967 +9787568133067 +9787568133135 +9787568134705 +9787568147392 +9787568147835 +9787568150224 +9787568150514 +9787568150859 +9787568151924 +9787568154994 +9787568156172 +9787568156738 +9787568161015 +9787568161473 +9787568161510 +9787568162357 +9787568162869 +9787568164344 +9787568164757 +9787568164771 +9787568164788 +9787568164795 +9787568164894 +9787568164931 +9787568164979 +9787568165082 +9787568165235 +9787568165365 +9787568165372 +9787568165488 +9787568166652 +9787568168670 +9787568169295 +9787568171922 +9787568172455 +9787568173438 +9787568174190 +9787568174206 +9787568176989 +9787568177184 +9787568177481 +9787568177634 +9787568178013 +9787568178488 +9787568179188 +9787568179294 +9787568180160 +9787568180641 +9787568181150 +9787568181280 +9787568181433 +9787568181778 +9787568181785 +9787568182577 +9787568182966 +9787568183697 +9787568184151 +9787568184168 +9787568184304 +9787568185226 +9787568186254 +9787568186360 +9787568188081 +9787568188272 +9787568188920 +9787568189125 +9787568189415 +9787568190565 +9787568191319 +9787568191531 +9787568191722 +9787568193023 +9787568193047 +9787568194488 +9787568194723 +9787568194945 +9787568196246 +9787568198738 +9787568198899 +9787568198905 +9787568204460 +9787568204958 +9787568204989 +9787568205306 +9787568205986 +9787568206273 +9787568209588 +9787568212328 +9787568215787 +9787568216142 +9787568219747 +9787568222396 +9787568224888 +9787568227742 +9787568233323 +9787568240673 +9787568241595 +9787568244015 +9787568244251 +9787568245173 +9787568245210 +9787568245531 +9787568246125 +9787568250733 +9787568252621 +9787568254168 +9787568254571 +9787568256070 +9787568256582 +9787568260183 +9787568262392 +9787568265331 +9787568266505 +9787568268035 +9787568270113 +9787568270168 +9787568271950 +9787568272001 +9787568272650 +9787568272834 +9787568274852 +9787568275118 +9787568275408 +9787568275767 +9787568275866 +9787568276368 +9787568276443 +9787568276535 +9787568277037 +9787568277471 +9787568277730 +9787568277815 +9787568277969 +9787568277990 +9787568278003 +9787568278096 +9787568278348 +9787568278843 +9787568278935 +9787568279079 +9787568279116 +9787568279574 +9787568280983 +9787568284493 +9787568284806 +9787568285797 +9787568287296 +9787568287708 +9787568288125 +9787568288491 +9787568289269 +9787568289511 +9787568290494 +9787568291293 +9787568291378 +9787568291637 +9787568292153 +9787568292696 +9787568292849 +9787568294171 +9787568294331 +9787568294423 +9787568294430 +9787568294614 +9787568294676 +9787568295024 +9787568295390 +9787568296779 +9787568297127 +9787568297226 +9787568297929 +9787568298025 +9787568298100 +9787568298292 +9787568298957 +9787568299176 +9787568308335 +9787568400657 +9787568402507 +9787568407328 +9787568407731 +9787568407779 +9787568407915 +9787568408288 +9787568408769 +9787568411189 +9787568411509 +9787568411882 +9787568411936 +9787568412032 +9787568412773 +9787568414142 +9787568414210 +9787568414371 +9787568414951 +9787568415415 +9787568415590 +9787568416115 +9787568416177 +9787568416191 +9787568416795 +9787568416801 +9787568417082 +9787568417624 +9787568417860 +9787568417945 +9787568418768 +9787568419024 +9787568419154 +9787568419215 +9787568419611 +9787568419697 +9787568419796 +9787568420143 +9787568420181 +9787568420471 +9787568420785 +9787568420907 +9787568421010 +9787568421775 +9787568422499 +9787568422703 +9787568492157 +9787568500197 +9787568502214 +9787568505628 +9787568506038 +9787568507998 +9787568508032 +9787568509121 +9787568510219 +9787568510561 +9787568510721 +9787568511353 +9787568512619 +9787568513654 +9787568513852 +9787568515795 +9787568516075 +9787568516136 +9787568517294 +9787568517478 +9787568519489 +9787568519571 +9787568522649 +9787568523301 +9787568523615 +9787568523738 +9787568523806 +9787568524636 +9787568526227 +9787568526579 +9787568527248 +9787568528276 +9787568528283 +9787568528511 +9787568529228 +9787568529549 +9787568529716 +9787568529815 +9787568530743 +9787568531030 +9787568531276 +9787568531979 +9787568532907 +9787568533270 +9787568534215 +9787568534550 +9787568535076 +9787568535083 +9787568535113 +9787568535151 +9787568536417 +9787568536783 +9787568537124 +9787568537148 +9787568537421 +9787568537513 +9787568538077 +9787568539708 +9787568539814 +9787568539999 +9787568541343 +9787568541350 +9787568541589 +9787568541619 +9787568542067 +9787568542869 +9787568543187 +9787568543934 +9787568544016 +9787568544054 +9787568544306 +9787568544443 +9787568544962 +9787568546805 +9787568548670 +9787568548823 +9787568549318 +9787568549325 +9787568549615 +9787568549714 +9787568550222 +9787568550253 +9787568550314 +9787568551045 +9787568551441 +9787568551977 +9787568553223 +9787568553605 +9787568601405 +9787568601610 +9787568602167 +9787568602822 +9787568602914 +9787568604277 +9787568604567 +9787568604680 +9787568606097 +9787568607209 +9787568607650 +9787568608039 +9787568609791 +9787568609913 +9787568610582 +9787568702706 +9787568703833 +9787568704571 +9787568706698 +9787568707015 +9787568708500 +9787568714556 +9787568800662 +9787568800808 +9787568801843 +9787568803991 +9787568804561 +9787568804578 +9787568804592 +9787568804653 +9787568804936 +9787568804967 +9787568805438 +9787568806015 +9787568806381 +9787568808255 +9787568808507 +9787568814577 +9787568825511 +9787568826648 +9787568827362 +9787568828642 +9787568830287 +9787568833066 +9787568833172 +9787568833240 +9787568834827 +9787568839303 +9787568839853 +9787568840002 +9787568840040 +9787568840064 +9787568845410 +9787568847247 +9787568855570 +9787568855594 +9787568865067 +9787568865074 +9787568866163 +9787568866255 +9787568867443 +9787568868594 +9787568870351 +9787568871365 +9787568872706 +9787568880831 +9787568880947 +9787568884051 +9787568884860 +9787568885928 +9787568886000 +9787568887007 +9787568887014 +9787568891974 +9787568893916 +9787568898713 +9787568901864 +9787568902205 +9787568902267 +9787568902427 +9787568906234 +9787568907675 +9787568907842 +9787568909747 +9787568910408 +9787568913324 +9787568913331 +9787568914680 +9787568914758 +9787568916387 +9787568917568 +9787568917902 +9787568918268 +9787568919067 +9787568919388 +9787568919517 +9787568920285 +9787568921237 +9787568921442 +9787568921602 +9787568922111 +9787568922654 +9787568922838 +9787568923927 +9787568924245 +9787568924252 +9787568924566 +9787568924795 +9787568924887 +9787568924900 +9787568925174 +9787568925266 +9787568925297 +9787568925624 +9787568925730 +9787568925747 +9787568925914 +9787568926355 +9787568926461 +9787568927529 +9787568927642 +9787568927659 +9787568928014 +9787568928243 +9787568928458 +9787568928489 +9787568929233 +9787568929264 +9787568929967 +9787568931403 +9787568932554 +9787568932998 +9787568933360 +9787568933605 +9787568935227 +9787568937849 +9787568938501 +9787568939171 +9787568940191 +9787568941013 +9787568941457 +9787568941846 +9787568942966 +9787568943093 +9787568943659 +9787568944755 +9787568945479 +9787568945547 +9787568945615 +9787568945783 +9787568946148 +9787568946353 +9787568946605 +9787568946919 +9787568947916 +9787568948098 +9787568948531 +9787568948906 +9787568948951 +9787568949316 +9787568949774 +9787568950381 +9787569003307 +9787569004687 +9787569004694 +9787569007367 +9787569007398 +9787569007510 +9787569008593 +9787569009262 +9787569010527 +9787569010602 +9787569010657 +9787569012835 +9787569014327 +9787569014389 +9787569015065 +9787569015546 +9787569017861 +9787569024333 +9787569025576 +9787569030457 +9787569033328 +9787569033809 +9787569034394 +9787569041064 +9787569047257 +9787569047998 +9787569048544 +9787569048780 +9787569048797 +9787569049091 +9787569049473 +9787569053937 +9787569056143 +9787569061932 +9787569065749 +9787569067736 +9787569067811 +9787569069297 +9787569070118 +9787569070736 +9787569072136 +9787569072327 +9787569072730 +9787569073317 +9787569073324 +9787569073355 +9787569073447 +9787569073492 +9787569074956 +9787569100372 +9787569102604 +9787569102703 +9787569103335 +9787569103410 +9787569103595 +9787569104387 +9787569104509 +9787569104660 +9787569104776 +9787569105025 +9787569105148 +9787569107364 +9787569108095 +9787569108125 +9787569108903 +9787569109924 +9787569201659 +9787569205008 +9787569205053 +9787569206401 +9787569210088 +9787569214413 +9787569225013 +9787569225594 +9787569228854 +9787569231373 +9787569232301 +9787569241686 +9787569247480 +9787569253337 +9787569254570 +9787569258110 +9787569261776 +9787569263749 +9787569264357 +9787569266092 +9787569268379 +9787569268812 +9787569269567 +9787569270587 +9787569270808 +9787569271003 +9787569273212 +9787569276176 +9787569276213 +9787569277647 +9787569278446 +9787569278453 +9787569279818 +9787569281286 +9787569282320 +9787569282382 +9787569282573 +9787569283037 +9787569283051 +9787569284744 +9787569294743 +9787569295603 +9787569296273 +9787569296433 +9787569296617 +9787569296778 +9787569302929 +9787569307269 +9787569307917 +9787569308259 +9787569309669 +9787569310009 +9787569310757 +9787569313239 +9787569313932 +9787569314908 +9787569314960 +9787569318692 +9787569319798 +9787569320299 +9787569322798 +9787569326154 +9787569327847 +9787569328141 +9787569328288 +9787569328394 +9787569328592 +9787569328783 +9787569329834 +9787569329902 +9787569330366 +9787569330526 +9787569331127 +9787569331240 +9787569332674 +9787569333022 +9787569334876 +9787569335521 +9787569335811 +9787569335941 +9787569336603 +9787569338508 +9787569338997 +9787569400632 +9787569403374 +9787569403671 +9787569425277 +9787569426076 +9787569428421 +9787569428469 +9787569430110 +9787569435177 +9787569437485 +9787569447606 +9787569500028 +9787569500097 +9787569500592 +9787569500721 +9787569501193 +9787569502596 +9787569503494 +9787569504187 +9787569504927 +9787569505085 +9787569505238 +9787569505252 +9787569505306 +9787569506044 +9787569506211 +9787569507263 +9787569510553 +9787569512106 +9787569512335 +9787569512342 +9787569513387 +9787569513943 +9787569513950 +9787569514131 +9787569514148 +9787569514377 +9787569514414 +9787569516654 +9787569517323 +9787569518146 +9787569518627 +9787569518634 +9787569519655 +9787569520019 +9787569520552 +9787569520569 +9787569520606 +9787569520637 +9787569520750 +9787569520866 +9787569521498 +9787569521528 +9787569521726 +9787569521917 +9787569522150 +9787569522570 +9787569522846 +9787569523065 +9787569526103 +9787569526776 +9787569529807 +9787569529876 +9787569529883 +9787569530766 +9787569531992 +9787569533811 +9787569534306 +9787569534382 +9787569534399 +9787569534405 +9787569534412 +9787569534429 +9787569534870 +9787569534993 +9787569535594 +9787569535853 +9787569536874 +9787569536881 +9787569537314 +9787569538335 +9787569538380 +9787569539530 +9787569539769 +9787569540215 +9787569540673 +9787569542158 +9787569542493 +9787569542974 +9787569543988 +9787569544510 +9787569545357 +9787569545364 +9787569545494 +9787569545548 +9787569545555 +9787569545944 +9787569546064 +9787569546835 +9787569547177 +9787569547528 +9787569549355 +9787569550238 +9787569553918 +9787569555929 +9787569600117 +9787569600278 +9787569601169 +9787569601237 +9787569601244 +9787569601749 +9787569601763 +9787569601862 +9787569602210 +9787569602531 +9787569603064 +9787569603750 +9787569700732 +9787569701876 +9787569702392 +9787569702927 +9787569703795 +9787569704419 +9787569704624 +9787569704990 +9787569705065 +9787569706109 +9787569707120 +9787569707694 +9787569707724 +9787569708318 +9787569708592 +9787569709407 +9787569710328 +9787569710519 +9787569711271 +9787569713251 +9787569713268 +9787569713381 +9787569713930 +9787569714029 +9787569716405 +9787569716863 +9787569716979 +9787569717792 +9787569717808 +9787569717877 +9787569718577 +9787569718959 +9787569719192 +9787569720228 +9787569720327 +9787569720457 +9787569720501 +9787569720518 +9787569720532 +9787569720600 +9787569720679 +9787569721720 +9787569721751 +9787569721843 +9787569722536 +9787569722994 +9787569723243 +9787569723465 +9787569724943 +9787569726992 +9787569729900 +9787569800531 +9787569800951 +9787569803006 +9787569803020 +9787569804270 +9787569805505 +9787569805703 +9787569807318 +9787569900187 +9787569900521 +9787569901429 +9787569902020 +9787569902389 +9787569903027 +9787569903034 +9787569906660 +9787569906851 +9787569907384 +9787569908428 +9787569908640 +9787569910902 +9787569911787 +9787569912159 +9787569912241 +9787569915693 +9787569917383 +9787569924824 +9787569926521 +9787569926781 +9787569927146 +9787569927467 +9787569928303 +9787569928341 +9787569931686 +9787569932188 +9787569932942 +9787569933598 +9787569933857 +9787569933963 +9787569934830 +9787569936278 +9787569936292 +9787569936575 +9787569937312 +9787569937602 +9787569937640 +9787569938272 +9787569938289 +9787569938722 +9787569939866 +9787569939897 +9787569940800 +9787569941067 +9787569941678 +9787569942149 +9787569942217 +9787569942729 +9787569942880 +9787569944136 +9787569946161 +9787569946710 +9787569947144 +9787569947267 +9787569947540 +9787569949148 +9787569949988 +9787569950328 +9787569950410 +9787569950458 +9787569950663 +9787569950700 +9787569951028 +9787569951141 +9787569953985 +9787569955095 +9787569956689 +9787569957938 +9787569959321 +9787569959451 +9787569959710 +9787569959871 +9787570001675 +9787570002368 +9787570002382 +9787570003549 +9787570003570 +9787570003792 +9787570007769 +9787570067336 +9787570102976 +9787570105649 +9787570106424 +9787570107391 +9787570107476 +9787570108480 +9787570108763 +9787570110056 +9787570110629 +9787570110704 +9787570110711 +9787570110728 +9787570110742 +9787570110810 +9787570110827 +9787570111237 +9787570111305 +9787570111398 +9787570111404 +9787570111411 +9787570111428 +9787570111503 +9787570111763 +9787570111787 +9787570111909 +9787570112166 +9787570113323 +9787570113804 +9787570114443 +9787570114450 +9787570114566 +9787570114696 +9787570116041 +9787570118731 +9787570118977 +9787570119066 +9787570119530 +9787570119875 +9787570120079 +9787570123773 +9787570125173 +9787570125227 +9787570125265 +9787570125296 +9787570125708 +9787570126668 +9787570127078 +9787570127207 +9787570127238 +9787570127351 +9787570128600 +9787570128617 +9787570128631 +9787570130184 +9787570130443 +9787570131754 +9787570132102 +9787570132126 +9787570133031 +9787570200825 +9787570201297 +9787570205141 +9787570205165 +9787570205233 +9787570205608 +9787570207404 +9787570208135 +9787570208142 +9787570208333 +9787570210404 +9787570211272 +9787570211463 +9787570212118 +9787570213429 +9787570213832 +9787570214914 +9787570215867 +9787570218172 +9787570219520 +9787570220151 +9787570221554 +9787570222285 +9787570225927 +9787570226115 +9787570226672 +9787570226696 +9787570226702 +9787570227143 +9787570227259 +9787570227488 +9787570228379 +9787570228799 +9787570228843 +9787570228867 +9787570228935 +9787570229499 +9787570229505 +9787570229536 +9787570229895 +9787570229956 +9787570230457 +9787570231119 +9787570231331 +9787570231430 +9787570231799 +9787570231874 +9787570231898 +9787570231911 +9787570231928 +9787570231942 +9787570233229 +9787570233359 +9787570233717 +9787570233748 +9787570233762 +9787570233786 +9787570233823 +9787570233861 +9787570233878 +9787570233953 +9787570233977 +9787570234134 +9787570235148 +9787570235308 +9787570236343 +9787570236855 +9787570236862 +9787570236886 +9787570237340 +9787570237401 +9787570237609 +9787570237753 +9787570238118 +9787570238156 +9787570238170 +9787570238422 +9787570238569 +9787570238583 +9787570238651 +9787570238668 +9787570238675 +9787570238682 +9787570238699 +9787570238705 +9787570238712 +9787570238729 +9787570238736 +9787570238743 +9787570238965 +9787570239030 +9787570239238 +9787570240180 +9787570240579 +9787570303397 +9787570304387 +9787570304998 +9787570305551 +9787570305698 +9787570305704 +9787570308095 +9787570308408 +9787570311484 +9787570312092 +9787570318308 +9787570327867 +9787570333844 +9787570335664 +9787570340576 +9787570400850 +9787570400911 +9787570401314 +9787570401321 +9787570401383 +9787570402106 +9787570402397 +9787570402960 +9787570403011 +9787570403028 +9787570403059 +9787570403394 +9787570403486 +9787570405039 +9787570406548 +9787570407408 +9787570408344 +9787570408528 +9787570408627 +9787570409525 +9787570409549 +9787570409600 +9787570411054 +9787570411115 +9787570411818 +9787570412341 +9787570412358 +9787570412365 +9787570413140 +9787570413157 +9787570413362 +9787570413423 +9787570413447 +9787570413508 +9787570414284 +9787570414758 +9787570414833 +9787570415298 +9787570415311 +9787570415328 +9787570415946 +9787570417094 +9787570417100 +9787570417117 +9787570417124 +9787570418374 +9787570418527 +9787570418565 +9787570419210 +9787570419944 +9787570419968 +9787570420261 +9787570420278 +9787570420865 +9787570420926 +9787570420957 +9787570420971 +9787570421145 +9787570421213 +9787570421329 +9787570421541 +9787570421565 +9787570421589 +9787570421817 +9787570421831 +9787570421855 +9787570421954 +9787570422418 +9787570422616 +9787570424429 +9787570424566 +9787570424887 +9787570424894 +9787570424955 +9787570425013 +9787570425044 +9787570425976 +9787570426027 +9787570426065 +9787570426805 +9787570427291 +9787570427307 +9787570427314 +9787570427321 +9787570427345 +9787570427673 +9787570427697 +9787570427840 +9787570428014 +9787570428786 +9787570428793 +9787570428960 +9787570429035 +9787570429042 +9787570429318 +9787570429325 +9787570429332 +9787570429592 +9787570430727 +9787570430963 +9787570431045 +9787570431090 +9787570431205 +9787570431236 +9787570431243 +9787570431915 +9787570431922 +9787570432035 +9787570432042 +9787570432226 +9787570432295 +9787570432370 +9787570432394 +9787570433773 +9787570433797 +9787570433858 +9787570433865 +9787570433872 +9787570433889 +9787570434282 +9787570435357 +9787570435364 +9787570435494 +9787570435500 +9787570435517 +9787570435555 +9787570435593 +9787570435913 +9787570436033 +9787570436040 +9787570436200 +9787570436217 +9787570436224 +9787570436231 +9787570436279 +9787570436286 +9787570436460 +9787570437214 +9787570437221 +9787570437245 +9787570437689 +9787570437696 +9787570437719 +9787570437726 +9787570437757 +9787570437764 +9787570437788 +9787570438754 +9787570439881 +9787570440245 +9787570440610 +9787570440924 +9787570440993 +9787570442225 +9787570442737 +9787570443604 +9787570443666 +9787570443673 +9787570443895 +9787570444021 +9787570444076 +9787570444441 +9787570444809 +9787570446674 +9787570447121 +9787570447138 +9787570447244 +9787570447381 +9787570447565 +9787570447596 +9787570447862 +9787570448067 +9787570448104 +9787570448111 +9787570449132 +9787570450718 +9787570450886 +9787570452491 +9787570453443 +9787570453658 +9787570453726 +9787570455157 +9787570456390 +9787570456420 +9787570456468 +9787570457762 +9787570458677 +9787570460106 +9787570460632 +9787570461523 +9787570462230 +9787570463022 +9787570463091 +9787570463411 +9787570463510 +9787570463701 +9787570464067 +9787570464401 +9787570464456 +9787570465828 +9787570466443 +9787570467051 +9787570472093 +9787570472109 +9787570475728 +9787570500048 +9787570500802 +9787570501274 +9787570502790 +9787570502950 +9787570503179 +9787570503216 +9787570505258 +9787570508266 +9787570509362 +9787570509386 +9787570509737 +9787570511228 +9787570513758 +9787570513772 +9787570516537 +9787570516803 +9787570516896 +9787570516919 +9787570516971 +9787570517046 +9787570518074 +9787570518654 +9787570519385 +9787570519439 +9787570519842 +9787570520435 +9787570520442 +9787570520466 +9787570521111 +9787570521128 +9787570521142 +9787570521555 +9787570525515 +9787570526734 +9787570529759 +9787570530823 +9787570535590 +9787570535828 +9787570535859 +9787570536658 +9787570536689 +9787570536719 +9787570536726 +9787570537846 +9787570538430 +9787570538959 +9787570540044 +9787570543380 +9787570543571 +9787570544585 +9787570544608 +9787570544646 +9787570546428 +9787570601592 +9787570606429 +9787570609413 +9787570611652 +9787570611935 +9787570612444 +9787570612468 +9787570612963 +9787570615575 +9787570615872 +9787570618637 +9787570619276 +9787570619306 +9787570619580 +9787570622757 +9787570623174 +9787570623419 +9787570626403 +9787570631520 +9787570632749 +9787570635023 +9787570635535 +9787570635566 +9787570636167 +9787570641635 +9787570642366 +9787570700325 +9787570700332 +9787570701407 +9787570701650 +9787570701681 +9787570702510 +9787570702657 +9787570702664 +9787570703036 +9787570703142 +9787570703661 +9787570703708 +9787570703913 +9787570704019 +9787570704286 +9787570704545 +9787570704590 +9787570704859 +9787570705443 +9787570705559 +9787570705832 +9787570706471 +9787570707003 +9787570707669 +9787570708048 +9787570708659 +9787570708895 +9787570708925 +9787570709199 +9787570709243 +9787570709250 +9787570709335 +9787570710102 +9787570710119 +9787570710737 +9787570710744 +9787570710751 +9787570710768 +9787570710782 +9787570710898 +9787570710935 +9787570711079 +9787570711383 +9787570712748 +9787570712984 +9787570713646 +9787570713707 +9787570713738 +9787570714070 +9787570714629 +9787570714889 +9787570714957 +9787570715022 +9787570715039 +9787570715251 +9787570715268 +9787570715381 +9787570715527 +9787570716449 +9787570716463 +9787570716524 +9787570716692 +9787570716968 +9787570717170 +9787570717194 +9787570717279 +9787570718351 +9787570718856 +9787570718931 +9787570719426 +9787570719433 +9787570719617 +9787570719662 +9787570719679 +9787570719884 +9787570719891 +9787570719969 +9787570720040 +9787570720170 +9787570720224 +9787570720248 +9787570720675 +9787570720729 +9787570720965 +9787570720972 +9787570720989 +9787570721146 +9787570721160 +9787570721382 +9787570721726 +9787570721740 +9787570721825 +9787570721962 +9787570722082 +9787570722181 +9787570722198 +9787570722303 +9787570722488 +9787570722495 +9787570722761 +9787570722839 +9787570723591 +9787570723720 +9787570724222 +9787570724390 +9787570724420 +9787570724727 +9787570724758 +9787570726011 +9787570804474 +9787570808823 +9787570809028 +9787570809301 +9787570810062 +9787570810147 +9787570810154 +9787570810161 +9787570811151 +9787570811663 +9787570812479 +9787570813254 +9787570815944 +9787570817788 +9787570818068 +9787570818112 +9787570818228 +9787570818488 +9787570819386 +9787570819775 +9787570820474 +9787570820504 +9787570821938 +9787570822348 +9787570822461 +9787570822577 +9787570822645 +9787570823109 +9787570823666 +9787570823734 +9787570824427 +9787570826209 +9787570828173 +9787570828876 +9787570900022 +9787570912698 +9787570914944 +9787570917976 +9787570921249 +9787570921379 +9787570923731 +9787570927371 +9787570929917 +9787570929955 +9787570930005 +9787570930104 +9787570930210 +9787570930616 +9787570930630 +9787570931057 +9787570933969 +9787570934003 +9787570934348 +9787570934515 +9787570938353 +9787570939237 +9787570940530 +9787570942763 +9787570942831 +9787570942961 +9787571000547 +9787571000783 +9787571001452 +9787571001643 +9787571001667 +9787571001810 +9787571001940 +9787571002862 +9787571004736 +9787571007188 +9787571007195 +9787571010379 +9787571010409 +9787571010584 +9787571010812 +9787571010829 +9787571010836 +9787571012670 +9787571015053 +9787571015268 +9787571015565 +9787571015664 +9787571017385 +9787571018993 +9787571020231 +9787571020798 +9787571021177 +9787571021696 +9787571022433 +9787571023041 +9787571023478 +9787571023515 +9787571023805 +9787571023904 +9787571024185 +9787571024802 +9787571025021 +9787571025106 +9787571025625 +9787571026820 +9787571026844 +9787571027827 +9787571028213 +9787571028367 +9787571028787 +9787571028862 +9787571028879 +9787571028893 +9787571028978 +9787571029265 +9787571029388 +9787571030230 +9787571030988 +9787571031244 +9787571031411 +9787571032098 +9787571032104 +9787571032463 +9787571032562 +9787571033224 +9787571033231 +9787571034054 +9787571034344 +9787571035006 +9787571035969 +9787571100001 +9787571101534 +9787571102470 +9787571103279 +9787571104573 +9787571104603 +9787571106195 +9787571106294 +9787571107277 +9787571107604 +9787571107611 +9787571108113 +9787571110437 +9787571112592 +9787571112806 +9787571112936 +9787571114091 +9787571114473 +9787571115203 +9787571115821 +9787571117078 +9787571117559 +9787571118600 +9787571118983 +9787571119324 +9787571119430 +9787571122089 +9787571124816 +9787571125394 +9787571125615 +9787571200015 +9787571201432 +9787571204556 +9787571206062 +9787571206079 +9787571207991 +9787571208066 +9787571208240 +9787571208745 +9787571209278 +9787571209490 +9787571211073 +9787571211509 +9787571212063 +9787571212117 +9787571212162 +9787571212179 +9787571213800 +9787571213824 +9787571213831 +9787571214029 +9787571215514 +9787571216160 +9787571216191 +9787571222475 +9787571223199 +9787571223564 +9787571223687 +9787571223779 +9787571223823 +9787571224295 +9787571303051 +9787571310011 +9787571310196 +9787571310998 +9787571311636 +9787571313111 +9787571315337 +9787571318369 +9787571318536 +9787571321666 +9787571322014 +9787571322335 +9787571324100 +9787571324711 +9787571327453 +9787571328252 +9787571328641 +9787571329457 +9787571329617 +9787571330798 +9787571330873 +9787571332006 +9787571332099 +9787571332877 +9787571333164 +9787571333614 +9787571334383 +9787571334741 +9787571335465 +9787571335472 +9787571335717 +9787571335861 +9787571337339 +9787571337568 +9787571337650 +9787571338503 +9787571339050 +9787571339067 +9787571339531 +9787571340490 +9787571340612 +9787571342258 +9787571342661 +9787571342944 +9787571343293 +9787571343569 +9787571343835 +9787571343903 +9787571344283 +9787571344733 +9787571345006 +9787571346157 +9787571346164 +9787571346775 +9787571346959 +9787571346980 +9787571347048 +9787571347253 +9787571347529 +9787571350000 +9787571352165 +9787571352745 +9787571353599 +9787571402099 +9787571403454 +9787571403898 +9787571404062 +9787571404093 +9787571405588 +9787571405991 +9787571406004 +9787571406165 +9787571406578 +9787571406592 +9787571406868 +9787571407841 +9787571407865 +9787571407872 +9787571408084 +9787571408176 +9787571408756 +9787571409050 +9787571409845 +9787571410087 +9787571410261 +9787571411459 +9787571412128 +9787571412340 +9787571413361 +9787571413569 +9787571413583 +9787571414092 +9787571414559 +9787571414719 +9787571415099 +9787571415716 +9787571415976 +9787571415983 +9787571416003 +9787571416393 +9787571416621 +9787571416645 +9787571416676 +9787571417093 +9787571417598 +9787571418038 +9787571418045 +9787571418755 +9787571419578 +9787571420635 +9787571420642 +9787571420659 +9787571420697 +9787571421946 +9787571422011 +9787571422172 +9787571422318 +9787571422509 +9787571422516 +9787571423438 +9787571423667 +9787571425043 +9787571425432 +9787571425616 +9787571426170 +9787571426590 +9787571426620 +9787571426897 +9787571427238 +9787571427252 +9787571428082 +9787571429430 +9787571429959 +9787571430535 +9787571430573 +9787571430740 +9787571430757 +9787571430764 +9787571431334 +9787571431358 +9787571431464 +9787571431693 +9787571431990 +9787571432331 +9787571432362 +9787571432409 +9787571432669 +9787571432690 +9787571433741 +9787571433758 +9787571433772 +9787571433796 +9787571434267 +9787571434410 +9787571434588 +9787571435127 +9787571435820 +9787571435899 +9787571436001 +9787571436599 +9787571436629 +9787571436681 +9787571436810 +9787571437862 +9787571438104 +9787571438265 +9787571438272 +9787571438463 +9787571438470 +9787571438524 +9787571438531 +9787571438562 +9787571438753 +9787571439071 +9787571439132 +9787571439323 +9787571439866 +9787571439965 +9787571439972 +9787571440213 +9787571440237 +9787571440572 +9787571440961 +9787571441074 +9787571441098 +9787571441395 +9787571441715 +9787571441760 +9787571441838 +9787571441845 +9787571441852 +9787571441869 +9787571441876 +9787571441883 +9787571442019 +9787571442033 +9787571442095 +9787571442378 +9787571442484 +9787571442699 +9787571442743 +9787571443030 +9787571443122 +9787571443276 +9787571443283 +9787571443320 +9787571443337 +9787571443399 +9787571443467 +9787571443504 +9787571443658 +9787571443986 +9787571444013 +9787571444037 +9787571444051 +9787571444235 +9787571444242 +9787571444648 +9787571444945 +9787571445010 +9787571445423 +9787571447199 +9787571500870 +9787571501549 +9787571501808 +9787571501969 +9787571502034 +9787571502232 +9787571504731 +9787571505875 +9787571506025 +9787571506087 +9787571506230 +9787571506308 +9787571506346 +9787571506902 +9787571507466 +9787571508319 +9787571508760 +9787571508777 +9787571508821 +9787571510909 +9787571511623 +9787571511661 +9787571512033 +9787571512248 +9787571512538 +9787571512835 +9787571512897 +9787571516321 +9787571516895 +9787571518714 +9787571518905 +9787571519148 +9787571519407 +9787571520137 +9787571520144 +9787571520151 +9787571520762 +9787571520984 +9787571521462 +9787571521486 +9787571523268 +9787571523329 +9787571523381 +9787571523435 +9787571523664 +9787571524876 +9787571601614 +9787571601638 +9787571602796 +9787571602901 +9787571602918 +9787571603366 +9787571603410 +9787571604561 +9787571604585 +9787571607524 +9787571608910 +9787571609399 +9787571609924 +9787571613822 +9787571615215 +9787571615918 +9787571615932 +9787571617004 +9787571617226 +9787571617790 +9787571618285 +9787571619442 +9787571619640 +9787571619664 +9787571619800 +9787571619886 +9787571621018 +9787571621049 +9787571621117 +9787571622671 +9787571623920 +9787571623937 +9787571623975 +9787571625412 +9787571625672 +9787571625689 +9787571627959 +9787571628482 +9787571629458 +9787571630362 +9787571630386 +9787571630584 +9787571631642 +9787571631741 +9787571632779 +9787571634537 +9787571635077 +9787571635374 +9787571635725 +9787571636463 +9787571637446 +9787571637781 +9787571638443 +9787571638641 +9787571638863 +9787571639884 +9787571641115 +9787571641993 +9787571643881 +9787571644192 +9787571645076 +9787571645465 +9787571645557 +9787571647223 +9787571647520 +9787571648688 +9787571648695 +9787571700539 +9787571703264 +9787571703943 +9787571705909 +9787571707033 +9787571707255 +9787571713331 +9787571713348 +9787571713355 +9787571713393 +9787571714543 +9787571714734 +9787571717018 +9787571717353 +9787571718831 +9787571719128 +9787571719272 +9787571720179 +9787571720186 +9787571721060 +9787571723798 +9787571800758 +9787571800956 +9787571801175 +9787571801472 +9787571802240 +9787571806118 +9787571807337 +9787571807443 +9787571808082 +9787571809997 +9787571811020 +9787571813000 +9787571813796 +9787571814236 +9787571814830 +9787571816018 +9787571816155 +9787571818173 +9787571819798 +9787571821876 +9787571823740 +9787571902803 +9787571906931 +9787571907303 +9787571909871 +9787571911140 +9787571915407 +9787571916787 +9787571917074 +9787571920999 +9787571923808 +9787571924119 +9787571924591 +9787571925895 +9787571925901 +9787571926359 +9787571926366 +9787571926441 +9787571926816 +9787572000065 +9787572000263 +9787572001833 +9787572001840 +9787572001857 +9787572001864 +9787572002168 +9787572003660 +9787572004087 +9787572004216 +9787572004254 +9787572004353 +9787572004650 +9787572004797 +9787572004827 +9787572005299 +9787572006180 +9787572007842 +9787572007866 +9787572008030 +9787572008047 +9787572008061 +9787572008092 +9787572008139 +9787572008146 +9787572008177 +9787572009143 +9787572009662 +9787572009839 +9787572011221 +9787572011238 +9787572011764 +9787572012983 +9787572013072 +9787572014222 +9787572014970 +9787572015472 +9787572016226 +9787572016455 +9787572016493 +9787572018619 +9787572018817 +9787572019135 +9787572019159 +9787572019579 +9787572019593 +9787572022401 +9787572023651 +9787572024337 +9787572024740 +9787572025334 +9787572025471 +9787572025648 +9787572027413 +9787572027635 +9787572028069 +9787572028441 +9787572028687 +9787572028717 +9787572028809 +9787572029042 +9787572029257 +9787572029448 +9787572030086 +9787572030574 +9787572030628 +9787572031007 +9787572031014 +9787572031021 +9787572031748 +9787572031809 +9787572032165 +9787572101717 +9787572101731 +9787572101847 +9787572102288 +9787572102301 +9787572102318 +9787572103599 +9787572103681 +9787572103896 +9787572103926 +9787572103933 +9787572104121 +9787572105784 +9787572105807 +9787572105821 +9787572105906 +9787572107894 +9787572107986 +9787572108259 +9787572108471 +9787572108495 +9787572108754 +9787572109348 +9787572110146 +9787572110948 +9787572111013 +9787572111877 +9787572113352 +9787572113369 +9787572113857 +9787572113901 +9787572113949 +9787572114939 +9787572115080 +9787572115936 +9787572116056 +9787572119262 +9787572119668 +9787572119682 +9787572120541 +9787572120671 +9787572121418 +9787572123726 +9787572123863 +9787572126031 +9787572126055 +9787572126062 +9787572126635 +9787572126666 +9787572127281 +9787572127311 +9787572127489 +9787572127922 +9787572127946 +9787572131479 +9787572131486 +9787572132469 +9787572132834 +9787572134876 +9787572135231 +9787572136665 +9787572136702 +9787572136764 +9787572136771 +9787572136788 +9787572138355 +9787572139666 +9787572140389 +9787572140471 +9787572140488 +9787572140518 +9787572141140 +9787572142116 +9787572142383 +9787572142642 +9787572143250 +9787572143564 +9787572143595 +9787572144141 +9787572145650 +9787572146169 +9787572148064 +9787572148071 +9787572148088 +9787572148095 +9787572148194 +9787572148477 +9787572149412 +9787572149832 +9787572150661 +9787572151170 +9787572152740 +9787572156496 +9787572157837 +9787572158797 +9787572200519 +9787572201189 +9787572201776 +9787572204692 +9787572205941 +9787572207952 +9787572208843 +9787572210280 +9787572210327 +9787572211416 +9787572212611 +9787572212635 +9787572213373 +9787572214820 +9787572216275 +9787572217210 +9787572217241 +9787572219795 +9787572219832 +9787572219955 +9787572220029 +9787572220081 +9787572220968 +9787572221583 +9787572222061 +9787572224010 +9787572224713 +9787572224737 +9787572224768 +9787572226328 +9787572226342 +9787572226373 +9787572226601 +9787572227653 +9787572228230 +9787572229930 +9787572229947 +9787572230325 +9787572231384 +9787572232442 +9787572232480 +9787572232626 +9787572234033 +9787572234170 +9787572234835 +9787572237287 +9787572237294 +9787572237317 +9787572237966 +9787572239243 +9787572239885 +9787572243813 +9787572243820 +9787572243981 +9787572247187 +9787572247200 +9787572247286 +9787572247293 +9787572247309 +9787572247316 +9787572247323 +9787572247330 +9787572252501 +9787572253300 +9787572253409 +9787572254994 +9787572257414 +9787572262722 +9787572262739 +9787572263651 +9787572264177 +9787572264320 +9787572264863 +9787572266454 +9787572267208 +9787572268113 +9787572268144 +9787572268168 +9787572268175 +9787572269646 +9787572270956 +9787572273513 +9787572273537 +9787572274206 +9787572276705 +9787572276767 +9787572276910 +9787572277221 +9787572277382 +9787572278877 +9787572279010 +9787572279317 +9787572281815 +9787572284670 +9787572284991 +9787572287190 +9787572287244 +9787572287794 +9787572287824 +9787572287947 +9787572288333 +9787572288357 +9787572288456 +9787572288821 +9787572289705 +9787572290077 +9787572290756 +9787572294273 +9787572295171 +9787572295645 +9787572296987 +9787572298301 +9787572298806 +9787572301438 +9787572302725 +9787572303166 +9787572304071 +9787572306730 +9787572306853 +9787572307881 +9787572309199 +9787572309762 +9787572311680 +9787572315862 +9787572316142 +9787572316180 +9787572316739 +9787572318344 +9787572320286 +9787572320309 +9787572320385 +9787572320415 +9787572320491 +9787572320798 +9787572320811 +9787572321092 +9787572321108 +9787572322358 +9787572322389 +9787572324031 +9787572325762 +9787572326295 +9787572402067 +9787572403811 +9787572412578 +9787572417979 +9787572419041 +9787572421518 +9787572423017 +9787572424090 +9787572425608 +9787572430442 +9787572431012 +9787572431593 +9787572432071 +9787572436567 +9787572436574 +9787572439469 +9787572439933 +9787572440915 +9787572444838 +9787572445460 +9787572446429 +9787572448317 +9787572449598 +9787572500275 +9787572500411 +9787572500510 +9787572500725 +9787572500770 +9787572500824 +9787572501241 +9787572501258 +9787572501487 +9787572501593 +9787572501678 +9787572503955 +9787572505508 +9787572506000 +9787572506826 +9787572507977 +9787572513848 +9787572516559 +9787572516955 +9787572517167 +9787572517778 +9787572521744 +9787572601095 +9787572602085 +9787572603297 +9787572603709 +9787572605635 +9787572606878 +9787572607905 +9787572607981 +9787572608551 +9787572609091 +9787572609381 +9787572609480 +9787572609510 +9787572609787 +9787572609817 +9787572609855 +9787572610325 +9787572611100 +9787572611261 +9787572611377 +9787572611544 +9787572611698 +9787572612039 +9787572612046 +9787572612220 +9787572612770 +9787572612800 +9787572613357 +9787572613401 +9787572613616 +9787572613746 +9787572613821 +9787572614163 +9787572614200 +9787572614293 +9787572614729 +9787572615313 +9787572615320 +9787572615337 +9787572615474 +9787572615863 +9787572615924 +9787572616167 +9787572616464 +9787572616884 +9787572616914 +9787572617065 +9787572617102 +9787572617126 +9787572617232 +9787572617249 +9787572617294 +9787572617331 +9787572617584 +9787572617669 +9787572618376 +9787572618383 +9787572618390 +9787572618420 +9787572618598 +9787572618642 +9787572618659 +9787572618673 +9787572618871 +9787572619014 +9787572619021 +9787572619045 +9787572619212 +9787572619328 +9787572619342 +9787572619755 +9787572619762 +9787572619779 +9787572619892 +9787572619946 +9787572619977 +9787572620027 +9787572620065 +9787572620119 +9787572620126 +9787572620140 +9787572620188 +9787572620201 +9787572620225 +9787572620256 +9787572620645 +9787572620652 +9787572620737 +9787572620782 +9787572620799 +9787572620805 +9787572620812 +9787572620829 +9787572620850 +9787572620898 +9787572620904 +9787572621079 +9787572621123 +9787572621130 +9787572621147 +9787572621154 +9787572621161 +9787572621253 +9787572621260 +9787572621345 +9787572621352 +9787572621369 +9787572621376 +9787572621390 +9787572621406 +9787572621413 +9787572621444 +9787572621468 +9787572621499 +9787572621581 +9787572621611 +9787572621666 +9787572621673 +9787572621697 +9787572621703 +9787572621734 +9787572621802 +9787572621819 +9787572621826 +9787572621833 +9787572621840 +9787572621857 +9787572621864 +9787572621895 +9787572621901 +9787572621918 +9787572621956 +9787572621970 +9787572622069 +9787572622113 +9787572622144 +9787572622212 +9787572622229 +9787572622250 +9787572622281 +9787572622298 +9787572622304 +9787572622311 +9787572622472 +9787572622502 +9787572622618 +9787572622625 +9787572622656 +9787572622687 +9787572622717 +9787572622724 +9787572622731 +9787572622755 +9787572622816 +9787572622830 +9787572622922 +9787572623080 +9787572623097 +9787572623264 +9787572623288 +9787572623370 +9787572623585 +9787572623714 +9787572623783 +9787572623813 +9787572623844 +9787572623851 +9787572623899 +9787572624001 +9787572624254 +9787572624360 +9787572624414 +9787572624421 +9787572624605 +9787572624629 +9787572624681 +9787572624704 +9787572624865 +9787572625091 +9787572625183 +9787572625190 +9787572625220 +9787572625299 +9787572625459 +9787572700019 +9787572700361 +9787572700613 +9787572701689 +9787572706172 +9787572709609 +9787572710346 +9787572710667 +9787572712142 +9787572713484 +9787572713576 +9787572713835 +9787572714214 +9787572714337 +9787572714405 +9787572714795 +9787572714801 +9787572715631 +9787572715761 +9787572715808 +9787572715921 +9787572800979 +9787572801044 +9787572803772 +9787572804076 +9787572804953 +9787572805707 +9787572808715 +9787572808869 +9787572809446 +9787572810978 +9787572811258 +9787572811425 +9787572811593 +9787572812293 +9787572812316 +9787572812422 +9787572813887 +9787572814785 +9787572815775 +9787572816604 +9787572816680 +9787572817205 +9787572817229 +9787572817236 +9787572817311 +9787572818011 +9787572821691 +9787572900990 +9787572902215 +9787572902468 +9787572902659 +9787572902864 +9787572902895 +9787572902925 +9787572904202 +9787572908125 +9787572908354 +9787572908491 +9787572910036 +9787572911910 +9787572913396 +9787572913594 +9787572913884 +9787572915123 +9787572916335 +9787572916472 +9787572916809 +9787572916861 +9787572917653 +9787572918254 +9787573002891 +9787573004598 +9787573004628 +9787573005731 +9787573007926 +9787573007940 +9787573007957 +9787573008091 +9787573010964 +9787573010971 +9787573011404 +9787573012777 +9787573013002 +9787573013590 +9787573013859 +9787573014399 +9787573015235 +9787573015716 +9787573016058 +9787573016584 +9787573016614 +9787573017130 +9787573018182 +9787573018236 +9787573018694 +9787573018793 +9787573019097 +9787573020222 +9787573020239 +9787573021243 +9787573021458 +9787573021687 +9787573022110 +9787573022875 +9787573024060 +9787573100160 +9787573101129 +9787573102553 +9787573102775 +9787573104144 +9787573104830 +9787573104915 +9787573105639 +9787573106162 +9787573107572 +9787573107589 +9787573109668 +9787573110091 +9787573110343 +9787573110930 +9787573110978 +9787573111104 +9787573111142 +9787573111609 +9787573111791 +9787573114662 +9787573115188 +9787573115195 +9787573115201 +9787573115300 +9787573115355 +9787573115393 +9787573118189 +9787573118394 +9787573118547 +9787573123718 +9787573123725 +9787573123787 +9787573124463 +9787573124609 +9787573126290 +9787573126900 +9787573127037 +9787573127334 +9787573127358 +9787573129840 +9787573132673 +9787573133861 +9787573133939 +9787573133977 +9787573134721 +9787573136664 +9787573136671 +9787573136688 +9787573136695 +9787573137593 +9787573143983 +9787573145055 +9787573145147 +9787573145451 +9787573145840 +9787573147738 +9787573149091 +9787573149152 +9787573149169 +9787573149183 +9787573149213 +9787573152220 +9787573154163 +9787573154972 +9787573156006 +9787573160188 +9787573160195 +9787573169266 +9787573201157 +9787573201263 +9787573202581 +9787573202918 +9787573203236 +9787573203847 +9787573206374 +9787573206794 +9787573207487 +9787573207906 +9787573207913 +9787573207937 +9787573208279 +9787573208767 +9787573209054 +9787573209146 +9787573209382 +9787573209528 +9787573209788 +9787573209832 +9787573209849 +9787573209962 +9787573210005 +9787573210074 +9787573210296 +9787573210401 +9787573210470 +9787573210685 +9787573210821 +9787573210838 +9787573211040 +9787573211149 +9787573211187 +9787573211194 +9787573211200 +9787573211217 +9787573211224 +9787573211330 +9787573211347 +9787573211361 +9787573211408 +9787573211460 +9787573211521 +9787573211569 +9787573211927 +9787573211934 +9787573212047 +9787573212429 +9787573212450 +9787573212580 +9787573212597 +9787573212719 +9787573212825 +9787573212887 +9787573212931 +9787573213174 +9787573213266 +9787573213303 +9787573213327 +9787573213334 +9787573213358 +9787573213600 +9787573213662 +9787573213693 +9787573213730 +9787573213761 +9787573213778 +9787573213839 +9787573213884 +9787573213914 +9787573214195 +9787573214294 +9787573214447 +9787573214638 +9787573214683 +9787573214737 +9787573214812 +9787573214829 +9787573214850 +9787573214898 +9787573215062 +9787573215086 +9787573215093 +9787573215215 +9787573215369 +9787573215604 +9787573215680 +9787573215741 +9787573215802 +9787573215857 +9787573216205 +9787573216274 +9787573216359 +9787573216366 +9787573216526 +9787573216564 +9787573216694 +9787573216786 +9787573217219 +9787573300010 +9787573307798 +9787573311085 +9787573321718 +9787573408402 +9787573408419 +9787573408839 +9787573409775 +9787573411211 +9787573411488 +9787573413390 +9787573413703 +9787573413918 +9787573416162 +9787573418777 +9787573421791 +9787573434661 +9787573436115 +9787573500427 +9787573500601 +9787573501981 +9787573505132 +9787573506023 +9787573506160 +9787573508782 +9787573508904 +9787573509185 +9787573509192 +9787573509475 +9787573509482 +9787573509666 +9787573509673 +9787573509765 +9787573509888 +9787573509901 +9787573509932 +9787573510037 +9787573510396 +9787573510433 +9787573510587 +9787573510921 +9787573511270 +9787573511515 +9787573601643 +9787573601667 +9787573601827 +9787573601926 +9787573602121 +9787573602657 +9787573602732 +9787573602749 +9787573603098 +9787573604705 +9787573604767 +9787573604828 +9787573604835 +9787573605054 +9787573606143 +9787573606808 +9787573609755 +9787573609922 +9787573610324 +9787573610799 +9787573611215 +9787573611666 +9787573613165 +9787573613950 +9787573614056 +9787573614063 +9787573615053 +9787573617408 +9787573617576 +9787573618764 +9787573619037 +9787573619105 +9787573619129 +9787573619594 +9787573619679 +9787573619693 +9787573620293 +9787573621894 +9787573622082 +9787573623065 +9787573623157 +9787573624956 +9787573624994 +9787573626080 +9787573626264 +9787573626271 +9787573627384 +9787573627667 +9787573627872 +9787573628992 +9787573629418 +9787573629425 +9787573631893 +9787573632067 +9787573632074 +9787573632586 +9787573632630 +9787573633149 +9787573634252 +9787573634511 +9787573634597 +9787573706379 +9787573706621 +9787573706690 +9787573706904 +9787573709011 +9787573709318 +9787573709332 +9787573709356 +9787573709790 +9787573712622 +9787573712844 +9787573801852 +9787573803085 +9787573803672 +9787573805164 +9787573805171 +9787573808172 +9787573808189 +9787573809469 +9787573812216 +9787573814425 +9787573814722 +9787573814913 +9787573814944 +9787573903273 +9787573903570 +9787573903587 +9787573903839 +9787573905833 +9787573906250 +9787573907578 +9787573907639 +9787573907875 +9787573908612 +9787573908773 +9787573908841 +9787573909190 +9787573909350 +9787573911605 +9787573911667 +9787573911681 +9787573912527 +9787573913906 +9787573914514 +9787573914897 +9787573915139 +9787573915177 +9787573915375 +9787573915382 +9787573915818 +9787573916198 +9787573916341 +9787573916358 +9787573916419 +9787573916440 +9787573916488 +9787573918192 +9787574000278 +9787574000292 +9787574001176 +9787574001275 +9787574001718 +9787574001985 +9787574002067 +9787574002470 +9787574002906 +9787574004108 +9787574004825 +9787574006751 +9787574007000 +9787574007888 +9787574008083 +9787574008212 +9787574008885 +9787574010086 +9787574010208 +9787574010420 +9787574010574 +9787574010727 +9787574011151 +9787574011175 +9787574011397 +9787574011779 +9787574012639 +9787574012875 +9787574012936 +9787574013315 +9787574013384 +9787574013834 +9787574015692 +9787574102835 +9787574109681 +9787574113800 +9787574116221 +9787574116252 +9787574117617 +9787574122727 +9787574122741 +9787574123335 +9787574123908 +9787574123915 +9787574126046 +9787574126527 +9787574202023 +9787574202429 +9787574202931 +9787574203075 +9787574203563 +9787574205017 +9787574205185 +9787574205482 +9787574205550 +9787574206472 +9787574206502 +9787574207134 +9787574207240 +9787574207622 +9787574207707 +9787574208841 +9787574209336 +9787574209398 +9787574209596 +9787574210585 +9787574210592 +9787574210707 +9787574210783 +9787574211247 +9787574211650 +9787574211742 +9787574211797 +9787574211803 +9787574212367 +9787574212374 +9787574213319 +9787574213500 +9787574214316 +9787574215030 +9787574215047 +9787574215191 +9787574215603 +9787574216907 +9787574216938 +9787574217454 +9787574217720 +9787574217836 +9787574218536 +9787574219038 +9787574219045 +9787574219083 +9787574219113 +9787574219267 +9787574219700 +9787574219922 +9787574219939 +9787574220751 +9787574221444 +9787574221451 +9787574221529 +9787574221772 +9787574222601 +9787574224216 +9787574224230 +9787574225015 +9787574225244 +9787574225725 +9787574225879 +9787574226142 +9787574226302 +9787574226869 +9787574226920 +9787574226999 +9787574227125 +9787574227606 +9787574228719 +9787574228788 +9787574229709 +9787574230026 +9787574230323 +9787574231153 +9787574232129 +9787574301566 +9787574302167 +9787574305373 +9787574308787 +9787574308800 +9787574309647 +9787574309715 +9787574310292 +9787574311053 +9787574312814 +9787574318977 +9787574400436 +9787574402928 +9787574404212 +9787574404434 +9787574405042 +9787574406469 +9787574407800 +9787574408692 +9787574409767 +9787574410282 +9787574410800 +9787574412750 +9787574415089 +9787574415751 +9787574416666 +9787574416673 +9787574417427 +9787574417458 +9787574417984 +9787574418011 +9787574418028 +9787574501744 +9787574502703 +9787574506749 +9787574506763 +9787574602168 +9787574603158 +9787574603639 +9787574603707 +9787574603745 +9787574603837 +9787574603868 +9787574603882 +9787574603929 +9787574604407 +9787574604711 +9787574605152 +9787574605299 +9787574605305 +9787574606234 +9787574606494 +9787574607088 +9787574607217 +9787574607224 +9787574607729 +9787574608092 +9787574700000 +9787574700376 +9787574700383 +9787574700857 +9787574700895 +9787574703551 +9787574703728 +9787574706170 +9787574707276 +9787574800939 +9787574801813 +9787574805552 +9787574809123 +9787574900295 +9787574900400 +9787574900462 +9787574900868 +9787574900882 +9787574901261 +9787574901285 +9787574901292 +9787574901636 +9787574902398 +9787574902619 +9787574902640 +9787574902879 +9787574902985 +9787574903142 +9787574903180 +9787574903616 +9787574903678 +9787574904194 +9787574905566 +9787574905726 +9787575007481 +9787575100601 +9787575100854 +9787575102865 +9787575102971 +9787575103367 +9787575104036 +9787575104043 +9787575104111 +9787575104166 +9787575104418 +9787575104487 +9787575104562 +9787575202343 +9787575202442 +9787575207072 +9787575208178 +9787575300070 +9787575300148 +9787575300551 +9787575300568 +9787575300575 +9787575300605 +9787575300698 +9787575300735 +9787575300810 +9787575300995 +9787575301053 +9787575301091 +9787575301268 +9787575301381 +9787575301572 +9787575302005 +9787575302036 +9787575302050 +9787575302234 +9787575302784 +9787575302838 +9787575303002 +9787575303040 +9787575303064 +9787575303088 +9787575303101 +9787575303149 +9787575303156 +9787575303217 +9787575303231 +9787575303279 +9787575303385 +9787575303392 +9787575303484 +9787575303675 +9787575303750 +9787575304320 +9787575304368 +9787575304450 +9787575304856 +9787575304917 +9787575305099 +9787575306188 +9787575306409 +9787575307130 +9787575307499 +9787575307796 +9787575308854 +9787575400756 +9787575400831 +9787575401289 +9787575401364 +9787575401371 +9787575401623 +9787575401876 +9787575401951 +9787575401968 +9787575401975 +9787575402033 +9787575402200 +9787575402231 +9787575402255 +9787575402415 +9787575402699 +9787575403306 +9787575403818 +9787575404518 +9787575404525 +9787575404716 +9787575405423 +9787575406253 +9787575406383 +9787575408066 +9787575408356 +9787575409513 +9787575409599 +9787575410137 +9787575411578 +9787575412131 +9787575505185 +9787575600378 +9787575600712 +9787575603225 +9787575700139 +9787575800068 +9787575800280 +9787575800853 +9787575801683 +9787575802147 +9787575802192 +9787575802895 +9787576000085 +9787576000832 +9787576001839 +9787576002096 +9787576002300 +9787576002706 +9787576002911 +9787576003413 +9787576004809 +9787576004908 +9787576005271 +9787576005479 +9787576006117 +9787576006537 +9787576007114 +9787576007367 +9787576007923 +9787576008012 +9787576008579 +9787576008944 +9787576009514 +9787576010046 +9787576010855 +9787576010886 +9787576011760 +9787576012484 +9787576012712 +9787576014396 +9787576015072 +9787576015843 +9787576015911 +9787576016376 +9787576017144 +9787576017229 +9787576017908 +9787576018691 +9787576018707 +9787576019186 +9787576019216 +9787576020410 +9787576020533 +9787576020557 +9787576020724 +9787576021486 +9787576023374 +9787576023923 +9787576025149 +9787576026412 +9787576026566 +9787576026849 +9787576027778 +9787576027983 +9787576029246 +9787576029253 +9787576029437 +9787576029574 +9787576029581 +9787576030297 +9787576030303 +9787576030310 +9787576030327 +9787576030617 +9787576030716 +9787576031218 +9787576031263 +9787576031355 +9787576031393 +9787576031836 +9787576032406 +9787576035186 +9787576035193 +9787576035520 +9787576035711 +9787576035803 +9787576037517 +9787576037999 +9787576038576 +9787576038873 +9787576039719 +9787576039726 +9787576039733 +9787576039740 +9787576039832 +9787576040586 +9787576040616 +9787576040623 +9787576040760 +9787576040913 +9787576041484 +9787576041590 +9787576041675 +9787576043266 +9787576043600 +9787576043617 +9787576044454 +9787576046120 +9787576046137 +9787576046458 +9787576046601 +9787576049091 +9787576049930 +9787576050400 +9787576050868 +9787576051377 +9787576051438 +9787576051780 +9787576051964 +9787576052527 +9787576052626 +9787576052930 +9787576052978 +9787576053210 +9787576053647 +9787576054057 +9787576054163 +9787576054170 +9787576054200 +9787576054491 +9787576054620 +9787576055108 +9787576055306 +9787576055375 +9787576055474 +9787576055917 +9787576056846 +9787576058918 +9787576060157 +9787576060379 +9787576100907 +9787576101287 +9787576101799 +9787576107753 +9787576202045 +9787576202250 +9787576204001 +9787576210507 +9787576213492 +9787576214406 +9787576215762 +9787576217322 +9787576219357 +9787576220261 +9787576223392 +9787576224511 +9787576224955 +9787576225389 +9787576226331 +9787576227628 +9787576232943 +9787576233872 +9787576234169 +9787576236842 +9787576236880 +9787576236910 +9787576239409 +9787576239935 +9787576240313 +9787576241426 +9787576241570 +9787576243383 +9787576244915 +9787576300161 +9787576300536 +9787576300604 +9787576300789 +9787576300963 +9787576301229 +9787576301267 +9787576301298 +9787576301526 +9787576302066 +9787576302103 +9787576302202 +9787576302448 +9787576302646 +9787576302875 +9787576302929 +9787576302950 +9787576303216 +9787576303223 +9787576303230 +9787576303506 +9787576303544 +9787576303599 +9787576303797 +9787576304329 +9787576304367 +9787576304398 +9787576304565 +9787576304749 +9787576304756 +9787576304831 +9787576304992 +9787576305012 +9787576305067 +9787576305081 +9787576305470 +9787576305777 +9787576306033 +9787576306170 +9787576306248 +9787576306781 +9787576306972 +9787576307092 +9787576307221 +9787576307252 +9787576307368 +9787576307443 +9787576307702 +9787576307757 +9787576307832 +9787576307863 +9787576308433 +9787576308587 +9787576308785 +9787576309096 +9787576309690 +9787576309812 +9787576309867 +9787576309959 +9787576310016 +9787576310160 +9787576310481 +9787576310924 +9787576311105 +9787576311518 +9787576311785 +9787576311914 +9787576312010 +9787576312140 +9787576312775 +9787576312898 +9787576312973 +9787576313130 +9787576313420 +9787576313802 +9787576314564 +9787576315004 +9787576315943 +9787576315950 +9787576315967 +9787576315998 +9787576316001 +9787576316605 +9787576317459 +9787576318388 +9787576318937 +9787576321289 +9787576321456 +9787576321517 +9787576321852 +9787576321975 +9787576322026 +9787576322521 +9787576322682 +9787576322989 +9787576323313 +9787576323849 +9787576324808 +9787576325171 +9787576325294 +9787576325362 +9787576326529 +9787576326819 +9787576328134 +9787576329353 +9787576329513 +9787576330663 +9787576331035 +9787576331325 +9787576332582 +9787576333640 +9787576333831 +9787576335262 +9787576335439 +9787576335446 +9787576335699 +9787576337495 +9787576337846 +9787576338270 +9787576338706 +9787576339062 +9787576339642 +9787576339703 +9787576339734 +9787576339987 +9787576340594 +9787576340600 +9787576340709 +9787576340785 +9787576340815 +9787576341683 +9787576342314 +9787576342369 +9787576343878 +9787576344745 +9787576344950 +9787576345032 +9787576345179 +9787576345186 +9787576345209 +9787576345346 +9787576346114 +9787576346381 +9787576346572 +9787576351200 +9787576351866 +9787576354232 +9787576400052 +9787576400830 +9787576401219 +9787576401479 +9787576401837 +9787576403084 +9787576403312 +9787576403374 +9787576403398 +9787576405293 +9787576405309 +9787576405712 +9787576406665 +9787576406719 +9787576406931 +9787576407181 +9787576407372 +9787576407426 +9787576407785 +9787576407792 +9787576407808 +9787576407815 +9787576408454 +9787576408959 +9787576409017 +9787576409031 +9787576409499 +9787576410259 +9787576410655 +9787576410945 +9787576411546 +9787576411607 +9787576411744 +9787576412192 +9787576412796 +9787576412925 +9787576412932 +9787576413243 +9787576413250 +9787576413670 +9787576413755 +9787576413878 +9787576414288 +9787576414356 +9787576414691 +9787576414899 +9787576414912 +9787576415193 +9787576415698 +9787576416237 +9787576416701 +9787576416930 +9787576417173 +9787576417326 +9787576417906 +9787576417951 +9787576420036 +9787576502909 +9787576505023 +9787576505641 +9787576505719 +9787576509311 +9787576509373 +9787576510898 +9787576511055 +9787576511611 +9787576511710 +9787576512045 +9787576512281 +9787576512397 +9787576512687 +9787576513448 +9787576513578 +9787576513851 +9787576601367 +9787576601978 +9787576604535 +9787576607505 +9787576607666 +9787576609226 +9787576609240 +9787576614084 +9787576614961 +9787576615074 +9787576615449 +9787576615586 +9787576615883 +9787576616330 +9787576616361 +9787576617429 +9787576617436 +9787576618761 +9787576700220 +9787576701296 +9787576702088 +9787576702705 +9787576703207 +9787576703306 +9787576704426 +9787576704464 +9787576705089 +9787576705232 +9787576705331 +9787576705669 +9787576705744 +9787576706574 +9787576707601 +9787576708158 +9787576708868 +9787576709056 +9787576709070 +9787576709681 +9787576709742 +9787576710397 +9787576710489 +9787576711257 +9787576711400 +9787576712131 +9787576712148 +9787576712162 +9787576712230 +9787576712841 +9787576713336 +9787576713749 +9787576713978 +9787576714326 +9787576714845 +9787576715224 +9787576715446 +9787576715620 +9787576715835 +9787576715842 +9787576716078 +9787576716092 +9787576716139 +9787576716252 +9787576717006 +9787576719468 +9787576720662 +9787576804010 +9787576808377 +9787576814521 +9787576818529 +9787576822854 +9787576825169 +9787576826180 +9787576900958 +9787576900965 +9787576901405 +9787576902181 +9787576902204 +9787576902358 +9787576904031 +9787576904079 +9787576904093 +9787576905168 +9787576906646 +9787577000978 +9787577001029 +9787577001913 +9787577002774 +9787577002965 +9787577003184 +9787577003610 +9787577004594 +9787577006147 +9787577007694 +9787577008042 +9787577010267 +9787577100395 +9787577101606 +9787577108858 +9787577109930 +9787577110967 +9787577111018 +9787577111568 +9787577111681 +9787577112565 +9787577112572 +9787577112633 +9787577113005 +9787577113487 +9787577113722 +9787577114101 +9787577115191 +9787577115993 +9787577116037 +9787577116068 +9787577118093 +9787577201139 +9787577203324 +9787577203447 +9787577203645 +9787577203652 +9787577204758 +9787577205212 +9787577205403 +9787577206400 +9787577207490 +9787577207711 +9787577207995 +9787577209111 +9787577209777 +9787577209876 +9787577210001 +9787577210124 +9787577211992 +9787577212142 +9787577212401 +9787577212869 +9787577214054 +9787577214146 +9787577215112 +9787577215211 +9787577217499 +9787577221113 +9787577300115 +9787577302270 +9787577302348 +9787577302690 +9787577304786 +9787577305714 +9787577309972 +9787577311562 +9787577400068 +9787577401324 +9787577402048 +9787577403588 +9787580100191 +9787580100474 +9787580100948 +9787580101037 +9787580101235 +9787580101969 +9787580101990 +9787580103734 +9787580104199 +9787580400734 +9787580400796 +9787586236214 +9787590501537 +9787595253493 +9787599409919 +9787600607051 +9787600609130 +9787600610235 +9787600668564 +9787600690787 +9787601011611 +9787601011888 +9787601012533 +9787601012564 +9787601013028 +9787601013066 +9787604230378 +9787626526664 +9787637833683 +9787644041941 +9787644192322 +9787688325885 +9787705253610 +9787705648744 +9787735846936 +9787780001236 +9787780007283 +9787780008624 +9787780009560 +9787780009621 +9787780010658 +9787780021777 +9787780036986 +9787789591172 +9787798614077 +9787798630053 +9787798978056 +9787798979046 +9787799122120 +9787799225319 +9787799313009 +9787799314068 +9787799317755 +9787799422381 +9787799602868 +9787799726342 +9787799806822 +9787799815770 +9787799822884 +9787799826486 +9787799827711 +9787799831718 +9787799911649 +9787800000157 +9787800000164 +9787800000546 +9787800001178 +9787800001390 +9787800001840 +9787800001871 +9787800002106 +9787800003493 +9787800003882 +9787800003912 +9787800003967 +9787800004049 +9787800004254 +9787800009860 +9787800010064 +9787800013737 +9787800014819 +9787800015182 +9787800015199 +9787800015748 +9787800016004 +9787800016547 +9787800017308 +9787800017506 +9787800017650 +9787800018008 +9787800018374 +9787800018466 +9787800018565 +9787800018855 +9787800018923 +9787800019401 +9787800019470 +9787800019524 +9787800019562 +9787800019883 +9787800019937 +9787800019975 +9787800020025 +9787800020056 +9787800020162 +9787800020209 +9787800020308 +9787800020407 +9787800020704 +9787800021237 +9787800021657 +9787800021718 +9787800021824 +9787800021923 +9787800021992 +9787800022371 +9787800022487 +9787800022531 +9787800022951 +9787800023378 +9787800023576 +9787800023620 +9787800023637 +9787800023675 +9787800023712 +9787800024177 +9787800024504 +9787800024696 +9787800024740 +9787800024924 +9787800025044 +9787800025372 +9787800025389 +9787800025396 +9787800025587 +9787800025822 +9787800026263 +9787800027314 +9787800027468 +9787800028441 +9787800028816 +9787800029257 +9787800029288 +9787800029691 +9787800029813 +9787800029820 +9787800029899 +9787800029929 +9787800032974 +9787800040207 +9787800041280 +9787800041846 +9787800041907 +9787800044649 +9787800045462 +9787800045479 +9787800046667 +9787800050084 +9787800050558 +9787800051081 +9787800051111 +9787800051128 +9787800051210 +9787800051425 +9787800051630 +9787800051722 +9787800052163 +9787800052200 +9787800052248 +9787800052262 +9787800052422 +9787800052460 +9787800052552 +9787800052569 +9787800053306 +9787800053351 +9787800053375 +9787800053412 +9787800053535 +9787800053641 +9787800053702 +9787800053719 +9787800053764 +9787800053832 +9787800053887 +9787800053894 +9787800053931 +9787800053955 +9787800053962 +9787800053979 +9787800054044 +9787800054051 +9787800054174 +9787800054372 +9787800054402 +9787800054419 +9787800054433 +9787800054440 +9787800054471 +9787800054532 +9787800054549 +9787800054860 +9787800054990 +9787800055058 +9787800055065 +9787800055072 +9787800055157 +9787800055393 +9787800055539 +9787800055621 +9787800055645 +9787800055652 +9787800055959 +9787800056079 +9787800056086 +9787800056093 +9787800056369 +9787800056420 +9787800056475 +9787800056543 +9787800056574 +9787800056666 +9787800056697 +9787800056758 +9787800056772 +9787800056789 +9787800056864 +9787800056895 +9787800056918 +9787800057069 +9787800057106 +9787800057175 +9787800057328 +9787800057335 +9787800057342 +9787800057359 +9787800057366 +9787800057380 +9787800057403 +9787800057410 +9787800057472 +9787800057571 +9787800057809 +9787800057847 +9787800057977 +9787800057991 +9787800058042 +9787800058134 +9787800058202 +9787800058233 +9787800058240 +9787800058318 +9787800058370 +9787800058394 +9787800058431 +9787800058448 +9787800058493 +9787800058769 +9787800058806 +9787800058813 +9787800058967 +9787800058974 +9787800059001 +9787800059063 +9787800059070 +9787800059230 +9787800059315 +9787800059414 +9787800059421 +9787800059551 +9787800059605 +9787800060175 +9787800060410 +9787800060434 +9787800060663 +9787800061073 +9787800061486 +9787800061714 +9787800062803 +9787800062810 +9787800062889 +9787800063008 +9787800063060 +9787800063114 +9787800063541 +9787800065125 +9787800065897 +9787800065989 +9787800065996 +9787800066962 +9787800067549 +9787800067693 +9787800068539 +9787800068690 +9787800068898 +9787800069185 +9787800069598 +9787800069604 +9787800069628 +9787800071126 +9787800071782 +9787800071799 +9787800072109 +9787800072246 +9787800072437 +9787800072741 +9787800072864 +9787800073069 +9787800073090 +9787800073335 +9787800073342 +9787800073823 +9787800074066 +9787800074080 +9787800074721 +9787800074752 +9787800074806 +9787800074929 +9787800075063 +9787800075070 +9787800075285 +9787800075667 +9787800075681 +9787800075728 +9787800075827 +9787800076282 +9787800076374 +9787800076541 +9787800076633 +9787800076640 +9787800076862 +9787800077074 +9787800077128 +9787800077234 +9787800077814 +9787800077821 +9787800077975 +9787800078217 +9787800078323 +9787800078569 +9787800079139 +9787800079160 +9787800079290 +9787800079344 +9787800079504 +9787800079665 +9787800080036 +9787800080272 +9787800090011 +9787800090202 +9787800090240 +9787800090479 +9787800090813 +9787800090905 +9787800090967 +9787800091025 +9787800091070 +9787800091148 +9787800091230 +9787800091599 +9787800092220 +9787800092237 +9787800092435 +9787800092879 +9787800092992 +9787800093043 +9787800093128 +9787800093142 +9787800093227 +9787800093364 +9787800093463 +9787800093555 +9787800093562 +9787800093579 +9787800093616 +9787800093715 +9787800093722 +9787800093883 +9787800094095 +9787800094255 +9787800094446 +9787800094651 +9787800094736 +9787800094774 +9787800094798 +9787800094873 +9787800094897 +9787800094903 +9787800094910 +9787800095139 +9787800095184 +9787800095191 +9787800095238 +9787800095405 +9787800095658 +9787800095726 +9787800095733 +9787800095757 +9787800095900 +9787800095962 +9787800096112 +9787800096198 +9787800096235 +9787800096242 +9787800096648 +9787800096686 +9787800096754 +9787800096884 +9787800096891 +9787800096921 +9787800096969 +9787800097003 +9787800097140 +9787800097188 +9787800098185 +9787800098420 +9787800098642 +9787800098826 +9787800099311 +9787800099502 +9787800100284 +9787800100574 +9787800100833 +9787800100888 +9787800101243 +9787800101571 +9787800103247 +9787800103766 +9787800104077 +9787800104336 +9787800106750 +9787800106910 +9787800107030 +9787800107078 +9787800107658 +9787800107955 +9787800108952 +9787800109027 +9787800109690 +9787800109706 +9787800112218 +9787800113024 +9787800113673 +9787800114144 +9787800115530 +9787800115745 +9787800116308 +9787800116315 +9787800117855 +9787800118067 +9787800119729 +9787800122064 +9787800122330 +9787800122552 +9787800122927 +9787800122965 +9787800123207 +9787800123313 +9787800123474 +9787800123665 +9787800124242 +9787800124488 +9787800125010 +9787800125218 +9787800125485 +9787800125980 +9787800126093 +9787800127267 +9787800127304 +9787800127625 +9787800128202 +9787800128547 +9787800129483 +9787800130106 +9787800130120 +9787800130243 +9787800130502 +9787800130762 +9787800130786 +9787800130793 +9787800130847 +9787800130878 +9787800130892 +9787800130915 +9787800130939 +9787800130946 +9787800130960 +9787800130984 +9787800131011 +9787800131080 +9787800131172 +9787800131189 +9787800131196 +9787800131240 +9787800131264 +9787800131295 +9787800131332 +9787800131356 +9787800131363 +9787800131370 +9787800131394 +9787800131462 +9787800131486 +9787800131516 +9787800131561 +9787800131608 +9787800131615 +9787800131646 +9787800131684 +9787800131714 +9787800131776 +9787800131806 +9787800131936 +9787800131950 +9787800131967 +9787800131974 +9787800132247 +9787800132308 +9787800132322 +9787800132360 +9787800132407 +9787800132490 +9787800132568 +9787800132636 +9787800132681 +9787800132698 +9787800132704 +9787800132711 +9787800132742 +9787800132803 +9787800132841 +9787800132858 +9787800132933 +9787800132940 +9787800133015 +9787800133084 +9787800133220 +9787800133329 +9787800133336 +9787800133435 +9787800133466 +9787800133527 +9787800133572 +9787800133862 +9787800133879 +9787800133893 +9787800133909 +9787800133916 +9787800133923 +9787800134029 +9787800134104 +9787800134166 +9787800134395 +9787800134579 +9787800134616 +9787800134647 +9787800134654 +9787800134661 +9787800134678 +9787800134753 +9787800134920 +9787800134937 +9787800135040 +9787800135088 +9787800135149 +9787800135194 +9787800135217 +9787800135392 +9787800135408 +9787800135484 +9787800135538 +9787800135767 +9787800135866 +9787800135965 +9787800136276 +9787800136283 +9787800136337 +9787800136351 +9787800136627 +9787800136917 +9787800136962 +9787800137129 +9787800137150 +9787800137211 +9787800137464 +9787800137532 +9787800137587 +9787800137785 +9787800137945 +9787800137969 +9787800138003 +9787800138218 +9787800138287 +9787800138331 +9787800138560 +9787800138584 +9787800138966 +9787800140594 +9787800140884 +9787800140891 +9787800141058 +9787800141355 +9787800141508 +9787800141522 +9787800141553 +9787800141560 +9787800141584 +9787800141652 +9787800141690 +9787800141942 +9787800142154 +9787800142277 +9787800142901 +9787800143168 +9787800143786 +9787800144165 +9787800144196 +9787800144295 +9787800144349 +9787800144653 +9787800144660 +9787800144936 +9787800144974 +9787800144981 +9787800145049 +9787800145179 +9787800145902 +9787800146091 +9787800146473 +9787800146497 +9787800146749 +9787800146787 +9787800146886 +9787800146985 +9787800146992 +9787800149269 +9787800149610 +9787800150197 +9787800150227 +9787800150319 +9787800150326 +9787800150623 +9787800150685 +9787800150760 +9787800150807 +9787800151019 +9787800151088 +9787800151187 +9787800151385 +9787800151392 +9787800151965 +9787800152467 +9787800152474 +9787800153075 +9787800153167 +9787800153235 +9787800153303 +9787800153327 +9787800153341 +9787800153389 +9787800153396 +9787800153587 +9787800153631 +9787800153693 +9787800154027 +9787800154034 +9787800154096 +9787800154164 +9787800154256 +9787800154614 +9787800154690 +9787800155185 +9787800155307 +9787800155611 +9787800155635 +9787800156014 +9787800156106 +9787800156229 +9787800156427 +9787800156557 +9787800156830 +9787800157295 +9787800157301 +9787800157424 +9787800157462 +9787800157653 +9787800158094 +9787800158131 +9787800158193 +9787800158339 +9787800158759 +9787800159077 +9787800159350 +9787800159367 +9787800159800 +9787800159909 +9787800160035 +9787800160219 +9787800160363 +9787800160486 +9787800161063 +9787800161094 +9787800161582 +9787800161650 +9787800161742 +9787800162008 +9787800162084 +9787800163425 +9787800163494 +9787800163579 +9787800163791 +9787800164019 +9787800164217 +9787800164231 +9787800164323 +9787800165184 +9787800165245 +9787800165900 +9787800166303 +9787800166518 +9787800168192 +9787800170393 +9787800170454 +9787800170522 +9787800170669 +9787800170690 +9787800170898 +9787800171031 +9787800171123 +9787800171192 +9787800171215 +9787800171239 +9787800172588 +9787800172816 +9787800172861 +9787800172946 +9787800173042 +9787800173134 +9787800173684 +9787800174025 +9787800174193 +9787800174254 +9787800174346 +9787800174407 +9787800174827 +9787800174971 +9787800175008 +9787800175077 +9787800175145 +9787800175220 +9787800175770 +9787800175992 +9787800176043 +9787800176098 +9787800176104 +9787800176661 +9787800176777 +9787800176821 +9787800176838 +9787800176968 +9787800177033 +9787800177064 +9787800177354 +9787800177378 +9787800177651 +9787800177675 +9787800177767 +9787800177774 +9787800177897 +9787800178276 +9787800178368 +9787800178443 +9787800178719 +9787800178764 +9787800178795 +9787800178825 +9787800178924 +9787800179174 +9787800179228 +9787800179419 +9787800179488 +9787800179624 +9787800179778 +9787800180279 +9787800180873 +9787800181047 +9787800181382 +9787800181542 +9787800181597 +9787800182303 +9787800190117 +9787800190155 +9787800190278 +9787800190476 +9787800190544 +9787800190599 +9787800190933 +9787800191602 +9787800191701 +9787800191770 +9787800192289 +9787800192395 +9787800192517 +9787800192630 +9787800192869 +9787800193194 +9787800193378 +9787800193583 +9787800193651 +9787800194290 +9787800194337 +9787800194641 +9787800194818 +9787800194832 +9787800194856 +9787800195099 +9787800195235 +9787800195259 +9787800195334 +9787800195419 +9787800195457 +9787800195501 +9787800195730 +9787800195815 +9787800195921 +9787800196188 +9787800196300 +9787800196331 +9787800196492 +9787800196799 +9787800196805 +9787800197208 +9787800197338 +9787800197499 +9787800197574 +9787800197642 +9787800197734 +9787800197819 +9787800197833 +9787800197949 +9787800197956 +9787800198052 +9787800198212 +9787800198243 +9787800198304 +9787800198311 +9787800198328 +9787800198342 +9787800198359 +9787800198472 +9787800198687 +9787800198724 +9787800198885 +9787800199028 +9787800199202 +9787800199288 +9787800199318 +9787800199325 +9787800200182 +9787800200199 +9787800200489 +9787800200656 +9787800200816 +9787800200823 +9787800200847 +9787800200960 +9787800200977 +9787800201028 +9787800201110 +9787800201318 +9787800201738 +9787800201899 +9787800201974 +9787800202087 +9787800202209 +9787800202223 +9787800202629 +9787800202643 +9787800202667 +9787800202681 +9787800202797 +9787800202841 +9787800203015 +9787800203022 +9787800203169 +9787800203282 +9787800203312 +9787800203435 +9787800203459 +9787800203473 +9787800203480 +9787800203718 +9787800203770 +9787800203824 +9787800203886 +9787800203954 +9787800204005 +9787800204104 +9787800204203 +9787800204234 +9787800204326 +9787800204333 +9787800204401 +9787800204449 +9787800204487 +9787800204616 +9787800204630 +9787800204685 +9787800204708 +9787800204852 +9787800204869 +9787800204876 +9787800205026 +9787800205149 +9787800205170 +9787800205514 +9787800205651 +9787800205712 +9787800205828 +9787800205835 +9787800205897 +9787800205989 +9787800206443 +9787800206566 +9787800206887 +9787800206931 +9787800207099 +9787800207334 +9787800207457 +9787800207532 +9787800207587 +9787800207648 +9787800207853 +9787800207907 +9787800207938 +9787800207952 +9787800208058 +9787800208164 +9787800208256 +9787800208577 +9787800208607 +9787800208775 +9787800208911 +9787800208980 +9787800209079 +9787800209277 +9787800209383 +9787800209437 +9787800209574 +9787800209642 +9787800209666 +9787800209819 +9787800209970 +9787800210044 +9787800210150 +9787800210174 +9787800210181 +9787800210303 +9787800210471 +9787800210624 +9787800210808 +9787800211041 +9787800211096 +9787800211478 +9787800211621 +9787800211751 +9787800211904 +9787800211959 +9787800211966 +9787800212048 +9787800212093 +9787800212239 +9787800212246 +9787800212413 +9787800212574 +9787800212581 +9787800212673 +9787800212710 +9787800212734 +9787800212796 +9787800213021 +9787800213151 +9787800213304 +9787800213397 +9787800213489 +9787800213502 +9787800213526 +9787800213540 +9787800213755 +9787800213793 +9787800213809 +9787800213830 +9787800213953 +9787800214127 +9787800214226 +9787800215469 +9787800215575 +9787800216633 +9787800216695 +9787800216718 +9787800216749 +9787800216930 +9787800217418 +9787800217517 +9787800217647 +9787800217746 +9787800218132 +9787800218149 +9787800218200 +9787800218439 +9787800218538 +9787800218651 +9787800218842 +9787800219023 +9787800219702 +9787800219733 +9787800219757 +9787800220005 +9787800220074 +9787800220135 +9787800220159 +9787800220180 +9787800220258 +9787800220272 +9787800220340 +9787800220388 +9787800220395 +9787800220517 +9787800220524 +9787800220531 +9787800220609 +9787800220623 +9787800220753 +9787800220869 +9787800220920 +9787800221057 +9787800221088 +9787800221095 +9787800221125 +9787800221279 +9787800221316 +9787800221354 +9787800221385 +9787800221392 +9787800221507 +9787800221552 +9787800221699 +9787800221712 +9787800221903 +9787800221927 +9787800221972 +9787800222009 +9787800222160 +9787800222177 +9787800222184 +9787800222207 +9787800222214 +9787800222412 +9787800222566 +9787800222689 +9787800222733 +9787800222788 +9787800222955 +9787800223075 +9787800223167 +9787800223396 +9787800223402 +9787800223501 +9787800223549 +9787800223631 +9787800223785 +9787800223808 +9787800223853 +9787800223914 +9787800224027 +9787800224041 +9787800224072 +9787800224126 +9787800224256 +9787800224263 +9787800224324 +9787800224348 +9787800224461 +9787800224485 +9787800224591 +9787800224638 +9787800224652 +9787800224720 +9787800224768 +9787800224775 +9787800224898 +9787800224973 +9787800225093 +9787800225130 +9787800225277 +9787800225369 +9787800225413 +9787800225468 +9787800225475 +9787800225512 +9787800225581 +9787800225697 +9787800225703 +9787800225833 +9787800225932 +9787800225970 +9787800226274 +9787800226366 +9787800226601 +9787800226656 +9787800226809 +9787800226946 +9787800226960 +9787800227042 +9787800227073 +9787800227097 +9787800227158 +9787800227226 +9787800227288 +9787800227325 +9787800227394 +9787800227400 +9787800227424 +9787800227936 +9787800227967 +9787800228070 +9787800228117 +9787800228155 +9787800228254 +9787800228292 +9787800228339 +9787800228377 +9787800228445 +9787800228483 +9787800228513 +9787800228636 +9787800228773 +9787800228896 +9787800228926 +9787800229022 +9787800229374 +9787800229404 +9787800229657 +9787800229695 +9787800229886 +9787800230004 +9787800230059 +9787800230066 +9787800230103 +9787800230134 +9787800230295 +9787800230400 +9787800230448 +9787800230462 +9787800230707 +9787800230738 +9787800230899 +9787800231094 +9787800231216 +9787800231339 +9787800231353 +9787800231544 +9787800231575 +9787800232213 +9787800232305 +9787800232695 +9787800232800 +9787800232817 +9787800232848 +9787800232992 +9787800233135 +9787800233197 +9787800233449 +9787800233494 +9787800233890 +9787800234248 +9787800234675 +9787800234750 +9787800234941 +9787800235023 +9787800235269 +9787800235399 +9787800235429 +9787800235641 +9787800235689 +9787800235856 +9787800236211 +9787800236310 +9787800236341 +9787800236365 +9787800237423 +9787800237430 +9787800237621 +9787800237638 +9787800237737 +9787800237836 +9787800237973 +9787800238109 +9787800238352 +9787800238406 +9787800238635 +9787800238734 +9787800238796 +9787800238802 +9787800238826 +9787800238857 +9787800238895 +9787800239045 +9787800239113 +9787800239267 +9787800239441 +9787800239656 +9787800239670 +9787800239694 +9787800239700 +9787800239816 +9787800239861 +9787800239977 +9787800240638 +9787800240904 +9787800241697 +9787800241963 +9787800242038 +9787800242977 +9787800243318 +9787800243998 +9787800244223 +9787800244339 +9787800244452 +9787800245381 +9787800245633 +9787800245855 +9787800246173 +9787800246227 +9787800246289 +9787800246326 +9787800246364 +9787800246531 +9787800246654 +9787800246845 +9787800247842 +9787800247958 +9787800248214 +9787800249662 +9787800249945 +9787800250002 +9787800250934 +9787800251016 +9787800251061 +9787800251269 +9787800251764 +9787800251863 +9787800252914 +9787800252969 +9787800252990 +9787800253133 +9787800253560 +9787800256042 +9787800257322 +9787800257940 +9787800259203 +9787800259692 +9787800261343 +9787800261398 +9787800262166 +9787800263446 +9787800263880 +9787800265068 +9787800265259 +9787800266249 +9787800267123 +9787800267420 +9787800268519 +9787800268885 +9787800268939 +9787800270086 +9787800270093 +9787800270147 +9787800270215 +9787800270246 +9787800270277 +9787800270307 +9787800270314 +9787800270321 +9787800270338 +9787800270369 +9787800270383 +9787800270475 +9787800270482 +9787800270512 +9787800270611 +9787800270901 +9787800271373 +9787800271540 +9787800271571 +9787800271595 +9787800271618 +9787800271663 +9787800271724 +9787800272011 +9787800272868 +9787800272929 +9787800273070 +9787800273377 +9787800274237 +9787800275135 +9787800276262 +9787800276507 +9787800277290 +9787800277672 +9787800278983 +9787800279058 +9787800279621 +9787800279645 +9787800279683 +9787800279935 +9787800280368 +9787800280412 +9787800280566 +9787800280702 +9787800282140 +9787800282409 +9787800282591 +9787800282690 +9787800282805 +9787800282898 +9787800282973 +9787800283055 +9787800283178 +9787800283239 +9787800283529 +9787800284038 +9787800284243 +9787800284281 +9787800284304 +9787800284786 +9787800284946 +9787800285059 +9787800285196 +9787800285219 +9787800285349 +9787800285707 +9787800285745 +9787800285875 +9787800286056 +9787800286209 +9787800286223 +9787800287350 +9787800287497 +9787800288371 +9787800289743 +9787800289781 +9787800300028 +9787800300035 +9787800300059 +9787800300080 +9787800300134 +9787800300165 +9787800300226 +9787800300264 +9787800300295 +9787800300462 +9787800300639 +9787800300684 +9787800300691 +9787800300707 +9787800300714 +9787800300721 +9787800300837 +9787800300899 +9787800300905 +9787800300929 +9787800300936 +9787800300943 +9787800300950 +9787800301179 +9787800301193 +9787800301223 +9787800301261 +9787800301421 +9787800301506 +9787800301575 +9787800301667 +9787800301834 +9787800301865 +9787800301940 +9787800310232 +9787800310324 +9787800312205 +9787800312908 +9787800313653 +9787800316128 +9787800317019 +9787800317033 +9787800317514 +9787800318955 +9787800330193 +9787800330247 +9787800330506 +9787800330759 +9787800330827 +9787800330865 +9787800330957 +9787800330995 +9787800331039 +9787800331145 +9787800331152 +9787800331343 +9787800331961 +9787800331992 +9787800340468 +9787800340888 +9787800340895 +9787800340970 +9787800341267 +9787800341359 +9787800341601 +9787800341625 +9787800342523 +9787800343858 +9787800343896 +9787800344800 +9787800345197 +9787800345302 +9787800346880 +9787800347283 +9787800347597 +9787800348075 +9787800348105 +9787800348594 +9787800348945 +9787800349126 +9787800349492 +9787800350252 +9787800350269 +9787800350405 +9787800350559 +9787800350566 +9787800350573 +9787800350825 +9787800350948 +9787800351020 +9787800351068 +9787800351105 +9787800351570 +9787800351907 +9787800351914 +9787800351938 +9787800351990 +9787800352270 +9787800352508 +9787800352577 +9787800353543 +9787800353598 +9787800353826 +9787800354076 +9787800354304 +9787800354915 +9787800355509 +9787800357183 +9787800358463 +9787800359255 +9787800359309 +9787800359484 +9787800359781 +9787800360091 +9787800360411 +9787800360435 +9787800360657 +9787800360800 +9787800360824 +9787800361449 +9787800361579 +9787800361807 +9787800362439 +9787800362453 +9787800362637 +9787800362842 +9787800363085 +9787800363313 +9787800363504 +9787800363726 +9787800363887 +9787800364358 +9787800364365 +9787800365034 +9787800365041 +9787800365058 +9787800365065 +9787800365690 +9787800366093 +9787800366451 +9787800366482 +9787800366529 +9787800366796 +9787800368349 +9787800368592 +9787800369193 +9787800369247 +9787800369858 +9787800369865 +9787800369896 +9787800369964 +9787800370014 +9787800370359 +9787800370366 +9787800370724 +9787800370830 +9787800371028 +9787800371035 +9787800371387 +9787800371400 +9787800371691 +9787800371882 +9787800371905 +9787800372230 +9787800372582 +9787800372612 +9787800372681 +9787800372803 +9787800372902 +9787800373299 +9787800373992 +9787800374074 +9787800374180 +9787800374623 +9787800374890 +9787800374913 +9787800375576 +9787800375682 +9787800375781 +9787800375873 +9787800375934 +9787800376085 +9787800376351 +9787800376412 +9787800376634 +9787800376641 +9787800376771 +9787800376795 +9787800376801 +9787800377037 +9787800377051 +9787800377112 +9787800377273 +9787800377952 +9787800378058 +9787800378195 +9787800378454 +9787800378546 +9787800378904 +9787800380518 +9787800381058 +9787800381720 +9787800382376 +9787800382604 +9787800382642 +9787800382901 +9787800383267 +9787800384165 +9787800384462 +9787800385117 +9787800385445 +9787800386244 +9787800387319 +9787800388453 +9787800390012 +9787800390104 +9787800390227 +9787800390319 +9787800390364 +9787800390456 +9787800390593 +9787800390777 +9787800390784 +9787800390968 +9787800391101 +9787800391156 +9787800391927 +9787800392009 +9787800392108 +9787800392207 +9787800392573 +9787800392665 +9787800392726 +9787800392986 +9787800393044 +9787800393068 +9787800393648 +9787800393693 +9787800393785 +9787800394317 +9787800394355 +9787800394461 +9787800394751 +9787800395109 +9787800395192 +9787800395383 +9787800395505 +9787800395529 +9787800395581 +9787800395734 +9787800395857 +9787800395956 +9787800395987 +9787800396151 +9787800396199 +9787800396250 +9787800396373 +9787800396427 +9787800396441 +9787800396465 +9787800396489 +9787800396632 +9787800396786 +9787800396939 +9787800397028 +9787800397219 +9787800397295 +9787800397318 +9787800397622 +9787800397677 +9787800397905 +9787800398087 +9787800398162 +9787800398261 +9787800398360 +9787800398452 +9787800398766 +9787800398803 +9787800398902 +9787800399039 +9787800399077 +9787800399466 +9787800399503 +9787800399558 +9787800399770 +9787800399848 +9787800399916 +9787800400117 +9787800400186 +9787800400407 +9787800400421 +9787800400469 +9787800400551 +9787800400650 +9787800400728 +9787800400872 +9787800400902 +9787800401008 +9787800401015 +9787800401022 +9787800401053 +9787800401183 +9787800401190 +9787800401251 +9787800401268 +9787800401336 +9787800401503 +9787800401602 +9787800401916 +9787800401923 +9787800402005 +9787800402487 +9787800402494 +9787800402678 +9787800402708 +9787800402869 +9787800402906 +9787800402937 +9787800402951 +9787800403071 +9787800403132 +9787800403217 +9787800403392 +9787800403415 +9787800403477 +9787800403521 +9787800403576 +9787800403590 +9787800403774 +9787800403804 +9787800403880 +9787800404108 +9787800404122 +9787800404146 +9787800404160 +9787800404382 +9787800404474 +9787800404566 +9787800404870 +9787800405013 +9787800405075 +9787800405105 +9787800405143 +9787800405174 +9787800405259 +9787800405266 +9787800405273 +9787800405280 +9787800405303 +9787800405365 +9787800405457 +9787800405624 +9787800405648 +9787800405808 +9787800405815 +9787800405846 +9787800405891 +9787800405952 +9787800406119 +9787800406317 +9787800406331 +9787800406454 +9787800406935 +9787800407031 +9787800407185 +9787800407451 +9787800407659 +9787800407840 +9787800407895 +9787800408199 +9787800409561 +9787800409721 +9787800410147 +9787800410529 +9787800410741 +9787800410949 +9787800411236 +9787800411281 +9787800411465 +9787800411472 +9787800411731 +9787800412042 +9787800420108 +9787800420146 +9787800420153 +9787800420191 +9787800420221 +9787800420269 +9787800420276 +9787800420283 +9787800420290 +9787800420306 +9787800420313 +9787800420351 +9787800420375 +9787800420436 +9787800420511 +9787800420528 +9787800420535 +9787800420610 +9787800420689 +9787800420771 +9787800421075 +9787800421112 +9787800421143 +9787800430480 +9787800430671 +9787800431913 +9787800431975 +9787800434549 +9787800435942 +9787800436062 +9787800436147 +9787800436246 +9787800436536 +9787800436949 +9787800437175 +9787800437526 +9787800437601 +9787800437793 +9787800438011 +9787800438042 +9787800438189 +9787800438752 +9787800439841 +9787800440007 +9787800440144 +9787800440236 +9787800440243 +9787800440250 +9787800440267 +9787800440274 +9787800440298 +9787800440311 +9787800440342 +9787800440373 +9787800440458 +9787800440571 +9787800440588 +9787800440779 +9787800440830 +9787800441042 +9787800441059 +9787800441103 +9787800441127 +9787800441165 +9787800441240 +9787800441394 +9787800441448 +9787800441486 +9787800441608 +9787800441868 +9787800442162 +9787800442216 +9787800442285 +9787800442292 +9787800442513 +9787800442698 +9787800442759 +9787800442827 +9787800450013 +9787800450754 +9787800451430 +9787800451478 +9787800451652 +9787800452659 +9787800452802 +9787800453991 +9787800454660 +9787800454912 +9787800455735 +9787800456787 +9787800460418 +9787800460890 +9787800461002 +9787800462689 +9787800463303 +9787800463778 +9787800464072 +9787800465185 +9787800465208 +9787800465253 +9787800465284 +9787800465321 +9787800465505 +9787800466045 +9787800466519 +9787800467592 +9787800467806 +9787800467875 +9787800469275 +9787800469312 +9787800469817 +9787800469862 +9787800469916 +9787800470028 +9787800470035 +9787800470042 +9787800470059 +9787800470110 +9787800470196 +9787800470240 +9787800470257 +9787800470400 +9787800470448 +9787800470677 +9787800470684 +9787800470745 +9787800470752 +9787800470820 +9787800470868 +9787800470936 +9787800471049 +9787800471063 +9787800471124 +9787800471148 +9787800471155 +9787800471193 +9787800471247 +9787800471292 +9787800471346 +9787800471360 +9787800471490 +9787800471643 +9787800471698 +9787800471780 +9787800472022 +9787800472060 +9787800472084 +9787800472190 +9787800472268 +9787800472275 +9787800472329 +9787800472367 +9787800472381 +9787800472473 +9787800472510 +9787800472527 +9787800472633 +9787800472640 +9787800472695 +9787800472725 +9787800472749 +9787800472756 +9787800472947 +9787800473098 +9787800473173 +9787800473364 +9787800474279 +9787800474347 +9787800474408 +9787800474675 +9787800474705 +9787800474866 +9787800474873 +9787800475207 +9787800475405 +9787800475481 +9787800475634 +9787800476143 +9787800476693 +9787800477713 +9787800478949 +9787800479014 +9787800479229 +9787800479434 +9787800480034 +9787800480096 +9787800480140 +9787800480171 +9787800480225 +9787800480263 +9787800480287 +9787800480348 +9787800480591 +9787800480683 +9787800490040 +9787800490088 +9787800490378 +9787800490491 +9787800490514 +9787800490590 +9787800490613 +9787800490668 +9787800490781 +9787800490804 +9787800490842 +9787800490927 +9787800491047 +9787800491061 +9787800491269 +9787800491283 +9787800491290 +9787800491627 +9787800491689 +9787800491702 +9787800491771 +9787800491795 +9787800491818 +9787800491863 +9787800491962 +9787800491993 +9787800492150 +9787800492167 +9787800492334 +9787800492365 +9787800492709 +9787800492747 +9787800492761 +9787800493010 +9787800493379 +9787800493416 +9787800493430 +9787800493737 +9787800494253 +9787800494369 +9787800494376 +9787800494468 +9787800494642 +9787800495106 +9787800495793 +9787800495847 +9787800495854 +9787800495861 +9787800496011 +9787800496103 +9787800496134 +9787800496233 +9787800496257 +9787800496363 +9787800496370 +9787800496479 +9787800496516 +9787800497032 +9787800497063 +9787800497094 +9787800497100 +9787800497315 +9787800497469 +9787800497841 +9787800497896 +9787800498213 +9787800498282 +9787800498374 +9787800498381 +9787800498435 +9787800498466 +9787800498916 +9787800499012 +9787800499029 +9787800499036 +9787800499074 +9787800499135 +9787800499159 +9787800499166 +9787800499180 +9787800499333 +9787800499531 +9787800499708 +9787800499838 +9787800500350 +9787800500398 +9787800500565 +9787800500800 +9787800500886 +9787800501050 +9787800501340 +9787800501548 +9787800501609 +9787800501777 +9787800501852 +9787800501869 +9787800502033 +9787800502071 +9787800502262 +9787800502392 +9787800502804 +9787800503399 +9787800503603 +9787800503702 +9787800504037 +9787800504235 +9787800504457 +9787800504785 +9787800505164 +9787800505386 +9787800505546 +9787800505607 +9787800505836 +9787800506192 +9787800506291 +9787800506352 +9787800506536 +9787800506604 +9787800506611 +9787800506741 +9787800506772 +9787800506796 +9787800506895 +9787800506963 +9787800507397 +9787800507427 +9787800508080 +9787800508271 +9787800508394 +9787800508417 +9787800508776 +9787800508875 +9787800508967 +9787800509094 +9787800509124 +9787800509193 +9787800509223 +9787800509599 +9787800509605 +9787800509629 +9787800509643 +9787800509681 +9787800509742 +9787800509841 +9787800509988 +9787800513350 +9787800513398 +9787800514081 +9787800515880 +9787800516610 +9787800517785 +9787800517952 +9787800518249 +9787800519741 +9787800521669 +9787800521690 +9787800522321 +9787800522499 +9787800523328 +9787800523335 +9787800523342 +9787800523847 +9787800524165 +9787800525162 +9787800525193 +9787800526008 +9787800527074 +9787800527814 +9787800527821 +9787800527838 +9787800528118 +9787800530036 +9787800530067 +9787800530159 +9787800530180 +9787800530241 +9787800530272 +9787800530364 +9787800530395 +9787800530401 +9787800530432 +9787800530548 +9787800530609 +9787800530616 +9787800530753 +9787800530784 +9787800530852 +9787800530975 +9787800531057 +9787800531095 +9787800531132 +9787800531194 +9787800531323 +9787800531330 +9787800531385 +9787800531484 +9787800531507 +9787800531804 +9787800531811 +9787800531866 +9787800532078 +9787800532207 +9787800532283 +9787800532351 +9787800532504 +9787800532511 +9787800532634 +9787800532894 +9787800532900 +9787800533501 +9787800533525 +9787800533617 +9787800533631 +9787800533754 +9787800534072 +9787800534348 +9787800534355 +9787800534720 +9787800534768 +9787800534850 +9787800535208 +9787800535635 +9787800535710 +9787800535819 +9787800535970 +9787800536083 +9787800536151 +9787800536175 +9787800536465 +9787800536502 +9787800536663 +9787800536892 +9787800537011 +9787800537097 +9787800537103 +9787800537271 +9787800537745 +9787800537752 +9787800537813 +9787800537936 +9787800538063 +9787800538100 +9787800538230 +9787800538346 +9787800538353 +9787800538360 +9787800539022 +9787800539329 +9787800539428 +9787800539558 +9787800539626 +9787800539671 +9787800539695 +9787800539701 +9787800539732 +9787800539893 +9787800540264 +9787800540332 +9787800540349 +9787800540677 +9787800540783 +9787800540882 +9787800541261 +9787800541315 +9787800541605 +9787800541971 +9787800542404 +9787800542466 +9787800542749 +9787800543272 +9787800543364 +9787800543586 +9787800544729 +9787800545269 +9787800545672 +9787800545931 +9787800546105 +9787800546341 +9787800546556 +9787800546563 +9787800546976 +9787800547737 +9787800548307 +9787800548352 +9787800548673 +9787800549175 +9787800549236 +9787800549502 +9787800560521 +9787800560729 +9787800565588 +9787800566677 +9787800567025 +9787800567278 +9787800567865 +9787800568107 +9787800568527 +9787800568732 +9787800568756 +9787800569609 +9787800569715 +9787800570506 +9787800570551 +9787800570605 +9787800570728 +9787800570780 +9787800570797 +9787800570827 +9787800570841 +9787800571367 +9787800571473 +9787800571480 +9787800571497 +9787800571619 +9787800571633 +9787800571640 +9787800571657 +9787800571688 +9787800571824 +9787800571909 +9787800571954 +9787800571978 +9787800572012 +9787800572111 +9787800572289 +9787800572302 +9787800572562 +9787800572777 +9787800573255 +9787800573262 +9787800573668 +9787800574078 +9787800574399 +9787800574429 +9787800574948 +9787800574993 +9787800575143 +9787800575440 +9787800575648 +9787800575709 +9787800576126 +9787800576430 +9787800576546 +9787800576584 +9787800576768 +9787800576782 +9787800577086 +9787800577116 +9787800577130 +9787800577161 +9787800577222 +9787800577338 +9787800577406 +9787800577505 +9787800577703 +9787800578007 +9787800578205 +9787800578410 +9787800578656 +9787800578663 +9787800578861 +9787800578892 +9787800580642 +9787800580925 +9787800581816 +9787800582196 +9787800583223 +9787800584626 +9787800585074 +9787800585500 +9787800585623 +9787800586613 +9787800586699 +9787800587580 +9787800587962 +9787800589959 +9787800590450 +9787800590665 +9787800591655 +9787800593208 +9787800593222 +9787800593239 +9787800593512 +9787800593574 +9787800600098 +9787800600319 +9787800600463 +9787800600661 +9787800600777 +9787800600791 +9787800600852 +9787800600982 +9787800602078 +9787800602450 +9787800602672 +9787800603020 +9787800603051 +9787800603181 +9787800603440 +9787800603754 +9787800604140 +9787800604447 +9787800605024 +9787800605260 +9787800605451 +9787800606038 +9787800606243 +9787800606250 +9787800606281 +9787800606700 +9787800607004 +9787800607189 +9787800607233 +9787800607288 +9787800607387 +9787800607509 +9787800607660 +9787800608254 +9787800608551 +9787800608674 +9787800608704 +9787800608919 +9787800608964 +9787800609855 +9787800610097 +9787800610578 +9787800610653 +9787800610660 +9787800610677 +9787800610776 +9787800610783 +9787800610981 +9787800611049 +9787800611131 +9787800611292 +9787800611407 +9787800611537 +9787800611551 +9787800611636 +9787800611643 +9787800611827 +9787800611865 +9787800612145 +9787800612350 +9787800613005 +9787800613043 +9787800613081 +9787800613616 +9787800613678 +9787800613715 +9787800613869 +9787800614040 +9787800614262 +9787800614460 +9787800614552 +9787800614743 +9787800614873 +9787800614880 +9787800615122 +9787800615573 +9787800615580 +9787800615658 +9787800615719 +9787800615740 +9787800615771 +9787800615788 +9787800615832 +9787800615849 +9787800615856 +9787800615870 +9787800615894 +9787800615900 +9787800615917 +9787800615931 +9787800615979 +9787800616082 +9787800616105 +9787800616112 +9787800616440 +9787800616471 +9787800616501 +9787800616525 +9787800616761 +9787800616778 +9787800616907 +9787800617089 +9787800617126 +9787800617133 +9787800617188 +9787800617287 +9787800617294 +9787800617300 +9787800617317 +9787800617348 +9787800617355 +9787800617362 +9787800617492 +9787800617515 +9787800617539 +9787800617546 +9787800617591 +9787800617607 +9787800617713 +9787800617775 +9787800618093 +9787800618123 +9787800618277 +9787800618390 +9787800618444 +9787800618604 +9787800618666 +9787800618680 +9787800619090 +9787800619267 +9787800619489 +9787800619496 +9787800619663 +9787800619717 +9787800619793 +9787800619816 +9787800619823 +9787800619854 +9787800619878 +9787800619908 +9787800619915 +9787800619960 +9787800619984 +9787800620072 +9787800620188 +9787800620317 +9787800620331 +9787800620584 +9787800620621 +9787800620737 +9787800621024 +9787800621055 +9787800630279 +9787800630460 +9787800630576 +9787800630859 +9787800630866 +9787800631009 +9787800631399 +9787800640582 +9787800641114 +9787800643040 +9787800644030 +9787800644795 +9787800645037 +9787800646300 +9787800648649 +9787800651106 +9787800651533 +9787800651564 +9787800651670 +9787800651953 +9787800652141 +9787800652318 +9787800652578 +9787800652585 +9787800652592 +9787800652950 +9787800653124 +9787800653537 +9787800653575 +9787800653674 +9787800653698 +9787800653728 +9787800654008 +9787800654015 +9787800654077 +9787800654084 +9787800654091 +9787800654169 +9787800654176 +9787800654510 +9787800654534 +9787800654657 +9787800654664 +9787800654725 +9787800654787 +9787800654794 +9787800654855 +9787800655012 +9787800655029 +9787800655104 +9787800655265 +9787800655999 +9787800656507 +9787800656668 +9787800657016 +9787800657078 +9787800670022 +9787800670251 +9787800670282 +9787800671142 +9787800671227 +9787800671241 +9787800671258 +9787800671661 +9787800671883 +9787800671906 +9787800671913 +9787800672002 +9787800672026 +9787800672149 +9787800672163 +9787800672545 +9787800673290 +9787800673450 +9787800673474 +9787800673481 +9787800673733 +9787800673740 +9787800673863 +9787800680007 +9787800680649 +9787800681127 +9787800681226 +9787800681622 +9787800681639 +9787800681745 +9787800681943 +9787800682414 +9787800682421 +9787800682803 +9787800683008 +9787800683015 +9787800683299 +9787800683992 +9787800684036 +9787800684210 +9787800684234 +9787800684425 +9787800684500 +9787800684531 +9787800684630 +9787800684692 +9787800684739 +9787800685033 +9787800685132 +9787800685774 +9787800685941 +9787800685958 +9787800685965 +9787800685972 +9787800686122 +9787800686443 +9787800687938 +9787800688034 +9787800688263 +9787800688270 +9787800688331 +9787800688355 +9787800688485 +9787800688683 +9787800688959 +9787800689055 +9787800689161 +9787800689185 +9787800689208 +9787800689260 +9787800689291 +9787800689345 +9787800689444 +9787800689499 +9787800689536 +9787800689659 +9787800689680 +9787800689703 +9787800690105 +9787800690471 +9787800691379 +9787800691621 +9787800691676 +9787800691843 +9787800691942 +9787800691980 +9787800692017 +9787800692031 +9787800692093 +9787800692116 +9787800692123 +9787800692192 +9787800692352 +9787800692383 +9787800692475 +9787800692499 +9787800692529 +9787800692642 +9787800692727 +9787800692802 +9787800692949 +9787800693144 +9787800693151 +9787800693250 +9787800693342 +9787800693540 +9787800693557 +9787800693564 +9787800693854 +9787800693984 +9787800694066 +9787800694165 +9787800694219 +9787800694226 +9787800694318 +9787800694332 +9787800694387 +9787800694424 +9787800694486 +9787800694608 +9787800694936 +9787800694943 +9787800694950 +9787800694967 +9787800695100 +9787800695117 +9787800695209 +9787800695643 +9787800695674 +9787800696022 +9787800696268 +9787800696329 +9787800696435 +9787800696619 +9787800696718 +9787800696930 +9787800697135 +9787800697272 +9787800697364 +9787800697678 +9787800697784 +9787800698101 +9787800698330 +9787800698675 +9787800698804 +9787800698965 +9787800699047 +9787800699498 +9787800699566 +9787800699627 +9787800700927 +9787800703362 +9787800704109 +9787800704673 +9787800704840 +9787800705823 +9787800706660 +9787800707063 +9787800707124 +9787800707957 +9787800708732 +9787800709340 +9787800709357 +9787800709449 +9787800709487 +9787800709746 +9787800709777 +9787800709869 +9787800709890 +9787800710032 +9787800710056 +9787800710209 +9787800710216 +9787800710353 +9787800710650 +9787800710667 +9787800710827 +9787800711053 +9787800711763 +9787800711930 +9787800712241 +9787800712265 +9787800712364 +9787800713804 +9787800713811 +9787800720949 +9787800721342 +9787800722271 +9787800722639 +9787800723032 +9787800724817 +9787800725111 +9787800725128 +9787800725135 +9787800725425 +9787800726064 +9787800726095 +9787800726286 +9787800726972 +9787800727122 +9787800727375 +9787800727665 +9787800727764 +9787800728051 +9787800728235 +9787800728495 +9787800729089 +9787800729140 +9787800729232 +9787800729300 +9787800729317 +9787800730412 +9787800730580 +9787800730658 +9787800731099 +9787800731587 +9787800732577 +9787800732638 +9787800732676 +9787800733024 +9787800733116 +9787800733345 +9787800733765 +9787800733871 +9787800734199 +9787800734359 +9787800734380 +9787800734519 +9787800734533 +9787800734618 +9787800734694 +9787800734847 +9787800735769 +9787800736933 +9787800737312 +9787800739187 +9787800739217 +9787800739460 +9787800740046 +9787800740091 +9787800740183 +9787800740367 +9787800740480 +9787800740503 +9787800740657 +9787800741036 +9787800741227 +9787800741395 +9787800741456 +9787800741623 +9787800741920 +9787800741944 +9787800742286 +9787800742408 +9787800742613 +9787800742668 +9787800743528 +9787800743573 +9787800743719 +9787800743788 +9787800744013 +9787800744082 +9787800744105 +9787800744181 +9787800744235 +9787800744365 +9787800744945 +9787800744969 +9787800745027 +9787800745126 +9787800745201 +9787800745249 +9787800745614 +9787800745645 +9787800745669 +9787800745676 +9787800746048 +9787800746222 +9787800746413 +9787800746543 +9787800746628 +9787800746727 +9787800746833 +9787800747014 +9787800747229 +9787800747243 +9787800747304 +9787800747458 +9787800747526 +9787800747564 +9787800747632 +9787800748233 +9787800748677 +9787800748837 +9787800748974 +9787800748998 +9787800749001 +9787800749087 +9787800749186 +9787800749209 +9787800749230 +9787800749438 +9787800749452 +9787800749544 +9787800749582 +9787800749605 +9787800749650 +9787800749742 +9787800749759 +9787800749766 +9787800749933 +9787800749971 +9787800749988 +9787800749995 +9787800760150 +9787800761409 +9787800761782 +9787800763168 +9787800763175 +9787800763182 +9787800764059 +9787800764417 +9787800764783 +9787800764882 +9787800765131 +9787800765155 +9787800765469 +9787800765506 +9787800765766 +9787800766039 +9787800766589 +9787800766688 +9787800766879 +9787800767616 +9787800767753 +9787800767791 +9787800767944 +9787800768118 +9787800768132 +9787800768187 +9787800768231 +9787800768286 +9787800768361 +9787800768460 +9787800768675 +9787800768736 +9787800768873 +9787800769528 +9787800769580 +9787800769740 +9787800771293 +9787800771941 +9787800772931 +9787800773068 +9787800773075 +9787800773686 +9787800773709 +9787800773730 +9787800774058 +9787800775611 +9787800775710 +9787800775796 +9787800776311 +9787800776496 +9787800776557 +9787800776564 +9787800776755 +9787800777806 +9787800778759 +9787800779596 +9787800779657 +9787800780141 +9787800781193 +9787800781575 +9787800783463 +9787800783715 +9787800783920 +9787800788734 +9787800789748 +9787800790126 +9787800790294 +9787800790621 +9787800790867 +9787800791208 +9787800792335 +9787800792373 +9787800792816 +9787800792823 +9787800794735 +9787800796302 +9787800797354 +9787800797408 +9787800797651 +9787800797736 +9787800797798 +9787800798917 +9787800799044 +9787800799341 +9787800799525 +9787800800252 +9787800800269 +9787800800283 +9787800800306 +9787800800337 +9787800800443 +9787800800801 +9787800800818 +9787800801051 +9787800801457 +9787800801488 +9787800801495 +9787800801846 +9787800801891 +9787800801983 +9787800802201 +9787800802553 +9787800802706 +9787800802782 +9787800802812 +9787800802928 +9787800803437 +9787800803789 +9787800804151 +9787800804342 +9787800804892 +9787800805035 +9787800805189 +9787800805196 +9787800807916 +9787800809118 +9787800809125 +9787800809132 +9787800809149 +9787800809156 +9787800809262 +9787800809446 +9787800809842 +9787800810923 +9787800811203 +9787800812132 +9787800813047 +9787800813351 +9787800813870 +9787800814839 +9787800814884 +9787800814891 +9787800814907 +9787800814914 +9787800814921 +9787800814938 +9787800815461 +9787800815683 +9787800815836 +9787800816277 +9787800816291 +9787800816321 +9787800816840 +9787800817052 +9787800817076 +9787800817083 +9787800817106 +9787800817328 +9787800817625 +9787800817939 +9787800817953 +9787800818028 +9787800818400 +9787800818486 +9787800818509 +9787800818899 +9787800818912 +9787800819070 +9787800819810 +9787800819872 +9787800819940 +9787800819988 +9787800820038 +9787800820090 +9787800820151 +9787800820229 +9787800820236 +9787800820540 +9787800820571 +9787800821172 +9787800821189 +9787800821264 +9787800821356 +9787800821592 +9787800821806 +9787800821868 +9787800821875 +9787800822391 +9787800822476 +9787800822612 +9787800822858 +9787800822971 +9787800823053 +9787800823077 +9787800823244 +9787800823459 +9787800823480 +9787800823589 +9787800823879 +9787800824272 +9787800824302 +9787800824326 +9787800824364 +9787800824982 +9787800825101 +9787800825118 +9787800825149 +9787800825194 +9787800825439 +9787800825491 +9787800825743 +9787800825941 +9787800825989 +9787800826122 +9787800826139 +9787800826450 +9787800826467 +9787800826474 +9787800826573 +9787800826597 +9787800826795 +9787800826832 +9787800827051 +9787800827068 +9787800827204 +9787800827280 +9787800827457 +9787800827464 +9787800827501 +9787800827549 +9787800827556 +9787800827693 +9787800827792 +9787800827884 +9787800827907 +9787800828034 +9787800828232 +9787800828263 +9787800828294 +9787800828393 +9787800828546 +9787800828584 +9787800828591 +9787800828768 +9787800828997 +9787800829512 +9787800829680 +9787800829697 +9787800830143 +9787800832871 +9787800832970 +9787800833076 +9787800834233 +9787800834332 +9787800835131 +9787800835841 +9787800837012 +9787800837456 +9787800840241 +9787800840449 +9787800840548 +9787800840821 +9787800840883 +9787800840951 +9787800841040 +9787800841095 +9787800841118 +9787800841125 +9787800841132 +9787800841187 +9787800841309 +9787800841484 +9787800841576 +9787800841729 +9787800841873 +9787800841958 +9787800842078 +9787800842092 +9787800842115 +9787800842214 +9787800842238 +9787800842252 +9787800842306 +9787800842344 +9787800842450 +9787800842658 +9787800842672 +9787800842702 +9787800842801 +9787800842849 +9787800842931 +9787800842993 +9787800843792 +9787800843815 +9787800843822 +9787800844041 +9787800844256 +9787800844270 +9787800844294 +9787800844829 +9787800845154 +9787800845239 +9787800845277 +9787800845321 +9787800845680 +9787800846373 +9787800846441 +9787800846724 +9787800846748 +9787800847998 +9787800848087 +9787800848223 +9787800848414 +9787800848490 +9787800848513 +9787800851391 +9787800860119 +9787800860294 +9787800861093 +9787800862212 +9787800862526 +9787800862632 +9787800863325 +9787800863554 +9787800863967 +9787800864773 +9787800865381 +9787800865442 +9787800865503 +9787800866074 +9787800866142 +9787800866524 +9787800866746 +9787800867323 +9787800867514 +9787800868696 +9787800868801 +9787800868825 +9787800869020 +9787800869105 +9787800870026 +9787800870330 +9787800870385 +9787800870521 +9787800871030 +9787800871481 +9787800871726 +9787800872488 +9787800872686 +9787800873065 +9787800873379 +9787800873560 +9787800873645 +9787800873805 +9787800874093 +9787800874116 +9787800874123 +9787800874642 +9787800874949 +9787800874963 +9787800875359 +9787800875939 +9787800876721 +9787800876967 +9787800876998 +9787800877063 +9787800877315 +9787800879647 +9787800880155 +9787800880322 +9787800880452 +9787800880810 +9787800882241 +9787800883392 +9787800883927 +9787800883934 +9787800884412 +9787800885358 +9787800885440 +9787800886003 +9787800886027 +9787800886140 +9787800886195 +9787800886201 +9787800886386 +9787800886409 +9787800886416 +9787800886508 +9787800886522 +9787800886539 +9787800886614 +9787800886812 +9787800886898 +9787800886942 +9787800887123 +9787800887314 +9787800887345 +9787800887376 +9787800887383 +9787800887437 +9787800887499 +9787800887635 +9787800887758 +9787800888144 +9787800888380 +9787800888397 +9787800888670 +9787800888755 +9787800888762 +9787800888809 +9787800888847 +9787800888878 +9787800889141 +9787800889325 +9787800889363 +9787800889387 +9787800889394 +9787800889417 +9787800889486 +9787800889738 +9787800890192 +9787800890376 +9787800890383 +9787800890482 +9787800890499 +9787800890567 +9787800890635 +9787800890642 +9787800890666 +9787800890758 +9787800890765 +9787800890772 +9787800890796 +9787800890871 +9787800891076 +9787800891144 +9787800891205 +9787800891212 +9787800891281 +9787800891298 +9787800891342 +9787800891380 +9787800891434 +9787800891465 +9787800891519 +9787800891533 +9787800891540 +9787800891557 +9787800891601 +9787800891816 +9787800891885 +9787800891915 +9787800891953 +9787800891960 +9787800891984 +9787800891991 +9787800892004 +9787800892011 +9787800892158 +9787800892448 +9787800892455 +9787800892509 +9787800892561 +9787800892837 +9787800892844 +9787800892929 +9787800893025 +9787800893032 +9787800893124 +9787800893131 +9787800893148 +9787800893247 +9787800893285 +9787800893315 +9787800893490 +9787800893506 +9787800893599 +9787800893759 +9787800893834 +9787800893889 +9787800894046 +9787800894107 +9787800894121 +9787800894558 +9787800894565 +9787800894695 +9787800894886 +9787800895111 +9787800895166 +9787800895289 +9787800895432 +9787800895494 +9787800895517 +9787800895722 +9787800896149 +9787800896354 +9787800896392 +9787800896637 +9787800896859 +9787800897313 +9787800897351 +9787800897450 +9787800897535 +9787800897696 +9787800897856 +9787800898440 +9787800898501 +9787800898532 +9787800898587 +9787800898693 +9787800899218 +9787800899294 +9787800899300 +9787800900167 +9787800900440 +9787800900877 +9787800901331 +9787800902819 +9787800904028 +9787800904035 +9787800904288 +9787800904653 +9787800904790 +9787800905629 +9787800906176 +9787800906619 +9787800907234 +9787800907296 +9787800907494 +9787800907746 +9787800907753 +9787800907838 +9787800908163 +9787800908590 +9787800908705 +9787800908866 +9787800910227 +9787800910470 +9787800910487 +9787800911255 +9787800911767 +9787800912061 +9787800912115 +9787800912214 +9787800912382 +9787800913440 +9787800913532 +9787800913655 +9787800914348 +9787800914416 +9787800914447 +9787800914768 +9787800914966 +9787800915192 +9787800915215 +9787800915314 +9787800915871 +9787800915888 +9787800915925 +9787800915994 +9787800916106 +9787800916120 +9787800916250 +9787800916533 +9787800916618 +9787800916656 +9787800916700 +9787800916786 +9787800916823 +9787800916991 +9787800917226 +9787800917233 +9787800918384 +9787800918391 +9787800918605 +9787800918636 +9787800918827 +9787800918841 +9787800918858 +9787800918872 +9787800918995 +9787800919008 +9787800919022 +9787800919145 +9787800919305 +9787800919312 +9787800919367 +9787800919503 +9787800919619 +9787800919640 +9787800919695 +9787800919701 +9787800919879 +9787800919947 +9787800919954 +9787800920066 +9787800920080 +9787800920127 +9787800920226 +9787800920394 +9787800920462 +9787800920622 +9787800920660 +9787800920691 +9787800921292 +9787800921469 +9787800921629 +9787800921636 +9787800921810 +9787800922022 +9787800922046 +9787800922091 +9787800922381 +9787800922688 +9787800922930 +9787800923050 +9787800923074 +9787800923159 +9787800923326 +9787800923487 +9787800923661 +9787800923685 +9787800923708 +9787800923715 +9787800923777 +9787800923791 +9787800923852 +9787800923975 +9787800924668 +9787800924774 +9787800925009 +9787800925054 +9787800925214 +9787800925344 +9787800925849 +9787800926198 +9787800926242 +9787800926648 +9787800926808 +9787800926822 +9787800926839 +9787800926860 +9787800926976 +9787800927126 +9787800927201 +9787800927225 +9787800927546 +9787800927577 +9787800927720 +9787800927805 +9787800927867 +9787800928222 +9787800928239 +9787800928277 +9787800928338 +9787800928543 +9787800929069 +9787800929236 +9787800929243 +9787800929304 +9787800929786 +9787800929861 +9787800929885 +9787800929892 +9787800930119 +9787800930225 +9787800931796 +9787800932076 +9787800933875 +9787800934452 +9787800936814 +9787800937781 +9787800937989 +9787800939136 +9787800939143 +9787800940071 +9787800940118 +9787800940125 +9787800940385 +9787800940514 +9787800940521 +9787800940736 +9787800940804 +9787800941177 +9787800941245 +9787800941337 +9787800941498 +9787800941825 +9787800941863 +9787800941870 +9787800942303 +9787800942358 +9787800942389 +9787800942471 +9787800942525 +9787800942587 +9787800942617 +9787800942679 +9787800942723 +9787800942945 +9787800943423 +9787800943447 +9787800943508 +9787800943522 +9787800943539 +9787800943584 +9787800943645 +9787800943713 +9787800943874 +9787800944000 +9787800944130 +9787800944192 +9787800944246 +9787800944505 +9787800944543 +9787800944550 +9787800944710 +9787800944932 +9787800945052 +9787800945120 +9787800945199 +9787800945359 +9787800945410 +9787800945434 +9787800945465 +9787800945502 +9787800945656 +9787800945700 +9787800945779 +9787800945786 +9787800945977 +9787800946028 +9787800946158 +9787800946165 +9787800946172 +9787800946196 +9787800946202 +9787800946219 +9787800946226 +9787800946370 +9787800946394 +9787800946462 +9787800946608 +9787800946615 +9787800946752 +9787800946776 +9787800946790 +9787800946806 +9787800946998 +9787800947063 +9787800947087 +9787800947247 +9787800947254 +9787800947285 +9787800947360 +9787800947841 +9787800947858 +9787800947865 +9787800947933 +9787800947964 +9787800948138 +9787800948152 +9787800948169 +9787800948275 +9787800948329 +9787800948343 +9787800948350 +9787800948367 +9787800948794 +9787800948909 +9787800948916 +9787800948923 +9787800949135 +9787800949210 +9787800949265 +9787800949319 +9787800949326 +9787800949364 +9787800949470 +9787800949708 +9787800949746 +9787800949937 +9787800950155 +9787800960918 +9787800961151 +9787800962387 +9787800963186 +9787800963667 +9787800963858 +9787800964152 +9787800964800 +9787800964855 +9787800965685 +9787800966514 +9787800966866 +9787800966897 +9787800967559 +9787800967597 +9787800967603 +9787800967641 +9787800968006 +9787800968273 +9787800968303 +9787800968587 +9787800969287 +9787800969584 +9787800969607 +9787800969645 +9787800970146 +9787800970351 +9787800970986 +9787800971082 +9787800971365 +9787800971457 +9787800971785 +9787800971815 +9787800971822 +9787800973123 +9787800973321 +9787800974557 +9787800975226 +9787800975769 +9787800976186 +9787800976636 +9787800977275 +9787800977589 +9787800977695 +9787800977770 +9787800977817 +9787800978180 +9787800978289 +9787800978517 +9787800979828 +9787800980886 +9787800981463 +9787800981555 +9787800982293 +9787800983238 +9787800984068 +9787800984181 +9787800984235 +9787800984389 +9787800984761 +9787800986192 +9787800986376 +9787800986864 +9787800986871 +9787800987687 +9787800987922 +9787800988530 +9787800988554 +9787800988844 +9787800989803 +9787800989988 +9787800990724 +9787800991059 +9787800991233 +9787800991301 +9787800992056 +9787800992421 +9787800992537 +9787800992773 +9787800992971 +9787800992988 +9787800993398 +9787800993480 +9787800993510 +9787800993978 +9787800994210 +9787800994623 +9787800994968 +9787800995873 +9787800995927 +9787800996207 +9787800996597 +9787800996931 +9787800998430 +9787800999017 +9787800999208 +9787800999611 +9787800999857 +9787800999925 +9787801000026 +9787801000316 +9787801000729 +9787801000750 +9787801001016 +9787801001115 +9787801001177 +9787801001191 +9787801001702 +9787801002167 +9787801002204 +9787801002228 +9787801002358 +9787801002372 +9787801002389 +9787801002488 +9787801002631 +9787801002877 +9787801002891 +9787801002969 +9787801003034 +9787801003058 +9787801003157 +9787801003294 +9787801003393 +9787801003683 +9787801003720 +9787801003744 +9787801004147 +9787801004253 +9787801004277 +9787801004284 +9787801004444 +9787801004758 +9787801004796 +9787801005106 +9787801005328 +9787801005410 +9787801005489 +9787801005885 +9787801006394 +9787801006479 +9787801006646 +9787801006738 +9787801006905 +9787801006912 +9787801006981 +9787801007025 +9787801007285 +9787801007377 +9787801007636 +9787801008367 +9787801008893 +9787801009104 +9787801010568 +9787801010629 +9787801010780 +9787801010933 +9787801011749 +9787801011862 +9787801012029 +9787801012043 +9787801012234 +9787801012487 +9787801012869 +9787801013286 +9787801013309 +9787801013514 +9787801013521 +9787801013729 +9787801013781 +9787801013835 +9787801014443 +9787801014474 +9787801014481 +9787801014597 +9787801014603 +9787801014610 +9787801014849 +9787801015655 +9787801015839 +9787801015853 +9787801016782 +9787801016799 +9787801016805 +9787801016966 +9787801016980 +9787801017505 +9787801018151 +9787801018168 +9787801018199 +9787801018205 +9787801018366 +9787801018793 +9787801030009 +9787801030016 +9787801030023 +9787801030245 +9787801030283 +9787801030474 +9787801030481 +9787801030528 +9787801030801 +9787801031051 +9787801031259 +9787801031679 +9787801031792 +9787801031815 +9787801031839 +9787801032027 +9787801032065 +9787801032232 +9787801032829 +9787801033215 +9787801033222 +9787801033338 +9787801036001 +9787801037244 +9787801038739 +9787801042477 +9787801043191 +9787801043818 +9787801045133 +9787801045140 +9787801046895 +9787801049469 +9787801050045 +9787801050335 +9787801050403 +9787801050427 +9787801050557 +9787801050748 +9787801050885 +9787801050892 +9787801050960 +9787801051127 +9787801051172 +9787801051271 +9787801051349 +9787801051394 +9787801051417 +9787801051523 +9787801051738 +9787801051745 +9787801051851 +9787801052032 +9787801052179 +9787801052254 +9787801052292 +9787801052438 +9787801052568 +9787801052582 +9787801052612 +9787801052650 +9787801052810 +9787801053053 +9787801053558 +9787801053619 +9787801053695 +9787801053831 +9787801053909 +9787801054531 +9787801054609 +9787801054708 +9787801054784 +9787801054937 +9787801054975 +9787801054999 +9787801055071 +9787801055149 +9787801055163 +9787801055231 +9787801055262 +9787801055286 +9787801055293 +9787801055385 +9787801055422 +9787801055484 +9787801055514 +9787801055606 +9787801055620 +9787801055842 +9787801055873 +9787801056214 +9787801056412 +9787801056610 +9787801056641 +9787801056702 +9787801056917 +9787801057143 +9787801057532 +9787801057945 +9787801058348 +9787801058720 +9787801059000 +9787801059062 +9787801059451 +9787801059734 +9787801060631 +9787801061065 +9787801061607 +9787801061669 +9787801061690 +9787801062048 +9787801062079 +9787801062253 +9787801062673 +9787801062857 +9787801063793 +9787801063885 +9787801064097 +9787801064172 +9787801064288 +9787801064370 +9787801065599 +9787801065605 +9787801065612 +9787801065674 +9787801065735 +9787801066060 +9787801066411 +9787801066428 +9787801066497 +9787801066541 +9787801066572 +9787801066671 +9787801066749 +9787801066756 +9787801066916 +9787801067043 +9787801067296 +9787801067333 +9787801067760 +9787801067814 +9787801067821 +9787801068255 +9787801068330 +9787801068538 +9787801068705 +9787801068781 +9787801069467 +9787801069689 +9787801070180 +9787801070746 +9787801071156 +9787801071774 +9787801072085 +9787801072122 +9787801072146 +9787801072450 +9787801072511 +9787801073907 +9787801074058 +9787801074799 +9787801075109 +9787801075154 +9787801075659 +9787801076717 +9787801077004 +9787801077127 +9787801077196 +9787801078810 +9787801078889 +9787801080028 +9787801080134 +9787801080196 +9787801080356 +9787801080479 +9787801080493 +9787801080943 +9787801081018 +9787801081094 +9787801081148 +9787801081155 +9787801081292 +9787801081476 +9787801081513 +9787801081544 +9787801081766 +9787801081933 +9787801081971 +9787801081988 +9787801082374 +9787801083135 +9787801083685 +9787801083975 +9787801084040 +9787801084088 +9787801084132 +9787801084316 +9787801084576 +9787801084798 +9787801085047 +9787801085238 +9787801085283 +9787801085290 +9787801085627 +9787801086037 +9787801086044 +9787801086266 +9787801086297 +9787801086471 +9787801086754 +9787801086792 +9787801087102 +9787801087751 +9787801088239 +9787801088260 +9787801089137 +9787801089403 +9787801089496 +9787801089793 +9787801089885 +9787801089960 +9787801090010 +9787801090171 +9787801090188 +9787801090195 +9787801090201 +9787801090225 +9787801090287 +9787801090324 +9787801090331 +9787801090362 +9787801090379 +9787801090393 +9787801090492 +9787801090508 +9787801090836 +9787801090935 +9787801091000 +9787801091048 +9787801091130 +9787801091550 +9787801092250 +9787801092298 +9787801092489 +9787801092588 +9787801092595 +9787801092632 +9787801092885 +9787801093066 +9787801093097 +9787801093158 +9787801093189 +9787801093318 +9787801093813 +9787801093882 +9787801094278 +9787801094612 +9787801094742 +9787801094889 +9787801094896 +9787801095107 +9787801095350 +9787801095572 +9787801096098 +9787801096234 +9787801096661 +9787801098252 +9787801098672 +9787801099174 +9787801099365 +9787801099532 +9787801099808 +9787801099969 +9787801101204 +9787801101211 +9787801101723 +9787801102072 +9787801104663 +9787801105080 +9787801105462 +9787801105653 +9787801106025 +9787801106087 +9787801106537 +9787801106797 +9787801106933 +9787801107138 +9787801107855 +9787801109392 +9787801109484 +9787801109859 +9787801109903 +9787801110503 +9787801110527 +9787801110572 +9787801110602 +9787801110619 +9787801112057 +9787801112064 +9787801112484 +9787801112965 +9787801113641 +9787801114273 +9787801114303 +9787801115973 +9787801116185 +9787801116215 +9787801116383 +9787801116505 +9787801116512 +9787801116635 +9787801119544 +9787801119827 +9787801119933 +9787801120151 +9787801120281 +9787801120403 +9787801120502 +9787801120823 +9787801120922 +9787801121486 +9787801121639 +9787801121691 +9787801121721 +9787801121806 +9787801122247 +9787801122346 +9787801122360 +9787801122889 +9787801122971 +9787801122995 +9787801123091 +9787801123381 +9787801123886 +9787801123978 +9787801124463 +9787801125040 +9787801125255 +9787801125798 +9787801126030 +9787801126115 +9787801126672 +9787801126979 +9787801126993 +9787801127143 +9787801127945 +9787801128430 +9787801131423 +9787801131430 +9787801131447 +9787801132291 +9787801132390 +9787801133274 +9787801134318 +9787801134332 +9787801134349 +9787801135346 +9787801136541 +9787801136893 +9787801137272 +9787801137326 +9787801137487 +9787801138323 +9787801138682 +9787801139269 +9787801139368 +9787801140050 +9787801140067 +9787801140166 +9787801140333 +9787801140401 +9787801140432 +9787801140449 +9787801140470 +9787801140487 +9787801140616 +9787801140630 +9787801140647 +9787801141040 +9787801141095 +9787801141309 +9787801141620 +9787801141675 +9787801141682 +9787801141767 +9787801141934 +9787801141996 +9787801142078 +9787801142191 +9787801142528 +9787801142535 +9787801142856 +9787801143037 +9787801143266 +9787801143372 +9787801143679 +9787801143990 +9787801144058 +9787801144157 +9787801144225 +9787801144348 +9787801144478 +9787801144607 +9787801144652 +9787801144737 +9787801144744 +9787801144812 +9787801144867 +9787801144874 +9787801144928 +9787801145062 +9787801145093 +9787801145215 +9787801145468 +9787801145598 +9787801145604 +9787801145666 +9787801145888 +9787801146038 +9787801146120 +9787801146175 +9787801146243 +9787801146380 +9787801146434 +9787801146564 +9787801146762 +9787801147097 +9787801147110 +9787801147165 +9787801147233 +9787801147486 +9787801147608 +9787801147707 +9787801148049 +9787801148117 +9787801148469 +9787801148773 +9787801148971 +9787801149466 +9787801149480 +9787801149855 +9787801149879 +9787801149886 +9787801149893 +9787801150011 +9787801150066 +9787801150127 +9787801150172 +9787801150196 +9787801150301 +9787801150325 +9787801150332 +9787801150387 +9787801150578 +9787801150776 +9787801150981 +9787801151087 +9787801151148 +9787801151155 +9787801151162 +9787801151247 +9787801151339 +9787801151490 +9787801151544 +9787801151704 +9787801151766 +9787801151834 +9787801152169 +9787801152381 +9787801152442 +9787801152657 +9787801152701 +9787801152947 +9787801153005 +9787801153067 +9787801153128 +9787801153371 +9787801153616 +9787801153692 +9787801153708 +9787801153883 +9787801154095 +9787801154163 +9787801154408 +9787801154460 +9787801154590 +9787801154873 +9787801155047 +9787801155702 +9787801155894 +9787801156518 +9787801156648 +9787801156822 +9787801157126 +9787801157249 +9787801157515 +9787801157560 +9787801157676 +9787801157911 +9787801158352 +9787801158727 +9787801159632 +9787801159793 +9787801159953 +9787801160201 +9787801160478 +9787801160546 +9787801160560 +9787801161161 +9787801163615 +9787801163868 +9787801164131 +9787801164322 +9787801164599 +9787801164803 +9787801165084 +9787801165114 +9787801165121 +9787801165169 +9787801165381 +9787801165701 +9787801166135 +9787801166401 +9787801166494 +9787801166500 +9787801169785 +9787801169792 +9787801171733 +9787801174468 +9787801178176 +9787801180681 +9787801181954 +9787801181992 +9787801182395 +9787801182760 +9787801183255 +9787801183804 +9787801184528 +9787801184665 +9787801185044 +9787801185518 +9787801186034 +9787801186461 +9787801186782 +9787801186935 +9787801187819 +9787801189189 +9787801190055 +9787801190826 +9787801191083 +9787801191830 +9787801192592 +9787801192776 +9787801192950 +9787801193339 +9787801193650 +9787801194879 +9787801194978 +9787801195944 +9787801198655 +9787801199492 +9787801199515 +9787801200013 +9787801200037 +9787801200129 +9787801200181 +9787801200532 +9787801200693 +9787801200846 +9787801200914 +9787801201157 +9787801201164 +9787801201201 +9787801201294 +9787801201454 +9787801201645 +9787801201652 +9787801201720 +9787801202154 +9787801202185 +9787801202260 +9787801202413 +9787801202710 +9787801202833 +9787801202840 +9787801202857 +9787801202864 +9787801203182 +9787801203304 +9787801203601 +9787801203663 +9787801203779 +9787801203809 +9787801203892 +9787801203908 +9787801203915 +9787801203922 +9787801203977 +9787801204103 +9787801204110 +9787801204233 +9787801204257 +9787801204301 +9787801204387 +9787801204493 +9787801204561 +9787801204806 +9787801205056 +9787801205070 +9787801205193 +9787801205391 +9787801205582 +9787801205612 +9787801205674 +9787801205742 +9787801205858 +9787801205865 +9787801205919 +9787801205940 +9787801206084 +9787801206152 +9787801206176 +9787801206206 +9787801206374 +9787801206404 +9787801206510 +9787801206695 +9787801206749 +9787801206756 +9787801207043 +9787801207142 +9787801207302 +9787801207340 +9787801207647 +9787801207951 +9787801208026 +9787801208132 +9787801208910 +9787801209245 +9787801209306 +9787801209573 +9787801209764 +9787801209917 +9787801210272 +9787801210395 +9787801210616 +9787801210685 +9787801210753 +9787801210906 +9787801211613 +9787801211743 +9787801213716 +9787801213853 +9787801215246 +9787801216991 +9787801220011 +9787801220028 +9787801220387 +9787801220486 +9787801220509 +9787801220615 +9787801220660 +9787801220745 +9787801221124 +9787801221216 +9787801221322 +9787801221858 +9787801222060 +9787801222077 +9787801222213 +9787801222343 +9787801223043 +9787801223104 +9787801223326 +9787801224132 +9787801224583 +9787801225160 +9787801225191 +9787801225375 +9787801226204 +9787801226327 +9787801226525 +9787801226624 +9787801226754 +9787801226778 +9787801227607 +9787801227690 +9787801227843 +9787801228949 +9787801229083 +9787801229120 +9787801229137 +9787801229182 +9787801229274 +9787801229380 +9787801229496 +9787801229816 +9787801230003 +9787801230027 +9787801230041 +9787801230065 +9787801230270 +9787801230287 +9787801230300 +9787801230317 +9787801230324 +9787801230331 +9787801230348 +9787801230355 +9787801230379 +9787801230386 +9787801230454 +9787801230461 +9787801230478 +9787801230485 +9787801230546 +9787801230553 +9787801230577 +9787801230645 +9787801230720 +9787801230751 +9787801230775 +9787801230829 +9787801230867 +9787801230881 +9787801230898 +9787801230959 +9787801231000 +9787801231062 +9787801231086 +9787801231093 +9787801231321 +9787801231338 +9787801231406 +9787801231413 +9787801231482 +9787801231499 +9787801231680 +9787801231697 +9787801231840 +9787801231888 +9787801231895 +9787801231901 +9787801231949 +9787801231987 +9787801232007 +9787801232021 +9787801232038 +9787801232045 +9787801232144 +9787801232151 +9787801232182 +9787801232199 +9787801232243 +9787801232298 +9787801232311 +9787801232342 +9787801232380 +9787801232472 +9787801232557 +9787801232564 +9787801232601 +9787801232632 +9787801232656 +9787801232731 +9787801232793 +9787801232830 +9787801232861 +9787801232878 +9787801232885 +9787801232922 +9787801232946 +9787801233004 +9787801233028 +9787801233035 +9787801233073 +9787801233080 +9787801233103 +9787801233219 +9787801233233 +9787801233363 +9787801233417 +9787801233448 +9787801233486 +9787801233660 +9787801233691 +9787801233714 +9787801233769 +9787801233783 +9787801233806 +9787801233813 +9787801233837 +9787801233929 +9787801234131 +9787801234148 +9787801234278 +9787801234377 +9787801234391 +9787801234414 +9787801234438 +9787801234483 +9787801234520 +9787801234568 +9787801234674 +9787801234711 +9787801234896 +9787801234919 +9787801234957 +9787801235053 +9787801235367 +9787801235428 +9787801235534 +9787801235602 +9787801235671 +9787801235732 +9787801235800 +9787801235855 +9787801235879 +9787801235961 +9787801236012 +9787801236029 +9787801236180 +9787801236197 +9787801236258 +9787801236319 +9787801236364 +9787801236401 +9787801236470 +9787801236487 +9787801236661 +9787801236715 +9787801237125 +9787801237590 +9787801237637 +9787801237699 +9787801237804 +9787801237941 +9787801238054 +9787801238146 +9787801238290 +9787801238474 +9787801238559 +9787801238627 +9787801238672 +9787801238757 +9787801238795 +9787801238818 +9787801239280 +9787801239341 +9787801239372 +9787801239648 +9787801239686 +9787801239860 +9787801241283 +9787801242099 +9787801244765 +9787801245786 +9787801246820 +9787801249661 +9787801250001 +9787801250391 +9787801251527 +9787801251565 +9787801253880 +9787801254801 +9787801255167 +9787801255839 +9787801255877 +9787801257215 +9787801258724 +9787801259592 +9787801260048 +9787801260055 +9787801260673 +9787801260765 +9787801260772 +9787801260789 +9787801260864 +9787801261137 +9787801261281 +9787801263315 +9787801263735 +9787801263742 +9787801263971 +9787801264015 +9787801264770 +9787801264879 +9787801264886 +9787801265203 +9787801265388 +9787801265401 +9787801266057 +9787801266118 +9787801266392 +9787801267009 +9787801267030 +9787801267528 +9787801268167 +9787801268297 +9787801268631 +9787801269034 +9787801270498 +9787801270511 +9787801270528 +9787801270634 +9787801270696 +9787801270771 +9787801271211 +9787801271778 +9787801271808 +9787801272331 +9787801272423 +9787801272836 +9787801273222 +9787801273239 +9787801273246 +9787801273338 +9787801273369 +9787801273543 +9787801273741 +9787801273758 +9787801273864 +9787801273895 +9787801273901 +9787801273932 +9787801273987 +9787801273994 +9787801274052 +9787801274113 +9787801274120 +9787801274175 +9787801274182 +9787801274298 +9787801274311 +9787801274328 +9787801274427 +9787801274519 +9787801274526 +9787801274557 +9787801274564 +9787801274588 +9787801274700 +9787801274717 +9787801274731 +9787801274779 +9787801274816 +9787801274823 +9787801274830 +9787801274892 +9787801275080 +9787801275219 +9787801275240 +9787801275264 +9787801275318 +9787801275325 +9787801275356 +9787801275370 +9787801275547 +9787801275646 +9787801275882 +9787801275929 +9787801276087 +9787801276193 +9787801276230 +9787801276285 +9787801276506 +9787801278500 +9787801279231 +9787801280244 +9787801280336 +9787801280497 +9787801280510 +9787801280565 +9787801280657 +9787801280671 +9787801280749 +9787801280787 +9787801280794 +9787801281036 +9787801281203 +9787801281302 +9787801281340 +9787801281395 +9787801281456 +9787801282095 +9787801282149 +9787801283092 +9787801283276 +9787801283580 +9787801284068 +9787801284785 +9787801285140 +9787801285614 +9787801285775 +9787801286772 +9787801286857 +9787801287212 +9787801287571 +9787801288585 +9787801288592 +9787801288950 +9787801289469 +9787801290465 +9787801290731 +9787801290755 +9787801290977 +9787801297556 +9787801297723 +9787801300003 +9787801300041 +9787801300065 +9787801300157 +9787801300164 +9787801300171 +9787801300232 +9787801300256 +9787801300287 +9787801300300 +9787801300430 +9787801300508 +9787801300515 +9787801300522 +9787801300553 +9787801300591 +9787801300607 +9787801300669 +9787801300690 +9787801300751 +9787801300775 +9787801300799 +9787801300805 +9787801300874 +9787801300942 +9787801300959 +9787801300966 +9787801300980 +9787801301284 +9787801301321 +9787801301383 +9787801301444 +9787801301499 +9787801301512 +9787801301536 +9787801301543 +9787801301574 +9787801301598 +9787801301604 +9787801301680 +9787801301703 +9787801301901 +9787801301949 +9787801301956 +9787801301994 +9787801302038 +9787801302199 +9787801302243 +9787801302359 +9787801302601 +9787801302687 +9787801302717 +9787801302724 +9787801302885 +9787801302922 +9787801302946 +9787801302960 +9787801303028 +9787801303295 +9787801303301 +9787801303349 +9787801303523 +9787801303547 +9787801303554 +9787801303585 +9787801303707 +9787801303721 +9787801303776 +9787801303783 +9787801303899 +9787801303929 +9787801303936 +9787801305138 +9787801305268 +9787801305381 +9787801305480 +9787801305503 +9787801305558 +9787801305626 +9787801305633 +9787801305916 +9787801306173 +9787801306494 +9787801306722 +9787801307576 +9787801307613 +9787801307637 +9787801307705 +9787801307729 +9787801307767 +9787801308344 +9787801308436 +9787801308931 +9787801309044 +9787801309143 +9787801309167 +9787801309532 +9787801309570 +9787801309778 +9787801309853 +9787801309884 +9787801309990 +9787801310019 +9787801310200 +9787801310217 +9787801310255 +9787801310309 +9787801310316 +9787801310620 +9787801310637 +9787801311009 +9787801311061 +9787801311092 +9787801311238 +9787801311245 +9787801311832 +9787801312211 +9787801312228 +9787801312501 +9787801312808 +9787801312839 +9787801312914 +9787801313003 +9787801313034 +9787801313041 +9787801313119 +9787801313157 +9787801313188 +9787801313201 +9787801314574 +9787801314598 +9787801314857 +9787801315038 +9787801315335 +9787801316028 +9787801316820 +9787801318244 +9787801319241 +9787801319517 +9787801319555 +9787801319746 +9787801319753 +9787801320421 +9787801322296 +9787801322524 +9787801322531 +9787801322579 +9787801322609 +9787801322753 +9787801322869 +9787801323385 +9787801323606 +9787801323705 +9787801323859 +9787801324467 +9787801324474 +9787801324795 +9787801325389 +9787801325419 +9787801326669 +9787801326805 +9787801326898 +9787801327253 +9787801327888 +9787801327949 +9787801328090 +9787801328670 +9787801328694 +9787801328946 +9787801329448 +9787801329486 +9787801329646 +9787801333032 +9787801334879 +9787801335418 +9787801335715 +9787801336125 +9787801336293 +9787801336354 +9787801336699 +9787801337382 +9787801337658 +9787801337801 +9787801337900 +9787801339218 +9787801339812 +9787801340153 +9787801340382 +9787801340559 +9787801340702 +9787801341297 +9787801341488 +9787801341853 +9787801342508 +9787801342515 +9787801343444 +9787801344496 +9787801345738 +9787801346568 +9787801347121 +9787801348197 +9787801350664 +9787801350695 +9787801351135 +9787801352293 +9787801354006 +9787801354167 +9787801355041 +9787801355386 +9787801356888 +9787801356956 +9787801357038 +9787801357069 +9787801357106 +9787801357168 +9787801357366 +9787801357571 +9787801357946 +9787801360076 +9787801360151 +9787801360175 +9787801360298 +9787801360328 +9787801360748 +9787801360755 +9787801360762 +9787801360892 +9787801360946 +9787801360991 +9787801361127 +9787801361196 +9787801361523 +9787801361653 +9787801361714 +9787801361769 +9787801361790 +9787801361837 +9787801362049 +9787801362162 +9787801362193 +9787801362247 +9787801362360 +9787801362681 +9787801362698 +9787801362704 +9787801362711 +9787801362858 +9787801363022 +9787801363107 +9787801363121 +9787801363183 +9787801363251 +9787801363404 +9787801363770 +9787801363930 +9787801363985 +9787801363992 +9787801364012 +9787801364142 +9787801364272 +9787801364302 +9787801364487 +9787801364548 +9787801364883 +9787801364982 +9787801365033 +9787801365057 +9787801365118 +9787801365385 +9787801365552 +9787801365897 +9787801365958 +9787801366252 +9787801366344 +9787801366405 +9787801366559 +9787801366627 +9787801366702 +9787801366931 +9787801367068 +9787801367075 +9787801367143 +9787801367259 +9787801367341 +9787801367426 +9787801367457 +9787801367716 +9787801367792 +9787801367808 +9787801367877 +9787801368003 +9787801368027 +9787801368423 +9787801368553 +9787801368584 +9787801369024 +9787801369086 +9787801369154 +9787801369253 +9787801369369 +9787801369437 +9787801369758 +9787801370044 +9787801370433 +9787801370464 +9787801370488 +9787801370495 +9787801370693 +9787801370716 +9787801371157 +9787801371164 +9787801371201 +9787801371218 +9787801371225 +9787801371232 +9787801371249 +9787801371379 +9787801371386 +9787801371553 +9787801371645 +9787801371737 +9787801371843 +9787801372086 +9787801372109 +9787801372192 +9787801372222 +9787801372338 +9787801372512 +9787801372932 +9787801373076 +9787801373106 +9787801373120 +9787801373311 +9787801373328 +9787801373373 +9787801373434 +9787801373533 +9787801373588 +9787801373618 +9787801373854 +9787801373878 +9787801373922 +9787801374523 +9787801374554 +9787801374622 +9787801374677 +9787801375117 +9787801375322 +9787801375667 +9787801375681 +9787801376244 +9787801376305 +9787801376633 +9787801376756 +9787801377036 +9787801377104 +9787801377289 +9787801378156 +9787801378316 +9787801378330 +9787801378347 +9787801378934 +9787801379016 +9787801379078 +9787801379108 +9787801379900 +9787801380005 +9787801380241 +9787801380388 +9787801381064 +9787801381453 +9787801381514 +9787801381804 +9787801382009 +9787801382092 +9787801382344 +9787801382580 +9787801382603 +9787801382610 +9787801382993 +9787801383624 +9787801384270 +9787801384355 +9787801384362 +9787801384690 +9787801384720 +9787801387004 +9787801387035 +9787801388322 +9787801389312 +9787801390028 +9787801390103 +9787801390653 +9787801391469 +9787801391513 +9787801391766 +9787801392619 +9787801392879 +9787801392893 +9787801393326 +9787801394088 +9787801394668 +9787801394736 +9787801395252 +9787801397157 +9787801397461 +9787801397898 +9787801398215 +9787801398239 +9787801399670 +9787801400079 +9787801400253 +9787801400277 +9787801400321 +9787801400338 +9787801400628 +9787801401670 +9787801403926 +9787801404589 +9787801404978 +9787801405265 +9787801405692 +9787801406842 +9787801407290 +9787801407412 +9787801407757 +9787801407986 +9787801408037 +9787801408884 +9787801409836 +9787801410061 +9787801410139 +9787801410184 +9787801410191 +9787801410412 +9787801410436 +9787801410528 +9787801410580 +9787801411068 +9787801411075 +9787801411129 +9787801411198 +9787801411327 +9787801411433 +9787801411457 +9787801411495 +9787801411570 +9787801411785 +9787801411945 +9787801412126 +9787801412270 +9787801412423 +9787801412447 +9787801412508 +9787801412515 +9787801412522 +9787801412584 +9787801412638 +9787801412768 +9787801412904 +9787801413581 +9787801413956 +9787801414335 +9787801414519 +9787801414946 +9787801415004 +9787801415035 +9787801415073 +9787801415615 +9787801415936 +9787801416100 +9787801416209 +9787801416285 +9787801416360 +9787801416452 +9787801416476 +9787801416766 +9787801417008 +9787801417459 +9787801420015 +9787801420244 +9787801420343 +9787801420381 +9787801420510 +9787801420527 +9787801420626 +9787801420633 +9787801420695 +9787801420794 +9787801420916 +9787801420961 +9787801421135 +9787801421166 +9787801421173 +9787801421203 +9787801421241 +9787801421418 +9787801422033 +9787801422217 +9787801422224 +9787801422255 +9787801422361 +9787801422804 +9787801422965 +9787801423160 +9787801423283 +9787801423498 +9787801424129 +9787801424426 +9787801424631 +9787801424709 +9787801424860 +9787801425287 +9787801425577 +9787801425669 +9787801425744 +9787801425799 +9787801426086 +9787801426178 +9787801426475 +9787801426772 +9787801427311 +9787801427335 +9787801427465 +9787801427557 +9787801427588 +9787801427601 +9787801428097 +9787801428400 +9787801428837 +9787801428899 +9787801429155 +9787801429360 +9787801430021 +9787801430229 +9787801430359 +9787801430564 +9787801430588 +9787801430656 +9787801431356 +9787801431400 +9787801431707 +9787801431738 +9787801431974 +9787801432025 +9787801432322 +9787801432407 +9787801432414 +9787801432421 +9787801432506 +9787801432605 +9787801432728 +9787801432780 +9787801433978 +9787801440488 +9787801441966 +9787801442826 +9787801443434 +9787801443557 +9787801443762 +9787801443793 +9787801447104 +9787801447623 +9787801448095 +9787801448170 +9787801449108 +9787801449221 +9787801450098 +9787801450104 +9787801450227 +9787801450265 +9787801450272 +9787801450296 +9787801450326 +9787801450333 +9787801450401 +9787801450432 +9787801450555 +9787801450609 +9787801450685 +9787801450715 +9787801450845 +9787801450883 +9787801451002 +9787801451149 +9787801451347 +9787801451453 +9787801451521 +9787801451552 +9787801451781 +9787801452085 +9787801452184 +9787801452528 +9787801452719 +9787801453228 +9787801453341 +9787801453471 +9787801453617 +9787801453976 +9787801454195 +9787801454249 +9787801454782 +9787801454843 +9787801454935 +9787801455307 +9787801455420 +9787801455529 +9787801455536 +9787801455543 +9787801455642 +9787801455703 +9787801455826 +9787801455888 +9787801456045 +9787801456052 +9787801456090 +9787801456106 +9787801456304 +9787801456519 +9787801456564 +9787801456670 +9787801456700 +9787801456762 +9787801456809 +9787801456830 +9787801456878 +9787801456915 +9787801457158 +9787801457547 +9787801457561 +9787801457707 +9787801457899 +9787801457912 +9787801458100 +9787801458414 +9787801458612 +9787801458698 +9787801458827 +9787801458865 +9787801459077 +9787801459176 +9787801459251 +9787801459534 +9787801459855 +9787801459862 +9787801460042 +9787801460059 +9787801460073 +9787801460080 +9787801460257 +9787801460271 +9787801460301 +9787801460349 +9787801460431 +9787801460455 +9787801460479 +9787801460578 +9787801460905 +9787801460912 +9787801460981 +9787801461032 +9787801461049 +9787801461117 +9787801461346 +9787801461414 +9787801461438 +9787801461469 +9787801461483 +9787801461513 +9787801461667 +9787801461803 +9787801461841 +9787801461872 +9787801461933 +9787801462008 +9787801462046 +9787801462244 +9787801462435 +9787801462459 +9787801462480 +9787801462541 +9787801462787 +9787801462794 +9787801462800 +9787801462848 +9787801462893 +9787801462909 +9787801462923 +9787801462961 +9787801463029 +9787801463050 +9787801463159 +9787801463210 +9787801463463 +9787801463531 +9787801463548 +9787801463555 +9787801463579 +9787801463777 +9787801463784 +9787801463791 +9787801464125 +9787801464231 +9787801464484 +9787801464644 +9787801464798 +9787801464897 +9787801465252 +9787801466105 +9787801466204 +9787801466297 +9787801466570 +9787801466655 +9787801466693 +9787801466907 +9787801467010 +9787801467072 +9787801467201 +9787801467324 +9787801467461 +9787801467492 +9787801467621 +9787801468024 +9787801468512 +9787801468758 +9787801469021 +9787801469069 +9787801469090 +9787801469168 +9787801469311 +9787801469403 +9787801469533 +9787801469540 +9787801469588 +9787801469816 +9787801469908 +9787801470065 +9787801470195 +9787801470560 +9787801470782 +9787801470799 +9787801471444 +9787801471482 +9787801471697 +9787801472137 +9787801472359 +9787801472663 +9787801472793 +9787801473288 +9787801473523 +9787801473721 +9787801473776 +9787801473936 +9787801474278 +9787801474773 +9787801475008 +9787801475190 +9787801475220 +9787801475343 +9787801475732 +9787801476265 +9787801476555 +9787801476654 +9787801476708 +9787801477613 +9787801477774 +9787801477873 +9787801478030 +9787801478061 +9787801478214 +9787801478658 +9787801478856 +9787801478863 +9787801479860 +9787801486189 +9787801486219 +9787801486486 +9787801487315 +9787801487742 +9787801487872 +9787801488565 +9787801490025 +9787801490032 +9787801490087 +9787801490100 +9787801490230 +9787801490247 +9787801490254 +9787801490278 +9787801490292 +9787801490476 +9787801490520 +9787801490605 +9787801490612 +9787801490698 +9787801491046 +9787801491091 +9787801491138 +9787801491268 +9787801491633 +9787801491657 +9787801491817 +9787801491831 +9787801491961 +9787801492074 +9787801492227 +9787801492289 +9787801492340 +9787801492784 +9787801492951 +9787801493026 +9787801493118 +9787801493439 +9787801493453 +9787801493507 +9787801493521 +9787801493743 +9787801493873 +9787801493965 +9787801494030 +9787801494054 +9787801494092 +9787801494122 +9787801494153 +9787801494597 +9787801494610 +9787801494665 +9787801494849 +9787801495167 +9787801495211 +9787801495396 +9787801495617 +9787801495624 +9787801495754 +9787801495778 +9787801495785 +9787801496027 +9787801496331 +9787801496447 +9787801497048 +9787801497086 +9787801497338 +9787801497345 +9787801497420 +9787801498250 +9787801498304 +9787801498519 +9787801498533 +9787801498663 +9787801498830 +9787801499134 +9787801499189 +9787801499219 +9787801499615 +9787801499769 +9787801499806 +9787801500076 +9787801500267 +9787801501073 +9787801501097 +9787801501868 +9787801502063 +9787801503060 +9787801503107 +9787801503510 +9787801504951 +9787801504982 +9787801504999 +9787801505002 +9787801505019 +9787801505033 +9787801506344 +9787801506504 +9787801508416 +9787801508966 +9787801510150 +9787801510419 +9787801510938 +9787801511249 +9787801511690 +9787801512499 +9787801512871 +9787801512994 +9787801513007 +9787801513144 +9787801513274 +9787801513762 +9787801513793 +9787801514462 +9787801514790 +9787801515049 +9787801515056 +9787801515063 +9787801515339 +9787801515698 +9787801515780 +9787801515810 +9787801516565 +9787801516725 +9787801516763 +9787801517074 +9787801517180 +9787801517425 +9787801518316 +9787801518330 +9787801518378 +9787801518385 +9787801518422 +9787801518477 +9787801519047 +9787801519665 +9787801520401 +9787801520418 +9787801520548 +9787801520555 +9787801520968 +9787801521118 +9787801521170 +9787801521309 +9787801521507 +9787801521644 +9787801521651 +9787801521675 +9787801521774 +9787801522344 +9787801522368 +9787801522399 +9787801522412 +9787801523815 +9787801523839 +9787801523945 +9787801524379 +9787801524645 +9787801526557 +9787801526687 +9787801526847 +9787801527042 +9787801527233 +9787801527493 +9787801527516 +9787801527677 +9787801527899 +9787801528056 +9787801529589 +9787801530837 +9787801531025 +9787801531032 +9787801531117 +9787801531247 +9787801531681 +9787801531698 +9787801532084 +9787801532381 +9787801532657 +9787801533159 +9787801533319 +9787801533333 +9787801533456 +9787801533470 +9787801533586 +9787801533708 +9787801533852 +9787801533869 +9787801534484 +9787801535030 +9787801535375 +9787801535511 +9787801535528 +9787801536099 +9787801536235 +9787801536273 +9787801536648 +9787801536792 +9787801537126 +9787801537348 +9787801537362 +9787801537447 +9787801537898 +9787801538086 +9787801538208 +9787801538239 +9787801538277 +9787801538956 +9787801539014 +9787801539038 +9787801539335 +9787801539359 +9787801539496 +9787801539663 +9787801540133 +9787801540218 +9787801540614 +9787801540621 +9787801540645 +9787801541765 +9787801543134 +9787801544247 +9787801544254 +9787801547200 +9787801549037 +9787801549334 +9787801549341 +9787801550279 +9787801550576 +9787801550606 +9787801550880 +9787801551313 +9787801551962 +9787801552327 +9787801552419 +9787801553195 +9787801554895 +9787801555243 +9787801555328 +9787801556158 +9787801556288 +9787801556707 +9787801556813 +9787801557452 +9787801559067 +9787801559548 +9787801560360 +9787801560391 +9787801560520 +9787801560766 +9787801560773 +9787801560803 +9787801560858 +9787801560872 +9787801560889 +9787801560902 +9787801560933 +9787801563309 +9787801563712 +9787801563842 +9787801565426 +9787801569066 +9787801569790 +9787801570017 +9787801570031 +9787801570437 +9787801570741 +9787801571267 +9787801571403 +9787801571694 +9787801571786 +9787801571892 +9787801571915 +9787801572066 +9787801572189 +9787801572424 +9787801572752 +9787801573070 +9787801573346 +9787801573711 +9787801573865 +9787801573902 +9787801574039 +9787801574213 +9787801574237 +9787801574244 +9787801574367 +9787801574374 +9787801574510 +9787801574961 +9787801575050 +9787801575272 +9787801575470 +9787801575685 +9787801576354 +9787801576590 +9787801580078 +9787801580580 +9787801580818 +9787801583130 +9787801584199 +9787801584298 +9787801584670 +9787801585110 +9787801585769 +9787801588555 +9787801588975 +9787801591142 +9787801591166 +9787801591173 +9787801591180 +9787801591203 +9787801591210 +9787801592453 +9787801592637 +9787801596703 +9787801596840 +9787801597755 +9787801600707 +9787801600721 +9787801601261 +9787801601278 +9787801601308 +9787801601339 +9787801601360 +9787801601377 +9787801601384 +9787801601391 +9787801601414 +9787801601438 +9787801601469 +9787801601490 +9787801601582 +9787801601889 +9787801602060 +9787801602381 +9787801603739 +9787801604361 +9787801604378 +9787801604385 +9787801604422 +9787801604538 +9787801605627 +9787801608055 +9787801611284 +9787801611536 +9787801611901 +9787801611963 +9787801612267 +9787801612953 +9787801613912 +9787801614650 +9787801615312 +9787801615602 +9787801615923 +9787801616623 +9787801617781 +9787801619082 +9787801619341 +9787801619860 +9787801620378 +9787801620668 +9787801620736 +9787801620767 +9787801622723 +9787801622761 +9787801622815 +9787801623140 +9787801624536 +9787801627308 +9787801628701 +9787801632623 +9787801633675 +9787801633682 +9787801633965 +9787801635181 +9787801636379 +9787801639639 +9787801640802 +9787801641182 +9787801641434 +9787801641694 +9787801642332 +9787801643360 +9787801645548 +9787801647337 +9787801650634 +9787801652379 +9787801653321 +9787801653505 +9787801655257 +9787801656162 +9787801660114 +9787801660268 +9787801660275 +9787801660374 +9787801660411 +9787801660428 +9787801660824 +9787801661180 +9787801661289 +9787801661685 +9787801662262 +9787801662668 +9787801662729 +9787801663047 +9787801663337 +9787801663405 +9787801663566 +9787801664051 +9787801664273 +9787801664297 +9787801664396 +9787801664570 +9787801664662 +9787801664716 +9787801664952 +9787801665652 +9787801666321 +9787801666857 +9787801667038 +9787801667267 +9787801667496 +9787801667502 +9787801668943 +9787801669407 +9787801669513 +9787801669605 +9787801669766 +9787801670717 +9787801672544 +9787801672728 +9787801673862 +9787801674906 +9787801676276 +9787801676351 +9787801676887 +9787801677334 +9787801679208 +9787801679468 +9787801680259 +9787801680303 +9787801680365 +9787801682208 +9787801683885 +9787801684646 +9787801686008 +9787801686527 +9787801686794 +9787801689986 +9787801690630 +9787801690920 +9787801692122 +9787801692146 +9787801692153 +9787801693105 +9787801693129 +9787801693150 +9787801693570 +9787801693952 +9787801696113 +9787801697837 +9787801698094 +9787801698117 +9787801698124 +9787801699275 +9787801700179 +9787801700292 +9787801700858 +9787801701152 +9787801701169 +9787801701206 +9787801701237 +9787801701589 +9787801701619 +9787801701671 +9787801701749 +9787801702098 +9787801702203 +9787801702364 +9787801702395 +9787801702814 +9787801703293 +9787801703613 +9787801703682 +9787801704269 +9787801704702 +9787801704849 +9787801704924 +9787801705006 +9787801705204 +9787801705433 +9787801705815 +9787801707161 +9787801709325 +9787801710086 +9787801710109 +9787801710185 +9787801710260 +9787801710284 +9787801710314 +9787801710369 +9787801710383 +9787801710529 +9787801710659 +9787801710673 +9787801710819 +9787801710963 +9787801711014 +9787801711168 +9787801711243 +9787801711281 +9787801711304 +9787801711663 +9787801711762 +9787801712004 +9787801712066 +9787801712158 +9787801712196 +9787801712226 +9787801712257 +9787801712387 +9787801712424 +9787801712516 +9787801712714 +9787801712745 +9787801712806 +9787801712813 +9787801712905 +9787801713322 +9787801713452 +9787801713674 +9787801713681 +9787801713728 +9787801713896 +9787801713926 +9787801714084 +9787801714145 +9787801714183 +9787801714282 +9787801714381 +9787801714527 +9787801714688 +9787801714879 +9787801714893 +9787801714930 +9787801714978 +9787801714992 +9787801715005 +9787801715012 +9787801715029 +9787801715258 +9787801715388 +9787801715456 +9787801715517 +9787801715531 +9787801715562 +9787801715982 +9787801716385 +9787801716804 +9787801716965 +9787801717184 +9787801717436 +9787801717443 +9787801717467 +9787801717658 +9787801717733 +9787801717962 +9787801717979 +9787801718198 +9787801718242 +9787801718310 +9787801718372 +9787801718518 +9787801718778 +9787801719034 +9787801719232 +9787801719270 +9787801719478 +9787801719508 +9787801719676 +9787801719867 +9787801720580 +9787801720795 +9787801721112 +9787801721150 +9787801721754 +9787801721952 +9787801722164 +9787801723741 +9787801723765 +9787801725011 +9787801725608 +9787801725851 +9787801726261 +9787801726278 +9787801726353 +9787801729156 +9787801729606 +9787801729965 +9787801730244 +9787801730435 +9787801730732 +9787801731432 +9787801732132 +9787801732330 +9787801732415 +9787801732422 +9787801732446 +9787801732453 +9787801732569 +9787801732590 +9787801733054 +9787801733108 +9787801733283 +9787801734662 +9787801734808 +9787801735157 +9787801735409 +9787801735584 +9787801735782 +9787801736192 +9787801736253 +9787801736956 +9787801736994 +9787801737076 +9787801737113 +9787801738479 +9787801739421 +9787801739827 +9787801740106 +9787801740359 +9787801740441 +9787801740656 +9787801741028 +9787801741066 +9787801741080 +9787801741172 +9787801741264 +9787801741370 +9787801741646 +9787801741745 +9787801742025 +9787801742308 +9787801742346 +9787801742391 +9787801742537 +9787801743091 +9787801743138 +9787801743633 +9787801743640 +9787801744432 +9787801744586 +9787801744616 +9787801744999 +9787801746061 +9787801746078 +9787801746177 +9787801746542 +9787801746894 +9787801748171 +9787801748430 +9787801748614 +9787801749802 +9787801750273 +9787801750280 +9787801750327 +9787801750334 +9787801750341 +9787801750358 +9787801750365 +9787801750372 +9787801750389 +9787801750563 +9787801750631 +9787801750655 +9787801750860 +9787801751270 +9787801751287 +9787801751324 +9787801751539 +9787801751751 +9787801751812 +9787801751836 +9787801751867 +9787801752680 +9787801752857 +9787801753908 +9787801754004 +9787801754288 +9787801754462 +9787801756077 +9787801756718 +9787801757272 +9787801757340 +9787801757760 +9787801758521 +9787801758682 +9787801758897 +9787801759092 +9787801759306 +9787801760227 +9787801760258 +9787801760708 +9787801761040 +9787801761682 +9787801761873 +9787801762047 +9787801763327 +9787801763440 +9787801763792 +9787801764164 +9787801765123 +9787801765147 +9787801765161 +9787801766281 +9787801766694 +9787801766885 +9787801767028 +9787801768193 +9787801768391 +9787801770196 +9787801770622 +9787801771346 +9787801771711 +9787801772015 +9787801772169 +9787801772961 +9787801773210 +9787801773302 +9787801773456 +9787801773722 +9787801773951 +9787801775641 +9787801777010 +9787801777683 +9787801777973 +9787801778437 +9787801778932 +9787801780089 +9787801780263 +9787801780270 +9787801780348 +9787801780409 +9787801781499 +9787801782175 +9787801782199 +9787801783271 +9787801783561 +9787801783721 +9787801783769 +9787801784360 +9787801784506 +9787801784513 +9787801784544 +9787801784681 +9787801784704 +9787801785794 +9787801786692 +9787801787378 +9787801788016 +9787801788269 +9787801788726 +9787801788900 +9787801788993 +9787801789310 +9787801789365 +9787801789389 +9787801790118 +9787801790163 +9787801790255 +9787801790439 +9787801790514 +9787801790934 +9787801790958 +9787801791382 +9787801791399 +9787801791535 +9787801791818 +9787801792808 +9787801793058 +9787801794598 +9787801794604 +9787801796783 +9787801797582 +9787801797674 +9787801799166 +9787801800565 +9787801800589 +9787801800640 +9787801801265 +9787801801319 +9787801801500 +9787801801531 +9787801801890 +9787801802965 +9787801803146 +9787801803542 +9787801803801 +9787801804457 +9787801804655 +9787801804662 +9787801805119 +9787801806451 +9787801806734 +9787801806901 +9787801806949 +9787801807649 +9787801808431 +9787801808509 +9787801811295 +9787801811837 +9787801811868 +9787801813206 +9787801814241 +9787801815521 +9787801816566 +9787801817037 +9787801817976 +9787801821645 +9787801823731 +9787801823786 +9787801824196 +9787801825339 +9787801828347 +9787801830593 +9787801831125 +9787801833020 +9787801836809 +9787801837844 +9787801838032 +9787801839114 +9787801840196 +9787801840820 +9787801840974 +9787801841162 +9787801842954 +9787801843272 +9787801843289 +9787801843302 +9787801843357 +9787801843661 +9787801844132 +9787801844330 +9787801844408 +9787801844613 +9787801845580 +9787801845610 +9787801847423 +9787801847669 +9787801848161 +9787801848581 +9787801848598 +9787801848833 +9787801849373 +9787801850119 +9787801850133 +9787801850409 +9787801851468 +9787801851819 +9787801852298 +9787801853042 +9787801853837 +9787801853967 +9787801855138 +9787801855299 +9787801855725 +9787801855930 +9787801856296 +9787801856937 +9787801857712 +9787801857798 +9787801858405 +9787801858481 +9787801858566 +9787801859389 +9787801860866 +9787801861900 +9787801862556 +9787801863775 +9787801864444 +9787801865076 +9787801865366 +9787801865618 +9787801867049 +9787801867711 +9787801868480 +9787801869432 +9787801869869 +9787801870018 +9787801870193 +9787801870247 +9787801870445 +9787801870681 +9787801870834 +9787801871022 +9787801871121 +9787801871183 +9787801871220 +9787801871244 +9787801871480 +9787801871534 +9787801871541 +9787801871589 +9787801871602 +9787801871657 +9787801871664 +9787801871763 +9787801871817 +9787801871886 +9787801871923 +9787801871947 +9787801872111 +9787801872135 +9787801872234 +9787801872265 +9787801872333 +9787801872340 +9787801872364 +9787801872401 +9787801872432 +9787801872494 +9787801872517 +9787801872661 +9787801872906 +9787801873347 +9787801873897 +9787801873996 +9787801874146 +9787801874351 +9787801874405 +9787801874474 +9787801874641 +9787801874818 +9787801874849 +9787801875136 +9787801875198 +9787801875570 +9787801875785 +9787801875860 +9787801876294 +9787801876539 +9787801876621 +9787801876669 +9787801876829 +9787801877192 +9787801877222 +9787801877321 +9787801877659 +9787801877819 +9787801877857 +9787801878168 +9787801878212 +9787801878229 +9787801878267 +9787801878335 +9787801878427 +9787801878991 +9787801879394 +9787801879561 +9787801879639 +9787801879653 +9787801879684 +9787801879738 +9787801879899 +9787801879905 +9787801881779 +9787801882264 +9787801882271 +9787801882455 +9787801884459 +9787801887092 +9787801887382 +9787801887504 +9787801888457 +9787801889867 +9787801890092 +9787801890252 +9787801892799 +9787801893383 +9787801895516 +9787801895721 +9787801895967 +9787801897251 +9787801900760 +9787801901354 +9787801901392 +9787801903112 +9787801903709 +9787801904652 +9787801904959 +9787801907639 +9787801908124 +9787801908131 +9787801911476 +9787801913135 +9787801917621 +9787801917676 +9787801918697 +9787801920164 +9787801920607 +9787801921109 +9787801921116 +9787801921369 +9787801922014 +9787801922298 +9787801922311 +9787801922779 +9787801923738 +9787801923974 +9787801924100 +9787801924759 +9787801925022 +9787801925268 +9787801925893 +9787801926951 +9787801927293 +9787801928351 +9787801928375 +9787801929754 +9787801929808 +9787801930217 +9787801930873 +9787801931245 +9787801933072 +9787801933195 +9787801933386 +9787801933744 +9787801934062 +9787801937988 +9787801941992 +9787801942982 +9787801943170 +9787801945655 +9787801945747 +9787801946270 +9787801948618 +9787801949561 +9787801950116 +9787801950369 +9787801950567 +9787801950574 +9787801950697 +9787801951168 +9787801951267 +9787801951281 +9787801951397 +9787801951441 +9787801951595 +9787801951878 +9787801952004 +9787801952257 +9787801952400 +9787801952431 +9787801952516 +9787801953049 +9787801953131 +9787801953308 +9787801953384 +9787801953698 +9787801953704 +9787801953803 +9787801953865 +9787801953889 +9787801954008 +9787801954077 +9787801954206 +9787801954213 +9787801954244 +9787801954312 +9787801955111 +9787801955128 +9787801955210 +9787801955852 +9787801956156 +9787801956682 +9787801956736 +9787801956774 +9787801956842 +9787801957498 +9787801957559 +9787801957566 +9787801958037 +9787801958044 +9787801958075 +9787801958099 +9787801958761 +9787801958792 +9787801959010 +9787801959355 +9787801959379 +9787801959423 +9787801959430 +9787801959461 +9787801960177 +9787801960221 +9787801960870 +9787801964908 +9787801965660 +9787801965677 +9787801965905 +9787801969453 +9787801970596 +9787801971166 +9787801971425 +9787801971685 +9787801972705 +9787801975577 +9787801976970 +9787801977991 +9787801979520 +9787801979544 +9787801984302 +9787801984395 +9787801984487 +9787801988331 +9787801990334 +9787801990389 +9787801990549 +9787801990693 +9787801990983 +9787801991126 +9787801991157 +9787801991393 +9787801991584 +9787801991706 +9787801991935 +9787801991959 +9787801992390 +9787801992536 +9787801992789 +9787801993793 +9787801993991 +9787801994158 +9787801994257 +9787801994271 +9787801994493 +9787801994509 +9787801994721 +9787801994936 +9787801994950 +9787801995018 +9787801995148 +9787801995353 +9787801995384 +9787801995513 +9787801995544 +9787801995582 +9787801995650 +9787801995827 +9787801995834 +9787801995858 +9787801996183 +9787801996251 +9787801996275 +9787801996312 +9787801996756 +9787801996916 +9787801997029 +9787801997128 +9787801998255 +9787801998590 +9787801998620 +9787801998774 +9787801998835 +9787801998910 +9787801998972 +9787801998989 +9787801999047 +9787801999061 +9787801999153 +9787801999344 +9787801999412 +9787801999542 +9787801999627 +9787801999634 +9787802000124 +9787802000513 +9787802001169 +9787802001206 +9787802001220 +9787802001299 +9787802001619 +9787802001770 +9787802002159 +9787802004146 +9787802005785 +9787802006904 +9787802007963 +9787802008694 +9787802010239 +9787802011830 +9787802012264 +9787802012356 +9787802012387 +9787802013469 +9787802013483 +9787802013957 +9787802014923 +9787802016958 +9787802018556 +9787802019928 +9787802019942 +9787802020344 +9787802020771 +9787802020832 +9787802021006 +9787802021174 +9787802022027 +9787802023093 +9787802023444 +9787802024083 +9787802025202 +9787802026063 +9787802026131 +9787802029552 +9787802030251 +9787802030480 +9787802030671 +9787802030985 +9787802031104 +9787802031326 +9787802031470 +9787802031852 +9787802032071 +9787802032170 +9787802032187 +9787802034204 +9787802034259 +9787802034693 +9787802034716 +9787802034808 +9787802035331 +9787802036345 +9787802036734 +9787802037212 +9787802037236 +9787802037717 +9787802039513 +9787802040014 +9787802040106 +9787802040113 +9787802040632 +9787802040786 +9787802040984 +9787802041448 +9787802041752 +9787802042704 +9787802042711 +9787802043374 +9787802043855 +9787802044340 +9787802044364 +9787802044791 +9787802044814 +9787802045859 +9787802046016 +9787802046511 +9787802047020 +9787802047075 +9787802047082 +9787802047099 +9787802047211 +9787802047242 +9787802047426 +9787802047532 +9787802047624 +9787802047730 +9787802048157 +9787802048430 +9787802048478 +9787802048560 +9787802048768 +9787802048898 +9787802048935 +9787802049215 +9787802049611 +9787802049758 +9787802051768 +9787802058699 +9787802059375 +9787802059511 +9787802060029 +9787802060302 +9787802061453 +9787802061460 +9787802061668 +9787802062467 +9787802062801 +9787802064362 +9787802064454 +9787802064652 +9787802064812 +9787802065680 +9787802065819 +9787802065826 +9787802066038 +9787802068070 +9787802068636 +9787802068940 +9787802069084 +9787802070875 +9787802072824 +9787802074941 +9787802076440 +9787802076532 +9787802077355 +9787802077362 +9787802078628 +9787802080041 +9787802080065 +9787802080164 +9787802080270 +9787802080331 +9787802080447 +9787802080621 +9787802080683 +9787802081178 +9787802081444 +9787802081543 +9787802081574 +9787802081826 +9787802082267 +9787802082670 +9787802082830 +9787802083370 +9787802083516 +9787802083523 +9787802084124 +9787802084148 +9787802084582 +9787802086128 +9787802086319 +9787802086470 +9787802086838 +9787802087217 +9787802087224 +9787802087545 +9787802087828 +9787802088269 +9787802088443 +9787802090057 +9787802090156 +9787802090828 +9787802095601 +9787802097209 +9787802098435 +9787802103139 +9787802103450 +9787802103634 +9787802103870 +9787802104556 +9787802105119 +9787802106840 +9787802107229 +9787802107762 +9787802108752 +9787802110410 +9787802110847 +9787802111202 +9787802111578 +9787802111592 +9787802112018 +9787802112476 +9787802114043 +9787802115507 +9787802115927 +9787802115941 +9787802116481 +9787802116511 +9787802116528 +9787802117099 +9787802117143 +9787802117792 +9787802118409 +9787802118461 +9787802118492 +9787802119475 +9787802120389 +9787802120914 +9787802121461 +9787802121577 +9787802125322 +9787802128125 +9787802128330 +9787802128361 +9787802129221 +9787802129269 +9787802130234 +9787802130449 +9787802130630 +9787802130753 +9787802130869 +9787802131002 +9787802131828 +9787802131903 +9787802132672 +9787802133631 +9787802135062 +9787802135321 +9787802136144 +9787802137530 +9787802138568 +9787802140073 +9787802140080 +9787802140158 +9787802140226 +9787802140332 +9787802141087 +9787802141186 +9787802141230 +9787802141254 +9787802141537 +9787802141629 +9787802142282 +9787802142732 +9787802143456 +9787802143562 +9787802143623 +9787802144101 +9787802144293 +9787802144385 +9787802144422 +9787802145085 +9787802145207 +9787802145351 +9787802145405 +9787802146556 +9787802146990 +9787802147539 +9787802147942 +9787802147980 +9787802148208 +9787802148307 +9787802149229 +9787802150133 +9787802151109 +9787802154384 +9787802154469 +9787802154933 +9787802155015 +9787802155480 +9787802155619 +9787802157392 +9787802157552 +9787802157583 +9787802157750 +9787802159112 +9787802159143 +9787802159389 +9787802160491 +9787802160583 +9787802160774 +9787802161337 +9787802162457 +9787802162969 +9787802163423 +9787802163706 +9787802164802 +9787802167292 +9787802168671 +9787802169173 +9787802170698 +9787802171336 +9787802172548 +9787802172661 +9787802173286 +9787802174382 +9787802174610 +9787802175952 +9787802176492 +9787802177819 +9787802179660 +9787802181175 +9787802182547 +9787802182721 +9787802182905 +9787802183407 +9787802183544 +9787802183605 +9787802185104 +9787802185111 +9787802185753 +9787802185883 +9787802186736 +9787802187054 +9787802187641 +9787802188112 +9787802188983 +9787802188990 +9787802189003 +9787802189072 +9787802189799 +9787802191952 +9787802192935 +9787802193567 +9787802196223 +9787802196438 +9787802196452 +9787802198104 +9787802198890 +9787802198937 +9787802200081 +9787802200258 +9787802201712 +9787802201804 +9787802201965 +9787802202092 +9787802202108 +9787802202467 +9787802202580 +9787802202702 +9787802202894 +9787802203358 +9787802204232 +9787802204997 +9787802205017 +9787802205208 +9787802205741 +9787802205925 +9787802206410 +9787802206540 +9787802206663 +9787802206724 +9787802206823 +9787802207424 +9787802207530 +9787802208568 +9787802208957 +9787802214064 +9787802219151 +9787802220843 +9787802221550 +9787802221772 +9787802222007 +9787802222519 +9787802223073 +9787802223219 +9787802223448 +9787802223905 +9787802223912 +9787802224407 +9787802224537 +9787802224841 +9787802225329 +9787802225558 +9787802227828 +9787802227941 +9787802227989 +9787802228207 +9787802230040 +9787802230309 +9787802230422 +9787802231580 +9787802231672 +9787802232167 +9787802232884 +9787802233140 +9787802233249 +9787802233362 +9787802233706 +9787802233911 +9787802234406 +9787802236028 +9787802236189 +9787802237513 +9787802250673 +9787802252035 +9787802252950 +9787802253469 +9787802254497 +9787802254756 +9787802255401 +9787802255913 +9787802256231 +9787802259102 +9787802259591 +9787802262607 +9787802265318 +9787802274518 +9787802274525 +9787802278967 +9787802279933 +9787802280182 +9787802280274 +9787802280328 +9787802280519 +9787802280632 +9787802280700 +9787802280717 +9787802280892 +9787802281011 +9787802281110 +9787802281165 +9787802281196 +9787802281219 +9787802281233 +9787802281240 +9787802281257 +9787802281264 +9787802281486 +9787802281523 +9787802281554 +9787802281578 +9787802281677 +9787802281806 +9787802281813 +9787802281844 +9787802281912 +9787802281929 +9787802281974 +9787802282155 +9787802282179 +9787802282193 +9787802282209 +9787802282278 +9787802282469 +9787802282544 +9787802282605 +9787802282612 +9787802282629 +9787802282636 +9787802282919 +9787802282957 +9787802283114 +9787802283220 +9787802283244 +9787802283374 +9787802283510 +9787802283534 +9787802283565 +9787802283688 +9787802283732 +9787802283848 +9787802283879 +9787802283909 +9787802283961 +9787802284005 +9787802284043 +9787802284180 +9787802284203 +9787802284210 +9787802284241 +9787802284265 +9787802284319 +9787802284586 +9787802284593 +9787802284609 +9787802284715 +9787802284760 +9787802284821 +9787802285002 +9787802285057 +9787802285071 +9787802285132 +9787802285149 +9787802285163 +9787802285293 +9787802285323 +9787802285439 +9787802285606 +9787802285620 +9787802285767 +9787802285774 +9787802285804 +9787802285873 +9787802285880 +9787802285903 +9787802285941 +9787802285958 +9787802286009 +9787802286016 +9787802286047 +9787802286214 +9787802286252 +9787802286597 +9787802286641 +9787802286702 +9787802286740 +9787802286801 +9787802286832 +9787802287242 +9787802287372 +9787802287518 +9787802287600 +9787802287617 +9787802287679 +9787802287914 +9787802288027 +9787802288034 +9787802288058 +9787802288164 +9787802288232 +9787802288256 +9787802288379 +9787802288539 +9787802288546 +9787802288935 +9787802289253 +9787802289611 +9787802289727 +9787802294431 +9787802296435 +9787802297708 +9787802301375 +9787802301962 +9787802303065 +9787802304680 +9787802306370 +9787802308497 +9787802308848 +9787802310957 +9787802320475 +9787802321137 +9787802321441 +9787802321564 +9787802322165 +9787802323162 +9787802324671 +9787802324923 +9787802325821 +9787802326019 +9787802326460 +9787802326477 +9787802329287 +9787802330146 +9787802330962 +9787802335820 +9787802338517 +9787802339354 +9787802339569 +9787802339613 +9787802344532 +9787802344761 +9787802346574 +9787802347847 +9787802348202 +9787802348875 +9787802349155 +9787802349377 +9787802351646 +9787802353923 +9787802357501 +9787802358270 +9787802358317 +9787802358690 +9787802360785 +9787802360969 +9787802361324 +9787802362468 +9787802362758 +9787802363540 +9787802363625 +9787802364400 +9787802364585 +9787802366497 +9787802367890 +9787802368835 +9787802370562 +9787802370999 +9787802371255 +9787802371675 +9787802372139 +9787802372450 +9787802372696 +9787802372702 +9787802373143 +9787802373594 +9787802373655 +9787802373662 +9787802373976 +9787802374119 +9787802374126 +9787802374652 +9787802374676 +9787802375062 +9787802375215 +9787802375895 +9787802375925 +9787802376182 +9787802376212 +9787802376434 +9787802376458 +9787802377448 +9787802377554 +9787802377653 +9787802377691 +9787802378025 +9787802378285 +9787802378537 +9787802379053 +9787802380110 +9787802380271 +9787802380813 +9787802381254 +9787802381636 +9787802382497 +9787802382930 +9787802383029 +9787802383050 +9787802383067 +9787802383111 +9787802383951 +9787802385009 +9787802385405 +9787802385429 +9787802387430 +9787802387805 +9787802388437 +9787802388987 +9787802389137 +9787802389335 +9787802389823 +9787802391949 +9787802400023 +9787802400450 +9787802400795 +9787802401334 +9787802401822 +9787802401853 +9787802401877 +9787802401969 +9787802402102 +9787802402157 +9787802402546 +9787802402966 +9787802403246 +9787802403260 +9787802403437 +9787802403703 +9787802404403 +9787802404717 +9787802404960 +9787802404991 +9787802405097 +9787802405134 +9787802405455 +9787802406391 +9787802407107 +9787802407527 +9787802407534 +9787802407978 +9787802408173 +9787802408449 +9787802408661 +9787802408838 +9787802408883 +9787802409491 +9787802409507 +9787802409644 +9787802409712 +9787802410831 +9787802410886 +9787802410978 +9787802411425 +9787802411456 +9787802411562 +9787802411784 +9787802411852 +9787802413023 +9787802415362 +9787802415379 +9787802415386 +9787802417113 +9787802417137 +9787802417205 +9787802417601 +9787802417922 +9787802418394 +9787802419421 +9787802419445 +9787802419452 +9787802419469 +9787802419476 +9787802419483 +9787802419490 +9787802419803 +9787802422438 +9787802423282 +9787802424654 +9787802425071 +9787802425644 +9787802426726 +9787802427013 +9787802427167 +9787802427730 +9787802430068 +9787802431782 +9787802431799 +9787802432352 +9787802432529 +9787802432765 +9787802432994 +9787802434813 +9787802435674 +9787802437210 +9787802438958 +9787802438965 +9787802439139 +9787802439214 +9787802439276 +9787802440449 +9787802440845 +9787802441545 +9787802443495 +9787802444362 +9787802444546 +9787802445383 +9787802446144 +9787802446281 +9787802447271 +9787802447448 +9787802448179 +9787802448186 +9787802448247 +9787802448278 +9787802448698 +9787802449091 +9787802449886 +9787802452657 +9787802454224 +9787802454699 +9787802454965 +9787802457157 +9787802460881 +9787802461529 +9787802461970 +9787802462465 +9787802463059 +9787802464339 +9787802464636 +9787802464742 +9787802464759 +9787802467088 +9787802467125 +9787802467170 +9787802467682 +9787802467774 +9787802467781 +9787802468047 +9787802468054 +9787802468283 +9787802468429 +9787802468443 +9787802469082 +9787802477773 +9787802478114 +9787802479050 +9787802480674 +9787802483484 +9787802486461 +9787802486737 +9787802487376 +9787802487628 +9787802488366 +9787802488649 +9787802488755 +9787802490017 +9787802492028 +9787802495913 +9787802498488 +9787802498525 +9787802499232 +9787802499560 +9787802499607 +9787802499614 +9787802500099 +9787802500105 +9787802500181 +9787802500853 +9787802501393 +9787802501744 +9787802501775 +9787802503212 +9787802503410 +9787802505063 +9787802505117 +9787802505230 +9787802505773 +9787802507340 +9787802508262 +9787802509450 +9787802511019 +9787802512917 +9787802513006 +9787802513419 +9787802513488 +9787802514294 +9787802514836 +9787802515796 +9787802515901 +9787802517455 +9787802518131 +9787802520059 +9787802520196 +9787802520882 +9787802521438 +9787802521964 +9787802522374 +9787802522787 +9787802523029 +9787802523388 +9787802523494 +9787802523562 +9787802525023 +9787802525344 +9787802525474 +9787802530218 +9787802530232 +9787802530249 +9787802530294 +9787802530324 +9787802531581 +9787802531598 +9787802531802 +9787802532120 +9787802532489 +9787802532526 +9787802534292 +9787802534551 +9787802535336 +9787802535480 +9787802535879 +9787802536258 +9787802536302 +9787802536364 +9787802536586 +9787802536609 +9787802536784 +9787802536906 +9787802536982 +9787802537231 +9787802537453 +9787802537675 +9787802537934 +9787802538238 +9787802538245 +9787802539211 +9787802539648 +9787802540095 +9787802540316 +9787802540521 +9787802540781 +9787802540798 +9787802541207 +9787802541290 +9787802541405 +9787802541443 +9787802541481 +9787802542402 +9787802542433 +9787802542617 +9787802543041 +9787802543089 +9787802543287 +9787802543331 +9787802543461 +9787802543577 +9787802543614 +9787802543720 +9787802543836 +9787802544000 +9787802544314 +9787802545137 +9787802545380 +9787802545465 +9787802545878 +9787802546318 +9787802546653 +9787802546684 +9787802546806 +9787802547513 +9787802548107 +9787802548770 +9787802548954 +9787802549098 +9787802549104 +9787802549159 +9787802549609 +9787802549685 +9787802549753 +9787802549807 +9787802549876 +9787802550834 +9787802551398 +9787802554412 +9787802554467 +9787802554931 +9787802555334 +9787802555969 +9787802556249 +9787802556751 +9787802557727 +9787802558441 +9787802559998 +9787802560697 +9787802560703 +9787802560925 +9787802561182 +9787802561229 +9787802563810 +9787802564022 +9787802564305 +9787802564886 +9787802565517 +9787802566231 +9787802568464 +9787802570184 +9787802571518 +9787802571525 +9787802572287 +9787802573529 +9787802574212 +9787802580640 +9787802581333 +9787802581807 +9787802582248 +9787802732728 +9787803055260 +9787803250214 +9787803251648 +9787803855389 +9787803956970 +9787804540154 +9787805000237 +9787805000435 +9787805010236 +9787805011356 +9787805011387 +9787805011394 +9787805011776 +9787805012377 +9787805012469 +9787805012582 +9787805012698 +9787805012780 +9787805013411 +9787805013725 +9787805013879 +9787805014067 +9787805014302 +9787805014432 +9787805017150 +9787805018591 +9787805020372 +9787805020402 +9787805020600 +9787805021416 +9787805022161 +9787805022574 +9787805023205 +9787805023236 +9787805026459 +9787805030050 +9787805030074 +9787805030173 +9787805030296 +9787805030494 +9787805030609 +9787805030777 +9787805030821 +9787805031057 +9787805031453 +9787805031637 +9787805031644 +9787805031842 +9787805031897 +9787805032009 +9787805032139 +9787805032245 +9787805032634 +9787805032641 +9787805032719 +9787805032771 +9787805033082 +9787805033099 +9787805033365 +9787805033761 +9787805033778 +9787805033839 +9787805034225 +9787805034386 +9787805035000 +9787805035383 +9787805035536 +9787805035550 +9787805035604 +9787805035635 +9787805035666 +9787805035703 +9787805035895 +9787805036595 +9787805036717 +9787805037158 +9787805037301 +9787805037516 +9787805037851 +9787805038346 +9787805038858 +9787805038926 +9787805039039 +9787805039114 +9787805039169 +9787805039374 +9787805039671 +9787805040219 +9787805040530 +9787805040615 +9787805040677 +9787805040783 +9787805040851 +9787805041223 +9787805041261 +9787805041285 +9787805041469 +9787805042602 +9787805043111 +9787805043241 +9787805043357 +9787805043531 +9787805043593 +9787805043609 +9787805043630 +9787805043647 +9787805043722 +9787805043739 +9787805043777 +9787805043951 +9787805043968 +9787805043975 +9787805044187 +9787805044194 +9787805044347 +9787805044354 +9787805044415 +9787805044491 +9787805044644 +9787805044804 +9787805045047 +9787805045146 +9787805045238 +9787805045337 +9787805045641 +9787805045832 +9787805045849 +9787805045979 +9787805046068 +9787805046112 +9787805046136 +9787805046143 +9787805046150 +9787805046167 +9787805046181 +9787805046204 +9787805046396 +9787805046402 +9787805046419 +9787805046518 +9787805046563 +9787805047010 +9787805047263 +9787805047751 +9787805048161 +9787805048314 +9787805048413 +9787805048598 +9787805048765 +9787805049618 +9787805049670 +9787805050010 +9787805050041 +9787805050072 +9787805050102 +9787805050225 +9787805050256 +9787805050263 +9787805050461 +9787805050577 +9787805050614 +9787805050645 +9787805050713 +9787805050881 +9787805050959 +9787805051185 +9787805051208 +9787805051215 +9787805051260 +9787805051277 +9787805051413 +9787805052366 +9787805052427 +9787805052465 +9787805052670 +9787805052786 +9787805052823 +9787805052861 +9787805052885 +9787805052984 +9787805052991 +9787805053271 +9787805053288 +9787805053370 +9787805053417 +9787805053493 +9787805053790 +9787805054049 +9787805054162 +9787805054605 +9787805054667 +9787805054759 +9787805054988 +9787805055015 +9787805055114 +9787805055152 +9787805055725 +9787805055886 +9787805056005 +9787805056159 +9787805056388 +9787805056500 +9787805056531 +9787805056708 +9787805056739 +9787805056791 +9787805056845 +9787805057071 +9787805057156 +9787805057170 +9787805057255 +9787805057279 +9787805057316 +9787805057347 +9787805057613 +9787805058139 +9787805058276 +9787805058764 +9787805059075 +9787805059129 +9787805059143 +9787805059259 +9787805059280 +9787805059297 +9787805059808 +9787805059822 +9787805059839 +9787805059853 +9787805060897 +9787805060989 +9787805062020 +9787805062037 +9787805062136 +9787805062174 +9787805062310 +9787805062464 +9787805062471 +9787805063331 +9787805063621 +9787805063652 +9787805063799 +9787805063805 +9787805064000 +9787805064109 +9787805064239 +9787805064246 +9787805064253 +9787805064376 +9787805064406 +9787805064413 +9787805064420 +9787805064680 +9787805064932 +9787805065199 +9787805065311 +9787805065328 +9787805065335 +9787805065359 +9787805065366 +9787805065373 +9787805065380 +9787805065397 +9787805065403 +9787805065441 +9787805065557 +9787805065601 +9787805065663 +9787805065687 +9787805065915 +9787805066257 +9787805066301 +9787805066332 +9787805066417 +9787805066448 +9787805066455 +9787805066462 +9787805066479 +9787805066486 +9787805066493 +9787805066516 +9787805066585 +9787805066653 +9787805067063 +9787805067131 +9787805067155 +9787805067186 +9787805067322 +9787805067407 +9787805067605 +9787805068190 +9787805068367 +9787805068459 +9787805068589 +9787805068855 +9787805068879 +9787805068923 +9787805069135 +9787805069159 +9787805069227 +9787805069562 +9787805069586 +9787805069692 +9787805069708 +9787805069975 +9787805069999 +9787805070025 +9787805070032 +9787805070049 +9787805070100 +9787805070148 +9787805070223 +9787805070254 +9787805070353 +9787805070360 +9787805070391 +9787805070452 +9787805070575 +9787805070636 +9787805070711 +9787805070728 +9787805070759 +9787805070841 +9787805070858 +9787805070865 +9787805070926 +9787805071404 +9787805071770 +9787805071831 +9787805071848 +9787805071879 +9787805072074 +9787805072104 +9787805072159 +9787805072166 +9787805072173 +9787805072203 +9787805072234 +9787805072296 +9787805072302 +9787805072326 +9787805072333 +9787805072784 +9787805072852 +9787805072999 +9787805073040 +9787805073163 +9787805073187 +9787805073224 +9787805073248 +9787805073255 +9787805073279 +9787805073385 +9787805073392 +9787805073439 +9787805073583 +9787805073835 +9787805074023 +9787805080666 +9787805081663 +9787805082080 +9787805082325 +9787805083193 +9787805085685 +9787805086804 +9787805087214 +9787805087221 +9787805087597 +9787805087979 +9787805088181 +9787805088600 +9787805088631 +9787805088754 +9787805088815 +9787805089010 +9787805089034 +9787805089188 +9787805089256 +9787805089492 +9787805089607 +9787805089652 +9787805089980 +9787805092591 +9787805100005 +9787805100081 +9787805100159 +9787805100173 +9787805100319 +9787805100357 +9787805100449 +9787805100456 +9787805100555 +9787805100647 +9787805100982 +9787805100999 +9787805101101 +9787805101118 +9787805101125 +9787805101217 +9787805101316 +9787805101378 +9787805101699 +9787805101835 +9787805102054 +9787805102078 +9787805102207 +9787805102290 +9787805102559 +9787805102580 +9787805102610 +9787805102733 +9787805102917 +9787805103129 +9787805103204 +9787805103358 +9787805105024 +9787805105031 +9787805105130 +9787805105918 +9787805106069 +9787805106588 +9787805106779 +9787805106885 +9787805107219 +9787805107325 +9787805107400 +9787805107479 +9787805107967 +9787805108919 +9787805108971 +9787805109138 +9787805109244 +9787805109350 +9787805109664 +9787805109725 +9787805109862 +9787805110042 +9787805110219 +9787805110240 +9787805110295 +9787805110356 +9787805110363 +9787805110479 +9787805110486 +9787805110691 +9787805110790 +9787805110806 +9787805110905 +9787805111117 +9787805111124 +9787805111131 +9787805111148 +9787805111155 +9787805111162 +9787805111179 +9787805111186 +9787805111193 +9787805111209 +9787805111216 +9787805111360 +9787805111520 +9787805111544 +9787805111582 +9787805111650 +9787805111681 +9787805111735 +9787805111797 +9787805112039 +9787805112046 +9787805112084 +9787805112114 +9787805112152 +9787805112220 +9787805112336 +9787805112367 +9787805112374 +9787805112480 +9787805112503 +9787805112589 +9787805112992 +9787805113029 +9787805113142 +9787805113241 +9787805113302 +9787805113333 +9787805113395 +9787805113531 +9787805113548 +9787805113609 +9787805113623 +9787805113739 +9787805113777 +9787805113807 +9787805113883 +9787805113975 +9787805114057 +9787805114071 +9787805114088 +9787805114095 +9787805114491 +9787805114552 +9787805114583 +9787805114668 +9787805114675 +9787805114743 +9787805114903 +9787805114910 +9787805114965 +9787805114989 +9787805115061 +9787805115276 +9787805115320 +9787805115511 +9787805115689 +9787805115788 +9787805116242 +9787805116259 +9787805116297 +9787805116310 +9787805116853 +9787805117034 +9787805117089 +9787805117416 +9787805117539 +9787805117577 +9787805117591 +9787805117836 +9787805118079 +9787805118536 +9787805118840 +9787805118857 +9787805118994 +9787805119519 +9787805119564 +9787805119748 +9787805119779 +9787805119946 +9787805119960 +9787805120119 +9787805120126 +9787805120157 +9787805120270 +9787805120355 +9787805120362 +9787805120409 +9787805120423 +9787805120553 +9787805120577 +9787805120584 +9787805120607 +9787805120676 +9787805120683 +9787805120706 +9787805120751 +9787805120768 +9787805120782 +9787805120881 +9787805120942 +9787805120959 +9787805120973 +9787805121031 +9787805121345 +9787805121383 +9787805121437 +9787805121444 +9787805121468 +9787805121581 +9787805121673 +9787805121772 +9787805121833 +9787805121932 +9787805121949 +9787805122090 +9787805122144 +9787805122168 +9787805122182 +9787805122397 +9787805122533 +9787805122571 +9787805122595 +9787805122601 +9787805122618 +9787805122694 +9787805123080 +9787805123097 +9787805123189 +9787805123196 +9787805123202 +9787805123264 +9787805123288 +9787805123318 +9787805123561 +9787805123653 +9787805123837 +9787805123844 +9787805123851 +9787805123868 +9787805123882 +9787805123899 +9787805124100 +9787805124186 +9787805124629 +9787805124650 +9787805124704 +9787805124711 +9787805124728 +9787805124759 +9787805124933 +9787805124940 +9787805125015 +9787805125329 +9787805125442 +9787805125602 +9787805125749 +9787805125794 +9787805125985 +9787805126258 +9787805126647 +9787805127118 +9787805127125 +9787805127262 +9787805127378 +9787805127835 +9787805128559 +9787805129594 +9787805129655 +9787805129792 +9787805130309 +9787805130828 +9787805130866 +9787805130989 +9787805131412 +9787805131627 +9787805132167 +9787805132198 +9787805132402 +9787805132945 +9787805133683 +9787805133966 +9787805135069 +9787805136059 +9787805137575 +9787805137636 +9787805137698 +9787805137865 +9787805137896 +9787805138039 +9787805138794 +9787805139333 +9787805139418 +9787805139692 +9787805139746 +9787805139753 +9787805139890 +9787805140865 +9787805141008 +9787805141497 +9787805141688 +9787805141930 +9787805142012 +9787805142104 +9787805142197 +9787805142456 +9787805142555 +9787805143064 +9787805143187 +9787805144122 +9787805144405 +9787805145037 +9787805145518 +9787805145747 +9787805145808 +9787805145938 +9787805146102 +9787805146614 +9787805146812 +9787805147550 +9787805147895 +9787805147901 +9787805149035 +9787805149561 +9787805150567 +9787805150871 +9787805151588 +9787805151625 +9787805151823 +9787805152158 +9787805152301 +9787805152387 +9787805152530 +9787805152875 +9787805153421 +9787805153575 +9787805154022 +9787805154152 +9787805155722 +9787805155845 +9787805156514 +9787805156545 +9787805156569 +9787805156576 +9787805157122 +9787805157160 +9787805157214 +9787805157443 +9787805157528 +9787805157702 +9787805158464 +9787805158532 +9787805158556 +9787805158792 +9787805158808 +9787805159508 +9787805159515 +9787805159539 +9787805159638 +9787805165103 +9787805166889 +9787805167800 +9787805170039 +9787805170169 +9787805170244 +9787805170299 +9787805170442 +9787805170831 +9787805171050 +9787805171142 +9787805171517 +9787805171524 +9787805171647 +9787805171814 +9787805171852 +9787805171982 +9787805172262 +9787805174310 +9787805174341 +9787805174372 +9787805174617 +9787805174860 +9787805175362 +9787805175737 +9787805175751 +9787805176529 +9787805176680 +9787805176888 +9787805177137 +9787805177595 +9787805178769 +9787805178912 +9787805178950 +9787805179117 +9787805180045 +9787805180083 +9787805180175 +9787805180250 +9787805180311 +9787805180533 +9787805180649 +9787805180700 +9787805180755 +9787805180786 +9787805180854 +9787805180908 +9787805180946 +9787805181028 +9787805181042 +9787805181110 +9787805181172 +9787805181202 +9787805181219 +9787805181264 +9787805181332 +9787805181370 +9787805181417 +9787805181431 +9787805181547 +9787805181615 +9787805181677 +9787805181707 +9787805181929 +9787805181943 +9787805181981 +9787805182049 +9787805182087 +9787805182094 +9787805182100 +9787805182117 +9787805182148 +9787805182377 +9787805182544 +9787805182605 +9787805182612 +9787805182643 +9787805182803 +9787805182827 +9787805182834 +9787805182889 +9787805182919 +9787805183152 +9787805183244 +9787805183343 +9787805183367 +9787805183404 +9787805183763 +9787805183800 +9787805183862 +9787805183886 +9787805184081 +9787805184258 +9787805184265 +9787805184456 +9787805184517 +9787805184616 +9787805184623 +9787805184630 +9787805184678 +9787805184715 +9787805184821 +9787805185118 +9787805185408 +9787805185903 +9787805185910 +9787805186351 +9787805186887 +9787805187167 +9787805187204 +9787805188256 +9787805188799 +9787805189499 +9787805189505 +9787805190013 +9787805190020 +9787805190037 +9787805190228 +9787805190266 +9787805190396 +9787805190433 +9787805190440 +9787805190457 +9787805190488 +9787805190501 +9787805190556 +9787805190679 +9787805190709 +9787805190785 +9787805190839 +9787805190853 +9787805190860 +9787805190907 +9787805190983 +9787805191027 +9787805191034 +9787805191140 +9787805191164 +9787805191225 +9787805191317 +9787805191324 +9787805191492 +9787805191522 +9787805191539 +9787805191607 +9787805191669 +9787805191683 +9787805191706 +9787805191829 +9787805191836 +9787805191850 +9787805191898 +9787805192000 +9787805192802 +9787805193199 +9787805193212 +9787805193328 +9787805193342 +9787805193359 +9787805193434 +9787805193472 +9787805193489 +9787805193526 +9787805193533 +9787805193540 +9787805193588 +9787805193656 +9787805193670 +9787805193700 +9787805193779 +9787805194226 +9787805194233 +9787805194240 +9787805194257 +9787805194264 +9787805194271 +9787805194288 +9787805194295 +9787805194301 +9787805194394 +9787805194417 +9787805194943 +9787805194967 +9787805195001 +9787805195070 +9787805195193 +9787805195254 +9787805195315 +9787805195322 +9787805195780 +9787805195810 +9787805196121 +9787805196138 +9787805196145 +9787805196169 +9787805196534 +9787805196626 +9787805196633 +9787805196770 +9787805196886 +9787805196923 +9787805196947 +9787805196954 +9787805197005 +9787805198293 +9787805198361 +9787805198439 +9787805198446 +9787805198545 +9787805198552 +9787805198583 +9787805199122 +9787805199351 +9787805199726 +9787805199764 +9787805200002 +9787805200040 +9787805200088 +9787805200118 +9787805200125 +9787805200149 +9787805200156 +9787805200279 +9787805200330 +9787805200415 +9787805200422 +9787805200484 +9787805200514 +9787805200569 +9787805200590 +9787805200668 +9787805200736 +9787805200903 +9787805200910 +9787805200965 +9787805201030 +9787805201115 +9787805201184 +9787805201191 +9787805201252 +9787805201320 +9787805201351 +9787805201375 +9787805201443 +9787805201467 +9787805201603 +9787805201795 +9787805201849 +9787805201856 +9787805201900 +9787805201931 +9787805202051 +9787805202075 +9787805202310 +9787805202495 +9787805202525 +9787805202549 +9787805202570 +9787805202631 +9787805202686 +9787805202730 +9787805202761 +9787805202785 +9787805202808 +9787805202839 +9787805202884 +9787805202907 +9787805202938 +9787805202952 +9787805203140 +9787805203164 +9787805203539 +9787805203652 +9787805203690 +9787805203706 +9787805203713 +9787805203744 +9787805203775 +9787805203782 +9787805203836 +9787805203843 +9787805203850 +9787805203942 +9787805203959 +9787805204024 +9787805204055 +9787805204062 +9787805204109 +9787805204208 +9787805204215 +9787805204260 +9787805204383 +9787805204406 +9787805204444 +9787805204499 +9787805204505 +9787805204550 +9787805204581 +9787805204598 +9787805204611 +9787805204628 +9787805204635 +9787805204772 +9787805204840 +9787805204932 +9787805205052 +9787805205083 +9787805205120 +9787805205151 +9787805205342 +9787805205410 +9787805205441 +9787805205472 +9787805205489 +9787805205632 +9787805205724 +9787805205731 +9787805205762 +9787805205793 +9787805205823 +9787805205885 +9787805206004 +9787805206028 +9787805206073 +9787805206080 +9787805206134 +9787805206219 +9787805206226 +9787805206233 +9787805206271 +9787805206332 +9787805206424 +9787805206462 +9787805206479 +9787805206516 +9787805206547 +9787805206820 +9787805206851 +9787805206875 +9787805207018 +9787805207063 +9787805207148 +9787805207216 +9787805207230 +9787805207414 +9787805207537 +9787805207704 +9787805207711 +9787805207780 +9787805207797 +9787805207896 +9787805207926 +9787805208008 +9787805208022 +9787805208091 +9787805208145 +9787805208183 +9787805208213 +9787805208244 +9787805208398 +9787805208435 +9787805208473 +9787805208510 +9787805208800 +9787805209234 +9787805209388 +9787805209432 +9787805209555 +9787805209579 +9787805209593 +9787805211534 +9787805212203 +9787805212210 +9787805212296 +9787805212302 +9787805212425 +9787805212678 +9787805212692 +9787805212791 +9787805212968 +9787805212982 +9787805213019 +9787805213064 +9787805213309 +9787805213385 +9787805213552 +9787805213699 +9787805213767 +9787805213903 +9787805213910 +9787805213996 +9787805214191 +9787805214207 +9787805214269 +9787805214634 +9787805214771 +9787805215372 +9787805215419 +9787805215501 +9787805215549 +9787805215648 +9787805215662 +9787805215716 +9787805215747 +9787805216089 +9787805216300 +9787805216348 +9787805216355 +9787805216409 +9787805216430 +9787805216447 +9787805216478 +9787805216515 +9787805216522 +9787805216546 +9787805216577 +9787805216621 +9787805216676 +9787805216836 +9787805216881 +9787805216898 +9787805216935 +9787805216959 +9787805217086 +9787805217093 +9787805217208 +9787805217222 +9787805217239 +9787805217284 +9787805217345 +9787805217420 +9787805217475 +9787805217598 +9787805217642 +9787805217796 +9787805218113 +9787805218311 +9787805218335 +9787805218373 +9787805218397 +9787805218434 +9787805218489 +9787805218588 +9787805218700 +9787805218748 +9787805218809 +9787805218977 +9787805219332 +9787805219509 +9787805219677 +9787805219776 +9787805219875 +9787805219936 +9787805221663 +9787805222691 +9787805223315 +9787805225128 +9787805225555 +9787805225616 +9787805226453 +9787805226460 +9787805227474 +9787805228433 +9787805228600 +9787805230016 +9787805230108 +9787805230139 +9787805230313 +9787805230337 +9787805230405 +9787805230450 +9787805230498 +9787805230504 +9787805230566 +9787805230603 +9787805230634 +9787805230658 +9787805230665 +9787805230825 +9787805231006 +9787805231112 +9787805231204 +9787805231211 +9787805231303 +9787805231327 +9787805231389 +9787805231402 +9787805231419 +9787805231471 +9787805231488 +9787805231525 +9787805231549 +9787805231563 +9787805231792 +9787805231914 +9787805231983 +9787805231990 +9787805232003 +9787805232058 +9787805232072 +9787805232096 +9787805232126 +9787805232294 +9787805232300 +9787805232669 +9787805232706 +9787805232737 +9787805232775 +9787805232973 +9787805233024 +9787805233239 +9787805233246 +9787805233253 +9787805233369 +9787805233444 +9787805233574 +9787805233581 +9787805233758 +9787805233918 +9787805233925 +9787805233956 +9787805234069 +9787805234076 +9787805234113 +9787805234137 +9787805234335 +9787805234595 +9787805234991 +9787805235028 +9787805235080 +9787805235103 +9787805235110 +9787805235127 +9787805235226 +9787805235264 +9787805235394 +9787805235639 +9787805235660 +9787805235769 +9787805235967 +9787805236322 +9787805236391 +9787805236407 +9787805236483 +9787805236520 +9787805236810 +9787805236872 +9787805236896 +9787805236964 +9787805237022 +9787805237145 +9787805237152 +9787805237503 +9787805237572 +9787805237718 +9787805237855 +9787805238012 +9787805238036 +9787805238098 +9787805238142 +9787805238203 +9787805238265 +9787805238333 +9787805238425 +9787805238579 +9787805238715 +9787805238777 +9787805238869 +9787805239316 +9787805239644 +9787805239682 +9787805239767 +9787805239774 +9787805239842 +9787805240015 +9787805240053 +9787805240992 +9787805241371 +9787805241418 +9787805251561 +9787805252209 +9787805252681 +9787805254432 +9787805254609 +9787805254869 +9787805256054 +9787805256115 +9787805257075 +9787805257884 +9787805257990 +9787805258140 +9787805258812 +9787805259581 +9787805260006 +9787805260020 +9787805260051 +9787805260129 +9787805260204 +9787805260334 +9787805260358 +9787805260372 +9787805260389 +9787805260617 +9787805260709 +9787805260808 +9787805260822 +9787805261010 +9787805261256 +9787805261270 +9787805261324 +9787805261454 +9787805261492 +9787805261515 +9787805261546 +9787805261607 +9787805261911 +9787805261928 +9787805262048 +9787805262062 +9787805262130 +9787805262192 +9787805262239 +9787805262338 +9787805262550 +9787805262567 +9787805262673 +9787805263021 +9787805263151 +9787805263168 +9787805263205 +9787805263519 +9787805263847 +9787805263892 +9787805264196 +9787805264363 +9787805264547 +9787805264738 +9787805264813 +9787805264837 +9787805265131 +9787805265193 +9787805265285 +9787805265452 +9787805265704 +9787805265827 +9787805265896 +9787805265902 +9787805266671 +9787805266695 +9787805267142 +9787805267333 +9787805267807 +9787805268507 +9787805269184 +9787805269283 +9787805270180 +9787805270548 +9787805270692 +9787805270753 +9787805271460 +9787805272177 +9787805273907 +9787805273945 +9787805274799 +9787805275581 +9787805275703 +9787805275857 +9787805276304 +9787805277158 +9787805277400 +9787805278063 +9787805279251 +9787805279404 +9787805280042 +9787805280127 +9787805280134 +9787805280141 +9787805280158 +9787805280226 +9787805280233 +9787805280240 +9787805280349 +9787805280370 +9787805280400 +9787805280455 +9787805280691 +9787805280752 +9787805280769 +9787805280899 +9787805280905 +9787805281032 +9787805281094 +9787805281131 +9787805281148 +9787805281254 +9787805281285 +9787805281445 +9787805281605 +9787805281728 +9787805281834 +9787805281919 +9787805282114 +9787805282282 +9787805282398 +9787805282442 +9787805282794 +9787805283050 +9787805283074 +9787805283111 +9787805283197 +9787805283241 +9787805283302 +9787805283562 +9787805283579 +9787805283647 +9787805283685 +9787805283739 +9787805283852 +9787805283937 +9787805283975 +9787805284071 +9787805284330 +9787805284422 +9787805284583 +9787805284637 +9787805284699 +9787805284767 +9787805285023 +9787805285122 +9787805285344 +9787805285412 +9787805285436 +9787805285917 +9787805286013 +9787805286020 +9787805286242 +9787805286259 +9787805286266 +9787805286303 +9787805286518 +9787805286525 +9787805286549 +9787805286648 +9787805286686 +9787805286747 +9787805286761 +9787805286778 +9787805286792 +9787805286853 +9787805286921 +9787805286983 +9787805287089 +9787805287126 +9787805287133 +9787805287140 +9787805287393 +9787805287430 +9787805287522 +9787805287607 +9787805287683 +9787805287690 +9787805287805 +9787805287843 +9787805287973 +9787805288185 +9787805288390 +9787805288437 +9787805289151 +9787805289199 +9787805289205 +9787805289267 +9787805289304 +9787805289328 +9787805289359 +9787805289403 +9787805289410 +9787805289427 +9787805289465 +9787805289472 +9787805289489 +9787805289540 +9787805289564 +9787805289571 +9787805289588 +9787805289595 +9787805289700 +9787805289748 +9787805289823 +9787805289892 +9787805289946 +9787805290560 +9787805293509 +9787805293837 +9787805294872 +9787805300061 +9787805300078 +9787805300634 +9787805300924 +9787805301075 +9787805301099 +9787805301150 +9787805301372 +9787805302133 +9787805302157 +9787805302256 +9787805302423 +9787805302881 +9787805302904 +9787805302928 +9787805303062 +9787805303994 +9787805304137 +9787805304526 +9787805304533 +9787805304618 +9787805304649 +9787805305158 +9787805305356 +9787805305578 +9787805305646 +9787805305905 +9787805305981 +9787805306513 +9787805307626 +9787805307718 +9787805308821 +9787805308883 +9787805308890 +9787805308906 +9787805308913 +9787805309989 +9787805310251 +9787805310732 +9787805310886 +9787805310909 +9787805311357 +9787805311654 +9787805311760 +9787805311852 +9787805312095 +9787805312101 +9787805312118 +9787805312125 +9787805312408 +9787805312651 +9787805312705 +9787805312958 +9787805312972 +9787805313030 +9787805313115 +9787805313221 +9787805313573 +9787805313634 +9787805313696 +9787805313702 +9787805313719 +9787805313825 +9787805313948 +9787805313986 +9787805314044 +9787805314051 +9787805314099 +9787805314129 +9787805314280 +9787805314464 +9787805314471 +9787805314556 +9787805314662 +9787805314686 +9787805314907 +9787805314952 +9787805314976 +9787805315560 +9787805315829 +9787805316253 +9787805316260 +9787805316284 +9787805316390 +9787805317649 +9787805318141 +9787805318677 +9787805318967 +9787805319032 +9787805319667 +9787805321998 +9787805324210 +9787805325415 +9787805329321 +9787805330051 +9787805330105 +9787805330112 +9787805330136 +9787805330204 +9787805330211 +9787805330754 +9787805330860 +9787805330983 +9787805331454 +9787805331652 +9787805331683 +9787805331799 +9787805331829 +9787805331904 +9787805332109 +9787805332147 +9787805332611 +9787805332888 +9787805333274 +9787805333878 +9787805334349 +9787805335179 +9787805336879 +9787805337944 +9787805338446 +9787805340104 +9787805340111 +9787805340142 +9787805340173 +9787805340203 +9787805340258 +9787805340388 +9787805340470 +9787805340524 +9787805340579 +9787805340623 +9787805340951 +9787805341118 +9787805341163 +9787805341521 +9787805341538 +9787805341552 +9787805341941 +9787805342023 +9787805342344 +9787805342405 +9787805342795 +9787805342863 +9787805342979 +9787805343020 +9787805343273 +9787805343983 +9787805344164 +9787805344348 +9787805344485 +9787805344713 +9787805345079 +9787805345116 +9787805345208 +9787805345284 +9787805345468 +9787805345901 +9787805346021 +9787805346090 +9787805346106 +9787805346144 +9787805346151 +9787805347646 +9787805347820 +9787805348148 +9787805348223 +9787805348384 +9787805348933 +9787805349510 +9787805349671 +9787805349992 +9787805350059 +9787805350097 +9787805350141 +9787805350202 +9787805350219 +9787805350271 +9787805350349 +9787805350356 +9787805350394 +9787805350530 +9787805350714 +9787805350721 +9787805350738 +9787805350752 +9787805350806 +9787805350837 +9787805350844 +9787805350868 +9787805350905 +9787805351094 +9787805351117 +9787805351209 +9787805351391 +9787805351438 +9787805351476 +9787805351575 +9787805351629 +9787805351636 +9787805351650 +9787805351773 +9787805351896 +9787805352114 +9787805352343 +9787805352350 +9787805352527 +9787805352701 +9787805352824 +9787805353005 +9787805353050 +9787805353104 +9787805353135 +9787805354101 +9787805354248 +9787805354354 +9787805354743 +9787805354798 +9787805354934 +9787805355344 +9787805355351 +9787805355399 +9787805355627 +9787805355672 +9787805356228 +9787805356389 +9787805356716 +9787805356730 +9787805356747 +9787805357133 +9787805357362 +9787805357430 +9787805357454 +9787805357621 +9787805357799 +9787805357966 +9787805357980 +9787805358055 +9787805358062 +9787805358192 +9787805358307 +9787805358376 +9787805358420 +9787805358437 +9787805358451 +9787805358628 +9787805358949 +9787805359007 +9787805359182 +9787805359267 +9787805359281 +9787805359625 +9787805359670 +9787805359731 +9787805359878 +9787805360010 +9787805360157 +9787805360188 +9787805360492 +9787805360508 +9787805360515 +9787805360546 +9787805361062 +9787805361116 +9787805361147 +9787805361307 +9787805361505 +9787805361512 +9787805361550 +9787805361703 +9787805361956 +9787805362540 +9787805362670 +9787805362762 +9787805362779 +9787805362830 +9787805362847 +9787805363066 +9787805363653 +9787805364520 +9787805364575 +9787805364667 +9787805365176 +9787805365374 +9787805365718 +9787805366302 +9787805366326 +9787805366333 +9787805367439 +9787805367590 +9787805367699 +9787805367750 +9787805367859 +9787805367873 +9787805368092 +9787805368641 +9787805369174 +9787805369389 +9787805370187 +9787805374338 +9787805375328 +9787805377056 +9787805378596 +9787805380001 +9787805380124 +9787805380148 +9787805380162 +9787805380193 +9787805380322 +9787805380360 +9787805380933 +9787805381725 +9787805381909 +9787805382319 +9787805382777 +9787805382975 +9787805383415 +9787805383767 +9787805383866 +9787805383873 +9787805383880 +9787805383941 +9787805383996 +9787805384559 +9787805384955 +9787805385136 +9787805385181 +9787805385273 +9787805385280 +9787805385495 +9787805385501 +9787805385631 +9787805385648 +9787805386553 +9787805386584 +9787805386652 +9787805386676 +9787805386751 +9787805386874 +9787805386904 +9787805386973 +9787805387031 +9787805387505 +9787805387512 +9787805387734 +9787805387796 +9787805388045 +9787805388168 +9787805388281 +9787805388328 +9787805388366 +9787805388380 +9787805388700 +9787805388748 +9787805389387 +9787805389394 +9787805390000 +9787805390017 +9787805390048 +9787805390055 +9787805390079 +9787805390123 +9787805390161 +9787805400020 +9787805400075 +9787805400198 +9787805400266 +9787805410753 +9787805411187 +9787805411323 +9787805411330 +9787805411408 +9787805411453 +9787805411699 +9787805411996 +9787805412559 +9787805412900 +9787805412924 +9787805412931 +9787805413129 +9787805413150 +9787805413174 +9787805413389 +9787805413853 +9787805414836 +9787805415352 +9787805415680 +9787805416045 +9787805416151 +9787805416199 +9787805416700 +9787805417875 +9787805420141 +9787805420233 +9787805420820 +9787805420837 +9787805421339 +9787805421575 +9787805421759 +9787805421865 +9787805421896 +9787805421988 +9787805422176 +9787805422732 +9787805423289 +9787805423296 +9787805423913 +9787805424118 +9787805424965 +9787805424996 +9787805425184 +9787805425351 +9787805425719 +9787805425771 +9787805425788 +9787805425962 +9787805425979 +9787805426006 +9787805426259 +9787805426334 +9787805426549 +9787805426877 +9787805427249 +9787805427256 +9787805427423 +9787805427539 +9787805427546 +9787805427843 +9787805428437 +9787805428529 +9787805428796 +9787805428987 +9787805429571 +9787805429656 +9787805429663 +9787805429847 +9787805429915 +9787805430010 +9787805430096 +9787805430119 +9787805430133 +9787805430225 +9787805430287 +9787805430836 +9787805430997 +9787805431000 +9787805431116 +9787805431123 +9787805431567 +9787805431765 +9787805431925 +9787805431987 +9787805431994 +9787805432229 +9787805432366 +9787805432380 +9787805432502 +9787805432939 +9787805433035 +9787805433363 +9787805433691 +9787805434223 +9787805434735 +9787805434759 +9787805434902 +9787805434995 +9787805435015 +9787805435244 +9787805435299 +9787805435459 +9787805435473 +9787805435558 +9787805435688 +9787805435701 +9787805435800 +9787805435817 +9787805435824 +9787805436036 +9787805436326 +9787805436555 +9787805437286 +9787805437460 +9787805437804 +9787805438986 +9787805439761 +9787805441986 +9787805444192 +9787805444895 +9787805445526 +9787805445908 +9787805446288 +9787805446592 +9787805453149 +9787805455020 +9787805458809 +9787805459936 +9787805460055 +9787805460147 +9787805461052 +9787805461120 +9787805461311 +9787805461403 +9787805461434 +9787805461533 +9787805461557 +9787805461571 +9787805461601 +9787805461700 +9787805461724 +9787805462097 +9787805462165 +9787805462394 +9787805462424 +9787805462523 +9787805462554 +9787805462608 +9787805462622 +9787805462653 +9787805462783 +9787805462820 +9787805462851 +9787805462905 +9787805462912 +9787805462950 +9787805462998 +9787805463490 +9787805463698 +9787805463797 +9787805463865 +9787805463957 +9787805464060 +9787805464084 +9787805464343 +9787805465098 +9787805465166 +9787805465401 +9787805465500 +9787805465593 +9787805467009 +9787805467399 +9787805467603 +9787805467887 +9787805468051 +9787805468082 +9787805468181 +9787805468617 +9787805468648 +9787805468747 +9787805468839 +9787805468846 +9787805468853 +9787805468969 +9787805469065 +9787805469171 +9787805469256 +9787805469263 +9787805469287 +9787805469300 +9787805469492 +9787805469614 +9787805469669 +9787805469805 +9787805469973 +9787805471310 +9787805471976 +9787805472232 +9787805473406 +9787805474205 +9787805474526 +9787805478203 +9787805478210 +9787805478234 +9787805480008 +9787805480046 +9787805480053 +9787805480077 +9787805480107 +9787805480114 +9787805480145 +9787805480152 +9787805480206 +9787805480213 +9787805480244 +9787805480329 +9787805480336 +9787805480350 +9787805480367 +9787805480374 +9787805480480 +9787805480596 +9787805480619 +9787805480695 +9787805480824 +9787805480879 +9787805480947 +9787805480992 +9787805481029 +9787805481067 +9787805481098 +9787805481128 +9787805481142 +9787805481203 +9787805481227 +9787805481234 +9787805481296 +9787805481357 +9787805481418 +9787805481531 +9787805481548 +9787805481555 +9787805481579 +9787805481630 +9787805481715 +9787805481777 +9787805481852 +9787805481890 +9787805481937 +9787805481982 +9787805482019 +9787805482026 +9787805482040 +9787805482057 +9787805482064 +9787805482088 +9787805482095 +9787805482132 +9787805482163 +9787805482231 +9787805482248 +9787805482255 +9787805482262 +9787805482330 +9787805482347 +9787805482361 +9787805482408 +9787805482422 +9787805482446 +9787805482460 +9787805482491 +9787805482538 +9787805482545 +9787805482620 +9787805482675 +9787805482729 +9787805482743 +9787805482767 +9787805482798 +9787805482835 +9787805482903 +9787805482958 +9787805483085 +9787805483108 +9787805483115 +9787805483160 +9787805483177 +9787805483184 +9787805483245 +9787805483252 +9787805483269 +9787805483276 +9787805483290 +9787805483337 +9787805483375 +9787805483412 +9787805483481 +9787805483504 +9787805483528 +9787805483610 +9787805483634 +9787805483641 +9787805483672 +9787805483689 +9787805483719 +9787805483849 +9787805483863 +9787805484037 +9787805484082 +9787805484105 +9787805484150 +9787805484167 +9787805484389 +9787805484488 +9787805484518 +9787805484525 +9787805484549 +9787805484570 +9787805484600 +9787805484617 +9787805484648 +9787805484679 +9787805484693 +9787805484709 +9787805484785 +9787805484822 +9787805484839 +9787805484846 +9787805484945 +9787805484952 +9787805484969 +9787805485003 +9787805485010 +9787805485041 +9787805485065 +9787805485089 +9787805485102 +9787805485126 +9787805485201 +9787805485249 +9787805485331 +9787805485379 +9787805485461 +9787805485478 +9787805485485 +9787805485492 +9787805485508 +9787805485539 +9787805485560 +9787805485645 +9787805485669 +9787805485720 +9787805485737 +9787805485836 +9787805485980 +9787805486017 +9787805486185 +9787805486208 +9787805486215 +9787805486437 +9787805486574 +9787805486765 +9787805486772 +9787805486819 +9787805486888 +9787805486932 +9787805486956 +9787805487014 +9787805487052 +9787805487168 +9787805487182 +9787805487267 +9787805487359 +9787805487809 +9787805487847 +9787805487878 +9787805488257 +9787805488479 +9787805488561 +9787805488721 +9787805488790 +9787805489513 +9787805489872 +9787805490007 +9787805490175 +9787805490250 +9787805490281 +9787805490298 +9787805490311 +9787805490335 +9787805490472 +9787805490526 +9787805490625 +9787805490830 +9787805491233 +9787805491257 +9787805491752 +9787805492209 +9787805492438 +9787805492766 +9787805500010 +9787805500294 +9787805500348 +9787805500461 +9787805500492 +9787805500782 +9787805500973 +9787805501154 +9787805501338 +9787805501505 +9787805501567 +9787805501581 +9787805501734 +9787805501765 +9787805501796 +9787805502168 +9787805502502 +9787805503080 +9787805503899 +9787805504056 +9787805504988 +9787805505732 +9787805505787 +9787805508993 +9787805510057 +9787805510064 +9787805511061 +9787805511085 +9787805512570 +9787805512587 +9787805512952 +9787805513447 +9787805513546 +9787805513799 +9787805513911 +9787805514413 +9787805514970 +9787805515793 +9787805516653 +9787805516851 +9787805517124 +9787805517186 +9787805517216 +9787805517254 +9787805518220 +9787805518275 +9787805518602 +9787805518794 +9787805519548 +9787805521084 +9787805522722 +9787805523095 +9787805523743 +9787805523804 +9787805523873 +9787805524078 +9787805524726 +9787805524900 +9787805525167 +9787805525457 +9787805527321 +9787805529448 +9787805529677 +9787805529721 +9787805530598 +9787805530727 +9787805530857 +9787805530963 +9787805531144 +9787805531533 +9787805531625 +9787805531656 +9787805532141 +9787805532219 +9787805532462 +9787805532806 +9787805533070 +9787805533230 +9787805533346 +9787805533353 +9787805533445 +9787805533599 +9787805534480 +9787805534497 +9787805535135 +9787805535487 +9787805535647 +9787805536149 +9787805536217 +9787805536446 +9787805536576 +9787805536644 +9787805536828 +9787805536842 +9787805537009 +9787805537061 +9787805537252 +9787805537610 +9787805537788 +9787805537955 +9787805538228 +9787805539027 +9787805539119 +9787805539669 +9787805539959 +9787805540481 +9787805540504 +9787805540955 +9787805541112 +9787805542430 +9787805542522 +9787805542706 +9787805542751 +9787805542843 +9787805543062 +9787805543253 +9787805543604 +9787805543635 +9787805544083 +9787805544106 +9787805545127 +9787805545318 +9787805545592 +9787805546230 +9787805548234 +9787805548647 +9787805548708 +9787805549231 +9787805549354 +9787805549507 +9787805550169 +9787805550541 +9787805550732 +9787805550992 +9787805551463 +9787805551586 +9787805551944 +9787805552286 +9787805552569 +9787805552675 +9787805553153 +9787805553504 +9787805553825 +9787805553849 +9787805554402 +9787805554631 +9787805554792 +9787805554808 +9787805554815 +9787805554921 +9787805555072 +9787805555126 +9787805556536 +9787805557489 +9787805557571 +9787805557601 +9787805558134 +9787805558141 +9787805558196 +9787805558448 +9787805558783 +9787805558790 +9787805560441 +9787805560854 +9787805562100 +9787805562766 +9787805562834 +9787805562940 +9787805562995 +9787805564067 +9787805564098 +9787805564111 +9787805564128 +9787805564234 +9787805564241 +9787805564258 +9787805564555 +9787805566047 +9787805566306 +9787805566399 +9787805566665 +9787805566757 +9787805566948 +9787805567341 +9787805567662 +9787805567860 +9787805568096 +9787805568119 +9787805568348 +9787805568799 +9787805569116 +9787805569253 +9787805569567 +9787805569628 +9787805569642 +9787805569819 +9787805569895 +9787805570136 +9787805570297 +9787805570525 +9787805570556 +9787805570747 +9787805570907 +9787805572116 +9787805573885 +9787805574066 +9787805574158 +9787805574257 +9787805575094 +9787805575179 +9787805575322 +9787805575551 +9787805575612 +9787805575827 +9787805575933 +9787805576022 +9787805576114 +9787805576251 +9787805576268 +9787805576435 +9787805576664 +9787805576831 +9787805576886 +9787805577197 +9787805577210 +9787805577319 +9787805577340 +9787805577432 +9787805577555 +9787805577654 +9787805577722 +9787805577739 +9787805577890 +9787805578439 +9787805578590 +9787805578668 +9787805578927 +9787805579009 +9787805579245 +9787805579986 +9787805580203 +9787805580289 +9787805580333 +9787805580401 +9787805580838 +9787805580975 +9787805581323 +9787805582108 +9787805583075 +9787805583464 +9787805583594 +9787805583662 +9787805583747 +9787805583877 +9787805584201 +9787805584218 +9787805585666 +9787805585994 +9787805586045 +9787805586069 +9787805586274 +9787805586748 +9787805586915 +9787805587028 +9787805587127 +9787805588353 +9787805588506 +9787805588575 +9787805588582 +9787805588971 +9787805588988 +9787805589732 +9787805589749 +9787805589787 +9787805589954 +9787805590059 +9787805590264 +9787805590318 +9787805590356 +9787805590493 +9787805601458 +9787805601809 +9787805602134 +9787805603384 +9787805603728 +9787805605999 +9787805606545 +9787805606873 +9787805607351 +9787805607801 +9787805609218 +9787805610016 +9787805610214 +9787805621098 +9787805624655 +9787805625133 +9787805625799 +9787805627403 +9787805627946 +9787805628578 +9787805628677 +9787805628714 +9787805628790 +9787805629704 +9787805630137 +9787805630410 +9787805631295 +9787805632001 +9787805632025 +9787805632285 +9787805632315 +9787805632469 +9787805632476 +9787805632865 +9787805632896 +9787805632964 +9787805634388 +9787805635026 +9787805635309 +9787805635767 +9787805636290 +9787805637280 +9787805637327 +9787805637341 +9787805637822 +9787805638010 +9787805638324 +9787805638829 +9787805638881 +9787805638997 +9787805639000 +9787805639109 +9787805639277 +9787805639284 +9787805639338 +9787805640433 +9787805640594 +9787805640600 +9787805641164 +9787805641225 +9787805641362 +9787805641522 +9787805641683 +9787805642253 +9787805642277 +9787805642314 +9787805642796 +9787805642864 +9787805643830 +9787805643847 +9787805644264 +9787805644363 +9787805644448 +9787805644714 +9787805644752 +9787805645247 +9787805645414 +9787805645766 +9787805645803 +9787805645810 +9787805645827 +9787805646398 +9787805646510 +9787805646848 +9787805646916 +9787805647043 +9787805647197 +9787805647418 +9787805647456 +9787805647524 +9787805647890 +9787805647944 +9787805648316 +9787805648538 +9787805648736 +9787805649160 +9787805649214 +9787805649269 +9787805649283 +9787805649467 +9787805649559 +9787805650111 +9787805650142 +9787805650166 +9787805650197 +9787805650531 +9787805650692 +9787805650883 +9787805650913 +9787805651088 +9787805651187 +9787805651200 +9787805651408 +9787805652757 +9787805652849 +9787805653860 +9787805654386 +9787805654539 +9787805655000 +9787805655130 +9787805655543 +9787805655659 +9787805656052 +9787805656090 +9787805656144 +9787805657424 +9787805657578 +9787805660059 +9787805661803 +9787805661957 +9787805662268 +9787805663067 +9787805663081 +9787805664446 +9787805664613 +9787805665399 +9787805665429 +9787805666495 +9787805666921 +9787805667218 +9787805667249 +9787805668833 +9787805669885 +9787805670034 +9787805670553 +9787805670935 +9787805671017 +9787805671024 +9787805671048 +9787805671260 +9787805671406 +9787805671949 +9787805671987 +9787805672182 +9787805672199 +9787805672496 +9787805672519 +9787805673226 +9787805673400 +9787805673776 +9787805673899 +9787805673936 +9787805674018 +9787805674056 +9787805674230 +9787805674247 +9787805674469 +9787805674513 +9787805674537 +9787805674612 +9787805675121 +9787805675251 +9787805675305 +9787805675497 +9787805675572 +9787805675824 +9787805675930 +9787805676289 +9787805676319 +9787805676326 +9787805676401 +9787805676487 +9787805676494 +9787805676531 +9787805676593 +9787805676609 +9787805676630 +9787805676715 +9787805676722 +9787805676739 +9787805676890 +9787805676999 +9787805677026 +9787805677064 +9787805677187 +9787805677385 +9787805677521 +9787805677590 +9787805677750 +9787805677767 +9787805677804 +9787805678085 +9787805678092 +9787805678269 +9787805678290 +9787805678320 +9787805678337 +9787805678559 +9787805678573 +9787805678597 +9787805678603 +9787805678696 +9787805678894 +9787805679099 +9787805679198 +9787805679228 +9787805679266 +9787805679327 +9787805679600 +9787805679617 +9787805679808 +9787805679853 +9787805679983 +9787805680149 +9787805680170 +9787805680200 +9787805680217 +9787805680231 +9787805680316 +9787805680323 +9787805680347 +9787805680361 +9787805680385 +9787805680446 +9787805680484 +9787805680675 +9787805680774 +9787805680880 +9787805680903 +9787805680910 +9787805680927 +9787805680941 +9787805680965 +9787805680972 +9787805681153 +9787805681184 +9787805681764 +9787805681788 +9787805681887 +9787805681894 +9787805681917 +9787805681955 +9787805682556 +9787805682600 +9787805682709 +9787805682747 +9787805682754 +9787805682761 +9787805682839 +9787805682853 +9787805682914 +9787805682969 +9787805683072 +9787805683096 +9787805683102 +9787805683126 +9787805683133 +9787805683218 +9787805683225 +9787805683294 +9787805683362 +9787805683515 +9787805683539 +9787805683546 +9787805683607 +9787805683683 +9787805683690 +9787805683720 +9787805683737 +9787805683850 +9787805683966 +9787805683997 +9787805684505 +9787805684529 +9787805684536 +9787805684543 +9787805684550 +9787805684598 +9787805684642 +9787805684673 +9787805684802 +9787805684826 +9787805684833 +9787805685021 +9787805685038 +9787805685212 +9787805685236 +9787805685243 +9787805685267 +9787805685335 +9787805685380 +9787805685625 +9787805685694 +9787805685717 +9787805685762 +9787805685885 +9787805685915 +9787805685922 +9787805686509 +9787805686578 +9787805686615 +9787805687322 +9787805687476 +9787805687506 +9787805687568 +9787805687612 +9787805687735 +9787805687827 +9787805687896 +9787805687964 +9787805687988 +9787805688053 +9787805688060 +9787805688428 +9787805688466 +9787805688534 +9787805688541 +9787805688633 +9787805688749 +9787805688763 +9787805688794 +9787805688923 +9787805688930 +9787805688947 +9787805688954 +9787805689029 +9787805689036 +9787805689050 +9787805689166 +9787805689319 +9787805689791 +9787805690063 +9787805690070 +9787805690094 +9787805690148 +9787805690421 +9787805690544 +9787805690643 +9787805690810 +9787805690964 +9787805690971 +9787805691053 +9787805691107 +9787805691114 +9787805691121 +9787805691138 +9787805691145 +9787805691176 +9787805691206 +9787805691251 +9787805691275 +9787805691305 +9787805691312 +9787805691329 +9787805691480 +9787805691770 +9787805691794 +9787805691848 +9787805691855 +9787805691879 +9787805691893 +9787805692067 +9787805692180 +9787805692272 +9787805692296 +9787805692319 +9787805692333 +9787805692340 +9787805692548 +9787805692616 +9787805692821 +9787805692845 +9787805692869 +9787805693200 +9787805693255 +9787805693286 +9787805693293 +9787805693354 +9787805693378 +9787805693453 +9787805693460 +9787805693538 +9787805693576 +9787805693590 +9787805693606 +9787805693613 +9787805693682 +9787805693736 +9787805693811 +9787805693880 +9787805694009 +9787805694023 +9787805694252 +9787805694368 +9787805694382 +9787805694559 +9787805694641 +9787805694672 +9787805694726 +9787805694733 +9787805694771 +9787805694795 +9787805694818 +9787805694863 +9787805694894 +9787805694900 +9787805694917 +9787805694924 +9787805694931 +9787805694955 +9787805694979 +9787805694993 +9787805695006 +9787805695150 +9787805695174 +9787805695198 +9787805695235 +9787805695242 +9787805695259 +9787805695273 +9787805695358 +9787805695396 +9787805695402 +9787805695426 +9787805695433 +9787805695730 +9787805695815 +9787805695860 +9787805695891 +9787805695952 +9787805695990 +9787805696065 +9787805696225 +9787805696669 +9787805696775 +9787805696805 +9787805696942 +9787805696980 +9787805697000 +9787805697017 +9787805697024 +9787805697031 +9787805697048 +9787805697079 +9787805697086 +9787805697413 +9787805697437 +9787805697529 +9787805697536 +9787805697611 +9787805697918 +9787805697970 +9787805698007 +9787805698090 +9787805698830 +9787805698892 +9787805698991 +9787805699165 +9787805699257 +9787805699288 +9787805699301 +9787805699325 +9787805699349 +9787805699356 +9787805699417 +9787805699523 +9787805699646 +9787805699653 +9787805699998 +9787805700144 +9787805700182 +9787805700328 +9787805700397 +9787805700434 +9787805700458 +9787805700472 +9787805700724 +9787805701257 +9787805701448 +9787805701608 +9787805701691 +9787805701820 +9787805701967 +9787805701998 +9787805702087 +9787805702261 +9787805702896 +9787805703411 +9787805703459 +9787805703466 +9787805703473 +9787805704135 +9787805704593 +9787805706184 +9787805706344 +9787805706481 +9787805706771 +9787805706993 +9787805707006 +9787805707020 +9787805707204 +9787805707655 +9787805707747 +9787805707976 +9787805708010 +9787805709253 +9787805709369 +9787805709673 +9787805710013 +9787805710020 +9787805710648 +9787805710921 +9787805710976 +9787805710983 +9787805711058 +9787805711119 +9787805711126 +9787805711171 +9787805711287 +9787805711317 +9787805711355 +9787805711362 +9787805711409 +9787805711508 +9787805711553 +9787805711577 +9787805711584 +9787805711591 +9787805711614 +9787805711799 +9787805711898 +9787805711966 +9787805711973 +9787805711997 +9787805712178 +9787805712550 +9787805712918 +9787805712949 +9787805712994 +9787805713007 +9787805713052 +9787805713083 +9787805713359 +9787805713366 +9787805713526 +9787805713779 +9787805714172 +9787805714424 +9787805714677 +9787805715209 +9787805715230 +9787805715810 +9787805715964 +9787805716008 +9787805716015 +9787805716022 +9787805716558 +9787805717067 +9787805717241 +9787805717449 +9787805717548 +9787805717555 +9787805717562 +9787805717579 +9787805717593 +9787805717890 +9787805717913 +9787805718057 +9787805718071 +9787805718347 +9787805718361 +9787805718422 +9787805718552 +9787805718613 +9787805718675 +9787805718804 +9787805718873 +9787805718910 +9787805718927 +9787805719078 +9787805720234 +9787805720364 +9787805720715 +9787805723051 +9787805723433 +9787805724171 +9787805724225 +9787805724232 +9787805724379 +9787805724416 +9787805724591 +9787805724652 +9787805725376 +9787805725666 +9787805725680 +9787805725826 +9787805725871 +9787805725987 +9787805726038 +9787805726298 +9787805726526 +9787805726540 +9787805726557 +9787805726649 +9787805726694 +9787805726908 +9787805727868 +9787805728292 +9787805728629 +9787805728742 +9787805729190 +9787805729527 +9787805730141 +9787805730219 +9787805730233 +9787805730240 +9787805730288 +9787805730653 +9787805731131 +9787805731940 +9787805732428 +9787805732695 +9787805733852 +9787805733906 +9787805734422 +9787805735849 +9787805736303 +9787805737331 +9787805737874 +9787805738079 +9787805738116 +9787805738185 +9787805738567 +9787805738635 +9787805738949 +9787805738994 +9787805740133 +9787805740164 +9787805740171 +9787805740331 +9787805740362 +9787805740577 +9787805740638 +9787805740683 +9787805740690 +9787805741499 +9787805741536 +9787805741642 +9787805741659 +9787805741888 +9787805742205 +9787805742311 +9787805742328 +9787805742342 +9787805742359 +9787805742526 +9787805742618 +9787805742632 +9787805742885 +9787805742922 +9787805742939 +9787805743073 +9787805743080 +9787805743226 +9787805743523 +9787805743592 +9787805743622 +9787805743646 +9787805743851 +9787805743868 +9787805743875 +9787805744247 +9787805744933 +9787805744940 +9787805745046 +9787805745107 +9787805745237 +9787805745268 +9787805745329 +9787805745718 +9787805745732 +9787805745879 +9787805745893 +9787805746012 +9787805746173 +9787805746210 +9787805746395 +9787805746715 +9787805746739 +9787805746869 +9787805746937 +9787805746951 +9787805747095 +9787805747705 +9787805748597 +9787805749099 +9787805749280 +9787805749709 +9787805749945 +9787805750248 +9787805750279 +9787805750453 +9787805750705 +9787805751801 +9787805751993 +9787805752044 +9787805752105 +9787805752532 +9787805752648 +9787805752938 +9787805752945 +9787805752969 +9787805753089 +9787805753102 +9787805753119 +9787805753393 +9787805753409 +9787805753423 +9787805753430 +9787805754161 +9787805754239 +9787805754284 +9787805755021 +9787805755267 +9787805755434 +9787805755557 +9787805756417 +9787805756493 +9787805756868 +9787805757070 +9787805757261 +9787805757704 +9787805757735 +9787805757742 +9787805757773 +9787805757797 +9787805757827 +9787805757872 +9787805757957 +9787805758022 +9787805758091 +9787805758213 +9787805758343 +9787805758404 +9787805758473 +9787805758589 +9787805758756 +9787805758800 +9787805759463 +9787805759647 +9787805760179 +9787805761756 +9787805762289 +9787805764030 +9787805765181 +9787805766621 +9787805766737 +9787805766768 +9787805767062 +9787805767604 +9787805770826 +9787805773445 +9787805774381 +9787805774640 +9787805776552 +9787805777597 +9787805778969 +9787805779133 +9787805781860 +9787805782195 +9787805782225 +9787805782775 +9787805782799 +9787805782898 +9787805784281 +9787805784298 +9787805784595 +9787805785004 +9787805785066 +9787805785493 +9787805787794 +9787805789408 +9787805790114 +9787805790220 +9787805790268 +9787805790381 +9787805790558 +9787805790916 +9787805791197 +9787805791227 +9787805791326 +9787805791555 +9787805791722 +9787805791784 +9787805792057 +9787805792231 +9787805792279 +9787805792347 +9787805792408 +9787805792422 +9787805792477 +9787805792484 +9787805793108 +9787805793115 +9787805793313 +9787805793351 +9787805793412 +9787805793788 +9787805793863 +9787805794440 +9787805794549 +9787805794716 +9787805795010 +9787805795140 +9787805795256 +9787805795874 +9787805795966 +9787805796277 +9787805796710 +9787805796932 +9787805797137 +9787805797304 +9787805797342 +9787805797403 +9787805797427 +9787805797489 +9787805797496 +9787805797779 +9787805797793 +9787805797977 +9787805798073 +9787805798707 +9787805798981 +9787805798998 +9787805799100 +9787805799278 +9787805799339 +9787805799575 +9787805799926 +9787805800219 +9787805800318 +9787805800523 +9787805800707 +9787805800790 +9787805801087 +9787805801742 +9787805801865 +9787805801896 +9787805802909 +9787805802947 +9787805802985 +9787805803258 +9787805803272 +9787805803326 +9787805803494 +9787805803500 +9787805804040 +9787805804095 +9787805804101 +9787805804460 +9787805804774 +9787805804811 +9787805804835 +9787805805252 +9787805805443 +9787805806303 +9787805806365 +9787805807546 +9787805807904 +9787805807911 +9787805807928 +9787805808888 +9787805809496 +9787805809526 +9787805809533 +9787805809618 +9787805815206 +9787805819068 +9787805819136 +9787805819617 +9787805820118 +9787805820200 +9787805820293 +9787805821139 +9787805821375 +9787805821528 +9787805821801 +9787805821955 +9787805821962 +9787805822013 +9787805824659 +9787805824772 +9787805825267 +9787805825298 +9787805825601 +9787805825649 +9787805825816 +9787805826387 +9787805826615 +9787805826622 +9787805826639 +9787805827131 +9787805827353 +9787805827360 +9787805827377 +9787805827568 +9787805828602 +9787805828640 +9787805828671 +9787805828718 +9787805829029 +9787805829197 +9787805829272 +9787805829487 +9787805834085 +9787805834931 +9787805836959 +9787805837024 +9787805840420 +9787805840512 +9787805840567 +9787805841229 +9787805841670 +9787805841809 +9787805842172 +9787805843377 +9787805844213 +9787805844268 +9787805844282 +9787805844299 +9787805845463 +9787805845548 +9787805845982 +9787805846484 +9787805847290 +9787805847764 +9787805860251 +9787805860695 +9787805861869 +9787805864150 +9787805864457 +9787805864952 +9787805865102 +9787805865201 +9787805865317 +9787805865362 +9787805865607 +9787805865980 +9787805866901 +9787805866963 +9787805867168 +9787805868295 +9787805868417 +9787805868622 +9787805869308 +9787805869360 +9787805870175 +9787805871066 +9787805871301 +9787805871394 +9787805871424 +9787805871493 +9787805871509 +9787805871578 +9787805871592 +9787805871608 +9787805871639 +9787805871677 +9787805871684 +9787805871882 +9787805872056 +9787805872070 +9787805872285 +9787805872384 +9787805872469 +9787805872551 +9787805872605 +9787805872681 +9787805872773 +9787805872780 +9787805872797 +9787805872841 +9787805872889 +9787805872919 +9787805873121 +9787805873374 +9787805873381 +9787805873404 +9787805873527 +9787805873558 +9787805873787 +9787805873794 +9787805873800 +9787805873886 +9787805874043 +9787805874265 +9787805874289 +9787805874319 +9787805874333 +9787805874425 +9787805874951 +9787805875088 +9787805875095 +9787805875149 +9787805875224 +9787805875330 +9787805875385 +9787805875392 +9787805875408 +9787805875477 +9787805875743 +9787805876153 +9787805876382 +9787805876412 +9787805876511 +9787805876535 +9787805877020 +9787805877358 +9787805877952 +9787805878720 +9787805879499 +9787805879598 +9787805880037 +9787805880426 +9787805880624 +9787805880716 +9787805880860 +9787805880884 +9787805881089 +9787805881102 +9787805881324 +9787805881409 +9787805881539 +9787805881706 +9787805882185 +9787805882338 +9787805882710 +9787805882727 +9787805883083 +9787805883335 +9787805883496 +9787805883502 +9787805883885 +9787805884103 +9787805884516 +9787805884851 +9787805884899 +9787805884950 +9787805885247 +9787805885384 +9787805885773 +9787805887135 +9787805887173 +9787805888217 +9787805889245 +9787805890265 +9787805890326 +9787805890395 +9787805890982 +9787805891552 +9787805891712 +9787805891736 +9787805892153 +9787805892184 +9787805892221 +9787805892283 +9787805893204 +9787805893211 +9787805893228 +9787805899015 +9787805899886 +9787805900117 +9787805900469 +9787805901114 +9787805901343 +9787805901374 +9787805901411 +9787805901541 +9787805901695 +9787805901787 +9787805901879 +9787805901992 +9787805902098 +9787805902111 +9787805902166 +9787805902333 +9787805902364 +9787805902524 +9787805902548 +9787805902593 +9787805902722 +9787805902753 +9787805902807 +9787805903040 +9787805903071 +9787805903095 +9787805903101 +9787805903231 +9787805903248 +9787805903408 +9787805903415 +9787805903453 +9787805903514 +9787805903545 +9787805903835 +9787805903996 +9787805904047 +9787805904276 +9787805904665 +9787805904672 +9787805904740 +9787805904764 +9787805904801 +9787805904887 +9787805904900 +9787805905006 +9787805905013 +9787805905136 +9787805905556 +9787805905570 +9787805905631 +9787805905815 +9787805905891 +9787805906041 +9787805906355 +9787805906416 +9787805906485 +9787805906553 +9787805907185 +9787805907277 +9787805907284 +9787805907321 +9787805907598 +9787805907703 +9787805907710 +9787805907833 +9787805907857 +9787805907925 +9787805907956 +9787805907963 +9787805908045 +9787805908137 +9787805908250 +9787805908649 +9787805908663 +9787805909189 +9787805909905 +9787805910017 +9787805910109 +9787805910444 +9787805910482 +9787805910499 +9787805910550 +9787805910758 +9787805910789 +9787805910956 +9787805910987 +9787805920658 +9787805921006 +9787805921082 +9787805921310 +9787805921815 +9787805921969 +9787805921976 +9787805922003 +9787805922010 +9787805922058 +9787805922171 +9787805922201 +9787805922331 +9787805922362 +9787805922379 +9787805922409 +9787805922515 +9787805922553 +9787805922577 +9787805922683 +9787805922720 +9787805923178 +9787805923253 +9787805923277 +9787805923345 +9787805923475 +9787805923505 +9787805923543 +9787805923758 +9787805923789 +9787805923864 +9787805924199 +9787805924250 +9787805924397 +9787805924465 +9787805924663 +9787805924809 +9787805924830 +9787805925219 +9787805925240 +9787805925318 +9787805925349 +9787805925356 +9787805925424 +9787805925509 +9787805925516 +9787805925585 +9787805925684 +9787805925714 +9787805925721 +9787805925769 +9787805925813 +9787805925929 +9787805926032 +9787805926100 +9787805926292 +9787805926438 +9787805926490 +9787805926681 +9787805926872 +9787805927077 +9787805927138 +9787805927305 +9787805928234 +9787805928371 +9787805929217 +9787805929330 +9787805929453 +9787805929576 +9787805929705 +9787805930039 +9787805930183 +9787805930350 +9787805930718 +9787805930794 +9787805931227 +9787805931432 +9787805931449 +9787805931500 +9787805931791 +9787805931852 +9787805932262 +9787805932682 +9787805933023 +9787805934167 +9787805935263 +9787805937632 +9787805937823 +9787805937946 +9787805938424 +9787805938448 +9787805938981 +9787805939063 +9787805940175 +9787805940199 +9787805941004 +9787805941202 +9787805941844 +9787805941912 +9787805941967 +9787805942346 +9787805942773 +9787805943633 +9787805944548 +9787805945088 +9787805945644 +9787805946184 +9787805946405 +9787805947709 +9787805947723 +9787805947976 +9787805949345 +9787805949598 +9787805950082 +9787805951034 +9787805951119 +9787805951362 +9787805951379 +9787805951515 +9787805951539 +9787805951676 +9787805951775 +9787805951867 +9787805951904 +9787805951942 +9787805952093 +9787805952192 +9787805952260 +9787805952277 +9787805952321 +9787805952338 +9787805952345 +9787805952352 +9787805952390 +9787805952420 +9787805952444 +9787805952482 +9787805952598 +9787805952635 +9787805952642 +9787805952666 +9787805952802 +9787805952895 +9787805952970 +9787805952987 +9787805953014 +9787805953021 +9787805953076 +9787805953205 +9787805953359 +9787805953434 +9787805953533 +9787805953564 +9787805953694 +9787805953809 +9787805954004 +9787805954059 +9787805954066 +9787805954172 +9787805954233 +9787805954264 +9787805954547 +9787805954554 +9787805954660 +9787805954707 +9787805954738 +9787805954820 +9787805954851 +9787805954875 +9787805954929 +9787805954967 +9787805954974 +9787805954981 +9787805955018 +9787805955131 +9787805955209 +9787805955278 +9787805955285 +9787805955315 +9787805955322 +9787805955377 +9787805955391 +9787805955568 +9787805955605 +9787805955742 +9787805955759 +9787805955766 +9787805955773 +9787805955858 +9787805956053 +9787805956169 +9787805956282 +9787805956527 +9787805956534 +9787805956572 +9787805956657 +9787805956701 +9787805956732 +9787805956800 +9787805956824 +9787805956862 +9787805956916 +9787805956961 +9787805956985 +9787805957012 +9787805957111 +9787805957180 +9787805957234 +9787805957241 +9787805957265 +9787805957289 +9787805957319 +9787805957333 +9787805957425 +9787805957494 +9787805957531 +9787805957555 +9787805957562 +9787805957609 +9787805957616 +9787805957623 +9787805957739 +9787805957777 +9787805957814 +9787805957821 +9787805957838 +9787805957852 +9787805957876 +9787805957883 +9787805957890 +9787805957906 +9787805957913 +9787805957937 +9787805957975 +9787805957999 +9787805958002 +9787805958033 +9787805958057 +9787805958088 +9787805958095 +9787805958163 +9787805958224 +9787805958231 +9787805958255 +9787805958279 +9787805958286 +9787805958309 +9787805958446 +9787805958484 +9787805958538 +9787805958545 +9787805958590 +9787805958606 +9787805958644 +9787805958675 +9787805958682 +9787805958699 +9787805958705 +9787805958712 +9787805958873 +9787805958958 +9787805959016 +9787805959061 +9787805959108 +9787805959184 +9787805959252 +9787805959320 +9787805959337 +9787805959405 +9787805959412 +9787805959443 +9787805959528 +9787805959535 +9787805959566 +9787805959573 +9787805959580 +9787805959634 +9787805959641 +9787805959665 +9787805959696 +9787805959795 +9787805959801 +9787805959832 +9787805959856 +9787805959894 +9787805959924 +9787805960432 +9787805962603 +9787805962887 +9787805963112 +9787805963488 +9787805964195 +9787805964416 +9787805965376 +9787805967677 +9787805967684 +9787805967707 +9787805970615 +9787805971247 +9787805971933 +9787805972626 +9787805973012 +9787805973906 +9787805973968 +9787805974033 +9787805974057 +9787805974767 +9787805975399 +9787805975559 +9787805975566 +9787805975894 +9787805976259 +9787805976501 +9787805976617 +9787805976730 +9787805976747 +9787805977065 +9787805977249 +9787805977683 +9787805977690 +9787805978291 +9787805978475 +9787805979397 +9787805979793 +9787805980515 +9787805980539 +9787805980553 +9787805980706 +9787805980768 +9787805980898 +9787805980928 +9787805980997 +9787805981178 +9787805981192 +9787805981222 +9787805981260 +9787805981277 +9787805981406 +9787805981505 +9787805981741 +9787805981772 +9787805981802 +9787805981840 +9787805981864 +9787805981871 +9787805982045 +9787805982083 +9787805982090 +9787805982274 +9787805982373 +9787805982472 +9787805982687 +9787805982717 +9787805982731 +9787805982816 +9787805982830 +9787805982977 +9787805982984 +9787805983097 +9787805983226 +9787805983240 +9787805983271 +9787805983530 +9787805983691 +9787805983851 +9787805983936 +9787805984025 +9787805984117 +9787805984155 +9787805984353 +9787805984506 +9787805984728 +9787805984834 +9787805984971 +9787805985169 +9787805985190 +9787805985305 +9787805985695 +9787805986104 +9787805986210 +9787805986333 +9787805986432 +9787805986746 +9787805986906 +9787805986920 +9787805986944 +9787805987071 +9787805987293 +9787805987927 +9787805987972 +9787805988092 +9787805988207 +9787805988269 +9787805988382 +9787805988696 +9787805988726 +9787805988795 +9787805989624 +9787805989662 +9787805990101 +9787805990835 +9787805991146 +9787805991597 +9787805991849 +9787805991993 +9787805992112 +9787805992792 +9787805992938 +9787805993256 +9787805993263 +9787805993355 +9787805993584 +9787805993805 +9787805993867 +9787805994284 +9787805994413 +9787805994710 +9787805994727 +9787805994758 +9787805994772 +9787805994789 +9787805994802 +9787805994833 +9787805994840 +9787805995144 +9787805995298 +9787805995304 +9787805995526 +9787805995632 +9787805995656 +9787805995663 +9787805995670 +9787805995694 +9787805995717 +9787805995748 +9787805995779 +9787805995786 +9787805995830 +9787805995861 +9787805995878 +9787805995908 +9787805995915 +9787805996127 +9787805996349 +9787805996400 +9787805996448 +9787805996622 +9787805996639 +9787805996714 +9787805996721 +9787805996745 +9787805996752 +9787805996882 +9787805997612 +9787805997643 +9787805997797 +9787805998633 +9787805999180 +9787805999319 +9787805999326 +9787805999364 +9787805999371 +9787805999814 +9787805999968 +9787805999982 +9787806000182 +9787806000281 +9787806000922 +9787806000977 +9787806001127 +9787806001165 +9787806001264 +9787806001806 +9787806002063 +9787806002209 +9787806002384 +9787806002407 +9787806003015 +9787806003107 +9787806003350 +9787806003572 +9787806003602 +9787806003695 +9787806003992 +9787806004463 +9787806004470 +9787806004487 +9787806004500 +9787806004777 +9787806004883 +9787806004890 +9787806004913 +9787806005200 +9787806005316 +9787806005583 +9787806005668 +9787806005927 +9787806006122 +9787806006221 +9787806006405 +9787806006429 +9787806006634 +9787806006917 +9787806006979 +9787806007129 +9787806007235 +9787806007365 +9787806007389 +9787806007570 +9787806008102 +9787806008119 +9787806008140 +9787806008287 +9787806008393 +9787806008522 +9787806009123 +9787806010044 +9787806010099 +9787806010280 +9787806010297 +9787806010686 +9787806010976 +9787806011614 +9787806011713 +9787806012178 +9787806012581 +9787806012673 +9787806012925 +9787806012949 +9787806013137 +9787806013236 +9787806013274 +9787806013366 +9787806013373 +9787806013441 +9787806013496 +9787806013731 +9787806014004 +9787806014424 +9787806014684 +9787806015056 +9787806015476 +9787806015520 +9787806015827 +9787806016169 +9787806016213 +9787806016244 +9787806016442 +9787806016503 +9787806017203 +9787806017876 +9787806018262 +9787806018675 +9787806018743 +9787806019122 +9787806019313 +9787806019498 +9787806019535 +9787806020869 +9787806021262 +9787806021361 +9787806021552 +9787806021569 +9787806022511 +9787806022702 +9787806022917 +9787806025314 +9787806026496 +9787806026809 +9787806028209 +9787806028605 +9787806028650 +9787806028711 +9787806029039 +9787806029206 +9787806029404 +9787806030011 +9787806030127 +9787806030158 +9787806030202 +9787806030219 +9787806030240 +9787806030486 +9787806030493 +9787806030509 +9787806030738 +9787806030967 +9787806031155 +9787806031285 +9787806031537 +9787806031544 +9787806031858 +9787806031872 +9787806031889 +9787806031926 +9787806031957 +9787806032169 +9787806032206 +9787806032275 +9787806032312 +9787806033067 +9787806033111 +9787806033548 +9787806033715 +9787806033975 +9787806034040 +9787806034224 +9787806034316 +9787806034484 +9787806034538 +9787806034651 +9787806035542 +9787806035658 +9787806035733 +9787806035771 +9787806035788 +9787806036037 +9787806036112 +9787806036143 +9787806036228 +9787806036273 +9787806036440 +9787806036594 +9787806036716 +9787806036808 +9787806036839 +9787806036877 +9787806036884 +9787806036983 +9787806037362 +9787806037997 +9787806038338 +9787806039045 +9787806040331 +9787806040362 +9787806040478 +9787806041109 +9787806041277 +9787806041505 +9787806041772 +9787806041864 +9787806041901 +9787806042076 +9787806042205 +9787806042243 +9787806042267 +9787806042311 +9787806042410 +9787806042526 +9787806042533 +9787806042540 +9787806042588 +9787806042670 +9787806042816 +9787806042830 +9787806042854 +9787806042922 +9787806043523 +9787806043592 +9787806043905 +9787806043974 +9787806044087 +9787806044407 +9787806044445 +9787806044643 +9787806044650 +9787806045060 +9787806045831 +9787806045855 +9787806045862 +9787806045916 +9787806045923 +9787806046234 +9787806046296 +9787806046463 +9787806046678 +9787806046685 +9787806046692 +9787806046715 +9787806046753 +9787806046760 +9787806046920 +9787806046982 +9787806047323 +9787806047668 +9787806048047 +9787806048108 +9787806048146 +9787806048436 +9787806048474 +9787806048535 +9787806048740 +9787806048764 +9787806049020 +9787806049167 +9787806049174 +9787806049181 +9787806049365 +9787806049457 +9787806049679 +9787806049730 +9787806050163 +9787806050248 +9787806050262 +9787806050279 +9787806050378 +9787806050392 +9787806050460 +9787806050484 +9787806050507 +9787806050514 +9787806050521 +9787806050538 +9787806050613 +9787806050651 +9787806050705 +9787806050750 +9787806050804 +9787806050835 +9787806050910 +9787806050934 +9787806051030 +9787806051061 +9787806051184 +9787806051245 +9787806051351 +9787806051375 +9787806051597 +9787806051658 +9787806051719 +9787806051733 +9787806051771 +9787806051894 +9787806051931 +9787806051948 +9787806051962 +9787806051986 +9787806051993 +9787806052006 +9787806052099 +9787806052150 +9787806052167 +9787806052198 +9787806052266 +9787806052273 +9787806052280 +9787806052327 +9787806052334 +9787806052341 +9787806052358 +9787806052372 +9787806052426 +9787806052495 +9787806052501 +9787806052679 +9787806052686 +9787806052709 +9787806052716 +9787806052723 +9787806052730 +9787806052754 +9787806052785 +9787806052907 +9787806053027 +9787806053034 +9787806053065 +9787806053072 +9787806053119 +9787806053133 +9787806053232 +9787806053263 +9787806053294 +9787806053317 +9787806053324 +9787806053348 +9787806053362 +9787806053379 +9787806053577 +9787806053614 +9787806053768 +9787806053867 +9787806053874 +9787806053898 +9787806053935 +9787806053959 +9787806053980 +9787806054048 +9787806054062 +9787806054086 +9787806054093 +9787806054178 +9787806054192 +9787806054208 +9787806054215 +9787806054239 +9787806054406 +9787806054413 +9787806054444 +9787806054505 +9787806054529 +9787806054550 +9787806054727 +9787806054758 +9787806054765 +9787806054796 +9787806054826 +9787806054833 +9787806054994 +9787806055168 +9787806055175 +9787806055182 +9787806055205 +9787806055212 +9787806055236 +9787806055250 +9787806055441 +9787806055465 +9787806055472 +9787806055489 +9787806055571 +9787806056561 +9787806056806 +9787806056813 +9787806056950 +9787806056974 +9787806057131 +9787806057247 +9787806057261 +9787806057308 +9787806057315 +9787806057339 +9787806057353 +9787806057452 +9787806057483 +9787806057506 +9787806058251 +9787806058299 +9787806058466 +9787806058558 +9787806058565 +9787806058572 +9787806058589 +9787806058718 +9787806058930 +9787806058961 +9787806059067 +9787806059203 +9787806059340 +9787806059364 +9787806059388 +9787806059500 +9787806059517 +9787806059586 +9787806059616 +9787806059692 +9787806059777 +9787806059791 +9787806059807 +9787806059913 +9787806059937 +9787806059951 +9787806060025 +9787806060186 +9787806060292 +9787806060322 +9787806060339 +9787806060636 +9787806060889 +9787806061541 +9787806061602 +9787806061701 +9787806061749 +9787806061886 +9787806062296 +9787806062470 +9787806062586 +9787806062746 +9787806062784 +9787806062920 +9787806063200 +9787806063248 +9787806063262 +9787806063279 +9787806063309 +9787806063354 +9787806063361 +9787806063484 +9787806063637 +9787806063651 +9787806063835 +9787806063842 +9787806063910 +9787806064030 +9787806064160 +9787806064177 +9787806064221 +9787806064306 +9787806064351 +9787806064368 +9787806064399 +9787806064528 +9787806064535 +9787806064542 +9787806064559 +9787806064580 +9787806064597 +9787806064757 +9787806064818 +9787806064825 +9787806064849 +9787806064894 +9787806064931 +9787806065068 +9787806065112 +9787806065167 +9787806065242 +9787806065327 +9787806065563 +9787806065617 +9787806065655 +9787806065662 +9787806065709 +9787806065716 +9787806065747 +9787806065754 +9787806065860 +9787806065969 +9787806066041 +9787806066058 +9787806066065 +9787806066126 +9787806066430 +9787806066621 +9787806066713 +9787806066768 +9787806066843 +9787806066973 +9787806067000 +9787806067147 +9787806067154 +9787806067161 +9787806067352 +9787806067451 +9787806067499 +9787806067536 +9787806068281 +9787806068441 +9787806068519 +9787806068601 +9787806068731 +9787806068786 +9787806069004 +9787806069813 +9787806070024 +9787806070031 +9787806070048 +9787806070321 +9787806070338 +9787806070345 +9787806070406 +9787806070734 +9787806070970 +9787806071052 +9787806071083 +9787806071090 +9787806071168 +9787806071175 +9787806071434 +9787806071588 +9787806071731 +9787806071755 +9787806071779 +9787806071878 +9787806071946 +9787806072042 +9787806072103 +9787806072110 +9787806072233 +9787806072424 +9787806072752 +9787806072776 +9787806072936 +9787806072943 +9787806073278 +9787806073476 +9787806073841 +9787806073926 +9787806074206 +9787806074213 +9787806074527 +9787806074558 +9787806074589 +9787806074596 +9787806074732 +9787806074848 +9787806074879 +9787806074916 +9787806074930 +9787806074985 +9787806075203 +9787806075210 +9787806075234 +9787806075241 +9787806075258 +9787806075319 +9787806075333 +9787806075647 +9787806075777 +9787806075807 +9787806075814 +9787806075906 +9787806075968 +9787806076057 +9787806076095 +9787806076170 +9787806076262 +9787806076415 +9787806076507 +9787806076651 +9787806076705 +9787806076811 +9787806076842 +9787806076866 +9787806076897 +9787806076958 +9787806077115 +9787806077306 +9787806077405 +9787806077436 +9787806077450 +9787806077511 +9787806077535 +9787806077542 +9787806077702 +9787806077733 +9787806077818 +9787806077887 +9787806077924 +9787806077979 +9787806078273 +9787806078341 +9787806078495 +9787806078594 +9787806078808 +9787806078815 +9787806078877 +9787806078921 +9787806078976 +9787806078983 +9787806079089 +9787806079096 +9787806079737 +9787806079744 +9787806079959 +9787806080313 +9787806080399 +9787806080887 +9787806080917 +9787806081068 +9787806081082 +9787806082331 +9787806083109 +9787806083116 +9787806083536 +9787806083598 +9787806083703 +9787806083710 +9787806083802 +9787806083987 +9787806084311 +9787806084403 +9787806084564 +9787806085233 +9787806085318 +9787806086216 +9787806086766 +9787806087268 +9787806087305 +9787806087367 +9787806087411 +9787806087589 +9787806088005 +9787806088166 +9787806088210 +9787806088265 +9787806088296 +9787806088623 +9787806088760 +9787806089576 +9787806089637 +9787806089682 +9787806089699 +9787806089897 +9787806089927 +9787806090008 +9787806090022 +9787806090077 +9787806090114 +9787806090138 +9787806090183 +9787806090220 +9787806090237 +9787806090251 +9787806090404 +9787806090510 +9787806090534 +9787806090695 +9787806090725 +9787806091005 +9787806091289 +9787806091296 +9787806091319 +9787806091333 +9787806091395 +9787806091432 +9787806091548 +9787806091555 +9787806091654 +9787806091678 +9787806091708 +9787806091784 +9787806092064 +9787806092071 +9787806092200 +9787806092613 +9787806092811 +9787806092859 +9787806092934 +9787806093085 +9787806093306 +9787806093344 +9787806093535 +9787806093603 +9787806093634 +9787806093801 +9787806094471 +9787806094488 +9787806094549 +9787806094686 +9787806094747 +9787806094754 +9787806094778 +9787806094877 +9787806094891 +9787806095492 +9787806095539 +9787806095553 +9787806095614 +9787806096093 +9787806096154 +9787806096161 +9787806096468 +9787806097465 +9787806097533 +9787806097724 +9787806097755 +9787806097809 +9787806097892 +9787806097991 +9787806098028 +9787806098035 +9787806098097 +9787806098219 +9787806098530 +9787806099469 +9787806099834 +9787806099889 +9787806101674 +9787806101971 +9787806102541 +9787806102848 +9787806103043 +9787806103685 +9787806104224 +9787806105290 +9787806105931 +9787806107485 +9787806108215 +9787806108253 +9787806108321 +9787806109632 +9787806109908 +9787806110102 +9787806110119 +9787806110133 +9787806110157 +9787806110188 +9787806110416 +9787806110515 +9787806110591 +9787806110881 +9787806111062 +9787806111086 +9787806111147 +9787806111277 +9787806111369 +9787806111420 +9787806111635 +9787806111666 +9787806111697 +9787806111888 +9787806111970 +9787806112106 +9787806112168 +9787806112236 +9787806112267 +9787806112434 +9787806112496 +9787806112540 +9787806112557 +9787806112762 +9787806112793 +9787806112830 +9787806112854 +9787806112885 +9787806112991 +9787806113004 +9787806113158 +9787806113172 +9787806113493 +9787806113592 +9787806113721 +9787806113929 +9787806113950 +9787806114094 +9787806114148 +9787806114155 +9787806114315 +9787806114421 +9787806114483 +9787806114667 +9787806114711 +9787806114919 +9787806114926 +9787806115039 +9787806115220 +9787806115244 +9787806115855 +9787806115879 +9787806115916 +9787806116128 +9787806116302 +9787806116395 +9787806116470 +9787806116586 +9787806116654 +9787806116807 +9787806117323 +9787806117354 +9787806118177 +9787806118498 +9787806118726 +9787806119112 +9787806119327 +9787806119631 +9787806120286 +9787806120293 +9787806120538 +9787806120545 +9787806120552 +9787806120897 +9787806121078 +9787806121139 +9787806121405 +9787806121412 +9787806121429 +9787806121702 +9787806121894 +9787806122150 +9787806122464 +9787806122778 +9787806122792 +9787806122860 +9787806122983 +9787806123386 +9787806124628 +9787806124697 +9787806124956 +9787806125106 +9787806127070 +9787806127117 +9787806127957 +9787806128152 +9787806128671 +9787806130018 +9787806130087 +9787806130131 +9787806130261 +9787806130513 +9787806130520 +9787806130636 +9787806130674 +9787806130698 +9787806130957 +9787806131015 +9787806131121 +9787806131992 +9787806132203 +9787806132258 +9787806132494 +9787806133637 +9787806133644 +9787806134115 +9787806135310 +9787806136928 +9787806138069 +9787806138236 +9787806139417 +9787806139936 +9787806140000 +9787806140017 +9787806140260 +9787806140970 +9787806141694 +9787806142226 +9787806142424 +9787806142806 +9787806144596 +9787806145180 +9787806145692 +9787806145975 +9787806146002 +9787806146057 +9787806146132 +9787806146934 +9787806148112 +9787806148310 +9787806149010 +9787806150184 +9787806150481 +9787806150559 +9787806150702 +9787806150856 +9787806150962 +9787806151082 +9787806151181 +9787806151402 +9787806151440 +9787806151679 +9787806151808 +9787806152119 +9787806152478 +9787806152669 +9787806152683 +9787806152713 +9787806152720 +9787806152942 +9787806153048 +9787806153086 +9787806153390 +9787806153512 +9787806153703 +9787806153789 +9787806153888 +9787806154076 +9787806154434 +9787806154670 +9787806154731 +9787806154915 +9787806154977 +9787806154991 +9787806155042 +9787806155295 +9787806156346 +9787806156490 +9787806156810 +9787806157251 +9787806157312 +9787806157510 +9787806157640 +9787806157930 +9787806157954 +9787806157978 +9787806158067 +9787806158425 +9787806158579 +9787806158593 +9787806159262 +9787806159460 +9787806159477 +9787806159989 +9787806160305 +9787806160527 +9787806160534 +9787806160817 +9787806160831 +9787806160848 +9787806160855 +9787806161098 +9787806161487 +9787806161494 +9787806161661 +9787806161883 +9787806161906 +9787806161951 +9787806162095 +9787806162101 +9787806162118 +9787806162194 +9787806162309 +9787806162477 +9787806162484 +9787806162705 +9787806162736 +9787806162774 +9787806162866 +9787806162873 +9787806162910 +9787806163146 +9787806163177 +9787806163368 +9787806163764 +9787806163801 +9787806164198 +9787806164242 +9787806164273 +9787806164358 +9787806164389 +9787806164433 +9787806164471 +9787806164655 +9787806164938 +9787806164990 +9787806165102 +9787806165591 +9787806165645 +9787806165669 +9787806166178 +9787806166239 +9787806166468 +9787806166499 +9787806166598 +9787806167212 +9787806167243 +9787806167373 +9787806167380 +9787806167632 +9787806167786 +9787806167823 +9787806167953 +9787806168158 +9787806168363 +9787806168387 +9787806168479 +9787806168608 +9787806168653 +9787806168691 +9787806168738 +9787806168837 +9787806169018 +9787806169025 +9787806169094 +9787806169377 +9787806169636 +9787806169667 +9787806169704 +9787806169735 +9787806169957 +9787806170212 +9787806170557 +9787806170601 +9787806170793 +9787806170830 +9787806170977 +9787806171455 +9787806171806 +9787806171905 +9787806171929 +9787806172025 +9787806172087 +9787806172414 +9787806172568 +9787806172575 +9787806172681 +9787806172759 +9787806172766 +9787806172773 +9787806172926 +9787806173022 +9787806173039 +9787806173145 +9787806173367 +9787806173756 +9787806173770 +9787806173787 +9787806173800 +9787806174098 +9787806174104 +9787806174128 +9787806174135 +9787806174166 +9787806174333 +9787806174357 +9787806174500 +9787806174524 +9787806174555 +9787806174647 +9787806175507 +9787806176122 +9787806176429 +9787806176498 +9787806177020 +9787806177235 +9787806177358 +9787806177372 +9787806177464 +9787806179031 +9787806179116 +9787806179147 +9787806179321 +9787806179642 +9787806179666 +9787806179802 +9787806179840 +9787806179925 +9787806179963 +9787806180556 +9787806180860 +9787806180891 +9787806181041 +9787806181317 +9787806181928 +9787806181966 +9787806182192 +9787806182277 +9787806182284 +9787806182307 +9787806182932 +9787806183069 +9787806183502 +9787806183779 +9787806183786 +9787806183793 +9787806183809 +9787806183847 +9787806183854 +9787806183878 +9787806184158 +9787806184370 +9787806184615 +9787806184844 +9787806185476 +9787806185537 +9787806185568 +9787806185575 +9787806185773 +9787806186039 +9787806186169 +9787806186183 +9787806186268 +9787806186282 +9787806186336 +9787806186794 +9787806186886 +9787806186909 +9787806187302 +9787806187388 +9787806187395 +9787806187562 +9787806187609 +9787806188125 +9787806188200 +9787806189009 +9787806189689 +9787806189931 +9787806190951 +9787806191361 +9787806192610 +9787806193211 +9787806193921 +9787806194485 +9787806194584 +9787806195031 +9787806195550 +9787806196656 +9787806197189 +9787806197622 +9787806197936 +9787806198261 +9787806198322 +9787806198773 +9787806198803 +9787806198834 +9787806198865 +9787806198964 +9787806198995 +9787806199350 +9787806199527 +9787806200001 +9787806201268 +9787806201329 +9787806201794 +9787806202258 +9787806202890 +9787806203972 +9787806204467 +9787806208144 +9787806211281 +9787806211489 +9787806211991 +9787806212066 +9787806212271 +9787806214480 +9787806214534 +9787806214893 +9787806215005 +9787806215562 +9787806220085 +9787806220269 +9787806220368 +9787806220511 +9787806220542 +9787806220634 +9787806220641 +9787806220658 +9787806220665 +9787806221051 +9787806221075 +9787806221082 +9787806221198 +9787806221365 +9787806221501 +9787806221563 +9787806221631 +9787806221761 +9787806221778 +9787806221792 +9787806221839 +9787806221877 +9787806221891 +9787806221907 +9787806221914 +9787806221921 +9787806222096 +9787806222133 +9787806222171 +9787806222188 +9787806222300 +9787806222478 +9787806222553 +9787806222577 +9787806222607 +9787806222614 +9787806222669 +9787806222935 +9787806222966 +9787806223000 +9787806223093 +9787806223383 +9787806223505 +9787806223536 +9787806223543 +9787806223550 +9787806223628 +9787806223680 +9787806223956 +9787806224052 +9787806224182 +9787806224212 +9787806224311 +9787806224328 +9787806224526 +9787806224540 +9787806224601 +9787806224779 +9787806224809 +9787806225028 +9787806225059 +9787806225103 +9787806225240 +9787806225370 +9787806225400 +9787806225530 +9787806225561 +9787806225820 +9787806225851 +9787806225967 +9787806225998 +9787806226056 +9787806226063 +9787806226117 +9787806226575 +9787806226667 +9787806226957 +9787806226971 +9787806227022 +9787806227107 +9787806227435 +9787806227442 +9787806227640 +9787806227657 +9787806227763 +9787806227787 +9787806227794 +9787806227947 +9787806227954 +9787806227978 +9787806228050 +9787806228227 +9787806228234 +9787806228418 +9787806228500 +9787806228531 +9787806228555 +9787806228845 +9787806229200 +9787806229224 +9787806229255 +9787806229330 +9787806229378 +9787806229446 +9787806229538 +9787806229644 +9787806230015 +9787806230022 +9787806230039 +9787806230206 +9787806230213 +9787806230220 +9787806230251 +9787806230299 +9787806230572 +9787806230589 +9787806230701 +9787806231043 +9787806231067 +9787806231289 +9787806231296 +9787806231302 +9787806231838 +9787806231845 +9787806232026 +9787806232200 +9787806232439 +9787806232699 +9787806232842 +9787806233160 +9787806233184 +9787806233412 +9787806234334 +9787806234570 +9787806235102 +9787806236024 +9787806236055 +9787806236307 +9787806236604 +9787806236680 +9787806236895 +9787806237496 +9787806237540 +9787806237588 +9787806237632 +9787806237823 +9787806238776 +9787806238981 +9787806239001 +9787806240342 +9787806240458 +9787806240472 +9787806240809 +9787806240816 +9787806240885 +9787806241240 +9787806241288 +9787806241332 +9787806241929 +9787806242186 +9787806242490 +9787806242520 +9787806242810 +9787806243459 +9787806243619 +9787806243831 +9787806245385 +9787806247396 +9787806249352 +9787806249369 +9787806249383 +9787806249482 +9787806250846 +9787806251065 +9787806251560 +9787806251812 +9787806251836 +9787806251874 +9787806252031 +9787806252666 +9787806252895 +9787806253069 +9787806253076 +9787806253120 +9787806253137 +9787806253373 +9787806253540 +9787806253557 +9787806253755 +9787806253939 +9787806254394 +9787806254417 +9787806254462 +9787806254479 +9787806254509 +9787806254622 +9787806254684 +9787806254691 +9787806254738 +9787806254745 +9787806254752 +9787806254820 +9787806255537 +9787806255728 +9787806255858 +9787806256220 +9787806256237 +9787806256381 +9787806256749 +9787806256831 +9787806256992 +9787806257067 +9787806257074 +9787806257081 +9787806257470 +9787806257692 +9787806257777 +9787806258569 +9787806258798 +9787806258880 +9787806259078 +9787806259658 +9787806259689 +9787806259740 +9787806260173 +9787806260203 +9787806260227 +9787806260302 +9787806260388 +9787806260418 +9787806260425 +9787806260517 +9787806260920 +9787806260975 +9787806261002 +9787806261088 +9787806261125 +9787806261187 +9787806261224 +9787806261231 +9787806261255 +9787806261262 +9787806261316 +9787806261385 +9787806261484 +9787806261514 +9787806261569 +9787806261606 +9787806261620 +9787806261651 +9787806261729 +9787806261743 +9787806261781 +9787806261873 +9787806262030 +9787806262283 +9787806262436 +9787806262535 +9787806262597 +9787806262627 +9787806262825 +9787806262955 +9787806263075 +9787806263327 +9787806263518 +9787806263549 +9787806263556 +9787806263778 +9787806263945 +9787806264164 +9787806264171 +9787806264256 +9787806264409 +9787806264423 +9787806264591 +9787806264621 +9787806264850 +9787806264898 +9787806264904 +9787806264928 +9787806264935 +9787806264942 +9787806264980 +9787806265055 +9787806265147 +9787806265161 +9787806265208 +9787806265383 +9787806265567 +9787806266335 +9787806266465 +9787806267042 +9787806267462 +9787806267523 +9787806268308 +9787806268582 +9787806269749 +9787806270103 +9787806270127 +9787806270158 +9787806270172 +9787806270196 +9787806270219 +9787806270226 +9787806270325 +9787806270332 +9787806270363 +9787806270370 +9787806270578 +9787806270615 +9787806270707 +9787806270769 +9787806270851 +9787806270912 +9787806270929 +9787806270943 +9787806270950 +9787806270981 +9787806271018 +9787806271216 +9787806271667 +9787806271742 +9787806271896 +9787806271971 +9787806272022 +9787806272077 +9787806272084 +9787806272091 +9787806272282 +9787806272299 +9787806272336 +9787806272473 +9787806272541 +9787806272701 +9787806273333 +9787806273586 +9787806273630 +9787806273715 +9787806273982 +9787806274095 +9787806274262 +9787806274439 +9787806274569 +9787806274613 +9787806275054 +9787806275344 +9787806275726 +9787806275825 +9787806276730 +9787806277843 +9787806278888 +9787806280034 +9787806280256 +9787806280447 +9787806281109 +9787806281222 +9787806281499 +9787806281789 +9787806282014 +9787806282076 +9787806282083 +9787806282779 +9787806283219 +9787806283318 +9787806283424 +9787806283523 +9787806283547 +9787806283653 +9787806283660 +9787806283691 +9787806283943 +9787806284179 +9787806284209 +9787806284537 +9787806284698 +9787806284803 +9787806285060 +9787806287248 +9787806287491 +9787806287545 +9787806287712 +9787806287910 +9787806288696 +9787806288894 +9787806288948 +9787806288962 +9787806288986 +9787806289914 +9787806290477 +9787806291115 +9787806291214 +9787806293799 +9787806294086 +9787806294277 +9787806295397 +9787806297834 +9787806298763 +9787806299203 +9787806300084 +9787806300138 +9787806300282 +9787806300312 +9787806300428 +9787806300459 +9787806300565 +9787806300794 +9787806301135 +9787806301166 +9787806301173 +9787806301272 +9787806301555 +9787806301715 +9787806301913 +9787806301982 +9787806302071 +9787806302088 +9787806302200 +9787806302651 +9787806302668 +9787806303351 +9787806303542 +9787806303573 +9787806303603 +9787806303764 +9787806303955 +9787806304402 +9787806304556 +9787806305102 +9787806305621 +9787806305645 +9787806306239 +9787806306574 +9787806307434 +9787806307458 +9787806307861 +9787806307915 +9787806308158 +9787806309667 +9787806309728 +9787806310281 +9787806310335 +9787806310342 +9787806310366 +9787806311240 +9787806311592 +9787806314685 +9787806316917 +9787806316993 +9787806317853 +9787806319109 +9787806319826 +9787806320082 +9787806320112 +9787806320334 +9787806320433 +9787806320587 +9787806320976 +9787806321591 +9787806321751 +9787806321805 +9787806321867 +9787806321959 +9787806322086 +9787806322130 +9787806322475 +9787806322567 +9787806322574 +9787806322598 +9787806322796 +9787806322833 +9787806323120 +9787806323175 +9787806323496 +9787806323953 +9787806325247 +9787806325285 +9787806325681 +9787806325728 +9787806325742 +9787806325759 +9787806325780 +9787806326947 +9787806327371 +9787806327739 +9787806328446 +9787806328491 +9787806328507 +9787806328866 +9787806329320 +9787806329672 +9787806329849 +9787806330074 +9787806330258 +9787806330456 +9787806330838 +9787806330890 +9787806331002 +9787806331316 +9787806331606 +9787806331958 +9787806332146 +9787806333488 +9787806334362 +9787806334430 +9787806334973 +9787806335017 +9787806335260 +9787806335741 +9787806337165 +9787806337240 +9787806337301 +9787806337325 +9787806337424 +9787806337585 +9787806337592 +9787806337691 +9787806338612 +9787806338667 +9787806338681 +9787806338728 +9787806338742 +9787806338995 +9787806339053 +9787806339237 +9787806339299 +9787806339541 +9787806339701 +9787806339718 +9787806340172 +9787806340202 +9787806340356 +9787806341612 +9787806342305 +9787806342718 +9787806344125 +9787806344835 +9787806348284 +9787806349458 +9787806349533 +9787806349625 +9787806349939 +9787806350126 +9787806350140 +9787806350157 +9787806350324 +9787806351079 +9787806351086 +9787806351093 +9787806351154 +9787806351383 +9787806351437 +9787806351444 +9787806353400 +9787806353516 +9787806353622 +9787806353646 +9787806353981 +9787806355138 +9787806355169 +9787806355176 +9787806355411 +9787806356142 +9787806356784 +9787806356814 +9787806356906 +9787806357255 +9787806358009 +9787806358085 +9787806358146 +9787806358252 +9787806359198 +9787806359396 +9787806360736 +9787806360989 +9787806361030 +9787806362372 +9787806362570 +9787806362617 +9787806362723 +9787806363201 +9787806364505 +9787806365311 +9787806366264 +9787806366585 +9787806366653 +9787806366851 +9787806367087 +9787806367568 +9787806367704 +9787806367735 +9787806367803 +9787806369487 +9787806370025 +9787806370735 +9787806370872 +9787806370971 +9787806370995 +9787806371008 +9787806383476 +9787806387023 +9787806387061 +9787806387740 +9787806388075 +9787806388532 +9787806388679 +9787806388969 +9787806389089 +9787806389157 +9787806389669 +9787806389799 +9787806390009 +9787806390696 +9787806390719 +9787806391204 +9787806391228 +9787806391402 +9787806391501 +9787806391563 +9787806391822 +9787806391891 +9787806392393 +9787806392720 +9787806392799 +9787806392812 +9787806393093 +9787806393147 +9787806393154 +9787806393161 +9787806393239 +9787806393338 +9787806393406 +9787806393420 +9787806394168 +9787806394335 +9787806394342 +9787806394380 +9787806394465 +9787806394472 +9787806394885 +9787806395097 +9787806395462 +9787806395677 +9787806395806 +9787806397053 +9787806397367 +9787806397978 +9787806398135 +9787806398647 +9787806399484 +9787806400050 +9787806400586 +9787806400937 +9787806401125 +9787806401200 +9787806401385 +9787806401514 +9787806403297 +9787806403686 +9787806404119 +9787806405833 +9787806405895 +9787806406694 +9787806407035 +9787806407691 +9787806408858 +9787806410028 +9787806410042 +9787806410134 +9787806410967 +9787806411612 +9787806411827 +9787806411889 +9787806411896 +9787806411902 +9787806411919 +9787806411957 +9787806411971 +9787806413036 +9787806413173 +9787806413388 +9787806413401 +9787806413784 +9787806413821 +9787806413999 +9787806414965 +9787806416167 +9787806416570 +9787806417348 +9787806417485 +9787806418659 +9787806420386 +9787806420836 +9787806420843 +9787806422427 +9787806424452 +9787806425831 +9787806426319 +9787806426517 +9787806426814 +9787806427347 +9787806429310 +9787806430323 +9787806430347 +9787806430705 +9787806430736 +9787806430927 +9787806431191 +9787806431290 +9787806431399 +9787806431726 +9787806431832 +9787806431849 +9787806431917 +9787806432037 +9787806432051 +9787806432334 +9787806432402 +9787806432679 +9787806432709 +9787806432747 +9787806432761 +9787806433119 +9787806433133 +9787806433188 +9787806433614 +9787806434055 +9787806434352 +9787806434567 +9787806434772 +9787806435861 +9787806435908 +9787806436455 +9787806436806 +9787806438084 +9787806438992 +9787806440681 +9787806440957 +9787806441466 +9787806441565 +9787806441671 +9787806441688 +9787806441916 +9787806443743 +9787806444436 +9787806444962 +9787806446454 +9787806446775 +9787806447062 +9787806448601 +9787806448762 +9787806449370 +9787806450260 +9787806450277 +9787806450321 +9787806451205 +9787806451229 +9787806451236 +9787806451243 +9787806451410 +9787806451472 +9787806452486 +9787806453940 +9787806454084 +9787806454275 +9787806454312 +9787806454565 +9787806454619 +9787806454770 +9787806454930 +9787806455609 +9787806455838 +9787806455869 +9787806455920 +9787806456347 +9787806456606 +9787806456668 +9787806456804 +9787806456828 +9787806456958 +9787806457269 +9787806457368 +9787806457504 +9787806457535 +9787806457719 +9787806458310 +9787806458488 +9787806459157 +9787806459294 +9787806459522 +9787806459546 +9787806459652 +9787806460146 +9787806460177 +9787806460184 +9787806460207 +9787806460238 +9787806460252 +9787806460399 +9787806460450 +9787806460689 +9787806460955 +9787806461242 +9787806461273 +9787806461402 +9787806461860 +9787806462218 +9787806462416 +9787806462775 +9787806462935 +9787806463468 +9787806463680 +9787806464069 +9787806464854 +9787806465400 +9787806465875 +9787806467985 +9787806468678 +9787806470077 +9787806470671 +9787806470688 +9787806470831 +9787806470923 +9787806471036 +9787806471081 +9787806471449 +9787806471456 +9787806471463 +9787806471777 +9787806471784 +9787806471807 +9787806471920 +9787806472026 +9787806472194 +9787806472347 +9787806472460 +9787806474228 +9787806474440 +9787806475751 +9787806476437 +9787806477120 +9787806477366 +9787806477939 +9787806478110 +9787806478134 +9787806478288 +9787806478349 +9787806478387 +9787806478875 +9787806478899 +9787806479100 +9787806479148 +9787806480052 +9787806480304 +9787806480434 +9787806480496 +9787806480588 +9787806481226 +9787806481233 +9787806481271 +9787806481844 +9787806481981 +9787806482131 +9787806482261 +9787806482278 +9787806482346 +9787806482513 +9787806482568 +9787806482599 +9787806483114 +9787806483329 +9787806483404 +9787806483411 +9787806483442 +9787806483473 +9787806483503 +9787806483626 +9787806483817 +9787806483855 +9787806484258 +9787806484692 +9787806484708 +9787806484715 +9787806484852 +9787806484920 +9787806485125 +9787806485149 +9787806485354 +9787806485729 +9787806485880 +9787806485934 +9787806486160 +9787806486382 +9787806486429 +9787806486597 +9787806486825 +9787806487013 +9787806487020 +9787806487143 +9787806487488 +9787806487587 +9787806488720 +9787806488898 +9787806488935 +9787806489147 +9787806489154 +9787806489673 +9787806490341 +9787806490440 +9787806490839 +9787806490976 +9787806491393 +9787806491454 +9787806491461 +9787806491492 +9787806492062 +9787806492079 +9787806492109 +9787806492413 +9787806492697 +9787806492703 +9787806499917 +9787806500484 +9787806501290 +9787806504680 +9787806510353 +9787806510742 +9787806510964 +9787806511244 +9787806511886 +9787806512265 +9787806512418 +9787806512524 +9787806512593 +9787806512692 +9787806512715 +9787806512722 +9787806513361 +9787806513828 +9787806513903 +9787806514818 +9787806514832 +9787806515242 +9787806515280 +9787806515433 +9787806515532 +9787806515679 +9787806515891 +9787806516478 +9787806517901 +9787806518069 +9787806518359 +9787806518496 +9787806519288 +9787806520017 +9787806520024 +9787806520031 +9787806520130 +9787806520147 +9787806520192 +9787806520208 +9787806520567 +9787806520581 +9787806520994 +9787806521236 +9787806521748 +9787806522448 +9787806522462 +9787806522646 +9787806523490 +9787806523520 +9787806524558 +9787806524664 +9787806525814 +9787806526101 +9787806526309 +9787806526415 +9787806526897 +9787806527115 +9787806527931 +9787806528891 +9787806530207 +9787806530641 +9787806530726 +9787806531228 +9787806531235 +9787806531396 +9787806531662 +9787806531938 +9787806532195 +9787806532287 +9787806532577 +9787806533338 +9787806533444 +9787806533482 +9787806533765 +9787806534090 +9787806535219 +9787806536490 +9787806536506 +9787806536841 +9787806536933 +9787806537152 +9787806537176 +9787806537206 +9787806537275 +9787806537435 +9787806537558 +9787806538852 +9787806538920 +9787806539361 +9787806539880 +9787806540510 +9787806540794 +9787806540855 +9787806540893 +9787806541036 +9787806541326 +9787806541500 +9787806541593 +9787806541814 +9787806541920 +9787806541937 +9787806542385 +9787806542606 +9787806542859 +9787806543108 +9787806543382 +9787806543528 +9787806543542 +9787806543672 +9787806543719 +9787806544082 +9787806544266 +9787806544686 +9787806545058 +9787806545102 +9787806545720 +9787806546222 +9787806546468 +9787806546895 +9787806547540 +9787806547670 +9787806548134 +9787806548202 +9787806548219 +9787806548769 +9787806549216 +9787806549223 +9787806549926 +9787806550014 +9787806550304 +9787806550427 +9787806550502 +9787806550564 +9787806550571 +9787806550588 +9787806550717 +9787806550748 +9787806550786 +9787806550960 +9787806551066 +9787806551172 +9787806551189 +9787806551387 +9787806551660 +9787806551820 +9787806552148 +9787806552483 +9787806552605 +9787806553572 +9787806553633 +9787806553749 +9787806554081 +9787806554302 +9787806554340 +9787806554371 +9787806554920 +9787806555064 +9787806555118 +9787806555200 +9787806555477 +9787806555491 +9787806556177 +9787806556894 +9787806556900 +9787806557242 +9787806557358 +9787806558188 +9787806558539 +9787806563526 +9787806563571 +9787806563687 +9787806564301 +9787806564318 +9787806564394 +9787806565629 +9787806565667 +9787806566084 +9787806567258 +9787806567494 +9787806567999 +9787806570111 +9787806570135 +9787806570197 +9787806570203 +9787806570340 +9787806570432 +9787806570449 +9787806570500 +9787806570548 +9787806570883 +9787806571248 +9787806571286 +9787806571323 +9787806571439 +9787806571743 +9787806571781 +9787806571804 +9787806572276 +9787806572368 +9787806572627 +9787806572962 +9787806573129 +9787806573136 +9787806573846 +9787806573945 +9787806574515 +9787806574942 +9787806575642 +9787806577950 +9787806578032 +9787806578193 +9787806578315 +9787806578698 +9787806578810 +9787806579923 +9787806580530 +9787806580707 +9787806581728 +9787806582794 +9787806583142 +9787806585184 +9787806586679 +9787806587843 +9787806588819 +9787806588925 +9787806590010 +9787806590027 +9787806590072 +9787806590522 +9787806590829 +9787806591468 +9787806591505 +9787806591611 +9787806591697 +9787806592021 +9787806592038 +9787806592090 +9787806592151 +9787806592250 +9787806592359 +9787806592519 +9787806592533 +9787806592649 +9787806592809 +9787806593271 +9787806593561 +9787806593684 +9787806593837 +9787806594155 +9787806594247 +9787806594391 +9787806595411 +9787806595602 +9787806595763 +9787806595787 +9787806595794 +9787806595817 +9787806595985 +9787806597002 +9787806597071 +9787806597095 +9787806597156 +9787806597736 +9787806598092 +9787806598207 +9787806598689 +9787806598733 +9787806599068 +9787806599341 +9787806599457 +9787806600535 +9787806601396 +9787806601655 +9787806601761 +9787806601877 +9787806602065 +9787806602164 +9787806602843 +9787806604502 +9787806605356 +9787806605509 +9787806606278 +9787806606315 +9787806607541 +9787806608326 +9787806609316 +9787806609354 +9787806610367 +9787806610572 +9787806611135 +9787806611319 +9787806611487 +9787806612484 +9787806614327 +9787806615539 +9787806615713 +9787806615966 +9787806616161 +9787806616413 +9787806616451 +9787806617960 +9787806618042 +9787806618509 +9787806619582 +9787806620960 +9787806620984 +9787806621875 +9787806624401 +9787806628300 +9787806628805 +9787806629529 +9787806630099 +9787806630198 +9787806630204 +9787806630471 +9787806630501 +9787806630778 +9787806631133 +9787806631386 +9787806631416 +9787806631591 +9787806631621 +9787806632017 +9787806632734 +9787806632994 +9787806633250 +9787806633403 +9787806633410 +9787806633984 +9787806634080 +9787806634479 +9787806634486 +9787806634646 +9787806634684 +9787806634707 +9787806634967 +9787806635209 +9787806635674 +9787806635759 +9787806635889 +9787806635988 +9787806636374 +9787806636565 +9787806636572 +9787806637210 +9787806637548 +9787806637814 +9787806637845 +9787806638019 +9787806638095 +9787806638132 +9787806638392 +9787806638460 +9787806638705 +9787806638842 +9787806638910 +9787806639023 +9787806639078 +9787806639689 +9787806639771 +9787806639795 +9787806639825 +9787806639986 +9787806640302 +9787806640654 +9787806641026 +9787806641347 +9787806641385 +9787806641996 +9787806642337 +9787806642597 +9787806642689 +9787806642788 +9787806643129 +9787806643167 +9787806643198 +9787806645628 +9787806645697 +9787806645840 +9787806646168 +9787806646243 +9787806646267 +9787806646335 +9787806646540 +9787806648346 +9787806649770 +9787806650158 +9787806650172 +9787806650233 +9787806650424 +9787806650578 +9787806650745 +9787806650752 +9787806650967 +9787806651124 +9787806651162 +9787806651209 +9787806651445 +9787806651902 +9787806652015 +9787806652091 +9787806652404 +9787806652411 +9787806652534 +9787806653418 +9787806653463 +9787806654422 +9787806654989 +9787806656303 +9787806656488 +9787806656532 +9787806657850 +9787806658246 +9787806658376 +9787806658499 +9787806659052 +9787806659120 +9787806659397 +9787806659571 +9787806659717 +9787806659748 +9787806660157 +9787806661666 +9787806661673 +9787806662403 +9787806662618 +9787806668207 +9787806668399 +9787806668580 +9787806668993 +9787806669198 +9787806669532 +9787806670187 +9787806671054 +9787806671108 +9787806671245 +9787806671252 +9787806671269 +9787806672839 +9787806672945 +9787806673249 +9787806673539 +9787806674796 +9787806675489 +9787806675496 +9787806676981 +9787806678138 +9787806678558 +9787806678688 +9787806679470 +9787806680117 +9787806680162 +9787806680223 +9787806680506 +9787806680636 +9787806681213 +9787806681985 +9787806682548 +9787806682623 +9787806682876 +9787806683286 +9787806683309 +9787806683354 +9787806683422 +9787806683866 +9787806684115 +9787806684559 +9787806684658 +9787806684702 +9787806686010 +9787806686072 +9787806686331 +9787806686430 +9787806687697 +9787806688526 +9787806689677 +9787806690468 +9787806691755 +9787806693490 +9787806694114 +9787806695586 +9787806697245 +9787806697429 +9787806699027 +9787806699096 +9787806699614 +9787806702673 +9787806703885 +9787806704448 +9787806707036 +9787806707067 +9787806710913 +9787806710937 +9787806711880 +9787806712757 +9787806714201 +9787806714232 +9787806714485 +9787806715246 +9787806715253 +9787806716861 +9787806717752 +9787806718193 +9787806719336 +9787806719893 +9787806719909 +9787806722398 +9787806722930 +9787806722992 +9787806723036 +9787806723241 +9787806723517 +9787806723531 +9787806723623 +9787806723722 +9787806724248 +9787806724477 +9787806724507 +9787806724644 +9787806724736 +9787806725931 +9787806726396 +9787806726747 +9787806726778 +9787806727737 +9787806728239 +9787806729540 +9787806729823 +9787806730454 +9787806730522 +9787806730539 +9787806730638 +9787806730713 +9787806731383 +9787806732021 +9787806732700 +9787806733677 +9787806734025 +9787806734636 +9787806735183 +9787806735282 +9787806735299 +9787806735305 +9787806735329 +9787806735466 +9787806735718 +9787806735732 +9787806736166 +9787806736463 +9787806736708 +9787806737255 +9787806737514 +9787806737521 +9787806738283 +9787806740217 +9787806740330 +9787806740583 +9787806740989 +9787806741061 +9787806741122 +9787806741344 +9787806741368 +9787806741658 +9787806741856 +9787806741863 +9787806742136 +9787806742150 +9787806742464 +9787806742594 +9787806742860 +9787806743027 +9787806745816 +9787806746219 +9787806746530 +9787806747377 +9787806747384 +9787806747391 +9787806747407 +9787806748350 +9787806749166 +9787806750179 +9787806750223 +9787806750308 +9787806750322 +9787806750537 +9787806750650 +9787806750995 +9787806751107 +9787806751138 +9787806751152 +9787806751176 +9787806751763 +9787806752050 +9787806752067 +9787806752272 +9787806752876 +9787806752982 +9787806753118 +9787806753194 +9787806753385 +9787806754016 +9787806754061 +9787806754085 +9787806754276 +9787806754610 +9787806756249 +9787806756287 +9787806756331 +9787806756430 +9787806756829 +9787806756928 +9787806756942 +9787806757109 +9787806757352 +9787806757482 +9787806757598 +9787806757833 +9787806758960 +9787806758991 +9787806759622 +9787806760819 +9787806761328 +9787806762004 +9787806762035 +9787806762745 +9787806763841 +9787806764046 +9787806764060 +9787806765494 +9787806766316 +9787806766668 +9787806766903 +9787806767740 +9787806768136 +9787806768174 +9787806768198 +9787806768228 +9787806768815 +9787806768976 +9787806769058 +9787806769164 +9787806770290 +9787806770368 +9787806770467 +9787806771273 +9787806771747 +9787806771884 +9787806772195 +9787806772881 +9787806773208 +9787806773277 +9787806773840 +9787806774946 +9787806776216 +9787806777398 +9787806778449 +9787806778920 +9787806779668 +9787806779835 +9787806779842 +9787806780183 +9787806780190 +9787806780312 +9787806781319 +9787806781517 +9787806782460 +9787806783924 +9787806783955 +9787806784068 +9787806784099 +9787806784730 +9787806785423 +9787806785720 +9787806785737 +9787806785874 +9787806786185 +9787806786628 +9787806787786 +9787806788097 +9787806788318 +9787806788516 +9787806790151 +9787806790823 +9787806790847 +9787806791004 +9787806791226 +9787806791240 +9787806791271 +9787806791301 +9787806791325 +9787806791332 +9787806791349 +9787806791356 +9787806792186 +9787806792193 +9787806792742 +9787806792957 +9787806792964 +9787806794258 +9787806794487 +9787806794524 +9787806795071 +9787806796337 +9787806796719 +9787806796740 +9787806796979 +9787806797587 +9787806797990 +9787806798355 +9787806798621 +9787806798935 +9787806798966 +9787806799161 +9787806799215 +9787806799505 +9787806799840 +9787806800225 +9787806800799 +9787806801178 +9787806801529 +9787806801628 +9787806801666 +9787806801673 +9787806801680 +9787806801697 +9787806801727 +9787806802847 +9787806803257 +9787806803356 +9787806803363 +9787806803684 +9787806804735 +9787806805008 +9787806805275 +9787806805381 +9787806805633 +9787806805916 +9787806805985 +9787806806227 +9787806806296 +9787806806432 +9787806806784 +9787806807217 +9787806807408 +9787806807736 +9787806808948 +9787806809563 +9787806810149 +9787806810347 +9787806810910 +9787806811443 +9787806811573 +9787806811689 +9787806812341 +9787806812853 +9787806813331 +9787806814697 +9787806814710 +9787806814956 +9787806814970 +9787806815359 +9787806815625 +9787806815977 +9787806816455 +9787806816646 +9787806816653 +9787806816790 +9787806816974 +9787806817391 +9787806817537 +9787806819814 +9787806820155 +9787806823521 +9787806826010 +9787806828793 +9787806829424 +9787806829431 +9787806830574 +9787806834985 +9787806835005 +9787806836576 +9787806839416 +9787806839560 +9787806841372 +9787806841747 +9787806842218 +9787806846742 +9787806847282 +9787806849545 +9787806853733 +9787806853870 +9787806854235 +9787806854297 +9787806855119 +9787806857403 +9787806858301 +9787806858486 +9787806859131 +9787806859148 +9787806859797 +9787806860434 +9787806860625 +9787806861219 +9787806861530 +9787806861646 +9787806862803 +9787806863633 +9787806863930 +9787806865736 +9787806866108 +9787806867099 +9787806867365 +9787806867921 +9787806867938 +9787806869604 +9787806870020 +9787806870150 +9787806870723 +9787806871089 +9787806871331 +9787806871799 +9787806872000 +9787806872147 +9787806872376 +9787806872550 +9787806872901 +9787806873342 +9787806873748 +9787806874516 +9787806874912 +9787806875810 +9787806875834 +9787806876596 +9787806876602 +9787806876855 +9787806878033 +9787806878132 +9787806880388 +9787806880517 +9787806880746 +9787806881620 +9787806881897 +9787806882368 +9787806882566 +9787806882580 +9787806882603 +9787806882801 +9787806883204 +9787806883730 +9787806883792 +9787806883938 +9787806884621 +9787806884836 +9787806885338 +9787806885376 +9787806885512 +9787806885895 +9787806886106 +9787806887448 +9787806887462 +9787806887486 +9787806888537 +9787806888728 +9787806888902 +9787806889442 +9787806889480 +9787806890349 +9787806890486 +9787806890530 +9787806890882 +9787806890912 +9787806891155 +9787806891278 +9787806891643 +9787806891650 +9787806892213 +9787806893180 +9787806893319 +9787806893920 +9787806894408 +9787806896112 +9787806896143 +9787806896679 +9787806896884 +9787806897829 +9787806897850 +9787806898031 +9787806898048 +9787806898109 +9787806898178 +9787806899144 +9787806899281 +9787806899984 +9787806900000 +9787806900727 +9787806900734 +9787806900895 +9787806901199 +9787806901366 +9787806901441 +9787806902431 +9787806902745 +9787806903773 +9787806903827 +9787806903872 +9787806904879 +9787806905319 +9787806905753 +9787806906293 +9787806906422 +9787806906811 +9787806906958 +9787806908495 +9787806908723 +9787806908730 +9787806908747 +9787806908792 +9787806909126 +9787806910115 +9787806910504 +9787806910559 +9787806911174 +9787806911280 +9787806911624 +9787806911822 +9787806911907 +9787806911945 +9787806911976 +9787806912492 +9787806912690 +9787806912751 +9787806912911 +9787806914250 +9787806914311 +9787806914588 +9787806915059 +9787806915165 +9787806915431 +9787806915677 +9787806915875 +9787806916193 +9787806916247 +9787806916735 +9787806916964 +9787806917589 +9787806917671 +9787806917886 +9787806917954 +9787806918012 +9787806918067 +9787806918197 +9787806918296 +9787806918920 +9787806919170 +9787806919231 +9787806919293 +9787806919439 +9787806919880 +9787806919910 +9787806920084 +9787806920169 +9787806921050 +9787806921081 +9787806921265 +9787806921456 +9787806921777 +9787806922293 +9787806922309 +9787806922743 +9787806922965 +9787806923122 +9787806923405 +9787806923443 +9787806926628 +9787806926680 +9787806927281 +9787806927755 +9787806928103 +9787806928486 +9787806929063 +9787806929155 +9787806929261 +9787806929513 +9787806929933 +9787806930090 +9787806930137 +9787806931639 +9787806931752 +9787806931769 +9787806931783 +9787806931820 +9787806931868 +9787806931905 +9787806931912 +9787806931929 +9787806932025 +9787806932032 +9787806932049 +9787806932056 +9787806932063 +9787806932681 +9787806932711 +9787806932735 +9787806933077 +9787806933121 +9787806934203 +9787806940853 +9787806940976 +9787806941096 +9787806941362 +9787806941607 +9787806942154 +9787806942383 +9787806942789 +9787806943847 +9787806944646 +9787806945117 +9787806945544 +9787806945650 +9787806946206 +9787806947333 +9787806947630 +9787806947791 +9787806948286 +9787806948408 +9787806948712 +9787806948927 +9787806949115 +9787806950166 +9787806950319 +9787806950487 +9787806950609 +9787806950623 +9787806951682 +9787806951750 +9787806951774 +9787806951835 +9787806952245 +9787806952252 +9787806952771 +9787806953099 +9787806953822 +9787806953952 +9787806954249 +9787806954577 +9787806955130 +9787806955444 +9787806955673 +9787806955918 +9787806956229 +9787806956274 +9787806956663 +9787806956922 +9787806957219 +9787806959183 +9787806959626 +9787806960332 +9787806960387 +9787806960523 +9787806960653 +9787806960981 +9787806961476 +9787806961667 +9787806961711 +9787806961810 +9787806962053 +9787806962299 +9787806962312 +9787806962558 +9787806962824 +9787806962961 +9787806963159 +9787806963364 +9787806963371 +9787806963814 +9787806963999 +9787806964132 +9787806964224 +9787806964279 +9787806964408 +9787806965139 +9787806965177 +9787806966044 +9787806966136 +9787806966709 +9787806966983 +9787806967027 +9787806968970 +9787806969113 +9787806969861 +9787806970522 +9787806970799 +9787806971154 +9787806971321 +9787806971406 +9787806971611 +9787806973158 +9787806973509 +9787806975169 +9787806975961 +9787806976180 +9787806976814 +9787806977071 +9787806977286 +9787806977651 +9787806977699 +9787806977811 +9787806977910 +9787806978641 +9787806979495 +9787806979815 +9787806980293 +9787806980590 +9787806981009 +9787806981047 +9787806981115 +9787806981344 +9787806981863 +9787806982495 +9787806982921 +9787806983683 +9787806983751 +9787806983812 +9787806983836 +9787806984185 +9787806984352 +9787806984697 +9787806985137 +9787806985526 +9787806988305 +9787806989975 +9787806990308 +9787806990971 +9787806990995 +9787806991022 +9787806991473 +9787806991619 +9787806991701 +9787806992135 +9787806992753 +9787806993125 +9787806993255 +9787806993309 +9787806993460 +9787806993521 +9787806993651 +9787806994153 +9787806994740 +9787806994917 +9787806994962 +9787806995280 +9787806995808 +9787806996232 +9787806996553 +9787806996720 +9787806996904 +9787806997895 +9787806998342 +9787806998670 +9787806998748 +9787806998762 +9787806999325 +9787806999691 +9787806999967 +9787807000082 +9787807000181 +9787807000204 +9787807000389 +9787807000488 +9787807000501 +9787807000563 +9787807000648 +9787807000846 +9787807000921 +9787807001072 +9787807001225 +9787807010333 +9787807010944 +9787807011996 +9787807012016 +9787807012856 +9787807013686 +9787807015925 +9787807016656 +9787807017004 +9787807018674 +9787807019237 +9787807020677 +9787807020868 +9787807021391 +9787807021889 +9787807022138 +9787807022169 +9787807022305 +9787807022466 +9787807022480 +9787807022626 +9787807022732 +9787807022947 +9787807023227 +9787807023425 +9787807023432 +9787807023449 +9787807023593 +9787807024743 +9787807025016 +9787807025108 +9787807027317 +9787807027454 +9787807028819 +9787807028864 +9787807029830 +9787807029885 +9787807030638 +9787807031222 +9787807034964 +9787807035435 +9787807035978 +9787807036432 +9787807036470 +9787807037033 +9787807039907 +9787807040613 +9787807045724 +9787807050001 +9787807050438 +9787807050957 +9787807051527 +9787807052043 +9787807052258 +9787807052883 +9787807053668 +9787807056737 +9787807058120 +9787807058298 +9787807059165 +9787807059240 +9787807059400 +9787807066088 +9787807066538 +9787807066545 +9787807069188 +9787807069959 +9787807070665 +9787807070702 +9787807071013 +9787807071051 +9787807071617 +9787807071648 +9787807073062 +9787807073154 +9787807073826 +9787807074090 +9787807074595 +9787807074632 +9787807075370 +9787807075769 +9787807077473 +9787807077930 +9787807078012 +9787807078258 +9787807078319 +9787807079545 +9787807079934 +9787807083061 +9787807084310 +9787807084907 +9787807086208 +9787807086437 +9787807086529 +9787807088608 +9787807089650 +9787807089681 +9787807090120 +9787807090533 +9787807091073 +9787807091882 +9787807093060 +9787807093176 +9787807093671 +9787807094623 +9787807094920 +9787807095279 +9787807095552 +9787807095705 +9787807096580 +9787807097754 +9787807099338 +9787807099345 +9787807099543 +9787807099611 +9787807099666 +9787807100393 +9787807101369 +9787807101970 +9787807102540 +9787807103240 +9787807103394 +9787807104001 +9787807104551 +9787807104735 +9787807105589 +9787807106128 +9787807106180 +9787807106890 +9787807108436 +9787807110989 +9787807111054 +9787807114277 +9787807114444 +9787807114482 +9787807116851 +9787807119333 +9787807120469 +9787807121749 +9787807121831 +9787807122555 +9787807122937 +9787807123392 +9787807125037 +9787807126317 +9787807126515 +9787807127499 +9787807127796 +9787807127963 +9787807127987 +9787807128649 +9787807131564 +9787807131649 +9787807132486 +9787807132950 +9787807133254 +9787807133964 +9787807133995 +9787807134145 +9787807134435 +9787807134459 +9787807134749 +9787807135302 +9787807135647 +9787807136057 +9787807138730 +9787807138860 +9787807139010 +9787807139973 +9787807140191 +9787807140672 +9787807140801 +9787807141006 +9787807141143 +9787807141761 +9787807142058 +9787807142089 +9787807142119 +9787807142140 +9787807142164 +9787807142355 +9787807142744 +9787807144441 +9787807144472 +9787807145363 +9787807146735 +9787807147398 +9787807150107 +9787807151364 +9787807151371 +9787807151401 +9787807153566 +9787807153597 +9787807153689 +9787807154457 +9787807154594 +9787807154990 +9787807155331 +9787807155348 +9787807155355 +9787807155669 +9787807156116 +9787807156628 +9787807157595 +9787807157687 +9787807157977 +9787807158226 +9787807158264 +9787807158332 +9787807159377 +9787807159568 +9787807159681 +9787807159773 +9787807159797 +9787807160700 +9787807160816 +9787807161905 +9787807162056 +9787807162094 +9787807162575 +9787807162971 +9787807163077 +9787807163725 +9787807164197 +9787807165408 +9787807165415 +9787807165422 +9787807165439 +9787807166061 +9787807166313 +9787807166924 +9787807167136 +9787807167457 +9787807167501 +9787807168058 +9787807168256 +9787807168263 +9787807168300 +9787807168553 +9787807168669 +9787807169949 +9787807169970 +9787807170556 +9787807174660 +9787807180388 +9787807181057 +9787807181613 +9787807181668 +9787807182627 +9787807182672 +9787807183587 +9787807183983 +9787807184287 +9787807184546 +9787807187219 +9787807187226 +9787807187288 +9787807188452 +9787807189053 +9787807189442 +9787807189572 +9787807190424 +9787807190479 +9787807190769 +9787807190882 +9787807191254 +9787807191506 +9787807192503 +9787807193210 +9787807193616 +9787807195801 +9787807195887 +9787807196327 +9787807196648 +9787807196907 +9787807197805 +9787807199762 +9787807200062 +9787807200598 +9787807201212 +9787807204060 +9787807205043 +9787807205883 +9787807206200 +9787807207832 +9787807207856 +9787807209904 +9787807210269 +9787807215820 +9787807217619 +9787807220695 +9787807221982 +9787807223771 +9787807225546 +9787807225553 +9787807230007 +9787807230021 +9787807230045 +9787807230052 +9787807230076 +9787807230083 +9787807230090 +9787807230120 +9787807230168 +9787807230175 +9787807230212 +9787807230311 +9787807230373 +9787807230649 +9787807230755 +9787807230762 +9787807230779 +9787807230786 +9787807230816 +9787807230823 +9787807230960 +9787807230984 +9787807231110 +9787807231127 +9787807231189 +9787807231325 +9787807231370 +9787807231417 +9787807231455 +9787807231486 +9787807231790 +9787807231806 +9787807231875 +9787807231936 +9787807231981 +9787807232070 +9787807232223 +9787807232452 +9787807232650 +9787807232759 +9787807232766 +9787807232803 +9787807232926 +9787807233282 +9787807233312 +9787807233442 +9787807233473 +9787807233497 +9787807233633 +9787807233640 +9787807233817 +9787807233824 +9787807234005 +9787807234135 +9787807234425 +9787807234463 +9787807234562 +9787807234579 +9787807234630 +9787807234968 +9787807234982 +9787807235040 +9787807235224 +9787807235279 +9787807235330 +9787807235552 +9787807235606 +9787807235767 +9787807235934 +9787807236047 +9787807236306 +9787807236535 +9787807236818 +9787807238133 +9787807238164 +9787807238256 +9787807240303 +9787807240327 +9787807241218 +9787807241461 +9787807241560 +9787807241645 +9787807241843 +9787807241867 +9787807242338 +9787807242406 +9787807242567 +9787807243021 +9787807243168 +9787807244431 +9787807244622 +9787807244943 +9787807246626 +9787807247036 +9787807247166 +9787807247449 +9787807248279 +9787807248514 +9787807249047 +9787807249290 +9787807249368 +9787807250326 +9787807251040 +9787807251392 +9787807251637 +9787807251644 +9787807251910 +9787807251996 +9787807252306 +9787807253013 +9787807253730 +9787807255147 +9787807255505 +9787807256069 +9787807256458 +9787807256557 +9787807256618 +9787807256854 +9787807257592 +9787807258704 +9787807258933 +9787807259275 +9787807260271 +9787807260417 +9787807260868 +9787807261292 +9787807261490 +9787807261940 +9787807262268 +9787807263098 +9787807263319 +9787807265276 +9787807267409 +9787807267744 +9787807273035 +9787807274261 +9787807274537 +9787807280170 +9787807280439 +9787807282617 +9787807283287 +9787807283423 +9787807283621 +9787807284178 +9787807284284 +9787807284345 +9787807284383 +9787807284680 +9787807285298 +9787807285441 +9787807285489 +9787807286066 +9787807286240 +9787807287346 +9787807290063 +9787807290384 +9787807290414 +9787807291367 +9787807291565 +9787807291725 +9787807292166 +9787807292173 +9787807293040 +9787807293125 +9787807294580 +9787807294641 +9787807295143 +9787807295761 +9787807295778 +9787807295846 +9787807296935 +9787807297505 +9787807297543 +9787807298229 +9787807298489 +9787807301370 +9787807301448 +9787807301530 +9787807301820 +9787807302681 +9787807303589 +9787807303732 +9787807304074 +9787807304340 +9787807306085 +9787807306825 +9787807307570 +9787807307785 +9787807307921 +9787807308898 +9787807309048 +9787807309147 +9787807309420 +9787807309659 +9787807309673 +9787807310174 +9787807310228 +9787807310303 +9787807310457 +9787807311270 +9787807311782 +9787807312956 +9787807312963 +9787807313007 +9787807313014 +9787807313021 +9787807313496 +9787807313786 +9787807313953 +9787807314387 +9787807314615 +9787807314646 +9787807315216 +9787807315643 +9787807316329 +9787807316411 +9787807317678 +9787807318002 +9787807318798 +9787807319030 +9787807319306 +9787807319313 +9787807324256 +9787807325888 +9787807326427 +9787807329251 +9787807329763 +9787807329848 +9787807330004 +9787807330400 +9787807330455 +9787807330660 +9787807330691 +9787807330790 +9787807331643 +9787807331650 +9787807331704 +9787807331810 +9787807332046 +9787807332862 +9787807333142 +9787807334057 +9787807334675 +9787807335610 +9787807335986 +9787807336884 +9787807337737 +9787807337959 +9787807338208 +9787807340829 +9787807350408 +9787807351542 +9787807352198 +9787807352426 +9787807352662 +9787807353430 +9787807354741 +9787807355168 +9787807355632 +9787807355779 +9787807357018 +9787807357469 +9787807358619 +9787807358800 +9787807359081 +9787807359180 +9787807359579 +9787807359777 +9787807360070 +9787807360384 +9787807360445 +9787807361022 +9787807361053 +9787807361541 +9787807362074 +9787807362562 +9787807362715 +9787807362999 +9787807363453 +9787807364474 +9787807365235 +9787807365372 +9787807365440 +9787807366881 +9787807366959 +9787807367758 +9787807368526 +9787807368649 +9787807369509 +9787807369660 +9787807369677 +9787807369851 +9787807370826 +9787807372813 +9787807374107 +9787807375777 +9787807375791 +9787807376729 +9787807378242 +9787807379829 +9787807379997 +9787807380252 +9787807380283 +9787807380290 +9787807380320 +9787807380887 +9787807381099 +9787807382188 +9787807383345 +9787807383581 +9787807384359 +9787807385530 +9787807385943 +9787807386230 +9787807386841 +9787807389408 +9787807390183 +9787807390701 +9787807391159 +9787807391913 +9787807391944 +9787807393078 +9787807393313 +9787807394396 +9787807394730 +9787807394860 +9787807394877 +9787807394891 +9787807395348 +9787807395898 +9787807395928 +9787807396147 +9787807396154 +9787807396178 +9787807397151 +9787807399254 +9787807401308 +9787807402091 +9787807403111 +9787807403586 +9787807404057 +9787807406372 +9787807407928 +9787807408499 +9787807408994 +9787807409274 +9787807409472 +9787807409489 +9787807409663 +9787807409717 +9787807410423 +9787807410584 +9787807411253 +9787807411321 +9787807412151 +9787807412267 +9787807413998 +9787807414018 +9787807418375 +9787807421023 +9787807421078 +9787807421566 +9787807421771 +9787807422174 +9787807422228 +9787807422679 +9787807422952 +9787807423133 +9787807424673 +9787807425816 +9787807427889 +9787807428817 +9787807429449 +9787807429456 +9787807429463 +9787807429517 +9787807430223 +9787807430360 +9787807430490 +9787807431350 +9787807431794 +9787807432340 +9787807433040 +9787807433200 +9787807433811 +9787807434108 +9787807434382 +9787807435532 +9787807435969 +9787807436720 +9787807437116 +9787807437727 +9787807438380 +9787807440710 +9787807440970 +9787807441014 +9787807441182 +9787807442998 +9787807443971 +9787807443995 +9787807444107 +9787807444114 +9787807444152 +9787807444176 +9787807444244 +9787807444299 +9787807444688 +9787807444763 +9787807445364 +9787807446804 +9787807449409 +9787807452416 +9787807452515 +9787807454144 +9787807455509 +9787807456889 +9787807460145 +9787807460510 +9787807460794 +9787807461913 +9787807462538 +9787807469780 +9787807470748 +9787807471240 +9787807471318 +9787807471660 +9787807473480 +9787807473503 +9787807473527 +9787807473893 +9787807474753 +9787807476498 +9787807476603 +9787807476993 +9787807478287 +9787807478300 +9787807478690 +9787807479468 +9787807479963 +9787807480693 +9787807481003 +9787807481768 +9787807481836 +9787807482673 +9787807482857 +9787807484127 +9787807485636 +9787807486411 +9787807487135 +9787807487821 +9787807487968 +9787807489924 +9787807489931 +9787807489993 +9787807490173 +9787807490982 +9787807491163 +9787807491378 +9787807491965 +9787807493464 +9787807493891 +9787807493907 +9787807494010 +9787807494034 +9787807494195 +9787807494751 +9787807494843 +9787807494911 +9787807496830 +9787807497097 +9787807497226 +9787807499114 +9787807499695 +9787807499855 +9787807500728 +9787807501732 +9787807502302 +9787807502425 +9787807502777 +9787807503125 +9787807503415 +9787807506263 +9787807506522 +9787807507093 +9787807507567 +9787807507574 +9787807507598 +9787807507604 +9787807508489 +9787807510208 +9787807511342 +9787807512301 +9787807513995 +9787807515869 +9787807516392 +9787807517986 +9787807518082 +9787807518372 +9787807518808 +9787807520108 +9787807520511 +9787807520870 +9787807521587 +9787807522324 +9787807522607 +9787807522614 +9787807522751 +9787807522843 +9787807524519 +9787807524601 +9787807524823 +9787807525325 +9787807525936 +9787807526483 +9787807526926 +9787807528333 +9787807528425 +9787807529477 +9787807529682 +9787807529729 +9787807530589 +9787807531395 +9787807531647 +9787807532026 +9787807534020 +9787807534839 +9787807534846 +9787807535263 +9787807536376 +9787807536543 +9787807536642 +9787807536680 +9787807536758 +9787807537014 +9787807537922 +9787807538356 +9787807538455 +9787807540496 +9787807541660 +9787807542704 +9787807542827 +9787807542889 +9787807545002 +9787807545057 +9787807548737 +9787807549826 +9787807550105 +9787807550150 +9787807550174 +9787807550532 +9787807551478 +9787807552321 +9787807552611 +9787807553274 +9787807553649 +9787807554202 +9787807554769 +9787807555223 +9787807556336 +9787807556541 +9787807556589 +9787807557036 +9787807557227 +9787807559191 +9787807560494 +9787807560609 +9787807560661 +9787807561040 +9787807561118 +9787807561385 +9787807561446 +9787807561576 +9787807561873 +9787807563457 +9787807563761 +9787807563846 +9787807565697 +9787807570264 +9787807570271 +9787807570356 +9787807570462 +9787807570523 +9787807570875 +9787807571230 +9787807574064 +9787807574361 +9787807574408 +9787807576600 +9787807577539 +9787807578994 +9787807580126 +9787807580423 +9787807582847 +9787807583172 +9787807583394 +9787807583653 +9787807583776 +9787807584292 +9787807585138 +9787807585152 +9787807585169 +9787807585664 +9787807585718 +9787807585848 +9787807587514 +9787807587910 +9787807588597 +9787807588818 +9787807588870 +9787807589754 +9787807589761 +9787807589778 +9787807589785 +9787807589792 +9787807589808 +9787807589884 +9787807589891 +9787807589907 +9787807589914 +9787807590873 +9787807591139 +9787807591238 +9787807591672 +9787807592204 +9787807592464 +9787807592570 +9787807592600 +9787807593713 +9787807595212 +9787807595380 +9787807595397 +9787807595403 +9787807595410 +9787807595670 +9787807596639 +9787807599203 +9787807599791 +9787807599920 +9787807600336 +9787807600510 +9787807600985 +9787807601418 +9787807601623 +9787807602651 +9787807604273 +9787807604556 +9787807609339 +9787807610038 +9787807610427 +9787807610441 +9787807610496 +9787807610809 +9787807611479 +9787807612858 +9787807613343 +9787807613367 +9787807613787 +9787807614463 +9787807615552 +9787807616078 +9787807617273 +9787807617341 +9787807617792 +9787807618225 +9787807618232 +9787807618751 +9787807619406 +9787807619802 +9787807621829 +9787807624561 +9787807625117 +9787807625124 +9787807627029 +9787807627319 +9787807627630 +9787807627722 +9787807627999 +9787807628576 +9787807628620 +9787807628798 +9787807628996 +9787807629085 +9787807629252 +9787807629283 +9787807629290 +9787807629306 +9787807629351 +9787807629467 +9787807630319 +9787807630340 +9787807631804 +9787807631927 +9787807633150 +9787807633327 +9787807634256 +9787807634867 +9787807635383 +9787807635390 +9787807635895 +9787807636205 +9787807636878 +9787807638131 +9787807638193 +9787807639121 +9787807639510 +9787807639824 +9787807641926 +9787807647843 +9787807650621 +9787807652625 +9787807652779 +9787807653875 +9787807654223 +9787807655060 +9787807656029 +9787807656081 +9787807657255 +9787807659150 +9787807660101 +9787807660293 +9787807660361 +9787807660408 +9787807661078 +9787807661108 +9787807661344 +9787807661948 +9787807662143 +9787807662488 +9787807662563 +9787807662686 +9787807662990 +9787807663430 +9787807663898 +9787807663911 +9787807665274 +9787807666004 +9787807668084 +9787807670841 +9787807671404 +9787807671541 +9787807671879 +9787807672456 +9787807674306 +9787807674399 +9787807674528 +9787807675679 +9787807675778 +9787807676300 +9787807676812 +9787807677499 +9787807678786 +9787807679240 +9787807679684 +9787807680239 +9787807680376 +9787807680451 +9787807680734 +9787807680970 +9787807681021 +9787807681083 +9787807681373 +9787807681656 +9787807681786 +9787807682035 +9787807682349 +9787807683032 +9787807683339 +9787807683384 +9787807683834 +9787807684152 +9787807684268 +9787807684282 +9787807684312 +9787807684329 +9787807684428 +9787807684473 +9787807684572 +9787807684589 +9787807684626 +9787807684633 +9787807684640 +9787807684657 +9787807684701 +9787807684947 +9787807684961 +9787807684992 +9787807690221 +9787807690290 +9787807693680 +9787807696179 +9787807697152 +9787807697589 +9787807700524 +9787807700746 +9787807700845 +9787807701699 +9787807701729 +9787807702658 +9787807702726 +9787807704454 +9787807704508 +9787807704522 +9787807704683 +9787807704706 +9787807706236 +9787807720065 +9787807720102 +9787807720133 +9787807720904 +9787807721161 +9787807721185 +9787807721284 +9787807721390 +9787807721499 +9787807721550 +9787807721710 +9787807721789 +9787807730521 +9787807730705 +9787807730743 +9787807730934 +9787807731023 +9787807731078 +9787807731863 +9787807732150 +9787807732167 +9787807732389 +9787807733324 +9787807733683 +9787807733706 +9787807733720 +9787807735786 +9787807735854 +9787807735892 +9787807737278 +9787807740643 +9787807741046 +9787807741053 +9787807750086 +9787807750130 +9787808376391 +9787808891191 +9787809618414 +9787810000499 +9787810000512 +9787810000673 +9787810000703 +9787810000796 +9787810001564 +9787810001991 +9787810003179 +9787810003315 +9787810005081 +9787810005180 +9787810005418 +9787810006514 +9787810006927 +9787810007702 +9787810008143 +9787810008884 +9787810009355 +9787810009751 +9787810010191 +9787810010290 +9787810010382 +9787810010443 +9787810010467 +9787810010535 +9787810010818 +9787810010856 +9787810011174 +9787810012362 +9787810013307 +9787810013338 +9787810013390 +9787810013512 +9787810013635 +9787810013994 +9787810014977 +9787810015073 +9787810015578 +9787810015585 +9787810015592 +9787810015660 +9787810016322 +9787810016339 +9787810016353 +9787810016445 +9787810016476 +9787810016896 +9787810016919 +9787810017428 +9787810017480 +9787810018128 +9787810018159 +9787810018319 +9787810019484 +9787810020398 +9787810020794 +9787810021043 +9787810021913 +9787810023320 +9787810025058 +9787810027328 +9787810027670 +9787810028424 +9787810030007 +9787810030076 +9787810030151 +9787810030380 +9787810030427 +9787810030595 +9787810030649 +9787810030670 +9787810030861 +9787810030915 +9787810030977 +9787810031011 +9787810031042 +9787810031073 +9787810031097 +9787810031165 +9787810031189 +9787810031271 +9787810031288 +9787810031332 +9787810031356 +9787810031363 +9787810031417 +9787810031424 +9787810031509 +9787810031523 +9787810031578 +9787810031608 +9787810031615 +9787810031622 +9787810031660 +9787810031677 +9787810031691 +9787810031707 +9787810031714 +9787810031745 +9787810031769 +9787810031783 +9787810031899 +9787810031943 +9787810031974 +9787810032063 +9787810032070 +9787810032087 +9787810032131 +9787810032162 +9787810032278 +9787810032315 +9787810032322 +9787810032339 +9787810032612 +9787810032698 +9787810032728 +9787810032759 +9787810032810 +9787810032827 +9787810032834 +9787810032858 +9787810032872 +9787810032957 +9787810033039 +9787810033053 +9787810033077 +9787810033084 +9787810033138 +9787810033282 +9787810033299 +9787810033305 +9787810033312 +9787810033381 +9787810033398 +9787810033428 +9787810033435 +9787810033503 +9787810033510 +9787810033534 +9787810033602 +9787810033824 +9787810033831 +9787810033855 +9787810033862 +9787810033916 +9787810033978 +9787810034029 +9787810034074 +9787810034104 +9787810034135 +9787810034142 +9787810034159 +9787810034173 +9787810034180 +9787810034210 +9787810034265 +9787810034289 +9787810034296 +9787810034579 +9787810034593 +9787810034609 +9787810034616 +9787810034654 +9787810034661 +9787810034715 +9787810034760 +9787810034777 +9787810034784 +9787810034791 +9787810034838 +9787810034845 +9787810034890 +9787810034913 +9787810035064 +9787810035088 +9787810035118 +9787810035156 +9787810035163 +9787810035194 +9787810035200 +9787810035286 +9787810035309 +9787810035316 +9787810035323 +9787810035415 +9787810035460 +9787810035484 +9787810035507 +9787810035521 +9787810035538 +9787810035729 +9787810035774 +9787810035903 +9787810035927 +9787810036023 +9787810036030 +9787810036047 +9787810036092 +9787810036153 +9787810036177 +9787810036252 +9787810036344 +9787810036351 +9787810036504 +9787810036542 +9787810036580 +9787810036597 +9787810036764 +9787810036863 +9787810036900 +9787810036917 +9787810036962 +9787810037075 +9787810037150 +9787810037167 +9787810037174 +9787810037181 +9787810037204 +9787810037211 +9787810037242 +9787810037259 +9787810037273 +9787810037297 +9787810037327 +9787810037341 +9787810037433 +9787810037525 +9787810037617 +9787810037655 +9787810037723 +9787810037747 +9787810037778 +9787810037822 +9787810037846 +9787810037877 +9787810037945 +9787810038041 +9787810038348 +9787810038393 +9787810038409 +9787810038423 +9787810038430 +9787810038461 +9787810038478 +9787810038485 +9787810038492 +9787810038645 +9787810038669 +9787810038799 +9787810038874 +9787810038881 +9787810038966 +9787810039000 +9787810039086 +9787810039130 +9787810039147 +9787810039154 +9787810039161 +9787810039215 +9787810039321 +9787810039338 +9787810039352 +9787810039369 +9787810039383 +9787810039406 +9787810039468 +9787810039482 +9787810039499 +9787810039550 +9787810039567 +9787810039581 +9787810039598 +9787810039628 +9787810039727 +9787810039765 +9787810039789 +9787810039796 +9787810039819 +9787810039840 +9787810039871 +9787810041218 +9787810042369 +9787810042550 +9787810042567 +9787810042604 +9787810042635 +9787810042642 +9787810042666 +9787810042734 +9787810042741 +9787810042840 +9787810043243 +9787810043281 +9787810043298 +9787810043311 +9787810043403 +9787810043533 +9787810043670 +9787810044165 +9787810044615 +9787810044936 +9787810044974 +9787810045056 +9787810045094 +9787810045124 +9787810045377 +9787810045810 +9787810045841 +9787810046343 +9787810046862 +9787810046916 +9787810046954 +9787810047029 +9787810047050 +9787810047067 +9787810047081 +9787810047197 +9787810047364 +9787810047562 +9787810047586 +9787810047609 +9787810047685 +9787810048231 +9787810048811 +9787810049405 +9787810049948 +9787810060455 +9787810060554 +9787810061711 +9787810061742 +9787810061841 +9787810065702 +9787810072892 +9787810073028 +9787810075558 +9787810077880 +9787810078795 +9787810080040 +9787810083157 +9787810083294 +9787810083768 +9787810086790 +9787810088534 +9787810088763 +9787810088770 +9787810089616 +9787810090087 +9787810090179 +9787810090506 +9787810090599 +9787810090650 +9787810090797 +9787810090810 +9787810091312 +9787810091374 +9787810091435 +9787810091626 +9787810092203 +9787810092616 +9787810092722 +9787810093286 +9787810093682 +9787810093811 +9787810093903 +9787810093934 +9787810093972 +9787810093989 +9787810094351 +9787810094399 +9787810095006 +9787810095037 +9787810095167 +9787810095624 +9787810095945 +9787810096102 +9787810096218 +9787810096263 +9787810096539 +9787810097239 +9787810097390 +9787810097574 +9787810097666 +9787810097994 +9787810098052 +9787810098724 +9787810098779 +9787810098922 +9787810099301 +9787810099745 +9787810099882 +9787810100052 +9787810100106 +9787810100151 +9787810100182 +9787810100328 +9787810100366 +9787810100380 +9787810100397 +9787810100465 +9787810100489 +9787810100496 +9787810100564 +9787810100588 +9787810100700 +9787810100731 +9787810100786 +9787810100878 +9787810100915 +9787810100953 +9787810100984 +9787810100991 +9787810101004 +9787810101028 +9787810101097 +9787810101158 +9787810101172 +9787810101189 +9787810101240 +9787810101363 +9787810101370 +9787810101387 +9787810101394 +9787810101424 +9787810101431 +9787810101455 +9787810101462 +9787810101486 +9787810101561 +9787810101578 +9787810101615 +9787810101639 +9787810101691 +9787810101714 +9787810101868 +9787810101899 +9787810101905 +9787810101936 +9787810101967 +9787810102100 +9787810102162 +9787810102216 +9787810102391 +9787810102414 +9787810102452 +9787810102568 +9787810102599 +9787810102629 +9787810102636 +9787810102780 +9787810102858 +9787810102902 +9787810102926 +9787810102940 +9787810103091 +9787810103114 +9787810103176 +9787810103183 +9787810103343 +9787810103398 +9787810103480 +9787810103558 +9787810103565 +9787810103596 +9787810103619 +9787810103770 +9787810103916 +9787810103961 +9787810103992 +9787810104166 +9787810104197 +9787810104296 +9787810104463 +9787810105033 +9787810105101 +9787810105262 +9787810105477 +9787810105644 +9787810105781 +9787810105934 +9787810106023 +9787810106054 +9787810106108 +9787810106115 +9787810106214 +9787810106276 +9787810106320 +9787810106726 +9787810106740 +9787810106955 +9787810107105 +9787810107372 +9787810107471 +9787810107648 +9787810107914 +9787810107983 +9787810107990 +9787810108157 +9787810108935 +9787810108966 +9787810109468 +9787810110297 +9787810110433 +9787810110877 +9787810111027 +9787810111188 +9787810111447 +9787810111911 +9787810112338 +9787810113052 +9787810113564 +9787810115650 +9787810115889 +9787810117357 +9787810117487 +9787810117579 +9787810117968 +9787810117975 +9787810118651 +9787810119573 +9787810120111 +9787810120357 +9787810120524 +9787810121224 +9787810122382 +9787810123419 +9787810124454 +9787810124607 +9787810124713 +9787810124966 +9787810124980 +9787810125260 +9787810125703 +9787810125963 +9787810126489 +9787810126922 +9787810126946 +9787810127011 +9787810127073 +9787810127172 +9787810127479 +9787810127820 +9787810128629 +9787810128766 +9787810128773 +9787810129008 +9787810129138 +9787810129923 +9787810129992 +9787810130042 +9787810130387 +9787810132749 +9787810133050 +9787810133654 +9787810134903 +9787810135023 +9787810135917 +9787810136709 +9787810138031 +9787810138734 +9787810139465 +9787810139694 +9787810139908 +9787810140324 +9787810140362 +9787810141741 +9787810141789 +9787810142700 +9787810143462 +9787810144346 +9787810144438 +9787810144568 +9787810145503 +9787810146197 +9787810146203 +9787810146241 +9787810146326 +9787810146982 +9787810147149 +9787810147309 +9787810150477 +9787810151078 +9787810151375 +9787810153027 +9787810154246 +9787810154949 +9787810155731 +9787810157421 +9787810157568 +9787810158534 +9787810158541 +9787810159838 +9787810160216 +9787810160568 +9787810162388 +9787810166317 +9787810167154 +9787810168281 +9787810169073 +9787810171052 +9787810171748 +9787810180214 +9787810180320 +9787810180436 +9787810180665 +9787810181204 +9787810181617 +9787810181655 +9787810181952 +9787810182058 +9787810182294 +9787810183871 +9787810184199 +9787810185189 +9787810185394 +9787810185417 +9787810185806 +9787810187138 +9787810187190 +9787810187244 +9787810187343 +9787810187633 +9787810187701 +9787810187831 +9787810188272 +9787810189866 +9787810190015 +9787810190084 +9787810190107 +9787810190138 +9787810190367 +9787810190374 +9787810190619 +9787810190626 +9787810190725 +9787810190800 +9787810191098 +9787810191111 +9787810191159 +9787810191333 +9787810191722 +9787810191807 +9787810191951 +9787810191975 +9787810191982 +9787810192866 +9787810192934 +9787810192941 +9787810193023 +9787810193061 +9787810193283 +9787810193320 +9787810193450 +9787810193993 +9787810194044 +9787810194181 +9787810194785 +9787810194822 +9787810195010 +9787810195263 +9787810195621 +9787810195836 +9787810195843 +9787810195850 +9787810195980 +9787810196086 +9787810196215 +9787810196581 +9787810196628 +9787810196949 +9787810197199 +9787810197335 +9787810197724 +9787810197922 +9787810198097 +9787810198332 +9787810199483 +9787810199902 +9787810199988 +9787810200592 +9787810200776 +9787810201537 +9787810204316 +9787810204620 +9787810204910 +9787810206181 +9787810207652 +9787810207799 +9787810209304 +9787810212403 +9787810214049 +9787810214223 +9787810214575 +9787810218115 +9787810221399 +9787810221979 +9787810222211 +9787810222655 +9787810224451 +9787810224628 +9787810224673 +9787810227995 +9787810230148 +9787810230711 +9787810230889 +9787810231053 +9787810231251 +9787810231800 +9787810232685 +9787810232944 +9787810233125 +9787810233347 +9787810234580 +9787810236232 +9787810236348 +9787810237222 +9787810237499 +9787810237512 +9787810238533 +9787810238830 +9787810239127 +9787810239295 +9787810239523 +9787810239974 +9787810240437 +9787810240970 +9787810241632 +9787810243650 +9787810244039 +9787810244060 +9787810244107 +9787810244251 +9787810244589 +9787810245036 +9787810245074 +9787810245388 +9787810245500 +9787810245524 +9787810246354 +9787810246989 +9787810247337 +9787810249119 +9787810249652 +9787810250283 +9787810250504 +9787810250696 +9787810252010 +9787810253703 +9787810256254 +9787810257954 +9787810258784 +9787810260015 +9787810260053 +9787810263443 +9787810264525 +9787810264747 +9787810264792 +9787810265515 +9787810267922 +9787810270106 +9787810270250 +9787810270397 +9787810270915 +9787810271639 +9787810271806 +9787810272513 +9787810272735 +9787810272834 +9787810272971 +9787810273244 +9787810273299 +9787810273930 +9787810274111 +9787810279673 +9787810280020 +9787810280150 +9787810280372 +9787810280815 +9787810280860 +9787810284523 +9787810284905 +9787810286381 +9787810286879 +9787810286909 +9787810287548 +9787810287722 +9787810287807 +9787810288002 +9787810288262 +9787810288569 +9787810289726 +9787810290111 +9787810290258 +9787810290302 +9787810290449 +9787810290777 +9787810290791 +9787810290852 +9787810291323 +9787810291378 +9787810291576 +9787810291996 +9787810292290 +9787810292443 +9787810292979 +9787810293174 +9787810293204 +9787810293433 +9787810293976 +9787810294041 +9787810294195 +9787810294409 +9787810294423 +9787810295239 +9787810295260 +9787810295307 +9787810295727 +9787810295949 +9787810296472 +9787810296885 +9787810297523 +9787810297608 +9787810297653 +9787810297745 +9787810297820 +9787810297851 +9787810298056 +9787810298735 +9787810299275 +9787810299282 +9787810299299 +9787810299312 +9787810299336 +9787810299350 +9787810299367 +9787810299381 +9787810304856 +9787810305068 +9787810306140 +9787810307390 +9787810310123 +9787810310666 +9787810310789 +9787810310987 +9787810315593 +9787810316095 +9787810317122 +9787810317801 +9787810318488 +9787810318785 +9787810318846 +9787810319270 +9787810319706 +9787810320429 +9787810322096 +9787810322263 +9787810324496 +9787810324922 +9787810325776 +9787810326285 +9787810326377 +9787810326698 +9787810327244 +9787810328463 +9787810328500 +9787810329446 +9787810330794 +9787810331067 +9787810331111 +9787810331432 +9787810333900 +9787810333924 +9787810334082 +9787810334174 +9787810334389 +9787810335584 +9787810335720 +9787810336123 +9787810336383 +9787810336680 +9787810336727 +9787810337120 +9787810337618 +9787810338103 +9787810338554 +9787810339605 +9787810339858 +9787810339919 +9787810340069 +9787810340557 +9787810340588 +9787810340649 +9787810341004 +9787810342100 +9787810342223 +9787810342377 +9787810342728 +9787810342766 +9787810342902 +9787810342940 +9787810343190 +9787810343213 +9787810343251 +9787810343268 +9787810343282 +9787810343329 +9787810343343 +9787810343589 +9787810343688 +9787810344098 +9787810344296 +9787810344388 +9787810344463 +9787810344654 +9787810344883 +9787810345323 +9787810345460 +9787810345477 +9787810346092 +9787810346238 +9787810346832 +9787810347105 +9787810347198 +9787810347334 +9787810347341 +9787810347532 +9787810347624 +9787810347631 +9787810347709 +9787810347976 +9787810348096 +9787810348249 +9787810348256 +9787810348652 +9787810348706 +9787810348867 +9787810348898 +9787810349291 +9787810349963 +9787810350648 +9787810351430 +9787810351485 +9787810352260 +9787810352666 +9787810352901 +9787810354837 +9787810355322 +9787810355513 +9787810355728 +9787810355803 +9787810356855 +9787810357142 +9787810357203 +9787810357845 +9787810358026 +9787810358194 +9787810358255 +9787810358828 +9787810359405 +9787810360661 +9787810360852 +9787810361224 +9787810361231 +9787810361347 +9787810361491 +9787810361736 +9787810361897 +9787810362122 +9787810362214 +9787810362238 +9787810362276 +9787810362337 +9787810362658 +9787810362665 +9787810362733 +9787810362788 +9787810362870 +9787810362887 +9787810362900 +9787810362924 +9787810363426 +9787810363730 +9787810364164 +9787810364539 +9787810365178 +9787810365482 +9787810365512 +9787810365574 +9787810365673 +9787810367233 +9787810367271 +9787810367516 +9787810367806 +9787810367899 +9787810368155 +9787810368278 +9787810368506 +9787810368971 +9787810369183 +9787810370004 +9787810371087 +9787810371292 +9787810371476 +9787810371766 +9787810371773 +9787810373623 +9787810374156 +9787810376556 +9787810377973 +9787810378239 +9787810382236 +9787810384209 +9787810384254 +9787810386388 +9787810386890 +9787810387071 +9787810390279 +9787810390286 +9787810390309 +9787810390316 +9787810391115 +9787810391504 +9787810391641 +9787810392754 +9787810393140 +9787810393478 +9787810394062 +9787810394253 +9787810394406 +9787810394598 +9787810394901 +9787810395953 +9787810396233 +9787810396547 +9787810396820 +9787810397575 +9787810397827 +9787810397834 +9787810398039 +9787810398268 +9787810398763 +9787810399210 +9787810399258 +9787810399586 +9787810402002 +9787810403979 +9787810404457 +9787810406505 +9787810407106 +9787810408226 +9787810410557 +9787810410793 +9787810410816 +9787810411103 +9787810411387 +9787810411684 +9787810411899 +9787810411943 +9787810411967 +9787810412087 +9787810412407 +9787810412520 +9787810413336 +9787810413480 +9787810414548 +9787810414708 +9787810415088 +9787810415491 +9787810415798 +9787810415941 +9787810415996 +9787810416115 +9787810416191 +9787810416450 +9787810416832 +9787810417228 +9787810417334 +9787810417495 +9787810417600 +9787810417938 +9787810418331 +9787810418850 +9787810418898 +9787810419048 +9787810419055 +9787810419062 +9787810419130 +9787810419321 +9787810419345 +9787810419826 +9787810419987 +9787810420068 +9787810420075 +9787810421027 +9787810421133 +9787810422307 +9787810423083 +9787810423106 +9787810423359 +9787810424714 +9787810431125 +9787810431682 +9787810431927 +9787810432894 +9787810435253 +9787810435321 +9787810436243 +9787810436458 +9787810437981 +9787810441766 +9787810442718 +9787810443463 +9787810445115 +9787810446327 +9787810446761 +9787810447119 +9787810447225 +9787810447553 +9787810448390 +9787810450058 +9787810450744 +9787810451147 +9787810452311 +9787810452861 +9787810453622 +9787810454247 +9787810454926 +9787810455282 +9787810457026 +9787810457491 +9787810459396 +9787810460439 +9787810460828 +9787810460965 +9787810461573 +9787810461689 +9787810461832 +9787810461863 +9787810461993 +9787810462914 +9787810462945 +9787810463034 +9787810463195 +9787810463256 +9787810463386 +9787810463638 +9787810463768 +9787810464116 +9787810464338 +9787810464383 +9787810464444 +9787810464581 +9787810464819 +9787810465267 +9787810465502 +9787810465908 +9787810466134 +9787810466431 +9787810466622 +9787810468787 +9787810469821 +9787810470377 +9787810470513 +9787810470520 +9787810471060 +9787810471237 +9787810472470 +9787810472920 +9787810473477 +9787810475976 +9787810476621 +9787810476874 +9787810477062 +9787810477581 +9787810478885 +9787810479318 +9787810479509 +9787810479653 +9787810479714 +9787810479912 +9787810480888 +9787810480918 +9787810481083 +9787810482394 +9787810482844 +9787810483810 +9787810483834 +9787810484305 +9787810485401 +9787810485845 +9787810487061 +9787810487405 +9787810487450 +9787810487498 +9787810488068 +9787810488518 +9787810490467 +9787810490634 +9787810491679 +9787810491792 +9787810492218 +9787810492256 +9787810492287 +9787810493017 +9787810493208 +9787810493314 +9787810494212 +9787810494359 +9787810495615 +9787810495943 +9787810496407 +9787810496797 +9787810497237 +9787810497459 +9787810497589 +9787810498753 +9787810500463 +9787810501323 +9787810502030 +9787810503259 +9787810503600 +9787810505277 +9787810505482 +9787810505574 +9787810507240 +9787810509510 +9787810509671 +9787810510202 +9787810510226 +9787810510240 +9787810510271 +9787810510318 +9787810510325 +9787810510394 +9787810510462 +9787810510516 +9787810510523 +9787810510530 +9787810510585 +9787810510592 +9787810510608 +9787810510622 +9787810510639 +9787810510691 +9787810510776 +9787810510783 +9787810510790 +9787810510882 +9787810510905 +9787810511018 +9787810511247 +9787810511261 +9787810511278 +9787810511285 +9787810511384 +9787810511599 +9787810511698 +9787810511704 +9787810511711 +9787810511902 +9787810511933 +9787810512008 +9787810512039 +9787810512138 +9787810512206 +9787810512251 +9787810512343 +9787810512374 +9787810512404 +9787810512435 +9787810512558 +9787810512947 +9787810513036 +9787810513074 +9787810513234 +9787810513289 +9787810513531 +9787810513555 +9787810513708 +9787810513777 +9787810513814 +9787810513821 +9787810513876 +9787810514255 +9787810514262 +9787810514392 +9787810514422 +9787810514545 +9787810514606 +9787810514613 +9787810514705 +9787810514750 +9787810514811 +9787810514958 +9787810515108 +9787810515160 +9787810515283 +9787810515511 +9787810515535 +9787810515580 +9787810515627 +9787810515740 +9787810515771 +9787810515900 +9787810516020 +9787810516044 +9787810516068 +9787810516303 +9787810516358 +9787810516495 +9787810516709 +9787810516884 +9787810517362 +9787810517416 +9787810517508 +9787810517614 +9787810517706 +9787810517744 +9787810517836 +9787810517867 +9787810517911 +9787810517942 +9787810518161 +9787810518352 +9787810518451 +9787810518468 +9787810518826 +9787810518871 +9787810518918 +9787810518956 +9787810519014 +9787810519076 +9787810519212 +9787810519335 +9787810520584 +9787810521093 +9787810521741 +9787810521765 +9787810523004 +9787810525602 +9787810528009 +9787810529723 +9787810530033 +9787810530040 +9787810530088 +9787810530156 +9787810530248 +9787810530453 +9787810530521 +9787810530576 +9787810532303 +9787810532761 +9787810533058 +9787810533546 +9787810533782 +9787810534291 +9787810534451 +9787810535496 +9787810536011 +9787810536448 +9787810537339 +9787810538305 +9787810538381 +9787810538879 +9787810541404 +9787810542227 +9787810542296 +9787810542326 +9787810543118 +9787810546676 +9787810547703 +9787810548090 +9787810549424 +9787810550185 +9787810551168 +9787810551403 +9787810551465 +9787810551830 +9787810552394 +9787810552431 +9787810552448 +9787810552479 +9787810552707 +9787810552738 +9787810554053 +9787810554220 +9787810554824 +9787810554930 +9787810555166 +9787810556552 +9787810557498 +9787810557726 +9787810559157 +9787810560580 +9787810560610 +9787810561693 +9787810562478 +9787810563499 +9787810563574 +9787810563635 +9787810563826 +9787810563888 +9787810564137 +9787810564342 +9787810564991 +9787810565240 +9787810565752 +9787810566131 +9787810566155 +9787810566223 +9787810566230 +9787810566254 +9787810566278 +9787810566476 +9787810566582 +9787810566612 +9787810567169 +9787810567176 +9787810567206 +9787810567299 +9787810567367 +9787810568289 +9787810568470 +9787810568906 +9787810569453 +9787810569835 +9787810570015 +9787810575218 +9787810578523 +9787810579353 +9787810579810 +9787810580120 +9787810580601 +9787810582926 +9787810582940 +9787810582957 +9787810583824 +9787810585286 +9787810587310 +9787810587709 +9787810587976 +9787810588393 +9787810588539 +9787810588560 +9787810588980 +9787810589543 +9787810589987 +9787810590150 +9787810590891 +9787810591140 +9787810591379 +9787810592666 +9787810592727 +9787810595735 +9787810595902 +9787810599450 +9787810600309 +9787810600521 +9787810600743 +9787810603270 +9787810603980 +9787810603997 +9787810604000 +9787810604017 +9787810604024 +9787810604970 +9787810604987 +9787810606349 +9787810606738 +9787810608992 +9787810610209 +9787810610216 +9787810610568 +9787810611503 +9787810611534 +9787810611541 +9787810615723 +9787810616096 +9787810616195 +9787810616478 +9787810617031 +9787810618441 +9787810630221 +9787810630597 +9787810640046 +9787810640107 +9787810640138 +9787810640145 +9787810640312 +9787810640862 +9787810640930 +9787810641043 +9787810641869 +9787810642217 +9787810645768 +9787810645799 +9787810645928 +9787810650007 +9787810653213 +9787810654760 +9787810655705 +9787810659437 +9787810659741 +9787810659871 +9787810661119 +9787810661577 +9787810663014 +9787810663144 +9787810664110 +9787810665421 +9787810666053 +9787810666343 +9787810666695 +9787810670524 +9787810670579 +9787810670975 +9787810671101 +9787810673266 +9787810674461 +9787810676175 +9787810679497 +9787810680318 +9787810680363 +9787810681018 +9787810683548 +9787810684491 +9787810685085 +9787810686136 +9787810686860 +9787810687096 +9787810687676 +9787810688444 +9787810690065 +9787810700030 +9787810700047 +9787810700054 +9787810700917 +9787810705912 +9787810709903 +9787810710091 +9787810710282 +9787810711876 +9787810712279 +9787810713528 +9787810714198 +9787810715317 +9787810715942 +9787810717144 +9787810717632 +9787810718417 +9787810718424 +9787810720748 +9787810720830 +9787810720977 +9787810721868 +9787810722193 +9787810722636 +9787810722919 +9787810723596 +9787810723978 +9787810724135 +9787810725255 +9787810726153 +9787810726641 +9787810727761 +9787810728942 +9787810729635 +9787810729659 +9787810732369 +9787810734479 +9787810734486 +9787810737579 +9787810737944 +9787810738750 +9787810740098 +9787810740357 +9787810740449 +9787810740579 +9787810740975 +9787810741514 +9787810741668 +9787810741941 +9787810742207 +9787810742399 +9787810742535 +9787810743181 +9787810743204 +9787810743600 +9787810743761 +9787810744386 +9787810744546 +9787810744669 +9787810744713 +9787810744904 +9787810744942 +9787810745383 +9787810745796 +9787810747103 +9787810748384 +9787810748537 +9787810749060 +9787810749213 +9787810750042 +9787810750219 +9787810750301 +9787810752497 +9787810752619 +9787810753364 +9787810755368 +9787810758741 +9787810759052 +9787810760263 +9787810762519 +9787810765343 +9787810767811 +9787810770682 +9787810771368 +9787810771559 +9787810771597 +9787810771733 +9787810771825 +9787810772181 +9787810772457 +9787810776059 +9787810777742 +9787810778800 +9787810779692 +9787810780322 +9787810780438 +9787810781336 +9787810782029 +9787810782043 +9787810782593 +9787810782722 +9787810783521 +9787810789721 +9787810790215 +9787810790260 +9787810790284 +9787810790444 +9787810790727 +9787810790741 +9787810790864 +9787810790871 +9787810791779 +9787810793827 +9787810800235 +9787810800303 +9787810800341 +9787810800549 +9787810800785 +9787810800938 +9787810801058 +9787810801270 +9787810802437 +9787810802710 +9787810803090 +9787810803274 +9787810806107 +9787810806145 +9787810807142 +9787810807340 +9787810808910 +9787810810135 +9787810811996 +9787810812016 +9787810812023 +9787810812634 +9787810813549 +9787810813815 +9787810813990 +9787810814492 +9787810814522 +9787810814607 +9787810815291 +9787810815307 +9787810815352 +9787810815369 +9787810815642 +9787810816625 +9787810816663 +9787810816885 +9787810819374 +9787810820172 +9787810821056 +9787810822251 +9787810824156 +9787810827171 +9787810827485 +9787810830102 +9787810830607 +9787810830911 +9787810831239 +9787810831352 +9787810832083 +9787810832106 +9787810832298 +9787810832335 +9787810832359 +9787810832441 +9787810832458 +9787810832472 +9787810832601 +9787810832670 +9787810832786 +9787810833288 +9787810833301 +9787810833943 +9787810834278 +9787810834537 +9787810834599 +9787810834872 +9787810834933 +9787810834940 +9787810835039 +9787810835169 +9787810835411 +9787810836296 +9787810837460 +9787810838009 +9787810838276 +9787810838658 +9787810838900 +9787810839303 +9787810839389 +9787810839396 +9787810839839 +9787810841252 +9787810844147 +9787810850315 +9787810850339 +9787810850735 +9787810851459 +9787810852401 +9787810852562 +9787810853439 +9787810853798 +9787810853989 +9787810854184 +9787810855327 +9787810857246 +9787810858144 +9787810859325 +9787810863186 +9787810865982 +9787810869133 +9787810871389 +9787810876667 +9787810878784 +9787810882835 +9787810883399 +9787810883566 +9787810890328 +9787810895484 +9787810896313 +9787810897327 +9787810898065 +9787810902816 +9787810902939 +9787810902960 +9787810905251 +9787810906180 +9787810907323 +9787810908399 +9787810908818 +9787810909662 +9787810910071 +9787810910866 +9787810910927 +9787810911610 +9787810911740 +9787810911849 +9787810912105 +9787810913089 +9787810913393 +9787810913492 +9787810913584 +9787810914253 +9787810914574 +9787810914758 +9787810914956 +9787810915113 +9787810915915 +9787810915960 +9787810916448 +9787810916462 +9787810916486 +9787810916509 +9787810918848 +9787810919234 +9787810919500 +9787810919869 +9787810921213 +9787810923057 +9787810924696 +9787810928137 +9787810929240 +9787810930161 +9787810930352 +9787810930789 +9787810932141 +9787810937436 +9787810938488 +9787810939102 +9787810941372 +9787810942386 +9787810946346 +9787810950510 +9787810956239 +9787810957298 +9787810958325 +9787810964210 +9787810965231 +9787810965293 +9787810965460 +9787810965972 +9787810967839 +9787810968201 +9787810968287 +9787810969536 +9787810969710 +9787810969765 +9787810970402 +9787810970709 +9787810971164 +9787810972765 +9787810975094 +9787810977876 +9787810978019 +9787810978958 +9787810980401 +9787810980548 +9787810980920 +9787810982221 +9787810982948 +9787810987233 +9787810989091 +9787810990585 +9787810991858 +9787810992435 +9787810993579 +9787810993630 +9787810994392 +9787810995276 +9787810995382 +9787810995863 +9787810996075 +9787810996143 +9787810996297 +9787810996495 +9787810996969 +9787810997423 +9787810997577 +9787810998680 +9787810999038 +9787811000771 +9787811000917 +9787811001921 +9787811001938 +9787811002225 +9787811002669 +9787811002751 +9787811003970 +9787811004588 +9787811004656 +9787811004748 +9787811004755 +9787811005097 +9787811005547 +9787811005653 +9787811007473 +9787811007527 +9787811007916 +9787811008104 +9787811009224 +9787811010886 +9787811011920 +9787811012453 +9787811013115 +9787811013139 +9787811013443 +9787811013832 +9787811014334 +9787811014471 +9787811014815 +9787811014983 +9787811015164 +9787811016048 +9787811016154 +9787811016482 +9787811016642 +9787811016857 +9787811016864 +9787811017342 +9787811017625 +9787811019100 +9787811019186 +9787811019209 +9787811019223 +9787811019254 +9787811019605 +9787811019698 +9787811019704 +9787811019759 +9787811025422 +9787811028201 +9787811040937 +9787811041675 +9787811044751 +9787811048971 +9787811051230 +9787811051285 +9787811054958 +9787811058574 +9787811059762 +9787811060522 +9787811060621 +9787811064919 +9787811065961 +9787811071085 +9787811073096 +9787811075755 +9787811077148 +9787811079623 +9787811080254 +9787811080278 +9787811080803 +9787811081039 +9787811082401 +9787811082470 +9787811084108 +9787811084313 +9787811084641 +9787811084917 +9787811085488 +9787811088823 +9787811088830 +9787811089264 +9787811091694 +9787811091885 +9787811092929 +9787811094299 +9787811094336 +9787811094510 +9787811095319 +9787811096408 +9787811097344 +9787811098297 +9787811100006 +9787811100778 +9787811103236 +9787811105278 +9787811107050 +9787811107401 +9787811110951 +9787811111842 +9787811111996 +9787811112573 +9787811121124 +9787811121339 +9787811121605 +9787811121872 +9787811123098 +9787811125139 +9787811125146 +9787811125207 +9787811128444 +9787811129236 +9787811129557 +9787811130072 +9787811132106 +9787811132465 +9787811134032 +9787811140026 +9787811142129 +9787811142945 +9787811147612 +9787811151060 +9787811151411 +9787811151626 +9787811151640 +9787811151817 +9787811152005 +9787811152142 +9787811152227 +9787811153682 +9787811154085 +9787811154603 +9787811155648 +9787811156782 +9787811157338 +9787811159295 +9787811159516 +9787811160949 +9787811161915 +9787811162080 +9787811166415 +9787811167160 +9787811170955 +9787811171051 +9787811172096 +9787811174250 +9787811180206 +9787811180770 +9787811183184 +9787811185485 +9787811186031 +9787811189049 +9787811189506 +9787811190021 +9787811190038 +9787811190045 +9787811190786 +9787811190793 +9787811190915 +9787811191004 +9787811191998 +9787811195071 +9787811197150 +9787811198621 +9787811198782 +9787811199055 +9787811200805 +9787811201468 +9787811202342 +9787811202410 +9787811203783 +9787811204650 +9787811205664 +9787811205817 +9787811205916 +9787811206098 +9787811206791 +9787811207057 +9787811207392 +9787811207446 +9787811208320 +9787811208351 +9787811209020 +9787811209617 +9787811209655 +9787811209969 +9787811210170 +9787811210279 +9787811211504 +9787811211528 +9787811211931 +9787811213164 +9787811214703 +9787811215588 +9787811216165 +9787811216226 +9787811217551 +9787811218015 +9787811218190 +9787811218817 +9787811219425 +9787811222180 +9787811228489 +9787811230673 +9787811235319 +9787811240016 +9787811243239 +9787811249729 +9787811251722 +9787811259476 +9787811261554 +9787811261592 +9787811262452 +9787811263695 +9787811265941 +9787811266238 +9787811267518 +9787811268744 +9787811268812 +9787811276787 +9787811280142 +9787811282887 +9787811284119 +9787811286243 +9787811286953 +9787811287226 +9787811287400 +9787811287417 +9787811289022 +9787811289046 +9787811291636 +9787811293753 +9787811293937 +9787811293982 +9787811293999 +9787811294002 +9787811294064 +9787811294071 +9787811299496 +9787811304756 +9787811305012 +9787811305463 +9787811306538 +9787811307016 +9787811309935 +9787811310986 +9787811312324 +9787811319842 +9787811320657 +9787811323573 +9787811324013 +9787811326536 +9787811329971 +9787811331073 +9787811340556 +9787811340747 +9787811343816 +9787811344271 +9787811345391 +9787811347463 +9787811348743 +9787811351316 +9787811352580 +9787811353297 +9787811353365 +9787811355727 +9787811356007 +9787811360653 +9787811364859 +9787811365184 +9787811365467 +9787811365627 +9787811368154 +9787811368673 +9787811369205 +9787811369595 +9787811370447 +9787811375206 +9787811375909 +9787811378696 +9787811379037 +9787811381207 +9787811393057 +9787811393163 +9787811393910 +9787811397109 +9787811402346 +9787811403374 +9787811403381 +9787811403398 +9787811403404 +9787811403411 +9787811403541 +9787811404869 +9787811407785 +9787811411683 +9787811420517 +9787811420821 +9787811424072 +9787811427011 +9787812003238 +9787813581063 +9787815344864 +9787815426256 +9787816121655 +9787824687921 +9787827814751 +9787830000783 +9787830001070 +9787830001117 +9787830001124 +9787830001162 +9787830001360 +9787830001377 +9787830001919 +9787830003449 +9787830003548 +9787830003586 +9787830003739 +9787830003746 +9787830003753 +9787830004149 +9787830004279 +9787830004293 +9787830004309 +9787830004477 +9787830004514 +9787830004606 +9787830004675 +9787830004897 +9787830004965 +9787830004989 +9787830005078 +9787830005320 +9787830005634 +9787830005771 +9787830023218 +9787830023690 +9787830023812 +9787830025694 +9787830026325 +9787830040253 +9787830040260 +9787830040277 +9787830040611 +9787830044022 +9787830044398 +9787830050887 +9787830053345 +9787830081997 +9787830082024 +9787830083151 +9787830083489 +9787830084295 +9787830093136 +9787830094799 +9787830095277 +9787830100322 +9787830111731 +9787830115012 +9787830116415 +9787830123161 +9787830123192 +9787830124168 +9787830124175 +9787830124182 +9787830124632 +9787830125301 +9787830125325 +9787830160050 +9787830160067 +9787830160135 +9787830160449 +9787830160579 +9787830160678 +9787830161026 +9787830161033 +9787830161040 +9787830161156 +9787830161163 +9787830161200 +9787830161309 +9787830161378 +9787830161392 +9787830161491 +9787830161514 +9787830161545 +9787842586312 +9787842787610 +9787844102183 +9787851884683 +9787853711888 +9787854288518 +9787854354527 +9787854873219 +9787857351868 +9787857728974 +9787858061025 +9787876788669 +9787880045697 +9787880048353 +9787880053814 +9787880108019 +9787880158014 +9787880159790 +9787880160550 +9787880163414 +9787880174113 +9787880177763 +9787880331684 +9787880331714 +9787880333534 +9787880333695 +9787880333701 +9787880333718 +9787880333749 +9787880334234 +9787880334692 +9787880334722 +9787880334753 +9787880336856 +9787880364248 +9787880492224 +9787880496697 +9787880501223 +9787880501858 +9787880502381 +9787880502435 +9787880502633 +9787880502688 +9787880503210 +9787880541489 +9787880654103 +9787880654127 +9787880721676 +9787880721867 +9787880733884 +9787880799460 +9787880834505 +9787880836370 +9787883042686 +9787883407492 +9787883525042 +9787883526544 +9787883527831 +9787883528425 +9787883528432 +9787883623885 +9787883623977 +9787883624790 +9787883624806 +9787883626213 +9787883626374 +9787883627432 +9787883628880 +9787883629214 +9787883629252 +9787883629429 +9787883629924 +9787883653691 +9787883692041 +9787883693086 +9787883720416 +9787883720553 +9787883721871 +9787883721932 +9787883721956 +9787883722014 +9787883722120 +9787883722182 +9787883722717 +9787883722731 +9787883722748 +9787883722786 +9787883723257 +9787883723271 +9787883724902 +9787883773160 +9787883779513 +9787883786177 +9787883923480 +9787884034666 +9787884086870 +9787884101474 +9787884105304 +9787884110247 +9787884129423 +9787884130054 +9787884139057 +9787884139095 +9787884139101 +9787884229055 +9787884291731 +9787884306671 +9787884308873 +9787884383627 +9787884753789 +9787884775040 +9787884790579 +9787884791583 +9787884820375 +9787884829156 +9787884832040 +9787884887088 +9787884900022 +9787884901210 +9787884965984 +9787884970049 +9787884970261 +9787884970797 +9787884970964 +9787884972548 +9787884973064 +9787884975020 +9787884976416 +9787884978700 +9787884979998 +9787885137632 +9787885138615 +9787885138653 +9787885160722 +9787885168995 +9787885212421 +9787885216313 +9787885256296 +9787885430146 +9787885430252 +9787885430283 +9787885431501 +9787885433116 +9787885435097 +9787885435226 +9787885435264 +9787885435332 +9787885435394 +9787885435608 +9787885435622 +9787885491635 +9787885781293 +9787885861261 +9787886004964 +9787886005343 +9787886005350 +9787886005367 +9787886005381 +9787886005398 +9787886005404 +9787886005633 +9787886005640 +9787886005664 +9787886005725 +9787886005732 +9787886005749 +9787886005756 +9787886005763 +9787886005770 +9787886005787 +9787886005794 +9787886005800 +9787886005817 +9787886005954 +9787886005985 +9787886006005 +9787886006012 +9787886006029 +9787886006210 +9787886006234 +9787886006241 +9787886006265 +9787886006302 +9787886006319 +9787886006333 +9787886006487 +9787886006494 +9787886006500 +9787886006524 +9787886006531 +9787886006548 +9787886006555 +9787886006562 +9787886006579 +9787886006708 +9787886006739 +9787886006746 +9787886007125 +9787886007149 +9787886007163 +9787886007194 +9787886007323 +9787886007330 +9787886007422 +9787886007439 +9787886007446 +9787886008467 +9787886110948 +9787886180620 +9787886181160 +9787886192883 +9787886193095 +9787887027016 +9787887033529 +9787887221131 +9787887221162 +9787887262066 +9787887262097 +9787887351944 +9787887421968 +9787887422316 +9787887524737 +9787887651136 +9787887790095 +9787888330450 +9787888330467 +9787888331532 +9787888331884 +9787888331952 +9787888332010 +9787888332478 +9787888332539 +9787888332737 +9787888333574 +9787888333697 +9787888333710 +9787888333758 +9787888334052 +9787888335417 +9787888337749 +9787888380370 +9787888460638 +9787888460720 +9787888498594 +9787888499355 +9787888532458 +9787888572140 +9787888950603 +9787888951044 +9787889122139 +9787889160346 +9787889160360 +9787889210898 +9787889297622 +9787889331159 +9787889331296 +9787889331630 +9787889332422 +9787889332439 +9787893891489 +9787893893681 +9787893963872 +9787894111678 +9787894223098 +9787894223104 +9787894252357 +9787894253330 +9787894254979 +9787894255303 +9787894295934 +9787894350121 +9787894351128 +9787894369239 +9787894464750 +9787894465368 +9787894466211 +9787894521163 +9787894521231 +9787894522177 +9787894522849 +9787894544605 +9787894545138 +9787894545282 +9787894621412 +9787894621658 +9787894621863 +9787894627506 +9787894660473 +9787894663344 +9787894663375 +9787894710772 +9787894731821 +9787894731845 +9787894731913 +9787894733689 +9787894734204 +9787894761705 +9787894761996 +9787894763174 +9787894764522 +9787894764874 +9787894764935 +9787894765017 +9787894765048 +9787894767295 +9787894773234 +9787894810199 +9787894810960 +9787894811363 +9787894811387 +9787894811943 +9787894903310 +9787894905086 +9787894912060 +9787894912817 +9787894916945 +9787894917317 +9787894917911 +9787894917935 +9787894917959 +9787894940438 +9787895093782 +9787895093829 +9787895150195 +9787895150249 +9787895193680 +9787895196179 +9787895197190 +9787895214842 +9787895261938 +9787895264748 +9787895332522 +9787895351158 +9787895362475 +9787895363236 +9787895410220 +9787895411869 +9787895448032 +9787899040843 +9787899041697 +9787899904787 +9787899905906 +9787899906873 +9787899906903 +9787899906910 +9787899920428 +9787899930984 +9787899930991 +9787899931868 +9787899931929 +9787899931936 +9787899933510 +9787899942369 +9787899943335 +9787899945209 +9787899945292 +9787899948637 +9787899949610 +9787899964651 +9787899986455 +9787899989777 +9787900000019 +9787900000200 +9787900000958 +9787900024619 +9787900024626 +9787900031075 +9787900031778 +9787900031945 +9787900049940 +9787900051363 +9787900057037 +9787900057112 +9787900057198 +9787900057372 +9787900060259 +9787900069443 +9787900071675 +9787900088529 +9787900095343 +9787900098818 +9787900100412 +9787900107992 +9787900114792 +9787900118981 +9787900128805 +9787900176738 +9787900183460 +9787900203496 +9787900272577 +9787900295316 +9787900335081 +9787900344175 +9787900347374 +9787900360663 +9787900360809 +9787900360885 +9787900360953 +9787900363114 +9787900366528 +9787900369635 +9787900391209 +9787900393524 +9787900399199 +9787900403384 +9787900403926 +9787900405999 +9787900406637 +9787900417992 +9787900419439 +9787900421029 +9787900424419 +9787900430182 +9787900444066 +9787900444769 +9787900444820 +9787900451156 +9787900451477 +9787900451996 +9787900452368 +9787900454140 +9787900486479 +9787900513847 +9787900513939 +9787900526762 +9787900556233 +9787900556547 +9787900592118 +9787900592606 +9787900592842 +9787900600660 +9787900600776 +9787900603579 +9787900617446 +9787900620682 +9787900625274 +9787900625441 +9787900629289 +9787900629319 +9787900629326 +9787900629838 +9787900630988 +9787900631480 +9787900631824 +9787900633668 +9787900635266 +9787900635754 +9787900637185 +9787900637598 +9787900640925 +9787900642912 +9787900652423 +9787900656483 +9787900659156 +9787900672032 +9787900676146 +9787900680716 +9787900681706 +9787900696212 +9787900696458 +9787900696854 +9787900721457 +9787900722287 +9787900722980 +9787900729378 +9787900730763 +9787900734921 +9787900756183 +9787900763846 +9787900782182 +9787900899149 +9787900991690 +9787902578974 +9787904529622 +9787980000299 +9787980015415 +9787980015729 +9787980023076 +9787980031668 +9787980037981 +9787980041681 +9787980047157 +9787980047782 +9787988461177 +9788005880209 +9788010200887 +9788129113788 +9788186336144 +9788484781424 +9788488386311 +9788488386397 +9788488386502 +9788493449230 +9788495951229 +9788497897341 +9788628987552 +9788721304621 +9788800696937 +9788861307162 +9788886542746 +9788936433673 +9788956351483 +9788956351520 +9788965010951 +9788965010968 +9788965011057 +9788965011064 +9788965011088 +9789071894084 +9789460650024 +9789570827798 +9789570840926 +9789570869477 +9789570869552 +9789570873832 +9789571443997 +9789571454887 +9789571458977 +9789571916095 +9789571925486 +9789576680496 +9789576682278 +9789576684012 +9789622012158 +9789787108024 +9789787208076 +9789787301159 +9789787313022 +9789787512203 +9789787552919 +9789787560952 +9789810986988 +9789811407758 +9789811480539 +9789811480560 +9789811480577 +9789814820967 +9789814994279 +9789865571931 +9789866078293 +9789887000129 +9789888869619 +9789900001416 +9789900057895 +9789900130253 +9789900133636 +9789900141051 +9789900187813 +9789900191148 +9789900193449 +9789900212515 +9789900218081 +9789900218678 +9789900270195 +9789900275442 +9789900364412 +9789900372356 +9789900376262 +9789900394655 +9789900399605 +9789900412649 +9789900412922 +9789900412953 +9789900413660 +9789900414278 +9789900414537 +9789900417408 +9789900417415 +9789997102973 +9797020049584 +9797020051730 +9797104020096 +9797104024681 +9797106021268 +9797108021587 +9797301049678 +9797301081579 +9797500457892 +9797500833085 +9797506016314 +9797508705124 +9797532918897 +9797533424632 +9797536671750 +9797536671767 +9797537825367 +9797543448604 +9797563510961 +9797801744790 +9797801744813 +9797802010238 +9797805688915 +9797805689998 +9797806852414 diff --git a/excel/3128518632404838050.xlsx b/excel/3128518632404838050.xlsx new file mode 100644 index 0000000..032b4fc Binary files /dev/null and b/excel/3128518632404838050.xlsx differ diff --git a/excel/3128518632404838051.xlsx b/excel/3128518632404838051.xlsx new file mode 100644 index 0000000..cbda304 Binary files /dev/null and b/excel/3128518632404838051.xlsx differ diff --git a/excel/dll/excel.dll b/excel/dll/excel.dll new file mode 100644 index 0000000..31411c7 Binary files /dev/null and b/excel/dll/excel.dll differ diff --git a/excel/dll/excel.h b/excel/dll/excel.h new file mode 100644 index 0000000..4d15731 --- /dev/null +++ b/excel/dll/excel.h @@ -0,0 +1,141 @@ +/* Code generated by cmd/cgo; DO NOT EDIT. */ + +/* package command-line-arguments */ + + +#line 1 "cgo-builtin-export-prolog" + +#include + +#ifndef GO_CGO_EXPORT_PROLOGUE_H +#define GO_CGO_EXPORT_PROLOGUE_H + +#ifndef GO_CGO_GOSTRING_TYPEDEF +typedef struct { const char *p; ptrdiff_t n; } _GoString_; +extern size_t _GoStringLen(_GoString_ s); +extern const char *_GoStringPtr(_GoString_ s); +#endif + +#endif + +/* Start of preamble from import "C" comments. */ + + +#line 3 "main.go" + +#include + +#line 1 "cgo-generated-wrapper" + + +/* End of preamble from import "C" comments. */ + + +/* Start of boilerplate cgo prologue. */ +#line 1 "cgo-gcc-export-header-prolog" + +#ifndef GO_CGO_PROLOGUE_H +#define GO_CGO_PROLOGUE_H + +typedef signed char GoInt8; +typedef unsigned char GoUint8; +typedef short GoInt16; +typedef unsigned short GoUint16; +typedef int GoInt32; +typedef unsigned int GoUint32; +typedef long long GoInt64; +typedef unsigned long long GoUint64; +typedef GoInt64 GoInt; +typedef GoUint64 GoUint; +typedef size_t GoUintptr; +typedef float GoFloat32; +typedef double GoFloat64; +#ifdef _MSC_VER +#if !defined(__cplusplus) || _MSVC_LANG <= 201402L +#include +typedef _Fcomplex GoComplex64; +typedef _Dcomplex GoComplex128; +#else +#include +typedef std::complex GoComplex64; +typedef std::complex GoComplex128; +#endif +#else +typedef float _Complex GoComplex64; +typedef double _Complex GoComplex128; +#endif + +/* + static assertion to make sure the file is being used on architecture + at least with matching size of GoInt. +*/ +typedef char _check_for_64_bit_pointer_matching_GoInt[sizeof(void*)==64/8 ? 1:-1]; + +#ifndef GO_CGO_GOSTRING_TYPEDEF +typedef _GoString_ GoString; +#endif +typedef void *GoMap; +typedef void *GoChan; +typedef struct { void *t; void *v; } GoInterface; +typedef struct { void *data; GoInt len; GoInt cap; } GoSlice; + +#endif + +/* End of boilerplate cgo prologue. */ + +#ifdef __cplusplus +extern "C" { +#endif + + +// 创建新的Excel管理器并返回指针 +// +extern __declspec(dllexport) long long int NewExcelManagerInstance(void); + +// 释放Excel管理器 +// +extern __declspec(dllexport) void FreeExcelManager(long long int handle); + +// 读取Excel数据 +// +extern __declspec(dllexport) int ReadExcelData(long long int handle, char* filename, char* sheet, char** result); + +// 批量写入数据到Excel文件 +// +extern __declspec(dllexport) int WriteBatchData(long long int handle, char* filename, char* sheet, char* cells, char* values, int count); + +// 追加数据到Excel文件末尾 +// +extern __declspec(dllexport) int AppendDataToExcel(long long int handle, char* filename, char* sheet, char* values, int count); + +// 搜索包含关键字的单元格 +// +extern __declspec(dllexport) int SearchByKeyword(long long int handle, char* filename, char* sheet, char* keyword, char** result); + +// 搜索整行包含关键字的行 +// +extern __declspec(dllexport) int SearchRowsByKeyword(long long int handle, char* filename, char* sheet, char* keyword, char** result); + +// 创建新文件并写入数据 +// +extern __declspec(dllexport) int CreateAndWriteExcel(long long int handle, char* filename, char* sheet, char* rowsData); + +// 增强版合并Excel文件（支持指定文件列表） +// +extern __declspec(dllexport) int MergeExcelFilesEx(long long int handle, char* sourceDir, char* specificFiles, char* outputFile, char* sheetName, int mergeByColumn, int includeHeaders, int skipEmptyRows, char* filePattern, char* sourceSheet, int addSourceColumn, int addIndexColumn); + +// 并行合并Excel文件（增强版） +// +extern __declspec(dllexport) int MergeExcelFilesParallelEx(long long int handle, char* sourceDir, char** specificFiles, int fileCount, char* outputFile, char* sheetName, int includeHeaders, int skipEmptyRows, char* filePattern, char* sourceSheet, int addSourceColumn, int addIndexColumn, int workers); + +// 合并同一文件中的多个sheet +// +extern __declspec(dllexport) int MergeSheetsInFile(long long int handle, char* filename, char* outputFile, char* targetSheetName); + +// 释放C字符串 +// +extern __declspec(dllexport) void FreeCString(char* str); + +#ifdef __cplusplus +} +#endif diff --git a/excel/excelDllTest.go b/excel/excelDllTest.go new file mode 100644 index 0000000..ca31237 --- /dev/null +++ b/excel/excelDllTest.go @@ -0,0 +1,516 @@ +package main + +import "C" +import ( + "encoding/json" + "fmt" + "log" + "os" + "path/filepath" + "strings" + "syscall" + "unsafe" + + "golang.org/x/sys/windows" +) + +// ExcelManagerDLL 封装DLL操作 +type ExcelManagerDLL struct { + dll *windows.LazyDLL + newExcelManager *windows.LazyProc + freeExcelManager *windows.LazyProc + readExcelData *windows.LazyProc + writeBatchData *windows.LazyProc + appendDataToExcel *windows.LazyProc + searchByKeyword *windows.LazyProc + searchRowsByKeyword *windows.LazyProc + createAndWriteExcel *windows.LazyProc + mergeExcelFilesEx *windows.LazyProc + mergeExcelFilesParallelEx *windows.LazyProc + mergeSheetsInFile *windows.LazyProc + freeCString *windows.LazyProc +} + +// LoadExcelManagerDLL 加载DLL并获取函数指针 +func LoadExcelManagerDLL(dllPath string) (*ExcelManagerDLL, error) { + // 使用windows包的LazyDLL加载DLL + dll := windows.NewLazyDLL(dllPath) + + // 验证DLL是否成功加载 + if err := dll.Load(); err != nil { + return nil, fmt.Errorf("加载DLL失败: %v", err) + } + + return &ExcelManagerDLL{ + dll: dll, + newExcelManager: dll.NewProc("NewExcelManagerInstance"), + freeExcelManager: dll.NewProc("FreeExcelManager"), + readExcelData: dll.NewProc("ReadExcelData"), + writeBatchData: dll.NewProc("WriteBatchData"), + appendDataToExcel: dll.NewProc("AppendDataToExcel"), + searchByKeyword: dll.NewProc("SearchByKeyword"), + searchRowsByKeyword: dll.NewProc("SearchRowsByKeyword"), + createAndWriteExcel: dll.NewProc("CreateAndWriteExcel"), + mergeExcelFilesEx: dll.NewProc("MergeExcelFilesEx"), + mergeExcelFilesParallelEx: dll.NewProc("MergeExcelFilesParallelEx"), + mergeSheetsInFile: dll.NewProc("MergeSheetsInFile"), + freeCString: dll.NewProc("FreeCString"), + }, nil +} + +// NewExcelManagerInstance 安全地创建实例（使用句柄） +func (dll *ExcelManagerDLL) NewExcelManagerInstance() (int64, error) { + ret, _, err := dll.newExcelManager.Call() + if err != windows.ERROR_SUCCESS { + return 0, fmt.Errorf("调用NewExcelManagerInstance失败: %v", err) + } + return int64(ret), nil +} + +func (dll *ExcelManagerDLL) FreeExcelManager(handle int64) error { + _, _, err := dll.freeExcelManager.Call(uintptr(handle)) + if err != windows.ERROR_SUCCESS { + return fmt.Errorf("调用FreeExcelManager失败: %v", err) + } + return nil +} + +func (dll *ExcelManagerDLL) ReadExcelData(handle int64, filename, sheet string) (string, error) { + var resultPtr uintptr + // 转换字符串 + filenamePtr, _ := syscall.BytePtrFromString(filename) + sheetPtr, _ := syscall.BytePtrFromString(sheet) + // 调用DLL函数 + ret, _, _ := dll.readExcelData.Call( + uintptr(handle), + uintptr(unsafe.Pointer(filenamePtr)), + uintptr(unsafe.Pointer(sheetPtr)), + uintptr(unsafe.Pointer(&resultPtr)), + ) + if int32(ret) != 0 { + return "", fmt.Errorf("读取Excel数据失败，错误码: %d", ret) + } + // 转换结果字符串 + if resultPtr != 0 { + resultStr := C.GoString((*C.char)(unsafe.Pointer(resultPtr))) + // 释放C字符串 + dll.FreeCString((*C.char)(unsafe.Pointer(resultPtr))) + return resultStr, nil + } + return "", nil +} + +func (dll *ExcelManagerDLL) WriteBatchData(handle int64, filename, sheet string, cells, values []string) error { + if len(cells) != len(values) { + return fmt.Errorf("单元格和值数量不匹配") + } + // 转换字符串 + filenamePtr, _ := syscall.BytePtrFromString(filename) + sheetPtr, _ := syscall.BytePtrFromString(sheet) + + cellMarshal, err := json.Marshal(cells) + if err != nil { + return fmt.Errorf("信息cells转换失败！") + } + cellsString := string(cellMarshal) + cellsPtr, _ := syscall.BytePtrFromString(cellsString) + + valuesMarshal, err := json.Marshal(values) + if err != nil { + return fmt.Errorf("信息values转换失败！") + } + valuesString := string(valuesMarshal) + valuesPtr, _ := syscall.BytePtrFromString(valuesString) + + // 调用DLL函数 + ret, _, _ := dll.writeBatchData.Call( + uintptr(handle), + uintptr(unsafe.Pointer(filenamePtr)), + uintptr(unsafe.Pointer(sheetPtr)), + uintptr(unsafe.Pointer(cellsPtr)), + uintptr(unsafe.Pointer(valuesPtr)), + uintptr(len(cells)), + ) + + if int32(ret) != 0 { + return fmt.Errorf("批量写入Excel数据失败，错误码: %d", ret) + } + + return nil +} + +func (dll *ExcelManagerDLL) AppendDataToExcel(handle int64, filename, sheet string, values []string) error { + // 转换字符串 + filenamePtr, _ := syscall.BytePtrFromString(filename) + sheetPtr, _ := syscall.BytePtrFromString(sheet) + + valuesMarshal, err := json.Marshal(values) + if err != nil { + return fmt.Errorf("信息values转换失败！") + } + valuesString := string(valuesMarshal) + valuesPtr, _ := syscall.BytePtrFromString(valuesString) + + // 调用DLL函数 + ret, _, err := dll.appendDataToExcel.Call( + uintptr(handle), + uintptr(unsafe.Pointer(filenamePtr)), + uintptr(unsafe.Pointer(sheetPtr)), + uintptr(unsafe.Pointer(valuesPtr)), + uintptr(len(values)), + ) + if int32(ret) != 0 { + return fmt.Errorf("追加Excel数据失败，错误码: %d", ret) + } + + return nil +} + +func (dll *ExcelManagerDLL) SearchByKeyword(handle int64, filename, sheet, keyword string) (string, error) { + // 转换字符串 + filenamePtr, _ := syscall.BytePtrFromString(filename) + sheetPtr, _ := syscall.BytePtrFromString(sheet) + keywordPtr, _ := syscall.BytePtrFromString(keyword) + // 分配内存存储结果指针 + var resultPtr uintptr + // 调用DLL函数 + ret, _, _ := dll.searchByKeyword.Call( + uintptr(handle), + uintptr(unsafe.Pointer(filenamePtr)), + uintptr(unsafe.Pointer(sheetPtr)), + uintptr(unsafe.Pointer(keywordPtr)), + uintptr(unsafe.Pointer(&resultPtr)), + ) + if int32(ret) != 0 { + return "", fmt.Errorf("搜索Excel数据失败，错误码: %d", ret) + } + // 转换结果字符串 + if resultPtr != 0 { + resultStr := C.GoString((*C.char)(unsafe.Pointer(resultPtr))) + // 释放C字符串 + dll.FreeCString((*C.char)(unsafe.Pointer(resultPtr))) + return resultStr, nil + } + return "", nil +} + +// CreateAndWriteExcel 创建新文件并写入数据 +func (dll *ExcelManagerDLL) CreateAndWriteExcel(handle int64, filename, sheet string, data [][]string) error { + // 确保目录存在 + dir := filepath.Dir(filename) + if err := os.MkdirAll(dir, 0755); err != nil { + return fmt.Errorf("创建目录失败: %v", err) + } + + fmt.Printf("调试信息:\n") + fmt.Printf(" - 文件名: %s\n", filename) + fmt.Printf(" - Sheet: %s\n", sheet) + + marshal, err2 := json.Marshal(data) + if err2 != nil { + return err2 + } + dataString := string(marshal) + filenamePtr, _ := syscall.BytePtrFromString(filename) + sheetPtr, _ := syscall.BytePtrFromString(sheet) + dataStringPtr, _ := syscall.BytePtrFromString(dataString) + + // 调用DLL函数 + ret, _, _ := dll.createAndWriteExcel.Call( + uintptr(handle), + uintptr(unsafe.Pointer(filenamePtr)), + uintptr(unsafe.Pointer(sheetPtr)), + uintptr(unsafe.Pointer(dataStringPtr)), + ) + fmt.Printf(" - DLL调用返回: %d\n", int32(ret)) + + if int32(ret) != 0 { + return fmt.Errorf("创建并写入Excel文件失败，错误码: %d", ret) + } + + return nil +} + +func (dll *ExcelManagerDLL) MergeExcelFilesEx(handle int64, config MergeConfig) error { + // 转换字符串 + sourceDirPtr, _ := syscall.BytePtrFromString(config.SourceDir) + outputFilePtr, _ := syscall.BytePtrFromString(config.OutputFile) + sheetNamePtr, _ := syscall.BytePtrFromString(config.SheetName) + filePatternPtr, _ := syscall.BytePtrFromString(config.FilePattern) + sourceSheetPtr, _ := syscall.BytePtrFromString(config.SourceSheet) + + marshal, err := json.Marshal(config.SpecificFiles) + if err != nil { + return fmt.Errorf("序列化失败: %s", err) + } + specificFilesString := string(marshal) + specificFilesPtr, _ := syscall.BytePtrFromString(specificFilesString) + + // 调用DLL函数 + ret, _, err := dll.mergeExcelFilesEx.Call( + uintptr(handle), + uintptr(unsafe.Pointer(sourceDirPtr)), + uintptr(unsafe.Pointer(specificFilesPtr)), + uintptr(unsafe.Pointer(outputFilePtr)), + uintptr(unsafe.Pointer(sheetNamePtr)), + uintptr(boolToInt(config.MergeByColumn)), + uintptr(boolToInt(config.IncludeHeaders)), + uintptr(boolToInt(config.SkipEmptyRows)), + uintptr(unsafe.Pointer(filePatternPtr)), + uintptr(unsafe.Pointer(sourceSheetPtr)), + uintptr(boolToInt(config.AddSourceColumn)), + uintptr(boolToInt(config.AddIndexColumn)), + ) + + if int32(ret) != 0 { + return fmt.Errorf("合并Excel文件失败，错误码: %d", ret) + } + + return nil +} + +func (dll *ExcelManagerDLL) FreeCString(str *C.char) { + if str != nil { + dll.freeCString.Call(uintptr(unsafe.Pointer(str))) + } +} + +//// MergeConfig 合并配置 +//type MergeConfig struct { +// SourceDir string // 源目录 +// SpecificFiles []string // 指定要合并的文件列表 +// OutputFile string // 输出文件 +// SheetName string // 目标sheet名称 +// MergeByColumn bool // 是否按列合并（默认按行） +// IncludeHeaders bool // 是否包含表头（仅第一个文件） +// SkipEmptyRows bool // 是否跳过空行 +// FilePattern string // 文件匹配模式，如 "*.xlsx" +// SourceSheet string // 源sheet名称（为空则使用第一个sheet） +// AddSourceColumn bool // 是否添加源文件列 +// AddIndexColumn bool // 是否添加序号列 +//} + +// 辅助函数 +func boolToInt(b bool) int32 { + if b { + return 1 + } + return 0 +} + +// 创建测试Excel文件 +func createTestExcelFile(filename string) error { + file, err := os.Create(filename) + if err != nil { + return err + } + defer file.Close() + + // 写入一些测试数据（简单的CSV格式） + content := `姓名,年龄,城市 +张三,25,北京 +李四,30,上海 +王五,28,广州 +测试数据,35,深圳` + + _, err = file.WriteString(content) + return err +} + +func main() { + fmt.Println("=== Excel Manager DLL 动态加载测试程序 ===") + + // 1. 加载DLL + dllPath := "excel/dll/excel.dll" + if _, err := os.Stat(dllPath); os.IsNotExist(err) { + log.Fatalf("找不到DLL文件: %s", dllPath) + } + + fmt.Printf("1. 加载DLL: %s\n", dllPath) + excelDLL, err := LoadExcelManagerDLL(dllPath) + if err != nil { + log.Fatalf("加载DLL失败: %v", err) + } + fmt.Println(" DLL加载成功") + + // 2. 创建ExcelManager实例 + fmt.Println("\n2. 创建ExcelManager实例...") + handle, err := excelDLL.NewExcelManagerInstance() + if err != nil || handle == 0 { + log.Fatalf("创建ExcelManager实例失败: %v", err) + } + fmt.Printf(" ExcelManager实例创建成功，句柄: 0x%x\n", handle) + defer excelDLL.FreeExcelManager(handle) + + //// 创建测试目录 + //testDir := "./test_data" + //if err := os.MkdirAll(testDir, 0755); err != nil { + // log.Fatalf("创建测试目录失败: %v", err) + //} + + //3. 测试CreateAndWriteExcel函数 + fmt.Println("\n3. 测试CreateAndWriteExcel函数...") + newFile := filepath.Join("excel", "3128518632404838051.xlsx") + + //// 创建测试数据 + //testData := [][]string{ + // {"序号", "姓名", "年龄", "城市"}, + // {"1", "张三", "25", "北京"}, + // {"2", "李四", "30", "上海"}, + // {"3", "王五", "28", "广州"}, + // {"4", "赵六", "35", "深圳"}, + // {"5", "测试人员", "40", "杭州"}, + //} + // + //fmt.Printf(" 创建新文件: %s\n", newFile) + //fmt.Printf(" 数据维度: %d行 × %d列\n", len(testData), len(testData[0])) + // + //if err := excelDLL.CreateAndWriteExcel(handle, newFile, "员工信息", testData); err != nil { + // fmt.Printf("CreateAndWriteExcel失败: %v\n", err) + //} else { + // fmt.Println("CreateAndWriteExcel成功") + // // 验证文件是否创建成功 + // if _, err := os.Stat(newFile); err == nil { + // fmt.Println(" 文件已成功创建") + // // 尝试读取刚刚创建的文件 + // fmt.Println(" 验证文件内容...") + result, err := excelDLL.ReadExcelData(handle, newFile, "订单操作记录") + if err != nil { + fmt.Printf(" 读取文件失败: %v\n", err) + } else { + fmt.Printf(" 原始数据:\n%s\n", result) + } + + // 1. 去除首尾可能存在的空格 + result = strings.TrimSpace(result) + // + // } + //} + // + //// 4. 测试批量写入 + //fmt.Println("\n5. 测试批量写入...") + //cells := []string{"A6", "B6", "C6", "D6", "E6"} + //values := []string{"5", "批量2", "批量3", "批量4", "批量5"} + //if err := excelDLL.WriteBatchData(handle, newFile, "员工信息", cells, values); err != nil { + // fmt.Printf(" 批量写入失败: %v\n", err) + //} else { + // fmt.Println(" 批量写入成功") + //} + // + //// 5. 测试追加数据 + //fmt.Println("\n6. 测试追加数据...") + //appendValues := []string{"6", "孙七", "32", "南京", "追加数据"} + //if err := excelDLL.AppendDataToExcel(handle, newFile, "员工信息", appendValues); err != nil { + // fmt.Printf(" 追加数据失败: %v\n", err) + //} else { + // fmt.Println(" 追加数据成功") + //} + // + //// 7. 测试搜索功能 + //fmt.Println("\n7. 测试搜索功能...") + //keyword := "nihao" + //searchResult, err := excelDLL.SearchByKeyword(handle, newFile, "员工信息", keyword) + //if err != nil { + // fmt.Printf("搜索失败: %v\n", err) + //} else { + // if searchResult == "" { + // fmt.Printf("没有搜索到该信息: %s\n", keyword) + // } else { + // fmt.Printf("搜索成功，结果:\n%s\n", searchResult) + // } + //} + // + //// 8. 测试合并文件（需要至少两个文件） + //fmt.Println("\n8. 测试合并文件...") + //// 合并两个文件 + //mergedFile := filepath.Join("excel", "merged_output.xlsx") + //fmt.Println(mergedFile) + //mergeConfig := MergeConfig{ + // SourceDir: "excel", + // SpecificFiles: []string{newFile, "excel/new_file1.xlsx"}, + // OutputFile: mergedFile, + // SheetName: "合并结果", + // MergeByColumn: false, + // IncludeHeaders: true, + // SkipEmptyRows: false, + // FilePattern: "", + // SourceSheet: "", // 使用默认sheet + // AddSourceColumn: true, + // AddIndexColumn: true, + //} + // + //if err := excelDLL.MergeExcelFilesEx(handle, mergeConfig); err != nil { + // fmt.Printf(" 合并文件失败: %v\n", err) + //} else { + // fmt.Println(" 合并文件成功") + // fmt.Printf(" 输出文件: %s\n", mergedFile) + //} + + //// 9. 清理测试文件（可选） + //fmt.Println("\n9. 清理测试文件...") + //cleanup := true + //if cleanup { + // filesToRemove := []string{ + // newFile, + // secondFile, + // filepath.Join(testDir, "merged_output.xlsx"), + // } + // + // for _, file := range filesToRemove { + // if _, err := os.Stat(file); err == nil { + // if err := os.Remove(file); err == nil { + // fmt.Printf(" 删除: %s\n", file) + // } + // } + // } +} + +//fmt.Println("\n=== 所有测试完成 ===") +// +////显 示测试总结 +//fmt.Println("\n测试总结:") +//fmt.Println("1. CreateAndWriteExcel - 创建新文件并写入数据 ✓") +//fmt.Println("2. WriteDataToExcel - 写入单个单元格 ✓") +//fmt.Println("3. WriteBatchData - 批量写入数据 ✓") +//fmt.Println("4. AppendDataToExcel - 追加数据 ✓") +//fmt.Println("5. SearchByKeyword - 搜索关键词 ✓") +//fmt.Println("6. MergeExcelFilesEx - 合并文件 ✓") +//fmt.Println("7. ReadExcelData - 读取数据 ✓") +//} + +//func ParseExcelDataToJSON(excelData string) ([]map[string]string, error) { +// if excelData == "" { +// return nil, fmt.Errorf("Excel数据为空") +// } +// +// // 使用csv解析器解析数据 +// reader := csv.NewReader(strings.NewReader(excelData)) +// records, err := reader.ReadAll() +// if err != nil { +// return nil, fmt.Errorf("解析CSV数据失败: %v", err) +// } +// +// if len(records) < 2 { +// return nil, fmt.Errorf("数据行数不足") +// } +// +// // 提取表头（第一行） +// headers := records[0] +// +// // 将数据转换为JSON格式 +// var jsonData []map[string]string +// +// // 从第二行开始（跳过表头） +// for i := 1; i < len(records); i++ { +// row := records[i] +// rowData := make(map[string]string) +// +// // 确保每行的列数与表头一致 +// for j := 0; j < len(headers) && j < len(row); j++ { +// rowData[headers[j]] = row[j] +// } +// jsonData = append(jsonData, rowData) +// } +// +// return jsonData, nil +//} diff --git a/excel/excel_so.go b/excel/excel_so.go new file mode 100644 index 0000000..d6c685b --- /dev/null +++ b/excel/excel_so.go @@ -0,0 +1,1425 @@ +package main + +///* +//#cgo LDFLAGS: -ldl +// +//#include +//#include +//#include +//*/ +//import "C" +//import ( +// "encoding/csv" +// "encoding/json" +// "fmt" +// "github.com/xuri/excelize/v2" +// "os" +// "path/filepath" +// "sort" +// "strings" +// "sync" +// "unsafe" +//) +// +//// ExcelManager 线程安全的Excel文件管理器 +//type ExcelManager struct { +// mu sync.RWMutex +// fileMap map[string]*excelize.File // 存储打开的文件 +//} +// +//// MergeConfig 合并配置 +//type MergeConfig struct { +// SourceDir string // 源目录 +// OutputFile string // 输出文件 +// SheetName string // 目标sheet名称 +// MergeByColumn bool // 是否按列合并（默认按行） +// IncludeHeaders bool // 是否包含表头（仅第一个文件） +// SkipEmptyRows bool // 是否跳过空行 +// FilePattern string // 文件匹配模式，如 "*.xlsx" +// SpecificFiles []string // 指定要合并的文件列表 +// SourceSheet string // 源sheet名称（为空则使用第一个sheet） +// AddSourceColumn bool // 是否添加源文件列 +// AddIndexColumn bool // 是否添加序号列 +//} +// +//// NewExcelManager 创建新的Excel管理器 +//func NewExcelManager() *ExcelManager { +// return &ExcelManager{ +// fileMap: make(map[string]*excelize.File), +// } +//} +// +//// ============ 基本Excel操作功能 ============ +// +//// ReadData 读取Excel数据 +//func (em *ExcelManager) ReadData(filename, sheet string) ([][]string, error) { +// em.mu.RLock() +// defer em.mu.RUnlock() +// fmt.Printf("[DEBUG] ReadData开始: file=%s, sheet=%s\n", filename, sheet) +// file, err := excelize.OpenFile(filename) +// if err != nil { +// return nil, err +// } +// defer file.Close() +// rows, err := file.GetRows(sheet) +// if err != nil { +// return nil, fmt.Errorf("读取sheet %s 失败: %v", sheet, err) +// } +// fmt.Printf("[DEBUG] 读取的数据：", rows) +// return rows, nil +//} +// +//// WriteData 写入数据到指定位置 +//func (em *ExcelManager) WriteData(filename, sheet string, data map[string]interface{}) error { +// em.mu.Lock() +// defer em.mu.Unlock() +// +// file, err := excelize.OpenFile(filename) +// if err != nil { +// // 文件不存在，创建新文件 +// file = excelize.NewFile() +// file.NewSheet(sheet) +// } else { +// // 确保sheet存在 +// index, _ := file.GetSheetIndex(sheet) +// if index == -1 { +// file.NewSheet(sheet) +// } +// } +// +// // 写入数据 +// for cell, value := range data { +// file.SetCellValue(sheet, cell, value) +// } +// +// // 保存文件 +// return file.SaveAs(filename) +//} +// +//// AppendData 追加数据到末尾 +//func (em *ExcelManager) AppendData(filename, sheet string, rowData []interface{}) error { +// em.mu.Lock() +// defer em.mu.Unlock() +// +// file, err := excelize.OpenFile(filename) +// if err != nil { +// return err +// } +// defer func() { +// file.SaveAs(filename) +// file.Close() +// }() +// +// // 确保sheet存在 +// index, _ := file.GetSheetIndex(sheet) +// if index == -1 { +// file.NewSheet(sheet) +// } +// +// // 获取当前最大行号 +// rows, err := file.GetRows(sheet) +// if err != nil { +// return err +// } +// +// nextRow := len(rows) + 1 +// if len(rows) == 0 { +// nextRow = 1 +// } +// +// // 写入新行 +// for col, value := range rowData { +// cell, _ := excelize.CoordinatesToCellName(col+1, nextRow) +// file.SetCellValue(sheet, cell, value) +// } +// +// return nil +//} +// +//// SearchByKeyword 搜索包含关键字的单元格 +//func (em *ExcelManager) SearchByKeyword(filename, sheet, keyword string) ([]string, error) { +// em.mu.RLock() +// defer em.mu.RUnlock() +// +// file, err := excelize.OpenFile(filename) +// if err != nil { +// return nil, err +// } +// defer file.Close() +// +// var results []string +// rows, err := file.GetRows(sheet) +// if err != nil { +// return nil, err +// } +// +// for rowIndex, row := range rows { +// for colIndex, cell := range row { +// if strings.Contains(cell, keyword) { +// cellName, _ := excelize.CoordinatesToCellName(colIndex+1, rowIndex+1) +// results = append(results, +// fmt.Sprintf("位置: %s, 值: %s", cellName, cell)) +// } +// } +// } +// +// return results, nil +//} +// +//// SearchRowData 搜索整行包含关键字的行 +//func (em *ExcelManager) SearchRowData(filename, sheet, keyword string) ([][]string, error) { +// em.mu.RLock() +// defer em.mu.RUnlock() +// +// file, err := excelize.OpenFile(filename) +// if err != nil { +// return nil, err +// } +// defer file.Close() +// +// var results [][]string +// rows, err := file.GetRows(sheet) +// if err != nil { +// return nil, err +// } +// +// for _, row := range rows { +// for _, cell := range row { +// if strings.Contains(cell, keyword) { +// results = append(results, row) +// break +// } +// } +// } +// +// return results, nil +//} +// +//// CreateAndWrite 创建新文件并写入数据 +//func (em *ExcelManager) CreateAndWrite(filename, sheet string, data [][]string) error { +// em.mu.Lock() +// defer em.mu.Unlock() +// +// // 创建新文件 +// file := excelize.NewFile() +// defer file.Close() +// +// // 如果指定sheet不是"Sheet1"，则重命名默认sheet +// if sheet != "Sheet1" { +// file.SetSheetName("Sheet1", sheet) +// } +// +// // 写入数据 +// for rowIndex, row := range data { +// for colIndex, value := range row { +// cell, _ := excelize.CoordinatesToCellName(colIndex+1, rowIndex+1) +// file.SetCellValue(sheet, cell, value) +// } +// } +// +// // 保存文件 +// return file.SaveAs(filename) +//} +// +//// CloseAll 关闭所有文件 +//func (em *ExcelManager) CloseAll() error { +// em.mu.Lock() +// defer em.mu.Unlock() +// +// var lastErr error +// for filename, file := range em.fileMap { +// if err := file.Close(); err != nil { +// lastErr = err +// } +// delete(em.fileMap, filename) +// } +// return lastErr +//} +// +//// ============ Excel合并功能 ============ +// +//// MergeExcelFiles 合并多个Excel文件（批次合并） +//func (em *ExcelManager) MergeExcelFiles(config MergeConfig) error { +// em.mu.Lock() +// defer em.mu.Unlock() +// +// // 获取要合并的文件列表 +// filesToMerge, err := em.getFilesToMerge(config) +// if err != nil { +// return err +// } +// +// fmt.Printf("开始合并 %d 个文件:\n", len(filesToMerge)) +// for i, file := range filesToMerge { +// fmt.Printf(" %d. %s\n", i+1, filepath.Base(file)) +// } +// +// // 创建新的输出文件 +// outputFile := excelize.NewFile() +// defer outputFile.Close() +// +// // 删除默认的Sheet1 +// outputFile.DeleteSheet("Sheet1") +// +// // 创建目标sheet并设置为活动sheet +// sheetIndex, err := outputFile.NewSheet(config.SheetName) +// if err != nil { +// return fmt.Errorf("创建sheet失败: %v", err) +// } +// outputFile.SetActiveSheet(sheetIndex) +// +// currentRow := 1 +// totalRowsMerged := 0 +// fileCount := len(filesToMerge) +// +// // 写入表头（如果需要） +// if config.IncludeHeaders && fileCount > 0 { +// headers, err := em.readFileHeaders(filesToMerge[0], config.SourceSheet) +// if err != nil { +// fmt.Printf("警告: 无法读取第一个文件的表头: %v\n", err) +// } else { +// // 添加额外的列（如果需要） +// colOffset := 0 +// if config.AddIndexColumn { +// headers = append([]string{"序号"}, headers...) +// colOffset++ +// } +// if config.AddSourceColumn { +// headers = append([]string{"源文件"}, headers...) +// colOffset++ +// } +// +// // 写入表头 +// for colIndex, header := range headers { +// cellName, _ := excelize.CoordinatesToCellName(colIndex+1, currentRow) +// outputFile.SetCellValue(config.SheetName, cellName, header) +// } +// currentRow++ +// fmt.Printf("写入表头: %v\n", headers) +// } +// } +// +// // 合并所有文件 +// for fileIndex, sourceFile := range filesToMerge { +// rowsMerged, err := em.mergeSingleFile(outputFile, config, sourceFile, fileIndex, fileCount, ¤tRow) +// if err != nil { +// fmt.Printf("警告: 合并文件 %s 时出错: %v，跳过\n", sourceFile, err) +// continue +// } +// totalRowsMerged += rowsMerged +// } +// +// // 保存输出文件 +// if err := outputFile.SaveAs(config.OutputFile); err != nil { +// return fmt.Errorf("保存合并文件失败: %v", err) +// } +// +// fmt.Printf("合并完成！结果保存在: %s\n", config.OutputFile) +// fmt.Printf("统计信息:\n") +// fmt.Printf(" - 合并文件数: %d\n", fileCount) +// fmt.Printf(" - 合并数据行数: %d\n", totalRowsMerged) +// fmt.Printf(" - 输出文件总行数: %d\n", currentRow-1) +// +// // 验证文件是否正确保存 +// if err := em.verifyMergeResult(config.OutputFile, config.SheetName); err != nil { +// return fmt.Errorf("合并结果验证失败: %v", err) +// } +// +// return nil +//} +// +//// getFilesToMerge 获取要合并的文件列表 +//func (em *ExcelManager) getFilesToMerge(config MergeConfig) ([]string, error) { +// var filesToMerge []string +// +// if len(config.SpecificFiles) > 0 { +// filesToMerge = config.SpecificFiles +// } else if config.SourceDir != "" { +// pattern := "*.xlsx" +// if config.FilePattern != "" { +// pattern = config.FilePattern +// } +// +// files, err := filepath.Glob(filepath.Join(config.SourceDir, pattern)) +// if err != nil { +// return nil, fmt.Errorf("查找文件失败: %v", err) +// } +// filesToMerge = files +// } else { +// return nil, fmt.Errorf("必须指定SourceDir或SpecificFiles") +// } +// +// if len(filesToMerge) == 0 { +// return nil, fmt.Errorf("没有找到要合并的Excel文件") +// } +// +// // 按文件名排序 +// sort.Strings(filesToMerge) +// return filesToMerge, nil +//} +// +//// readFileHeaders 读取文件的表头 +//func (em *ExcelManager) readFileHeaders(filename, sheetName string) ([]string, error) { +// srcFile, err := excelize.OpenFile(filename) +// if err != nil { +// return nil, err +// } +// defer srcFile.Close() +// +// sourceSheet := em.getSourceSheet(srcFile, sheetName) +// if sourceSheet == "" { +// return nil, fmt.Errorf("未找到可用的sheet") +// } +// +// rows, err := srcFile.GetRows(sourceSheet) +// if err != nil { +// return nil, err +// } +// +// if len(rows) == 0 { +// return nil, fmt.Errorf("文件没有数据") +// } +// +// return rows[0], nil +//} +// +//// mergeSingleFile 合并单个文件 +//func (em *ExcelManager) mergeSingleFile(outputFile *excelize.File, config MergeConfig, +// sourceFile string, fileIndex, fileCount int, currentRow *int) (int, error) { +// +// fmt.Printf("\n[%d/%d] 正在处理文件: %s\n", fileIndex+1, fileCount, filepath.Base(sourceFile)) +// +// // 打开源文件 +// srcFile, err := excelize.OpenFile(sourceFile) +// if err != nil { +// return 0, fmt.Errorf("打开文件失败: %v", err) +// } +// defer srcFile.Close() +// +// // 确定要读取的sheet +// sourceSheet := em.getSourceSheet(srcFile, config.SourceSheet) +// if sourceSheet == "" { +// return 0, fmt.Errorf("未找到可用的sheet") +// } +// +// // 读取源文件数据 +// rows, err := srcFile.GetRows(sourceSheet) +// if err != nil { +// return 0, fmt.Errorf("读取数据失败: %v", err) +// } +// +// if len(rows) == 0 { +// fmt.Printf(" 警告: 文件没有数据，跳过\n") +// return 0, nil +// } +// +// fmt.Printf(" 读取到 %d 行数据\n", len(rows)) +// +// rowsMerged := 0 +// +// // 处理数据行 +// for rowIndex, row := range rows { +// // 跳过空行 +// if config.SkipEmptyRows && em.isRowEmpty(row) { +// continue +// } +// fmt.Println(rowIndex) +// // 处理表头（如果是第一个文件且包含表头，第一行已经处理过了） +// if config.IncludeHeaders && rowIndex == 0 { +// if fileIndex == 0 { +// // 第一个文件的表头已处理，跳过 +// continue +// } else { +// // 后续文件的表头跳过 +// continue +// } +// } +// +// // 写入数据行 +// colOffset := 0 +// +// // 添加序号列 +// if config.AddIndexColumn { +// cellName, _ := excelize.CoordinatesToCellName(1, *currentRow) +// outputFile.SetCellValue(config.SheetName, cellName, rowsMerged+1) +// colOffset++ +// } +// +// // 添加源文件列 +// if config.AddSourceColumn { +// cellName, _ := excelize.CoordinatesToCellName(1+colOffset, *currentRow) +// outputFile.SetCellValue(config.SheetName, cellName, filepath.Base(sourceFile)) +// colOffset++ +// } +// +// // 写入原始数据 +// for colIndex, cell := range row { +// cellName, _ := excelize.CoordinatesToCellName(colIndex+1+colOffset, *currentRow) +// outputFile.SetCellValue(config.SheetName, cellName, cell) +// } +// +// rowsMerged++ +// *currentRow++ +// } +// +// //// 添加文件分隔信息（如果有数据被合并） +// //if rowsMerged > 0 { +// // // 添加分隔行 +// // separatorCell, _ := excelize.CoordinatesToCellName(1, *currentRow) +// // outputFile.SetCellValue(config.SheetName, separatorCell, +// // fmt.Sprintf("=== 文件 %d/%d: %s (合并了 %d 行) ===", +// // fileIndex+1, fileCount, filepath.Base(sourceFile), rowsMerged)) +// // *currentRow++ +// //} +// +// fmt.Printf(" 文件处理完成，合并了 %d 行数据\n", rowsMerged) +// return rowsMerged, nil +//} +// +//// getSourceSheet 获取源sheet名称 +//func (em *ExcelManager) getSourceSheet(file *excelize.File, preferredSheet string) string { +// if preferredSheet != "" { +// if index, _ := file.GetSheetIndex(preferredSheet); index != -1 { +// return preferredSheet +// } +// } +// +// // 返回第一个sheet +// sheets := file.GetSheetList() +// if len(sheets) > 0 { +// return sheets[0] +// } +// return "" +//} +// +//// verifyMergeResult 验证合并结果 +//func (em *ExcelManager) verifyMergeResult(filename, sheet string) error { +// file, err := excelize.OpenFile(filename) +// if err != nil { +// return fmt.Errorf("打开验证文件失败: %v", err) +// } +// defer file.Close() +// +// rows, err := file.GetRows(sheet) +// if err != nil { +// return fmt.Errorf("读取sheet失败: %v", err) +// } +// +// fmt.Printf("\n验证结果:\n") +// fmt.Printf(" 文件: %s\n", filename) +// fmt.Printf(" Sheet: %s\n", sheet) +// fmt.Printf(" 总行数: %d\n", len(rows)) +// +// if len(rows) == 0 { +// return fmt.Errorf("警告: 合并后的文件没有数据!") +// } +// +// // 显示前5行数据 +// limit := 5 +// if len(rows) < limit { +// limit = len(rows) +// } +// +// fmt.Printf(" 前%d行数据预览:\n", limit) +// for i := 0; i < limit; i++ { +// // 只显示前5列（避免输出过长） +// previewCols := 5 +// if len(rows[i]) < previewCols { +// previewCols = len(rows[i]) +// } +// fmt.Printf(" 第%d行: %v", i+1, rows[i][:previewCols]) +// if len(rows[i]) > previewCols { +// fmt.Printf(" ... (+%d列)", len(rows[i])-previewCols) +// } +// fmt.Println() +// } +// +// return nil +//} +// +//// MergeExcelFilesParallel 并行合并Excel文件（高性能） +//func (em *ExcelManager) MergeExcelFilesParallel(config MergeConfig, workers int) error { +// em.mu.Lock() +// defer em.mu.Unlock() +// +// // 获取要合并的文件列表 +// filesToMerge, err := em.getFilesToMerge(config) +// if err != nil { +// return err +// } +// +// fmt.Printf("开始并行合并 %d 个文件，使用 %d 个worker:\n", len(filesToMerge), workers) +// +// // 创建通道和等待组 +// fileChan := make(chan fileTask, len(filesToMerge)) +// resultChan := make(chan fileResult, len(filesToMerge)) +// var wg sync.WaitGroup +// +// // 启动worker goroutines +// for i := 0; i < workers; i++ { +// wg.Add(1) +// go func(workerID int) { +// defer wg.Done() +// for task := range fileChan { +// fmt.Printf("Worker %d 正在处理: %s (文件 %d/%d)\n", +// workerID, filepath.Base(task.filename), task.index+1, task.total) +// data := em.readExcelFileParallel(task.filename, config.SourceSheet) +// resultChan <- fileResult{ +// filename: task.filename, +// index: task.index, +// data: data, +// } +// } +// }(i) +// } +// +// // 发送文件任务到通道 +// for i, file := range filesToMerge { +// fileChan <- fileTask{ +// filename: file, +// index: i, +// total: len(filesToMerge), +// } +// } +// close(fileChan) +// +// // 等待所有worker完成 +// go func() { +// wg.Wait() +// close(resultChan) +// }() +// +// // 收集结果 +// var results []fileResult +// for result := range resultChan { +// results = append(results, result) +// } +// +// // 按文件索引排序 +// sort.Slice(results, func(i, j int) bool { +// return results[i].index < results[j].index +// }) +// +// // 创建新的输出文件 +// outputFile := excelize.NewFile() +// defer outputFile.Close() +// +// // 删除默认的Sheet1 +// outputFile.DeleteSheet("Sheet1") +// +// // 创建目标sheet +// sheetIndex, err := outputFile.NewSheet(config.SheetName) +// if err != nil { +// return fmt.Errorf("创建sheet失败: %v", err) +// } +// outputFile.SetActiveSheet(sheetIndex) +// +// // 合并数据 +// currentRow := 1 +// totalRowsMerged := 0 +// +// // 写入表头（如果需要） +// headersWritten := false +// if config.IncludeHeaders && len(results) > 0 { +// for _, result := range results { +// if result.data.err == nil && len(result.data.rows) > 0 { +// headers := result.data.rows[0] +// // 添加额外的列 +// colOffset := 0 +// if config.AddIndexColumn { +// headers = append([]string{"序号"}, headers...) +// colOffset++ +// } +// if config.AddSourceColumn { +// headers = append([]string{"源文件"}, headers...) +// colOffset++ +// } +// +// // 写入表头 +// for colIndex, header := range headers { +// cellName, _ := excelize.CoordinatesToCellName(colIndex+1, currentRow) +// outputFile.SetCellValue(config.SheetName, cellName, header) +// } +// currentRow++ +// headersWritten = true +// fmt.Printf("写入表头: %v\n", headers) +// break // 只取第一个有效文件的表头 +// } +// } +// } +// +// // 写入数据 +// for _, result := range results { +// if result.data.err != nil { +// fmt.Printf("警告: 文件 %s 处理失败: %v，跳过\n", result.filename, result.data.err) +// continue +// } +// +// if len(result.data.rows) == 0 { +// fmt.Printf("警告: 文件 %s 没有数据，跳过\n", result.filename) +// continue +// } +// +// rowsMerged := 0 +// for rowIndex, row := range result.data.rows { +// // 跳过表头（如果已经处理过） +// if config.IncludeHeaders && rowIndex == 0 && headersWritten { +// continue +// } +// +// // 跳过空行 +// if config.SkipEmptyRows && em.isRowEmpty(row) { +// continue +// } +// +// // 写入数据行 +// colOffset := 0 +// +// // 添加序号列 +// if config.AddIndexColumn { +// cellName, _ := excelize.CoordinatesToCellName(1, currentRow) +// outputFile.SetCellValue(config.SheetName, cellName, totalRowsMerged+1) +// colOffset++ +// } +// +// // 添加源文件列 +// if config.AddSourceColumn { +// cellName, _ := excelize.CoordinatesToCellName(1+colOffset, currentRow) +// outputFile.SetCellValue(config.SheetName, cellName, filepath.Base(result.filename)) +// colOffset++ +// } +// +// // 写入原始数据 +// for colIndex, cell := range row { +// cellName, _ := excelize.CoordinatesToCellName(colIndex+1+colOffset, currentRow) +// outputFile.SetCellValue(config.SheetName, cellName, cell) +// } +// +// currentRow++ +// rowsMerged++ +// totalRowsMerged++ +// } +// +// //// 添加分隔行 +// //if rowsMerged > 0 { +// // separatorCell, _ := excelize.CoordinatesToCellName(1, currentRow) +// // outputFile.SetCellValue(config.SheetName, separatorCell, +// // fmt.Sprintf("=== 文件 %d/%d: %s ===", +// // result.index+1, len(results), filepath.Base(result.filename))) +// // currentRow++ +// //} +// } +// +// // 保存输出文件 +// if err := outputFile.SaveAs(config.OutputFile); err != nil { +// return fmt.Errorf("保存合并文件失败: %v", err) +// } +// +// fmt.Printf("并行合并完成！结果保存在: %s\n", config.OutputFile) +// fmt.Printf("统计信息:\n") +// fmt.Printf(" - 合并文件数: %d\n", len(results)) +// fmt.Printf(" - 合并数据行数: %d\n", totalRowsMerged) +// +// return em.verifyMergeResult(config.OutputFile, config.SheetName) +//} +// +//// MergeByColumn 按列合并Excel文件 +//func (em *ExcelManager) MergeByColumn(config MergeConfig) error { +// em.mu.Lock() +// defer em.mu.Unlock() +// +// // 获取要合并的文件列表 +// filesToMerge, err := em.getFilesToMerge(config) +// if err != nil { +// return err +// } +// +// fmt.Printf("开始按列合并 %d 个文件:\n", len(filesToMerge)) +// +// // 创建新的输出文件 +// outputFile := excelize.NewFile() +// defer outputFile.Close() +// +// // 删除默认的Sheet1 +// outputFile.DeleteSheet("Sheet1") +// +// // 创建目标sheet +// sheetIndex, err := outputFile.NewSheet(config.SheetName) +// if err != nil { +// return fmt.Errorf("创建sheet失败: %v", err) +// } +// outputFile.SetActiveSheet(sheetIndex) +// +// currentCol := 1 +// +// // 合并所有文件 +// for fileIndex, sourceFile := range filesToMerge { +// fmt.Printf("[%d/%d] 正在处理文件: %s\n", fileIndex+1, len(filesToMerge), filepath.Base(sourceFile)) +// +// // 打开源文件 +// srcFile, err := excelize.OpenFile(sourceFile) +// if err != nil { +// return fmt.Errorf("打开文件 %s 失败: %v", sourceFile, err) +// } +// defer srcFile.Close() +// +// // 确定要读取的sheet +// sourceSheet := em.getSourceSheet(srcFile, config.SourceSheet) +// if sourceSheet == "" { +// return fmt.Errorf("未找到可用的sheet") +// } +// +// // 读取源文件数据 +// rows, err := srcFile.GetRows(sourceSheet) +// if err != nil { +// return fmt.Errorf("读取文件 %s 失败: %v，跳过\n", sourceFile, err) +// } +// +// if len(rows) == 0 { +// fmt.Printf("警告: 文件 %s 的sheet '%s' 没有数据，跳过\n", sourceFile, sourceSheet) +// continue +// } +// +// // 按列写入数据 +// for rowIndex, row := range rows { +// // 写入当前列的所有行 +// for colIndex, cell := range row { +// targetRow := rowIndex + 1 +// cellName, _ := excelize.CoordinatesToCellName(currentCol+colIndex, targetRow) +// outputFile.SetCellValue(config.SheetName, cellName, cell) +// } +// } +// +// // 添加文件名称到第一行（作为列标题） +// titleCell, _ := excelize.CoordinatesToCellName(currentCol, 1) +// outputFile.SetCellValue(config.SheetName, titleCell, filepath.Base(sourceFile)) +// +// // 移动到下一组列 +// if len(rows) > 0 && len(rows[0]) > 0 { +// currentCol += len(rows[0]) +// } else { +// currentCol += 1 +// } +// } +// +// // 保存输出文件 +// if err := outputFile.SaveAs(config.OutputFile); err != nil { +// return fmt.Errorf("保存合并文件失败: %v", err) +// } +// +// fmt.Printf("按列合并完成！结果保存在: %s\n", config.OutputFile) +// return nil +//} +// +//// MergeSheetsInSameFile 合并同一文件中的多个sheet +//func (em *ExcelManager) MergeSheetsInSameFile(filename, outputFile string, targetSheetName string) error { +// em.mu.RLock() +// defer em.mu.RUnlock() +// +// file, err := excelize.OpenFile(filename) +// if err != nil { +// return err +// } +// defer file.Close() +// +// // 获取所有sheet +// sheets := file.GetSheetList() +// if len(sheets) == 0 { +// return fmt.Errorf("文件 %s 中没有sheet", filename) +// } +// +// // 创建新的输出文件 +// output := excelize.NewFile() +// defer output.Close() +// +// // 删除默认的Sheet1 +// output.DeleteSheet("Sheet1") +// +// // 创建目标sheet +// sheetIndex, err := output.NewSheet(targetSheetName) +// if err != nil { +// return fmt.Errorf("创建sheet失败: %v", err) +// } +// output.SetActiveSheet(sheetIndex) +// +// currentRow := 1 +// +// for _, sheet := range sheets { +// // 读取sheet数据 +// rows, err := file.GetRows(sheet) +// if err != nil { +// fmt.Printf("警告: 读取sheet %s 失败: %v，跳过\n", sheet, err) +// continue +// } +// +// if len(rows) == 0 { +// continue +// } +// +// // 添加sheet名称作为标题 +// titleCell, _ := excelize.CoordinatesToCellName(1, currentRow) +// output.SetCellValue(targetSheetName, titleCell, fmt.Sprintf("=== Sheet: %s ===", sheet)) +// currentRow++ +// +// // 写入sheet数据 +// for _, row := range rows { +// for colIndex, cell := range row { +// cellName, _ := excelize.CoordinatesToCellName(colIndex+1, currentRow) +// output.SetCellValue(targetSheetName, cellName, cell) +// } +// currentRow++ +// } +// +// // 添加空行分隔 +// currentRow++ +// } +// +// // 保存输出文件 +// return output.SaveAs(outputFile) +//} +// +//// ============ 辅助结构和方法 ============ +// +//// 文件任务结构 +//type fileTask struct { +// filename string +// index int +// total int +//} +// +//// 文件结果结构 +//type fileResult struct { +// filename string +// index int +// data fileData +//} +// +//// 文件数据结构 +//type fileData struct { +// rows [][]string +// err error +//} +// +//// 并行读取Excel文件 +//func (em *ExcelManager) readExcelFileParallel(filename, sheetName string) fileData { +// srcFile, err := excelize.OpenFile(filename) +// if err != nil { +// return fileData{err: err} +// } +// defer srcFile.Close() +// +// sourceSheet := em.getSourceSheet(srcFile, sheetName) +// if sourceSheet == "" { +// return fileData{err: fmt.Errorf("未找到可用的sheet")} +// } +// +// rows, err := srcFile.GetRows(sourceSheet) +// return fileData{ +// rows: rows, +// err: err, +// } +//} +// +//// 检查行是否为空 +//func (em *ExcelManager) isRowEmpty(row []string) bool { +// for _, cell := range row { +// if strings.TrimSpace(cell) != "" { +// return false +// } +// } +// return true +//} +// +//// 清理测试文件 +//func cleanupFiles(file string) { +// if _, err := os.Stat(file); err == nil { +// os.Remove(file) +// fmt.Printf("删除: %s\n", file) +// } +//} +// +//// 辅助函数：将数据转换为JSON字符串 +//func convertToJSON(data interface{}) string { +// // 这里使用简单的转换，实际可以使用 encoding/json 包 +// switch v := data.(type) { +// case [][]string: +// var result []string +// for _, row := range v { +// result = append(result, strings.Join(row, ",")) +// } +// return strings.Join(result, "\n") +// case []string: +// return strings.Join(v, "\n") +// default: +// return fmt.Sprintf("%v", data) +// } +//} +// +//// 将C字符串数组转换为Go字符串切片 +//func cStringArrayToStringSlice(cArray **C.char, length int) []string { +// if cArray == nil || length == 0 { +// return nil +// } +// +// var goStrs []string +// for i := 0; i < length; i++ { +// ptr := (**C.char)(unsafe.Pointer(uintptr(unsafe.Pointer(cArray)) + uintptr(i)*unsafe.Sizeof(uintptr(0)))) +// if *ptr != nil { +// goStrs = append(goStrs, C.GoString(*ptr)) +// } +// } +// +// return goStrs +//} +// +//// 辅助函数：设置错误信息 +//func setError(err string) { +// // 这里可以添加日志记录等操作 +// fmt.Printf("Excel操作错误: %s\n", err) +//} +// +//func ParseExcelDataToJSON(excelData string) ([]map[string]string, error) { +// if excelData == "" { +// return nil, fmt.Errorf("Excel数据为空") +// } +// +// // 使用csv解析器解析数据 +// reader := csv.NewReader(strings.NewReader(excelData)) +// records, err := reader.ReadAll() +// if err != nil { +// return nil, fmt.Errorf("解析CSV数据失败: %v", err) +// } +// +// if len(records) < 2 { +// return nil, fmt.Errorf("数据行数不足") +// } +// +// // 提取表头（第一行） +// headers := records[0] +// +// // 将数据转换为JSON格式 +// var jsonData []map[string]string +// +// // 从第二行开始（跳过表头） +// for i := 1; i < len(records); i++ { +// row := records[i] +// rowData := make(map[string]string) +// +// // 确保每行的列数与表头一致 +// for j := 0; j < len(headers) && j < len(row); j++ { +// rowData[headers[j]] = row[j] +// } +// jsonData = append(jsonData, rowData) +// } +// +// return jsonData, nil +//} +// +//// ============ CGO 导出函数 ============ +// +//var ( +// managerStore sync.Map +// nextHandle int64 = 1 +// handleMutex sync.Mutex // 添加互斥锁保证线程安全 +//) +// +//// 创建新的Excel管理器并返回指针 +//// +////export NewExcelManagerInstance +//func NewExcelManagerInstance() C.longlong { +// manager := NewExcelManager() +// +// handleMutex.Lock() +// handle := nextHandle +// nextHandle++ +// handleMutex.Unlock() +// +// // 将Go对象存储在map中 +// managerStore.Store(handle, manager) +// +// return C.longlong(handle) +//} +// +//// 释放Excel管理器 +//// +////export FreeExcelManager +//func FreeExcelManager(handle C.longlong) { +// h := int64(handle) +// +// // 从map中删除并清理 +// if mgr, ok := managerStore.Load(h); ok { +// if manager, ok := mgr.(*ExcelManager); ok { +// manager.CloseAll() +// } +// managerStore.Delete(h) +// } +//} +// +//// 读取Excel数据 +//// +////export ReadExcelData +//func ReadExcelData(handle C.longlong, filename *C.char, sheet *C.char, result **C.char) C.int { +// h := int64(handle) +// mgr, ok := managerStore.Load(h) +// if !ok { +// return C.int(-1) +// } +// manager, ok := mgr.(*ExcelManager) +// if !ok { +// return C.int(-1) +// } +// goFilename := C.GoString(filename) +// goSheet := C.GoString(sheet) +// data, err := manager.ReadData(goFilename, goSheet) +// if err != nil { +// return C.int(-1) +// } +// // 将数据转换为JSON字符串 +// jsonStr := convertToJSON(data) +// +// // 将结果转换为JSON格式 +// jsonData, err := ParseExcelDataToJSON(jsonStr) +// var datas string +// if err != nil { +// fmt.Printf("转换JSON失败: %v\n", err) +// } else { +// // 将JSON数据格式化输出 +// jsonBytes, err := json.MarshalIndent(jsonData, "", " ") +// if err != nil { +// fmt.Printf("格式化JSON失败: %v\n", err) +// } else { +// datas = string(jsonBytes) +// } +// } +// +// *result = C.CString(datas) +// return C.int(0) +//} +// +//// 批量写入数据到Excel文件 +//// +////export WriteBatchData +//func WriteBatchData(handle C.longlong, filename *C.char, sheet *C.char, cells *C.char, values *C.char, count C.int) C.int { +// h := int64(handle) +// mgr, ok := managerStore.Load(h) +// if !ok { +// return C.int(-1) +// } +// manager, ok := mgr.(*ExcelManager) +// if !ok { +// return C.int(-1) +// } +// goFilename := C.GoString(filename) +// goSheet := C.GoString(sheet) +// goCells := C.GoString(cells) +// goValues := C.GoString(values) +// +// var cell []string +// var value []string +// err := json.Unmarshal([]byte(goCells), &cell) +// if err != nil { +// setError(fmt.Sprintf("解析数据失败: %v，数据: %s", err, goCells)) +// return C.int(-1) +// } +// err = json.Unmarshal([]byte(goValues), &value) +// if err != nil { +// setError(fmt.Sprintf("解析数据失败: %v，数据: %s", err, goValues)) +// return C.int(-1) +// } +// // 构建数据映射 +// data := make(map[string]interface{}) +// for i, c := range cell { +// data[c] = value[i] +// } +// err = manager.WriteData(goFilename, goSheet, data) +// if err != nil { +// fmt.Printf("批量写入数据失败: %v\n", err) +// return C.int(-1) +// } +// return C.int(0) +//} +// +//// 追加数据到Excel文件末尾 +//// +////export AppendDataToExcel +//func AppendDataToExcel(handle C.longlong, filename *C.char, sheet *C.char, values *C.char, count C.int) C.int { +// h := int64(handle) +// +// mgr, ok := managerStore.Load(h) +// if !ok { +// return C.int(-1) +// } +// manager, ok := mgr.(*ExcelManager) +// if !ok { +// return C.int(-1) +// } +// goFilename := C.GoString(filename) +// goSheet := C.GoString(sheet) +// goValues := C.GoString(values) +// var value []string +// err := json.Unmarshal([]byte(goValues), &value) +// if err != nil { +// setError(fmt.Sprintf("解析数据失败: %v，数据: %s", err, goValues)) +// return C.int(-1) +// } +// // 转换为interface{}切片 +// var rowData []interface{} +// for _, val := range value { +// rowData = append(rowData, val) +// } +// err = manager.AppendData(goFilename, goSheet, rowData) +// if err != nil { +// fmt.Printf("追加数据失败: %v\n", err) +// return C.int(-1) +// } +// return C.int(0) +//} +// +//// 搜索包含关键字的单元格 +//// +////export SearchByKeyword +//func SearchByKeyword(handle C.longlong, filename *C.char, sheet *C.char, keyword *C.char, result **C.char) C.int { +// h := int64(handle) +// mgr, ok := managerStore.Load(h) +// if !ok { +// return C.int(-1) +// } +// manager, ok := mgr.(*ExcelManager) +// if !ok { +// return C.int(-1) +// } +// goFilename := C.GoString(filename) +// goSheet := C.GoString(sheet) +// goKeyword := C.GoString(keyword) +// results, err := manager.SearchByKeyword(goFilename, goSheet, goKeyword) +// if err != nil { +// return C.int(-1) +// } +// // 将结果转换为JSON字符串 +// jsonStr := convertToJSON(results) +// *result = C.CString(jsonStr) +// return C.int(0) +//} +// +//// 搜索整行包含关键字的行 +//// +////export SearchRowsByKeyword +//func SearchRowsByKeyword(handle C.longlong, +// filename *C.char, +// sheet *C.char, +// keyword *C.char, +// result **C.char) C.int { +// h := int64(handle) +// mgr, ok := managerStore.Load(h) +// if !ok { +// return C.int(-1) +// } +// manager, ok := mgr.(*ExcelManager) +// if !ok { +// return C.int(-1) +// } +// goFilename := C.GoString(filename) +// goSheet := C.GoString(sheet) +// goKeyword := C.GoString(keyword) +// results, err := manager.SearchRowData(goFilename, goSheet, goKeyword) +// if err != nil { +// return C.int(-1) +// } +// // 将结果转换为JSON字符串 +// jsonStr := convertToJSON(results) +// *result = C.CString(jsonStr) +// return C.int(0) +//} +// +//// 创建新文件并写入数据 +//// +////export CreateAndWriteExcel +//func CreateAndWriteExcel(handle C.longlong, filename *C.char, sheet *C.char, rowsData *C.char) C.int { +// h := int64(handle) +// +// // 获取管理器 +// mgr, ok := managerStore.Load(h) +// if !ok { +// setError("Invalid handle") +// return C.int(-1) +// } +// +// manager, ok := mgr.(*ExcelManager) +// if !ok { +// setError("Invalid manager type") +// return C.int(-1) +// } +// goFilename := C.GoString(filename) +// goSheet := C.GoString(sheet) +// goRowsData := C.GoString(rowsData) +// var data [][]string +// err2 := json.Unmarshal([]byte(goRowsData), &data) +// if err2 != nil { +// // 更详细的错误信息 +// setError(fmt.Sprintf("解析数据失败: %v, 数据: %s", err2, goRowsData)) +// return C.int(-1) +// } +// // 调用管理器方法 +// err := manager.CreateAndWrite(goFilename, goSheet, data) +// if err != nil { +// setError(fmt.Sprintf("创建并写入文件失败: %v", err)) +// return C.int(-1) +// } +// fmt.Printf("文件创建成功: %s\n", goFilename) +// return C.int(0) +//} +// +//// 增强版合并Excel文件（支持指定文件列表） +//// +////export MergeExcelFilesEx +//func MergeExcelFilesEx(handle C.longlong, +// sourceDir *C.char, +// specificFiles *C.char, +// outputFile *C.char, +// sheetName *C.char, +// mergeByColumn C.int, +// includeHeaders C.int, +// skipEmptyRows C.int, +// filePattern *C.char, +// sourceSheet *C.char, +// addSourceColumn C.int, +// addIndexColumn C.int) C.int { +// h := int64(handle) +// mgr, ok := managerStore.Load(h) +// if !ok { +// return C.int(-1) +// } +// manager, ok := mgr.(*ExcelManager) +// if !ok { +// return C.int(-1) +// } +// +// goSpecificFiles := C.GoString(specificFiles) +// var data []string +// err2 := json.Unmarshal([]byte(goSpecificFiles), &data) +// if err2 != nil { +// // 更详细的错误信息 +// setError(fmt.Sprintf("解析数据失败: %v, 数据: %s", err2, goSpecificFiles)) +// return C.int(-1) +// } +// // 构建配置 +// config := MergeConfig{ +// SourceDir: C.GoString(sourceDir), +// SpecificFiles: data, +// OutputFile: C.GoString(outputFile), +// SheetName: C.GoString(sheetName), +// MergeByColumn: mergeByColumn != 0, +// IncludeHeaders: includeHeaders != 0, +// SkipEmptyRows: skipEmptyRows != 0, +// FilePattern: C.GoString(filePattern), +// AddSourceColumn: addSourceColumn != 0, +// AddIndexColumn: addIndexColumn != 0, +// SourceSheet: C.GoString(sourceSheet), +// } +// // 根据合并模式调用不同的方法 +// var err error +// if config.MergeByColumn { +// err = manager.MergeByColumn(config) +// } else { +// err = manager.MergeExcelFiles(config) +// } +// if err != nil { +// fmt.Printf("合并Excel文件失败: %v\n", err) +// return C.int(-1) +// } +// return C.int(0) +//} +// +//// 并行合并Excel文件（增强版） +//// +////export MergeExcelFilesParallelEx +//func MergeExcelFilesParallelEx(handle C.longlong, +// sourceDir *C.char, +// specificFiles **C.char, +// fileCount C.int, +// outputFile *C.char, +// sheetName *C.char, +// includeHeaders C.int, +// skipEmptyRows C.int, +// filePattern *C.char, +// sourceSheet *C.char, +// addSourceColumn C.int, +// addIndexColumn C.int, +// workers C.int) C.int { +// h := int64(handle) +// mgr, ok := managerStore.Load(h) +// if !ok { +// return C.int(-1) +// } +// manager, ok := mgr.(*ExcelManager) +// if !ok { +// return C.int(-1) +// } +// // 构建配置 +// config := MergeConfig{ +// SourceDir: C.GoString(sourceDir), +// OutputFile: C.GoString(outputFile), +// SheetName: C.GoString(sheetName), +// IncludeHeaders: includeHeaders != 0, +// SkipEmptyRows: skipEmptyRows != 0, +// FilePattern: C.GoString(filePattern), +// AddSourceColumn: addSourceColumn != 0, +// AddIndexColumn: addIndexColumn != 0, +// SourceSheet: C.GoString(sourceSheet), +// } +// +// // 如果有指定的文件列表，则添加到配置中 +// if fileCount > 0 && specificFiles != nil { +// config.SpecificFiles = cStringArrayToStringSlice(specificFiles, int(fileCount)) +// } +// +// err := manager.MergeExcelFilesParallel(config, int(workers)) +// if err != nil { +// fmt.Printf("并行合并Excel文件失败: %v\n", err) +// return C.int(-1) +// } +// +// return C.int(0) +//} +// +//// 合并同一文件中的多个sheet +//// +////export MergeSheetsInFile +//func MergeSheetsInFile(handle C.longlong, +// filename *C.char, +// outputFile *C.char, +// targetSheetName *C.char) C.int { +// h := int64(handle) +// mgr, ok := managerStore.Load(h) +// if !ok { +// return C.int(-1) +// } +// manager, ok := mgr.(*ExcelManager) +// if !ok { +// return C.int(-1) +// } +// goFilename := C.GoString(filename) +// goOutputFile := C.GoString(outputFile) +// goTargetSheet := C.GoString(targetSheetName) +// +// err := manager.MergeSheetsInSameFile(goFilename, goOutputFile, goTargetSheet) +// if err != nil { +// fmt.Printf("合并sheet失败: %v\n", err) +// return C.int(-1) +// } +// +// return C.int(0) +//} +// +//// 释放C字符串 +//// +////export FreeCString +//func FreeCString(str *C.char) { +// if str != nil { +// C.free(unsafe.Pointer(str)) +// } +//} +// +////func main() { +//// +////} diff --git a/excel/main.go b/excel/main.go new file mode 100644 index 0000000..0861392 --- /dev/null +++ b/excel/main.go @@ -0,0 +1,1451 @@ +package main + +/* +#include +*/ +import "C" +import ( + "encoding/csv" + "encoding/json" + "fmt" + "github.com/xuri/excelize/v2" + "os" + "path/filepath" + "sort" + "strings" + "sync" + "unsafe" +) + +// ExcelManager 线程安全的Excel文件管理器 +type ExcelManager struct { + mu sync.RWMutex + fileMap map[string]*excelize.File // 存储打开的文件 +} + +// MergeConfig 合并配置 +type MergeConfig struct { + SourceDir string // 源目录 + OutputFile string // 输出文件 + SheetName string // 目标sheet名称 + MergeByColumn bool // 是否按列合并（默认按行） + IncludeHeaders bool // 是否包含表头（仅第一个文件） + SkipEmptyRows bool // 是否跳过空行 + FilePattern string // 文件匹配模式，如 "*.xlsx" + SpecificFiles []string // 指定要合并的文件列表 + SourceSheet string // 源sheet名称（为空则使用第一个sheet） + AddSourceColumn bool // 是否添加源文件列 + AddIndexColumn bool // 是否添加序号列 +} + +// NewExcelManager 创建新的Excel管理器 +func NewExcelManager() *ExcelManager { + return &ExcelManager{ + fileMap: make(map[string]*excelize.File), + } +} + +// ============ 基本Excel操作功能 ============ + +// ReadData 读取Excel数据 +func (em *ExcelManager) ReadData(filename, sheet string) ([][]string, error) { + em.mu.RLock() + defer em.mu.RUnlock() + fmt.Printf("[DEBUG] ReadData开始: file=%s, sheet=%s\n", filename, sheet) + file, err := excelize.OpenFile(filename) + if err != nil { + return nil, err + } + defer file.Close() + rows, err := file.GetRows(sheet) + if err != nil { + return nil, fmt.Errorf("读取sheet %s 失败: %v", sheet, err) + } + fmt.Printf("[DEBUG] 读取的数据：", rows) + return rows, nil +} + +// WriteData 写入数据到指定位置 +func (em *ExcelManager) WriteData(filename, sheet string, data map[string]interface{}) error { + em.mu.Lock() + defer em.mu.Unlock() + + file, err := excelize.OpenFile(filename) + if err != nil { + // 文件不存在，创建新文件 + file = excelize.NewFile() + file.NewSheet(sheet) + } else { + // 确保sheet存在 + index, _ := file.GetSheetIndex(sheet) + if index == -1 { + file.NewSheet(sheet) + } + } + + // 写入数据 + for cell, value := range data { + file.SetCellValue(sheet, cell, value) + } + + // 保存文件 + return file.SaveAs(filename) +} + +// AppendData 追加数据到末尾 +func (em *ExcelManager) AppendData(filename, sheet string, rowData []interface{}) error { + em.mu.Lock() + defer em.mu.Unlock() + + file, err := excelize.OpenFile(filename) + if err != nil { + return err + } + defer func() { + file.SaveAs(filename) + file.Close() + }() + + // 确保sheet存在 + index, _ := file.GetSheetIndex(sheet) + if index == -1 { + file.NewSheet(sheet) + } + + // 获取当前最大行号 + rows, err := file.GetRows(sheet) + if err != nil { + return err + } + + nextRow := len(rows) + 1 + if len(rows) == 0 { + nextRow = 1 + } + + // 写入新行 + for col, value := range rowData { + cell, _ := excelize.CoordinatesToCellName(col+1, nextRow) + file.SetCellValue(sheet, cell, value) + } + + return nil +} + +// SearchByKeyword 搜索包含关键字的单元格 +func (em *ExcelManager) SearchByKeyword(filename, sheet, keyword string) ([]string, error) { + em.mu.RLock() + defer em.mu.RUnlock() + + file, err := excelize.OpenFile(filename) + if err != nil { + return nil, err + } + defer file.Close() + + var results []string + rows, err := file.GetRows(sheet) + if err != nil { + return nil, err + } + + for rowIndex, row := range rows { + for colIndex, cell := range row { + if strings.Contains(cell, keyword) { + cellName, _ := excelize.CoordinatesToCellName(colIndex+1, rowIndex+1) + results = append(results, + fmt.Sprintf("位置: %s, 值: %s", cellName, cell)) + } + } + } + + return results, nil +} + +// SearchRowData 搜索整行包含关键字的行 +func (em *ExcelManager) SearchRowData(filename, sheet, keyword string) ([][]string, error) { + em.mu.RLock() + defer em.mu.RUnlock() + + file, err := excelize.OpenFile(filename) + if err != nil { + return nil, err + } + defer file.Close() + + var results [][]string + rows, err := file.GetRows(sheet) + if err != nil { + return nil, err + } + + for _, row := range rows { + for _, cell := range row { + if strings.Contains(cell, keyword) { + results = append(results, row) + break + } + } + } + + return results, nil +} + +// CreateAndWrite 创建新文件并写入数据 +func (em *ExcelManager) CreateAndWrite(filename, sheet string, data [][]string) error { + em.mu.Lock() + defer em.mu.Unlock() + + // 创建新文件 + file := excelize.NewFile() + defer file.Close() + + // 如果指定sheet不是"Sheet1"，则重命名默认sheet + if sheet != "Sheet1" { + file.SetSheetName("Sheet1", sheet) + } + + // 写入数据 + for rowIndex, row := range data { + for colIndex, value := range row { + cell, _ := excelize.CoordinatesToCellName(colIndex+1, rowIndex+1) + file.SetCellValue(sheet, cell, value) + } + } + + // 保存文件 + return file.SaveAs(filename) +} + +// CloseAll 关闭所有文件 +func (em *ExcelManager) CloseAll() error { + em.mu.Lock() + defer em.mu.Unlock() + + var lastErr error + for filename, file := range em.fileMap { + if err := file.Close(); err != nil { + lastErr = err + } + delete(em.fileMap, filename) + } + return lastErr +} + +// ============ Excel合并功能 ============ + +// MergeExcelFiles 合并多个Excel文件（批次合并） +func (em *ExcelManager) MergeExcelFiles(config MergeConfig) error { + em.mu.Lock() + defer em.mu.Unlock() + + // 获取要合并的文件列表 + filesToMerge, err := em.getFilesToMerge(config) + if err != nil { + return err + } + + fmt.Printf("开始合并 %d 个文件:\n", len(filesToMerge)) + for i, file := range filesToMerge { + fmt.Printf(" %d. %s\n", i+1, filepath.Base(file)) + } + + // 创建新的输出文件 + outputFile := excelize.NewFile() + defer outputFile.Close() + + // 删除默认的Sheet1 + outputFile.DeleteSheet("Sheet1") + + // 创建目标sheet并设置为活动sheet + sheetIndex, err := outputFile.NewSheet(config.SheetName) + if err != nil { + return fmt.Errorf("创建sheet失败: %v", err) + } + outputFile.SetActiveSheet(sheetIndex) + + currentRow := 1 + totalRowsMerged := 0 + fileCount := len(filesToMerge) + + // 写入表头（如果需要） + if config.IncludeHeaders && fileCount > 0 { + headers, err := em.readFileHeaders(filesToMerge[0], config.SourceSheet) + if err != nil { + fmt.Printf("警告: 无法读取第一个文件的表头: %v\n", err) + } else { + // 添加额外的列（如果需要） + colOffset := 0 + if config.AddIndexColumn { + headers = append([]string{"序号"}, headers...) + colOffset++ + } + if config.AddSourceColumn { + headers = append([]string{"源文件"}, headers...) + colOffset++ + } + + // 写入表头 + for colIndex, header := range headers { + cellName, _ := excelize.CoordinatesToCellName(colIndex+1, currentRow) + outputFile.SetCellValue(config.SheetName, cellName, header) + } + currentRow++ + fmt.Printf("写入表头: %v\n", headers) + } + } + + // 合并所有文件 + for fileIndex, sourceFile := range filesToMerge { + rowsMerged, err := em.mergeSingleFile(outputFile, config, sourceFile, fileIndex, fileCount, ¤tRow) + if err != nil { + fmt.Printf("警告: 合并文件 %s 时出错: %v，跳过\n", sourceFile, err) + continue + } + totalRowsMerged += rowsMerged + } + + // 保存输出文件 + if err := outputFile.SaveAs(config.OutputFile); err != nil { + return fmt.Errorf("保存合并文件失败: %v", err) + } + + fmt.Printf("合并完成！结果保存在: %s\n", config.OutputFile) + fmt.Printf("统计信息:\n") + fmt.Printf(" - 合并文件数: %d\n", fileCount) + fmt.Printf(" - 合并数据行数: %d\n", totalRowsMerged) + fmt.Printf(" - 输出文件总行数: %d\n", currentRow-1) + + // 验证文件是否正确保存 + if err := em.verifyMergeResult(config.OutputFile, config.SheetName); err != nil { + return fmt.Errorf("合并结果验证失败: %v", err) + } + + return nil +} + +// getFilesToMerge 获取要合并的文件列表 +func (em *ExcelManager) getFilesToMerge(config MergeConfig) ([]string, error) { + var filesToMerge []string + + if len(config.SpecificFiles) > 0 { + filesToMerge = config.SpecificFiles + } else if config.SourceDir != "" { + pattern := "*.xlsx" + if config.FilePattern != "" { + pattern = config.FilePattern + } + + files, err := filepath.Glob(filepath.Join(config.SourceDir, pattern)) + if err != nil { + return nil, fmt.Errorf("查找文件失败: %v", err) + } + filesToMerge = files + } else { + return nil, fmt.Errorf("必须指定SourceDir或SpecificFiles") + } + + if len(filesToMerge) == 0 { + return nil, fmt.Errorf("没有找到要合并的Excel文件") + } + + // 按文件名排序 + sort.Strings(filesToMerge) + return filesToMerge, nil +} + +// readFileHeaders 读取文件的表头 +func (em *ExcelManager) readFileHeaders(filename, sheetName string) ([]string, error) { + srcFile, err := excelize.OpenFile(filename) + if err != nil { + return nil, err + } + defer srcFile.Close() + + sourceSheet := em.getSourceSheet(srcFile, sheetName) + if sourceSheet == "" { + return nil, fmt.Errorf("未找到可用的sheet") + } + + rows, err := srcFile.GetRows(sourceSheet) + if err != nil { + return nil, err + } + + if len(rows) == 0 { + return nil, fmt.Errorf("文件没有数据") + } + + return rows[0], nil +} + +// mergeSingleFile 合并单个文件 +func (em *ExcelManager) mergeSingleFile(outputFile *excelize.File, config MergeConfig, + sourceFile string, fileIndex, fileCount int, currentRow *int) (int, error) { + + fmt.Printf("\n[%d/%d] 正在处理文件: %s\n", fileIndex+1, fileCount, filepath.Base(sourceFile)) + + // 打开源文件 + srcFile, err := excelize.OpenFile(sourceFile) + if err != nil { + return 0, fmt.Errorf("打开文件失败: %v", err) + } + defer srcFile.Close() + + // 确定要读取的sheet + sourceSheet := em.getSourceSheet(srcFile, config.SourceSheet) + if sourceSheet == "" { + return 0, fmt.Errorf("未找到可用的sheet") + } + + // 读取源文件数据 + rows, err := srcFile.GetRows(sourceSheet) + if err != nil { + return 0, fmt.Errorf("读取数据失败: %v", err) + } + + if len(rows) == 0 { + fmt.Printf(" 警告: 文件没有数据，跳过\n") + return 0, nil + } + + fmt.Printf(" 读取到 %d 行数据\n", len(rows)) + + rowsMerged := 0 + + // 处理数据行 + for rowIndex, row := range rows { + // 跳过空行 + if config.SkipEmptyRows && em.isRowEmpty(row) { + continue + } + fmt.Println(rowIndex) + // 处理表头（如果是第一个文件且包含表头，第一行已经处理过了） + if config.IncludeHeaders && rowIndex == 0 { + if fileIndex == 0 { + // 第一个文件的表头已处理，跳过 + continue + } else { + // 后续文件的表头跳过 + continue + } + } + + // 写入数据行 + colOffset := 0 + + // 添加序号列 + if config.AddIndexColumn { + cellName, _ := excelize.CoordinatesToCellName(1, *currentRow) + outputFile.SetCellValue(config.SheetName, cellName, rowsMerged+1) + colOffset++ + } + + // 添加源文件列 + if config.AddSourceColumn { + cellName, _ := excelize.CoordinatesToCellName(1+colOffset, *currentRow) + outputFile.SetCellValue(config.SheetName, cellName, filepath.Base(sourceFile)) + colOffset++ + } + + // 写入原始数据 + for colIndex, cell := range row { + cellName, _ := excelize.CoordinatesToCellName(colIndex+1+colOffset, *currentRow) + outputFile.SetCellValue(config.SheetName, cellName, cell) + } + + rowsMerged++ + *currentRow++ + } + + //// 添加文件分隔信息（如果有数据被合并） + //if rowsMerged > 0 { + // // 添加分隔行 + // separatorCell, _ := excelize.CoordinatesToCellName(1, *currentRow) + // outputFile.SetCellValue(config.SheetName, separatorCell, + // fmt.Sprintf("=== 文件 %d/%d: %s (合并了 %d 行) ===", + // fileIndex+1, fileCount, filepath.Base(sourceFile), rowsMerged)) + // *currentRow++ + //} + + fmt.Printf(" 文件处理完成，合并了 %d 行数据\n", rowsMerged) + return rowsMerged, nil +} + +// getSourceSheet 获取源sheet名称 +func (em *ExcelManager) getSourceSheet(file *excelize.File, preferredSheet string) string { + if preferredSheet != "" { + if index, _ := file.GetSheetIndex(preferredSheet); index != -1 { + return preferredSheet + } + } + + // 返回第一个sheet + sheets := file.GetSheetList() + if len(sheets) > 0 { + return sheets[0] + } + return "" +} + +// verifyMergeResult 验证合并结果 +func (em *ExcelManager) verifyMergeResult(filename, sheet string) error { + file, err := excelize.OpenFile(filename) + if err != nil { + return fmt.Errorf("打开验证文件失败: %v", err) + } + defer file.Close() + + rows, err := file.GetRows(sheet) + if err != nil { + return fmt.Errorf("读取sheet失败: %v", err) + } + + fmt.Printf("\n验证结果:\n") + fmt.Printf(" 文件: %s\n", filename) + fmt.Printf(" Sheet: %s\n", sheet) + fmt.Printf(" 总行数: %d\n", len(rows)) + + if len(rows) == 0 { + return fmt.Errorf("警告: 合并后的文件没有数据!") + } + + // 显示前5行数据 + limit := 5 + if len(rows) < limit { + limit = len(rows) + } + + fmt.Printf(" 前%d行数据预览:\n", limit) + for i := 0; i < limit; i++ { + // 只显示前5列（避免输出过长） + previewCols := 5 + if len(rows[i]) < previewCols { + previewCols = len(rows[i]) + } + fmt.Printf(" 第%d行: %v", i+1, rows[i][:previewCols]) + if len(rows[i]) > previewCols { + fmt.Printf(" ... (+%d列)", len(rows[i])-previewCols) + } + fmt.Println() + } + + return nil +} + +// MergeExcelFilesParallel 并行合并Excel文件（高性能） +func (em *ExcelManager) MergeExcelFilesParallel(config MergeConfig, workers int) error { + em.mu.Lock() + defer em.mu.Unlock() + + // 获取要合并的文件列表 + filesToMerge, err := em.getFilesToMerge(config) + if err != nil { + return err + } + + fmt.Printf("开始并行合并 %d 个文件，使用 %d 个worker:\n", len(filesToMerge), workers) + + // 创建通道和等待组 + fileChan := make(chan fileTask, len(filesToMerge)) + resultChan := make(chan fileResult, len(filesToMerge)) + var wg sync.WaitGroup + + // 启动worker goroutines + for i := 0; i < workers; i++ { + wg.Add(1) + go func(workerID int) { + defer wg.Done() + for task := range fileChan { + fmt.Printf("Worker %d 正在处理: %s (文件 %d/%d)\n", + workerID, filepath.Base(task.filename), task.index+1, task.total) + data := em.readExcelFileParallel(task.filename, config.SourceSheet) + resultChan <- fileResult{ + filename: task.filename, + index: task.index, + data: data, + } + } + }(i) + } + + // 发送文件任务到通道 + for i, file := range filesToMerge { + fileChan <- fileTask{ + filename: file, + index: i, + total: len(filesToMerge), + } + } + close(fileChan) + + // 等待所有worker完成 + go func() { + wg.Wait() + close(resultChan) + }() + + // 收集结果 + var results []fileResult + for result := range resultChan { + results = append(results, result) + } + + // 按文件索引排序 + sort.Slice(results, func(i, j int) bool { + return results[i].index < results[j].index + }) + + // 创建新的输出文件 + outputFile := excelize.NewFile() + defer outputFile.Close() + + // 删除默认的Sheet1 + outputFile.DeleteSheet("Sheet1") + + // 创建目标sheet + sheetIndex, err := outputFile.NewSheet(config.SheetName) + if err != nil { + return fmt.Errorf("创建sheet失败: %v", err) + } + outputFile.SetActiveSheet(sheetIndex) + + // 合并数据 + currentRow := 1 + totalRowsMerged := 0 + + // 写入表头（如果需要） + headersWritten := false + if config.IncludeHeaders && len(results) > 0 { + for _, result := range results { + if result.data.err == nil && len(result.data.rows) > 0 { + headers := result.data.rows[0] + // 添加额外的列 + colOffset := 0 + if config.AddIndexColumn { + headers = append([]string{"序号"}, headers...) + colOffset++ + } + if config.AddSourceColumn { + headers = append([]string{"源文件"}, headers...) + colOffset++ + } + + // 写入表头 + for colIndex, header := range headers { + cellName, _ := excelize.CoordinatesToCellName(colIndex+1, currentRow) + outputFile.SetCellValue(config.SheetName, cellName, header) + } + currentRow++ + headersWritten = true + fmt.Printf("写入表头: %v\n", headers) + break // 只取第一个有效文件的表头 + } + } + } + + // 写入数据 + for _, result := range results { + if result.data.err != nil { + fmt.Printf("警告: 文件 %s 处理失败: %v，跳过\n", result.filename, result.data.err) + continue + } + + if len(result.data.rows) == 0 { + fmt.Printf("警告: 文件 %s 没有数据，跳过\n", result.filename) + continue + } + + rowsMerged := 0 + for rowIndex, row := range result.data.rows { + // 跳过表头（如果已经处理过） + if config.IncludeHeaders && rowIndex == 0 && headersWritten { + continue + } + + // 跳过空行 + if config.SkipEmptyRows && em.isRowEmpty(row) { + continue + } + + // 写入数据行 + colOffset := 0 + + // 添加序号列 + if config.AddIndexColumn { + cellName, _ := excelize.CoordinatesToCellName(1, currentRow) + outputFile.SetCellValue(config.SheetName, cellName, totalRowsMerged+1) + colOffset++ + } + + // 添加源文件列 + if config.AddSourceColumn { + cellName, _ := excelize.CoordinatesToCellName(1+colOffset, currentRow) + outputFile.SetCellValue(config.SheetName, cellName, filepath.Base(result.filename)) + colOffset++ + } + + // 写入原始数据 + for colIndex, cell := range row { + cellName, _ := excelize.CoordinatesToCellName(colIndex+1+colOffset, currentRow) + outputFile.SetCellValue(config.SheetName, cellName, cell) + } + + currentRow++ + rowsMerged++ + totalRowsMerged++ + } + + //// 添加分隔行 + //if rowsMerged > 0 { + // separatorCell, _ := excelize.CoordinatesToCellName(1, currentRow) + // outputFile.SetCellValue(config.SheetName, separatorCell, + // fmt.Sprintf("=== 文件 %d/%d: %s ===", + // result.index+1, len(results), filepath.Base(result.filename))) + // currentRow++ + //} + } + + // 保存输出文件 + if err := outputFile.SaveAs(config.OutputFile); err != nil { + return fmt.Errorf("保存合并文件失败: %v", err) + } + + fmt.Printf("并行合并完成！结果保存在: %s\n", config.OutputFile) + fmt.Printf("统计信息:\n") + fmt.Printf(" - 合并文件数: %d\n", len(results)) + fmt.Printf(" - 合并数据行数: %d\n", totalRowsMerged) + + return em.verifyMergeResult(config.OutputFile, config.SheetName) +} + +// MergeByColumn 按列合并Excel文件 +func (em *ExcelManager) MergeByColumn(config MergeConfig) error { + em.mu.Lock() + defer em.mu.Unlock() + + // 获取要合并的文件列表 + filesToMerge, err := em.getFilesToMerge(config) + if err != nil { + return err + } + + fmt.Printf("开始按列合并 %d 个文件:\n", len(filesToMerge)) + + // 创建新的输出文件 + outputFile := excelize.NewFile() + defer outputFile.Close() + + // 删除默认的Sheet1 + outputFile.DeleteSheet("Sheet1") + + // 创建目标sheet + sheetIndex, err := outputFile.NewSheet(config.SheetName) + if err != nil { + return fmt.Errorf("创建sheet失败: %v", err) + } + outputFile.SetActiveSheet(sheetIndex) + + currentCol := 1 + + // 合并所有文件 + for fileIndex, sourceFile := range filesToMerge { + fmt.Printf("[%d/%d] 正在处理文件: %s\n", fileIndex+1, len(filesToMerge), filepath.Base(sourceFile)) + + // 打开源文件 + srcFile, err := excelize.OpenFile(sourceFile) + if err != nil { + return fmt.Errorf("打开文件 %s 失败: %v", sourceFile, err) + } + defer srcFile.Close() + + // 确定要读取的sheet + sourceSheet := em.getSourceSheet(srcFile, config.SourceSheet) + if sourceSheet == "" { + return fmt.Errorf("未找到可用的sheet") + } + + // 读取源文件数据 + rows, err := srcFile.GetRows(sourceSheet) + if err != nil { + return fmt.Errorf("读取文件 %s 失败: %v，跳过\n", sourceFile, err) + } + + if len(rows) == 0 { + fmt.Printf("警告: 文件 %s 的sheet '%s' 没有数据，跳过\n", sourceFile, sourceSheet) + continue + } + + // 按列写入数据 + for rowIndex, row := range rows { + // 写入当前列的所有行 + for colIndex, cell := range row { + targetRow := rowIndex + 1 + cellName, _ := excelize.CoordinatesToCellName(currentCol+colIndex, targetRow) + outputFile.SetCellValue(config.SheetName, cellName, cell) + } + } + + // 添加文件名称到第一行（作为列标题） + titleCell, _ := excelize.CoordinatesToCellName(currentCol, 1) + outputFile.SetCellValue(config.SheetName, titleCell, filepath.Base(sourceFile)) + + // 移动到下一组列 + if len(rows) > 0 && len(rows[0]) > 0 { + currentCol += len(rows[0]) + } else { + currentCol += 1 + } + } + + // 保存输出文件 + if err := outputFile.SaveAs(config.OutputFile); err != nil { + return fmt.Errorf("保存合并文件失败: %v", err) + } + + fmt.Printf("按列合并完成！结果保存在: %s\n", config.OutputFile) + return nil +} + +// MergeSheetsInSameFile 合并同一文件中的多个sheet +func (em *ExcelManager) MergeSheetsInSameFile(filename, outputFile string, targetSheetName string) error { + em.mu.RLock() + defer em.mu.RUnlock() + + file, err := excelize.OpenFile(filename) + if err != nil { + return err + } + defer file.Close() + + // 获取所有sheet + sheets := file.GetSheetList() + if len(sheets) == 0 { + return fmt.Errorf("文件 %s 中没有sheet", filename) + } + + // 创建新的输出文件 + output := excelize.NewFile() + defer output.Close() + + // 删除默认的Sheet1 + output.DeleteSheet("Sheet1") + + // 创建目标sheet + sheetIndex, err := output.NewSheet(targetSheetName) + if err != nil { + return fmt.Errorf("创建sheet失败: %v", err) + } + output.SetActiveSheet(sheetIndex) + + currentRow := 1 + + for _, sheet := range sheets { + // 读取sheet数据 + rows, err := file.GetRows(sheet) + if err != nil { + fmt.Printf("警告: 读取sheet %s 失败: %v，跳过\n", sheet, err) + continue + } + + if len(rows) == 0 { + continue + } + + // 添加sheet名称作为标题 + titleCell, _ := excelize.CoordinatesToCellName(1, currentRow) + output.SetCellValue(targetSheetName, titleCell, fmt.Sprintf("=== Sheet: %s ===", sheet)) + currentRow++ + + // 写入sheet数据 + for _, row := range rows { + for colIndex, cell := range row { + cellName, _ := excelize.CoordinatesToCellName(colIndex+1, currentRow) + output.SetCellValue(targetSheetName, cellName, cell) + } + currentRow++ + } + + // 添加空行分隔 + currentRow++ + } + + // 保存输出文件 + return output.SaveAs(outputFile) +} + +// ============ 辅助结构和方法 ============ + +// 文件任务结构 +type fileTask struct { + filename string + index int + total int +} + +// 文件结果结构 +type fileResult struct { + filename string + index int + data fileData +} + +// 文件数据结构 +type fileData struct { + rows [][]string + err error +} + +// 并行读取Excel文件 +func (em *ExcelManager) readExcelFileParallel(filename, sheetName string) fileData { + srcFile, err := excelize.OpenFile(filename) + if err != nil { + return fileData{err: err} + } + defer srcFile.Close() + + sourceSheet := em.getSourceSheet(srcFile, sheetName) + if sourceSheet == "" { + return fileData{err: fmt.Errorf("未找到可用的sheet")} + } + + rows, err := srcFile.GetRows(sourceSheet) + return fileData{ + rows: rows, + err: err, + } +} + +// 检查行是否为空 +func (em *ExcelManager) isRowEmpty(row []string) bool { + for _, cell := range row { + if strings.TrimSpace(cell) != "" { + return false + } + } + return true +} + +// 清理测试文件 +func cleanupFiles(file string) { + if _, err := os.Stat(file); err == nil { + os.Remove(file) + fmt.Printf("删除: %s\n", file) + } +} + +// 辅助函数：将数据转换为JSON字符串 +func convertToJSON(data interface{}) string { + // 这里使用简单的转换，实际可以使用 encoding/json 包 + switch v := data.(type) { + case [][]string: + return convertRowsToJSON(v) + case []string: + return strings.Join(v, "\n") + default: + return fmt.Sprintf("%v", data) + } +} + +// 将行数据转换为 JSON 字符串 +func convertRowsToJSON(rows [][]string) string { + if len(rows) == 0 { + return "[]" + } + + // 如果有表头，将数据转换为对象数组 + if len(rows) > 1 { + headers := rows[0] + var result []map[string]string + + // 从第二行开始（跳过表头） + for i := 1; i < len(rows); i++ { + rowData := make(map[string]string) + for j := 0; j < len(headers) && j < len(rows[i]); j++ { + rowData[headers[j]] = rows[i][j] + } + result = append(result, rowData) + } + + jsonBytes, err := json.Marshal(result) + if err != nil { + // 如果序列化失败，返回简单格式 + return fmt.Sprintf("%v", rows) + } + return string(jsonBytes) + } + + // 如果没有表头，返回二维数组 + jsonBytes, err := json.Marshal(rows) + if err != nil { + return fmt.Sprintf("%v", rows) + } + return string(jsonBytes) +} + +// 将C字符串数组转换为Go字符串切片 +func cStringArrayToStringSlice(cArray **C.char, length int) []string { + if cArray == nil || length == 0 { + return nil + } + + var goStrs []string + for i := 0; i < length; i++ { + ptr := (**C.char)(unsafe.Pointer(uintptr(unsafe.Pointer(cArray)) + uintptr(i)*unsafe.Sizeof(uintptr(0)))) + if *ptr != nil { + goStrs = append(goStrs, C.GoString(*ptr)) + } + } + + return goStrs +} + +// 辅助函数：设置错误信息 +func setError(err string) { + // 这里可以添加日志记录等操作 + fmt.Printf("Excel操作错误: %s\n", err) +} + +// ============ CGO 导出函数 ============ + +var ( + managerStore sync.Map + nextHandle int64 = 1 +) + +// 创建新的Excel管理器并返回指针 +// +//export NewExcelManagerInstance +func NewExcelManagerInstance() C.longlong { + manager := NewExcelManager() + handle := nextHandle + nextHandle++ + + // 将Go对象存储在map中 + managerStore.Store(handle, manager) + + return C.longlong(handle) +} + +// 释放Excel管理器 +// +//export FreeExcelManager +func FreeExcelManager(handle C.longlong) { + h := int64(handle) + + // 从map中删除并清理 + if mgr, ok := managerStore.Load(h); ok { + if manager, ok := mgr.(*ExcelManager); ok { + manager.CloseAll() + } + managerStore.Delete(h) + } +} + +// 读取Excel数据 +// +//export ReadExcelData +func ReadExcelData(handle C.longlong, filename *C.char, sheet *C.char, result **C.char) C.int { + h := int64(handle) + mgr, ok := managerStore.Load(h) + if !ok { + return C.int(-1) + } + manager, ok := mgr.(*ExcelManager) + if !ok { + return C.int(-1) + } + goFilename := C.GoString(filename) + goSheet := C.GoString(sheet) + data, err := manager.ReadData(goFilename, goSheet) + if err != nil { + return C.int(-1) + } + + jsonStr := convertRowsToJSON(data) + // 将数据转换为JSON字符串 + //jsonStr := convertToJSON(data) + + //// 将结果转换为JSON格式 + //jsonData, err := ParseExcelDataToJSON(jsonStr) + //var datas string + //if err != nil { + // fmt.Printf("转换JSON失败: %v\n", err) + //} else { + // // 将JSON数据格式化输出 + // jsonBytes, err := json.Marshal(jsonData) + // if err != nil { + // fmt.Printf("格式化JSON失败: %v\n", err) + // } else { + // datas = string(jsonBytes) + // } + //} + *result = C.CString(jsonStr) + return C.int(0) +} + +func ParseExcelDataToJSON(excelData string) ([]map[string]string, error) { + if excelData == "" { + return nil, fmt.Errorf("Excel数据为空") + } + + // 使用csv解析器解析数据 + reader := csv.NewReader(strings.NewReader(excelData)) + records, err := reader.ReadAll() + if err != nil { + return nil, fmt.Errorf("解析Excel数据失败: %v", err) + } + + if len(records) < 2 { + return nil, fmt.Errorf("数据行数不足") + } + + // 提取表头（第一行） + headers := records[0] + + // 将数据转换为JSON格式 + var jsonData []map[string]string + + // 从第二行开始（跳过表头） + for i := 1; i < len(records); i++ { + row := records[i] + rowData := make(map[string]string) + + // 确保每行的列数与表头一致 + for j := 0; j < len(headers) && j < len(row); j++ { + rowData[headers[j]] = row[j] + } + jsonData = append(jsonData, rowData) + } + + return jsonData, nil +} + +// 批量写入数据到Excel文件 +// +//export WriteBatchData +func WriteBatchData(handle C.longlong, filename *C.char, sheet *C.char, cells *C.char, values *C.char, count C.int) C.int { + h := int64(handle) + mgr, ok := managerStore.Load(h) + if !ok { + return C.int(-1) + } + manager, ok := mgr.(*ExcelManager) + if !ok { + return C.int(-1) + } + goFilename := C.GoString(filename) + goSheet := C.GoString(sheet) + goCells := C.GoString(cells) + goValues := C.GoString(values) + + var cell []string + var value []string + err := json.Unmarshal([]byte(goCells), &cell) + if err != nil { + setError(fmt.Sprintf("解析数据失败: %v，数据: %s", err, goCells)) + return C.int(-1) + } + err = json.Unmarshal([]byte(goValues), &value) + if err != nil { + setError(fmt.Sprintf("解析数据失败: %v，数据: %s", err, goValues)) + return C.int(-1) + } + // 构建数据映射 + data := make(map[string]interface{}) + for i, c := range cell { + data[c] = value[i] + } + err = manager.WriteData(goFilename, goSheet, data) + if err != nil { + fmt.Printf("批量写入数据失败: %v\n", err) + return C.int(-1) + } + return C.int(0) +} + +// 追加数据到Excel文件末尾 +// +//export AppendDataToExcel +func AppendDataToExcel(handle C.longlong, filename *C.char, sheet *C.char, values *C.char, count C.int) C.int { + h := int64(handle) + mgr, ok := managerStore.Load(h) + if !ok { + return C.int(-1) + } + manager, ok := mgr.(*ExcelManager) + if !ok { + return C.int(-1) + } + goFilename := C.GoString(filename) + goSheet := C.GoString(sheet) + goValues := C.GoString(values) + var value []string + err := json.Unmarshal([]byte(goValues), &value) + if err != nil { + setError(fmt.Sprintf("解析数据失败: %v，数据: %s", err, goValues)) + return C.int(-1) + } + // 转换为interface{}切片 + var rowData []interface{} + for _, val := range value { + rowData = append(rowData, val) + } + err = manager.AppendData(goFilename, goSheet, rowData) + if err != nil { + fmt.Printf("追加数据失败: %v\n", err) + return C.int(-1) + } + return C.int(0) +} + +// 搜索包含关键字的单元格 +// +//export SearchByKeyword +func SearchByKeyword(handle C.longlong, filename *C.char, sheet *C.char, keyword *C.char, result **C.char) C.int { + h := int64(handle) + mgr, ok := managerStore.Load(h) + if !ok { + return C.int(-1) + } + manager, ok := mgr.(*ExcelManager) + if !ok { + return C.int(-1) + } + goFilename := C.GoString(filename) + goSheet := C.GoString(sheet) + goKeyword := C.GoString(keyword) + results, err := manager.SearchByKeyword(goFilename, goSheet, goKeyword) + if err != nil { + return C.int(-1) + } + // 将结果转换为JSON字符串 + jsonStr := convertToJSON(results) + *result = C.CString(jsonStr) + return C.int(0) +} + +// 搜索整行包含关键字的行 +// +//export SearchRowsByKeyword +func SearchRowsByKeyword(handle C.longlong, + filename *C.char, + sheet *C.char, + keyword *C.char, + result **C.char) C.int { + h := int64(handle) + mgr, ok := managerStore.Load(h) + if !ok { + return C.int(-1) + } + manager, ok := mgr.(*ExcelManager) + if !ok { + return C.int(-1) + } + goFilename := C.GoString(filename) + goSheet := C.GoString(sheet) + goKeyword := C.GoString(keyword) + results, err := manager.SearchRowData(goFilename, goSheet, goKeyword) + if err != nil { + return C.int(-1) + } + // 将结果转换为JSON字符串 + jsonStr := convertToJSON(results) + *result = C.CString(jsonStr) + return C.int(0) +} + +// 创建新文件并写入数据 +// +//export CreateAndWriteExcel +func CreateAndWriteExcel(handle C.longlong, filename *C.char, sheet *C.char, rowsData *C.char) C.int { + h := int64(handle) + + fmt.Println("managerStore:", managerStore) + + // 获取管理器 + mgr, ok := managerStore.Load(h) + if !ok { + setError("Invalid handle") + return C.int(-1) + } + + manager, ok := mgr.(*ExcelManager) + if !ok { + setError("Invalid manager type") + return C.int(-1) + } + goFilename := C.GoString(filename) + goSheet := C.GoString(sheet) + goRowsData := C.GoString(rowsData) + var data [][]string + err2 := json.Unmarshal([]byte(goRowsData), &data) + if err2 != nil { + // 更详细的错误信息 + setError(fmt.Sprintf("解析数据失败: %v, 数据: %s", err2, goRowsData)) + return C.int(-1) + } + // 调用管理器方法 + err := manager.CreateAndWrite(goFilename, goSheet, data) + if err != nil { + setError(fmt.Sprintf("创建并写入文件失败: %v", err)) + return C.int(-1) + } + fmt.Printf("文件创建成功: %s\n", goFilename) + return C.int(0) +} + +// 增强版合并Excel文件（支持指定文件列表） +// +//export MergeExcelFilesEx +func MergeExcelFilesEx(handle C.longlong, + sourceDir *C.char, + specificFiles *C.char, + outputFile *C.char, + sheetName *C.char, + mergeByColumn C.int, + includeHeaders C.int, + skipEmptyRows C.int, + filePattern *C.char, + sourceSheet *C.char, + addSourceColumn C.int, + addIndexColumn C.int) C.int { + h := int64(handle) + mgr, ok := managerStore.Load(h) + if !ok { + return C.int(-1) + } + manager, ok := mgr.(*ExcelManager) + if !ok { + return C.int(-1) + } + + goSpecificFiles := C.GoString(specificFiles) + var data []string + err2 := json.Unmarshal([]byte(goSpecificFiles), &data) + if err2 != nil { + // 更详细的错误信息 + setError(fmt.Sprintf("解析数据失败: %v, 数据: %s", err2, goSpecificFiles)) + return C.int(-1) + } + // 构建配置 + config := MergeConfig{ + SourceDir: C.GoString(sourceDir), + SpecificFiles: data, + OutputFile: C.GoString(outputFile), + SheetName: C.GoString(sheetName), + MergeByColumn: mergeByColumn != 0, + IncludeHeaders: includeHeaders != 0, + SkipEmptyRows: skipEmptyRows != 0, + FilePattern: C.GoString(filePattern), + AddSourceColumn: addSourceColumn != 0, + AddIndexColumn: addIndexColumn != 0, + SourceSheet: C.GoString(sourceSheet), + } + // 根据合并模式调用不同的方法 + var err error + if config.MergeByColumn { + err = manager.MergeByColumn(config) + } else { + err = manager.MergeExcelFiles(config) + } + if err != nil { + fmt.Printf("合并Excel文件失败: %v\n", err) + return C.int(-1) + } + return C.int(0) +} + +// 并行合并Excel文件（增强版） +// +//export MergeExcelFilesParallelEx +func MergeExcelFilesParallelEx(handle C.longlong, + sourceDir *C.char, + specificFiles **C.char, + fileCount C.int, + outputFile *C.char, + sheetName *C.char, + includeHeaders C.int, + skipEmptyRows C.int, + filePattern *C.char, + sourceSheet *C.char, + addSourceColumn C.int, + addIndexColumn C.int, + workers C.int) C.int { + h := int64(handle) + mgr, ok := managerStore.Load(h) + if !ok { + return C.int(-1) + } + manager, ok := mgr.(*ExcelManager) + if !ok { + return C.int(-1) + } + // 构建配置 + config := MergeConfig{ + SourceDir: C.GoString(sourceDir), + OutputFile: C.GoString(outputFile), + SheetName: C.GoString(sheetName), + IncludeHeaders: includeHeaders != 0, + SkipEmptyRows: skipEmptyRows != 0, + FilePattern: C.GoString(filePattern), + AddSourceColumn: addSourceColumn != 0, + AddIndexColumn: addIndexColumn != 0, + SourceSheet: C.GoString(sourceSheet), + } + + // 如果有指定的文件列表，则添加到配置中 + if fileCount > 0 && specificFiles != nil { + config.SpecificFiles = cStringArrayToStringSlice(specificFiles, int(fileCount)) + } + + err := manager.MergeExcelFilesParallel(config, int(workers)) + if err != nil { + fmt.Printf("并行合并Excel文件失败: %v\n", err) + return C.int(-1) + } + + return C.int(0) +} + +// 合并同一文件中的多个sheet +// +//export MergeSheetsInFile +func MergeSheetsInFile(handle C.longlong, + filename *C.char, + outputFile *C.char, + targetSheetName *C.char) C.int { + h := int64(handle) + mgr, ok := managerStore.Load(h) + if !ok { + return C.int(-1) + } + manager, ok := mgr.(*ExcelManager) + if !ok { + return C.int(-1) + } + goFilename := C.GoString(filename) + goOutputFile := C.GoString(outputFile) + goTargetSheet := C.GoString(targetSheetName) + + err := manager.MergeSheetsInSameFile(goFilename, goOutputFile, goTargetSheet) + if err != nil { + fmt.Printf("合并sheet失败: %v\n", err) + return C.int(-1) + } + + return C.int(0) +} + +// 释放C字符串 +// +//export FreeCString +func FreeCString(str *C.char) { + if str != nil { + C.free(unsafe.Pointer(str)) + } +} + +//func main() { +// +//} diff --git a/excel/new_file.xlsx b/excel/new_file.xlsx new file mode 100644 index 0000000..dfd3f53 Binary files /dev/null and b/excel/new_file.xlsx differ diff --git a/excel/test.go b/excel/test.go new file mode 100644 index 0000000..1cc88a1 --- /dev/null +++ b/excel/test.go @@ -0,0 +1,621 @@ +package main + +//import ( +// "fmt" +// "github.com/xuri/excelize/v2" +// "os" +// "time" +//) +// +//// ============ main函数 ============ +// +//func main() { +// // 创建Excel管理器 +// excelMgr := NewExcelManager() +// defer excelMgr.CloseAll() +// +// fmt.Println("=== Excel文件操作工具 ===") +// fmt.Println() +// +// // 1. 创建测试文件 +// fmt.Println("=== 步骤1: 创建测试文件 ===") +// createTestFiles() +// fmt.Println() +// +// // 2. 测试基本功能 +// fmt.Println("=== 步骤2: 测试基本功能 ===") +// testBasicFunctions(excelMgr) +// fmt.Println() +// +// // 3. 测试WriteData函数 +// fmt.Println("=== 步骤3: 测试WriteData函数 ===") +// testWriteDataFunction(excelMgr) +// fmt.Println() +// +// // 4. 测试SearchRowData函数 +// fmt.Println("=== 步骤4: 测试SearchRowData函数 ===") +// testSearchRowDataFunction(excelMgr) +// fmt.Println() +// // +// //// 5. 测试CreateAndWrite函数 +// fmt.Println("=== 步骤5: 测试CreateAndWrite函数 ===") +// testCreateAndWriteFunction(excelMgr) +// fmt.Println() +// +// //// 3. 测试合并功能（包含源文件和序号） +// //fmt.Println("=== 步骤3: 测试合并功能（包含源文件和序号）===") +// //start := time.Now() +// //mergeConfig := MergeConfig{ +// // SourceDir: ".", +// // OutputFile: "excel/merged_with_info.xlsx", +// // SheetName: "合并数据", +// // SourceSheet: "员工数据", +// // IncludeHeaders: true, +// // SkipEmptyRows: false, +// // FilePattern: "excel/data*.xlsx", +// // AddSourceColumn: false, +// // AddIndexColumn: false, +// //} +// // +// //err := excelMgr.MergeExcelFiles(mergeConfig) +// //if err != nil { +// // fmt.Printf("合并失败: %v\n", err) +// //} else { +// // elapsed := time.Since(start) +// // fmt.Printf("合并完成，耗时: %v\n", elapsed) +// //} +// //fmt.Println() +// +// //// 4. 测试并行合并 +// //fmt.Println("=== 步骤4: 测试并行合并 ===") +// //start = time.Now() +// //parallelConfig := MergeConfig{ +// // SourceDir: ".", +// // OutputFile: "excel/merged_parallel.xlsx", +// // SheetName: "并行合并数据", +// // SourceSheet: "员工数据", +// // IncludeHeaders: true, +// // SkipEmptyRows: false, +// // FilePattern: "excel/data*.xlsx", +// // AddSourceColumn: false, +// // AddIndexColumn: false, +// //} +// // +// //err = excelMgr.MergeExcelFilesParallel(parallelConfig, 2) +// //if err != nil { +// // fmt.Printf("并行合并失败: %v\n", err) +// //} else { +// // elapsed := time.Since(start) +// // fmt.Printf("并行合并完成，耗时: %v\n", elapsed) +// //} +// +// //// 5. 测试按列合并 +// //fmt.Println("=== 步骤5: 测试按列合并 ===") +// //start = time.Now() +// //columnConfig := MergeConfig{ +// // SourceDir: ".", +// // OutputFile: "merged_by_column.xlsx", +// // SheetName: "按列合并", +// // SourceSheet: "员工数据", +// // IncludeHeaders: false, +// // MergeByColumn: true, +// // FilePattern: "data*.xlsx", +// //} +// // +// //err = excelMgr.MergeByColumn(columnConfig) +// //if err != nil { +// // fmt.Printf("按列合并失败: %v\n", err) +// //} else { +// // elapsed := time.Since(start) +// // fmt.Printf("按列合并完成，耗时: %v\n", elapsed) +// //} +// //fmt.Println() +// +// // 6. 测试合并指定文件 +// fmt.Println("=== 步骤6: 测试合并指定文件 ===") +// start := time.Now() +// specificConfig := MergeConfig{ +// SpecificFiles: []string{"excel/data1.xlsx", "excel/data3.xlsx"}, +// OutputFile: "excel/merged_specific.xlsx", +// SheetName: "指定文件合并", +// SourceSheet: "员工数据", +// IncludeHeaders: true, +// SkipEmptyRows: false, +// AddSourceColumn: false, +// AddIndexColumn: false, +// } +// +// err := excelMgr.MergeExcelFiles(specificConfig) +// if err != nil { +// fmt.Printf("指定文件合并失败: %v\n", err) +// } else { +// elapsed := time.Since(start) +// fmt.Printf("指定文件合并完成，耗时: %v\n", elapsed) +// } +// fmt.Println() +// +// //// 7. 测试合并多sheet文件 +// //fmt.Println("=== 步骤7: 测试合并多sheet文件 ===") +// //err = createMultiSheetFile() +// //if err != nil { +// // fmt.Printf("创建多sheet文件失败: %v\n", err) +// // return +// //} +// // +// //start = time.Now() +// //err = excelMgr.MergeSheetsInSameFile("multi_sheet.xlsx", "merged_sheets.xlsx", "所有Sheet数据") +// //if err != nil { +// // fmt.Printf("合并sheet失败: %v\n", err) +// //} else { +// // elapsed := time.Since(start) +// // fmt.Printf("合并sheet完成，耗时: %v\n", elapsed) +// //} +// //fmt.Println() +// +// // 8. 清理测试文件 +// //fmt.Println("=== 步骤8: 清理测试文件 ===") +// //cleanupTestFiles() +//} +// +//// 测试基本功能 +//func testBasicFunctions(em *ExcelManager) { +// // 测试读取数据 +// rows, err := em.ReadData("excel/data1.xlsx", "员工数据") +// if err != nil { +// fmt.Printf("读取数据失败: %v\n", err) +// return +// } +// fmt.Printf("data1.xlsx 有 %d 行数据\n", len(rows)) +// +// // 测试搜索功能 +// results, err := em.SearchByKeyword("excel/data1.xlsx", "员工数据", "员工") +// if err != nil { +// fmt.Printf("搜索失败: %v\n", err) +// } else { +// fmt.Printf("找到包含'员工'的 %d 个结果\n", len(results)) +// } +// +// // 测试追加数据 +// newRow := []interface{}{999, "测试员工", 30, "测试部", "2023-12-01", 20000} +// err = em.AppendData("excel/data1.xlsx", "员工数据", newRow) +// if err != nil { +// fmt.Printf("追加数据失败: %v\n", err) +// } else { +// fmt.Println("追加数据成功") +// } +//} +// +////// 测试WriteData函数 - 从最大行后面加入新数据 +////func testWriteDataFunction(em *ExcelManager) { +//// // 1. 首先读取现有文件获取最大行数 +//// fmt.Println("1. 读取现有文件获取最大行数:") +//// rows, err := em.ReadData("excel/data1.xlsx", "员工数据") +//// if err != nil { +//// fmt.Printf("读取数据失败: %v\n", err) +//// return +//// } +//// +//// maxRow := len(rows) +//// fmt.Printf(" 文件当前有 %d 行数据\n", maxRow) +//// +//// // 显示最后几行数据 +//// if maxRow > 0 { +//// showRows := 3 +//// if maxRow < showRows { +//// showRows = maxRow +//// } +//// fmt.Printf(" 最后%d行数据预览:\n", showRows) +//// for i := maxRow - showRows; i < maxRow; i++ { +//// fmt.Printf(" 第%d行: %v\n", i+1, rows[i]) +//// } +//// } +//// +//// // 2. 在最大行后面添加新数据 +//// fmt.Println("\n2. 在最大行后面添加新数据:") +//// +//// // 计算新数据开始的行号 +//// // 注意：Excel行号从1开始，但rows长度已经包含了所有行 +//// startRow := maxRow + 1 +//// +//// // 准备要添加的新数据（从startRow开始） +//// newData := make(map[string]interface{}) +//// +//// // 添加第1条新记录（在startRow行） +//// newData[fmt.Sprintf("A%d", startRow)] = maxRow + 1 +//// newData[fmt.Sprintf("B%d", startRow)] = "新增员工1" +//// newData[fmt.Sprintf("C%d", startRow)] = 35 +//// newData[fmt.Sprintf("D%d", startRow)] = "研发部" +//// newData[fmt.Sprintf("E%d", startRow)] = time.Now().Format("2006-01-02") +//// newData[fmt.Sprintf("F%d", startRow)] = 25000 +//// +//// // 添加第2条新记录（在startRow+1行） +//// newData[fmt.Sprintf("A%d", startRow+1)] = maxRow + 2 +//// newData[fmt.Sprintf("B%d", startRow+1)] = "新增员工2" +//// newData[fmt.Sprintf("C%d", startRow+1)] = 28 +//// newData[fmt.Sprintf("D%d", startRow+1)] = "测试部" +//// newData[fmt.Sprintf("E%d", startRow+1)] = time.Now().Format("2006-01-02") +//// newData[fmt.Sprintf("F%d", startRow+1)] = 18000 +//// +//// // 添加第3条新记录（在startRow+2行） +//// newData[fmt.Sprintf("A%d", startRow+2)] = maxRow + 3 +//// newData[fmt.Sprintf("B%d", startRow+2)] = "新增员工3" +//// newData[fmt.Sprintf("C%d", startRow+2)] = 32 +//// newData[fmt.Sprintf("D%d", startRow+2)] = "运维部" +//// newData[fmt.Sprintf("E%d", startRow+2)] = time.Now().Format("2006-01-02") +//// newData[fmt.Sprintf("F%d", startRow+2)] = 22000 +//// +//// fmt.Printf(" 将在第%d行开始添加3条新记录\n", startRow) +//// +//// // 使用WriteData写入新数据 +//// err = em.WriteData("excel/data1.xlsx", "员工数据", newData) +//// if err != nil { +//// fmt.Printf("写入新数据失败: %v\n", err) +//// return +//// } +//// +//// fmt.Println(" 写入新数据成功") +//// +//// // 3. 验证添加结果 +//// fmt.Println("\n3. 验证添加结果:") +//// +//// // 重新读取文件 +//// rows, err = em.ReadData("excel/data1.xlsx", "员工数据") +//// if err != nil { +//// fmt.Printf("重新读取数据失败: %v\n", err) +//// return +//// } +//// +//// newMaxRow := len(rows) +//// fmt.Printf(" 添加后文件有 %d 行数据，增加了 %d 行\n", newMaxRow, newMaxRow-maxRow) +//// +//// // 显示新增的几行数据 +//// if newMaxRow > maxRow { +//// addedRows := newMaxRow - maxRow +//// fmt.Printf(" 新增的%d行数据:\n", addedRows) +//// for i := maxRow; i < newMaxRow; i++ { +//// fmt.Printf(" 第%d行: %v\n", i+1, rows[i]) +//// } +//// } +//// +//// // 4. 测试在空文件的最大行后添加数据 +//// fmt.Println("\n4. 测试在空文件的最大行后添加数据:") +//// +//// // 创建一个新的空Excel文件 +//// emptyData := [][]interface{}{ +//// {"ID", "Name", "Value"}, // 只有表头 +//// } +//// +//// // 先创建只有表头的文件 +//// emptyErr := em.CreateAndWrite("excel/empty_test.xlsx", "测试数据", emptyData) +//// if emptyErr != nil { +//// fmt.Printf("创建空文件失败: %v\n", emptyErr) +//// } else { +//// fmt.Println(" 创建空文件成功") +//// +//// // 读取空文件 +//// emptyRows, readErr := em.ReadData("excel/empty_test.xlsx", "测试数据") +//// if readErr != nil { +//// fmt.Printf("读取空文件失败: %v\n", readErr) +//// } else { +//// emptyMaxRow := len(emptyRows) +//// fmt.Printf(" 空文件有 %d 行数据\n", emptyMaxRow) +//// +//// // 在空文件的最大行后添加数据 +//// emptyNewData := make(map[string]interface{}) +//// +//// // 由于只有表头，所以从第2行开始添加 +//// emptyStartRow := emptyMaxRow + 1 +//// +//// // 添加测试数据 +//// emptyNewData[fmt.Sprintf("A%d", emptyStartRow)] = 1 +//// emptyNewData[fmt.Sprintf("B%d", emptyStartRow)] = "测试项目1" +//// emptyNewData[fmt.Sprintf("C%d", emptyStartRow)] = 100.5 +//// +//// emptyNewData[fmt.Sprintf("A%d", emptyStartRow+1)] = 2 +//// emptyNewData[fmt.Sprintf("B%d", emptyStartRow+1)] = "测试项目2" +//// emptyNewData[fmt.Sprintf("C%d", emptyStartRow+1)] = 200.75 +//// +//// fmt.Printf(" 将在空文件的第%d行开始添加2条记录\n", emptyStartRow) +//// +//// // 写入数据 +//// writeErr := em.WriteData("excel/empty_test.xlsx", "测试数据", emptyNewData) +//// if writeErr != nil { +//// fmt.Printf(" 向空文件写入数据失败: %v\n", writeErr) +//// } else { +//// fmt.Println(" 向空文件写入数据成功") +//// +//// // 验证结果 +//// finalRows, finalErr := em.ReadData("excel/empty_test.xlsx", "测试数据") +//// if finalErr != nil { +//// fmt.Printf(" 验证数据失败: %v\n", finalErr) +//// } else { +//// finalRowCount := len(finalRows) +//// fmt.Printf(" 最终文件有 %d 行数据:\n", finalRowCount) +//// +//// for i, row := range finalRows { +//// fmt.Printf(" 第%d行: %v\n", i+1, row) +//// } +//// } +//// } +//// } +//// } +//// +//// // 5. 测试替换现有行的数据 +//// fmt.Println("\n5. 测试替换现有行的数据:") +//// +//// // 替换第2行的部分数据 +//// replaceData := map[string]interface{}{ +//// "B2": "修改后的姓名", +//// "D2": "修改后的部门", +//// "F2": 30000, // 修改薪资 +//// } +//// +//// fmt.Println(" 将修改第2行的数据:") +//// fmt.Println(" B2: '修改后的姓名'") +//// fmt.Println(" D2: '修改后的部门'") +//// fmt.Println(" F2: 30000") +//// +//// replaceErr := em.WriteData("excel/data1.xlsx", "员工数据", replaceData) +//// if replaceErr != nil { +//// fmt.Printf(" 修改数据失败: %v\n", replaceErr) +//// } else { +//// fmt.Println(" 修改数据成功") +//// +//// // 验证修改结果 +//// verifyRows, verifyErr := em.ReadData("excel/data1.xlsx", "员工数据") +//// if verifyErr != nil { +//// fmt.Printf(" 验证修改失败: %v\n", verifyErr) +//// } else if len(verifyRows) >= 2 { +//// fmt.Printf(" 修改后的第2行数据: %v\n", verifyRows[1]) +//// } +//// } +////} +// +//// 测试SearchRowData函数 +//func testSearchRowDataFunction(em *ExcelManager) { +// fmt.Println("1. 测试搜索包含'员工'的行:") +// rows, err := em.SearchRowData("excel/data1.xlsx", "员工数据", "员工") +// if err != nil { +// fmt.Printf("搜索行数据失败: %v\n", err) +// } else { +// fmt.Printf("找到 %d 行包含'员工':\n", len(rows)) +// for i, row := range rows { +// fmt.Printf(" 第%d行: %v\n", i+1, row) +// } +// } +// +// fmt.Println("\n2. 测试搜索包含'技术部'的行:") +// rows, err = em.SearchRowData("excel/data1.xlsx", "员工数据", "技术部") +// if err != nil { +// fmt.Printf("搜索行数据失败: %v\n", err) +// } else { +// fmt.Printf("找到 %d 行包含'技术部':\n", len(rows)) +// for i, row := range rows { +// fmt.Printf(" 第%d行: %v\n", i+1, row) +// } +// } +// +// fmt.Println("\n3. 测试搜索包含'30000'的行:") +// rows, err = em.SearchRowData("excel/data1.xlsx", "员工数据", "30000") +// if err != nil { +// fmt.Printf("搜索行数据失败: %v\n", err) +// } else { +// fmt.Printf("找到 %d 行包含'30000':\n", len(rows)) +// for i, row := range rows { +// fmt.Printf(" 第%d行: %v\n", i+1, row) +// } +// } +// +// fmt.Println("\n4. 测试搜索不存在的关键词:") +// rows, err = em.SearchRowData("excel/data1.xlsx", "员工数据", "不存在的关键词") +// if err != nil { +// fmt.Printf("搜索行数据失败: %v\n", err) +// } else { +// fmt.Printf("找到 %d 行包含'不存在的关键词'\n", len(rows)) +// if len(rows) == 0 { +// fmt.Println(" (正确: 没有找到匹配的行)") +// } +// } +//} +// +//// 测试CreateAndWrite函数 +//func testCreateAndWriteFunction(em *ExcelManager) { +// fmt.Println("1. 测试创建新文件并写入数据:") +// +// //// 准备测试数据 +// //testData := [][]string{}{ +// // {"序号", "产品名称", "价格", "库存", "类别"}, +// // {1, "笔记本电脑", 6999.99, 50, "电子产品"}, +// // {2, "智能手机", 3999.99, 100, "电子产品"}, +// // {3, "办公椅", 899.99, 30, "办公家具"}, +// // {4, "台灯", 199.99, 80, "家居用品"}, +// // {5, "书籍", 59.99, 200, "文化用品"}, +// // {6, "水杯", 39.99, 150, "日用品"}, +// // {7, "背包", 299.99, 60, "箱包"}, +// // {8, "鼠标", 99.99, 120, "电子产品"}, +// // {9, "键盘", 199.99, 70, "电子产品"}, +// // {10, "显示器", 1299.99, 40, "电子产品"}, +// //} +// +// err := em.CreateAndWrite("excel/test_create.xlsx", "产品数据", testData) +// if err != nil { +// fmt.Printf("创建并写入文件失败: %v\n", err) +// } else { +// fmt.Println("创建并写入文件成功") +// +// // 验证文件 +// if _, err := os.Stat("excel/test_create.xlsx"); err == nil { +// fmt.Println("文件创建成功: excel/test_create.xlsx") +// +// rows, err := em.ReadData("excel/test_create.xlsx", "产品数据") +// if err != nil { +// fmt.Printf("读取文件失败: %v\n", err) +// } else { +// fmt.Printf("文件有 %d 行数据:\n", len(rows)) +// +// // 显示前5行 +// limit := 5 +// if len(rows) < limit { +// limit = len(rows) +// } +// +// fmt.Println(" 前5行数据:") +// for i := 0; i < limit; i++ { +// fmt.Printf(" 第%d行: %v\n", i+1, rows[i]) +// } +// +// if len(rows) > limit { +// fmt.Printf(" ... 还有 %d 行数据\n", len(rows)-limit) +// } +// } +// +// // 测试搜索功能 +// fmt.Println("\n2. 在新建文件中测试搜索:") +// searchResults, err := em.SearchByKeyword("excel/test_create.xlsx", "产品数据", "电子") +// if err != nil { +// fmt.Printf("搜索失败: %v\n", err) +// } else { +// fmt.Printf("找到 %d 个包含'电子'的单元格:\n", len(searchResults)) +// for i, result := range searchResults { +// fmt.Printf(" %d. %s\n", i+1, result) +// } +// } +// +// // 测试行搜索 +// fmt.Println("\n3. 在新建文件中测试行搜索:") +// rowResults, err := em.SearchRowData("excel/test_create.xlsx", "产品数据", "电子") +// if err != nil { +// fmt.Printf("行搜索失败: %v\n", err) +// } else { +// fmt.Printf("找到 %d 行包含'电子':\n", len(rowResults)) +// for i, row := range rowResults { +// fmt.Printf(" 第%d行: %v\n", i+1, row) +// } +// } +// } +// } +//} +// +//// 创建测试文件 +//func createTestFiles() { +// testFiles := []string{ +// "excel/data1.xlsx", +// "excel/data2.xlsx", +// "excel/data3.xlsx", +// } +// +// for i, filename := range testFiles { +// data := [][]interface{}{ +// {"ID", "姓名", "年龄", "部门", "入职日期", "薪资"}, +// {i*100 + 1, fmt.Sprintf("员工%d", i*3+1), 25 + i, "技术部", "2023-01-15", 15000 + i*1000}, +// {i*100 + 2, fmt.Sprintf("员工%d", i*3+2), 28 + i, "市场部", "2023-02-20", 12000 + i*1000}, +// {i*100 + 3, fmt.Sprintf("员工%d", i*3+3), 32 + i, "销售部", "2023-03-10", 18000 + i*1000}, +// {i*100 + 4, fmt.Sprintf("员工%d", i*3+4), 26 + i, "人事部", "2023-04-05", 10000 + i*1000}, +// } +// err := createExcelFile(filename, "员工数据", data) +// if err != nil { +// fmt.Printf("创建文件 %s 失败: %v\n", filename, err) +// return +// } +// fmt.Printf("创建文件: %s (共%d行数据)\n", filename, len(data)) +// } +//} +// +//// 创建多sheet测试文件 +//func createMultiSheetFile() error { +// file := excelize.NewFile() +// defer file.Close() +// +// // Sheet1 +// file.NewSheet("部门数据") +// data1 := [][]interface{}{ +// {"部门", "人数", "预算"}, +// {"技术部", 50, 1000000}, +// {"市场部", 30, 800000}, +// {"销售部", 40, 900000}, +// } +// writeDataToSheet(file, "部门数据", data1) +// +// // Sheet2 +// file.NewSheet("项目数据") +// data2 := [][]interface{}{ +// {"项目", "负责人", "进度", "预算"}, +// {"项目A", "张三", "80%", 500000}, +// {"项目B", "李四", "60%", 300000}, +// {"项目C", "王五", "90%", 400000}, +// } +// writeDataToSheet(file, "项目数据", data2) +// +// // Sheet3 +// file.NewSheet("财务数据") +// data3 := [][]interface{}{ +// {"月份", "收入", "支出", "利润"}, +// {"1月", 500000, 300000, 200000}, +// {"2月", 550000, 320000, 230000}, +// {"3月", 600000, 350000, 250000}, +// } +// writeDataToSheet(file, "财务数据", data3) +// +// // 删除默认的Sheet1 +// file.DeleteSheet("Sheet1") +// +// return file.SaveAs("multi_sheet.xlsx") +//} +// +//// 写入数据到sheet +//func writeDataToSheet(file *excelize.File, sheet string, data [][]interface{}) { +// for rowIndex, row := range data { +// for colIndex, value := range row { +// cell, _ := excelize.CoordinatesToCellName(colIndex+1, rowIndex+1) +// file.SetCellValue(sheet, cell, value) +// } +// } +//} +// +//// 创建Excel文件 +//func createExcelFile(filename, sheet string, data [][]interface{}) error { +// file := excelize.NewFile() +// defer file.Close() +// +// // 删除默认的Sheet1 +// file.DeleteSheet("Sheet1") +// +// // 创建新sheet +// sheetIndex, err := file.NewSheet(sheet) +// if err != nil { +// return err +// } +// file.SetActiveSheet(sheetIndex) +// +// // 写入数据 +// for rowIndex, row := range data { +// for colIndex, value := range row { +// cell, _ := excelize.CoordinatesToCellName(colIndex+1, rowIndex+1) +// file.SetCellValue(sheet, cell, value) +// } +// } +// +// return file.SaveAs(filename) +//} +// +//// 清理测试文件 +//func cleanupTestFiles() { +// filesToClean := []string{ +// "data1.xlsx", +// "data2.xlsx", +// "data3.xlsx", +// "merged_with_info.xlsx", +// "merged_parallel.xlsx", +// "merged_by_column.xlsx", +// "merged_specific.xlsx", +// "multi_sheet.xlsx", +// "merged_sheets.xlsx", +// } +// +// for _, file := range filesToClean { +// if _, err := os.Stat(file); err == nil { +// os.Remove(file) +// fmt.Printf("删除: %s\n", file) +// } +// } +//} diff --git a/go.mod b/go.mod index e5bc59c..476e6cf 100644 --- a/go.mod +++ b/go.mod @@ -5,9 +5,14 @@ go 1.25 require ( github.com/PuerkitoBio/goquery v1.10.3 github.com/chromedp/chromedp v0.14.2 - github.com/go-ini/ini v1.67.0 + github.com/disintegration/imaging v1.6.2 + github.com/elastic/go-elasticsearch/v8 v8.19.0 github.com/go-sql-driver/mysql v1.9.3 + github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646 github.com/parnurzeal/gorequest v0.3.0 + github.com/xuri/excelize/v2 v2.10.0 + golang.org/x/image v0.25.0 + golang.org/x/sys v0.37.0 ) require ( @@ -15,15 +20,26 @@ require ( github.com/andybalholm/cascadia v1.3.3 // indirect github.com/chromedp/cdproto v0.0.0-20250724212937-08a3db8b4327 // indirect github.com/chromedp/sysutil v1.1.0 // indirect + github.com/elastic/elastic-transport-go/v8 v8.7.0 // indirect github.com/elazarl/goproxy v1.7.2 // indirect github.com/go-json-experiment/json v0.0.0-20250725192818-e39067aee2d2 // indirect + github.com/go-logr/logr v1.4.2 // indirect + github.com/go-logr/stdr v1.2.2 // indirect github.com/gobwas/httphead v0.1.0 // indirect github.com/gobwas/pool v0.2.1 // indirect github.com/gobwas/ws v1.4.0 // indirect github.com/moul/http2curl v1.0.0 // indirect github.com/pkg/errors v0.9.1 // indirect + github.com/richardlehane/mscfb v1.0.4 // indirect + github.com/richardlehane/msoleps v1.0.4 // indirect github.com/smartystreets/goconvey v1.8.1 // indirect - github.com/stretchr/testify v1.10.0 // indirect - golang.org/x/net v0.39.0 // indirect - golang.org/x/sys v0.34.0 // indirect + github.com/tiendc/go-deepcopy v1.7.1 // indirect + github.com/xuri/efp v0.0.1 // indirect + github.com/xuri/nfp v0.0.2-0.20250530014748-2ddeb826f9a9 // indirect + go.opentelemetry.io/otel v1.28.0 // indirect + go.opentelemetry.io/otel/metric v1.28.0 // indirect + go.opentelemetry.io/otel/trace v1.28.0 // indirect + golang.org/x/crypto v0.43.0 // indirect + golang.org/x/net v0.46.0 // indirect + golang.org/x/text v0.30.0 // indirect ) diff --git a/go.sum b/go.sum index 7267768..6ca92c1 100644 --- a/go.sum +++ b/go.sum @@ -12,12 +12,21 @@ github.com/chromedp/sysutil v1.1.0 h1:PUFNv5EcprjqXZD9nJb9b/c9ibAbxiYo4exNWZyipw github.com/chromedp/sysutil v1.1.0/go.mod h1:WiThHUdltqCNKGc4gaU50XgYjwjYIhKWoHGPTUfWTJ8= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/disintegration/imaging v1.6.2 h1:w1LecBlG2Lnp8B3jk5zSuNqd7b4DXhcjwek1ei82L+c= +github.com/disintegration/imaging v1.6.2/go.mod h1:44/5580QXChDfwIclfc/PCwrr44amcmDAg8hxG0Ewe4= +github.com/elastic/elastic-transport-go/v8 v8.7.0 h1:OgTneVuXP2uip4BA658Xi6Hfw+PeIOod2rY3GVMGoVE= +github.com/elastic/elastic-transport-go/v8 v8.7.0/go.mod h1:YLHer5cj0csTzNFXoNQ8qhtGY1GTvSqPnKWKaqQE3Hk= +github.com/elastic/go-elasticsearch/v8 v8.19.0 h1:VmfBLNRORY7RZL+9hTxBD97ehl9H8Nxf2QigDh6HuMU= +github.com/elastic/go-elasticsearch/v8 v8.19.0/go.mod h1:F3j9e+BubmKvzvLjNui/1++nJuJxbkhHefbaT0kFKGY= github.com/elazarl/goproxy v1.7.2 h1:Y2o6urb7Eule09PjlhQRGNsqRfPmYI3KKQLFpCAV3+o= github.com/elazarl/goproxy v1.7.2/go.mod h1:82vkLNir0ALaW14Rc399OTTjyNREgmdL2cVoIbS6XaE= -github.com/go-ini/ini v1.67.0 h1:z6ZrTEZqSWOTyH2FlglNbNgARyHG8oLW9gMELqKr06A= -github.com/go-ini/ini v1.67.0/go.mod h1:ByCAeIL28uOIIG0E3PJtZPDL8WnHpFKFOtgjp+3Ies8= github.com/go-json-experiment/json v0.0.0-20250725192818-e39067aee2d2 h1:iizUGZ9pEquQS5jTGkh4AqeeHCMbfbjeb0zMt0aEFzs= github.com/go-json-experiment/json v0.0.0-20250725192818-e39067aee2d2/go.mod h1:TiCD2a1pcmjd7YnhGH0f/zKNcCD06B029pHhzV23c2M= +github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY= +github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= +github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/go-sql-driver/mysql v1.9.3 h1:U/N249h2WzJ3Ukj8SowVFjdtZKfu9vlLZxjPXV1aweo= github.com/go-sql-driver/mysql v1.9.3/go.mod h1:qn46aNg1333BRMNU69Lq93t8du/dwxI64Gl8i5p1WMU= github.com/gobwas/httphead v0.1.0 h1:exrUm0f4YX0L7EBwZHuCF4GDp8aJfVeBrlLQrs6NqWU= @@ -26,6 +35,7 @@ github.com/gobwas/pool v0.2.1 h1:xfeeEhW7pwmX8nuLVlqbzVc7udMDrwetjEv+TZIz1og= github.com/gobwas/pool v0.2.1/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw= github.com/gobwas/ws v1.4.0 h1:CTaoG1tojrh4ucGPcoJFiAQUAsEWekEWvLy7GsVNqGs= github.com/gobwas/ws v1.4.0/go.mod h1:G3gNqMNtPppf5XUz7O4shetPpcZ1VJ7zt18dlUeakrc= +github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= github.com/gopherjs/gopherjs v1.17.2 h1:fQnZVsXk8uxXIStYb0N4bGk7jeyTalG/wsZjQ25dO0g= github.com/gopherjs/gopherjs v1.17.2/go.mod h1:pRRIvn/QzFLrKfvEz3qUuEhtE/zLCWfreZ6J5gM2i+k= @@ -35,6 +45,8 @@ github.com/ledongthuc/pdf v0.0.0-20220302134840-0c2507a12d80 h1:6Yzfa6GP0rIo/kUL github.com/ledongthuc/pdf v0.0.0-20220302134840-0c2507a12d80/go.mod h1:imJHygn/1yfhB7XSJJKlFZKl/J+dCPAknuiaGOshXAs= github.com/moul/http2curl v1.0.0 h1:dRMWoAtb+ePxMlLkrCbAqh4TlPHXvoGUSQ323/9Zahs= github.com/moul/http2curl v1.0.0/go.mod h1:8UbvGypXm98wA/IqH45anm5Y2Z6ep6O31QGOAZ3H0fQ= +github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646 h1:zYyBkD/k9seD2A7fsi6Oo2LfFZAehjjQMERAvZLEDnQ= +github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646/go.mod h1:jpp1/29i3P1S/RLdc7JQKbRpFeM1dOBd8T9ki5s+AY8= github.com/orisano/pixelmatch v0.0.0-20220722002657-fb0b55479cde h1:x0TT0RDC7UhAVbbWWBzr41ElhJx5tXPWkIHA2HWPRuw= github.com/orisano/pixelmatch v0.0.0-20220722002657-fb0b55479cde/go.mod h1:nZgzbfBr3hhjoZnS66nKrHmduYNpc34ny7RK4z5/HM0= github.com/parnurzeal/gorequest v0.3.0 h1:SoFyqCDC9COr1xuS6VA8fC8RU7XyrJZN2ona1kEX7FI= @@ -43,19 +55,45 @@ github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/richardlehane/mscfb v1.0.4 h1:WULscsljNPConisD5hR0+OyZjwK46Pfyr6mPu5ZawpM= +github.com/richardlehane/mscfb v1.0.4/go.mod h1:YzVpcZg9czvAuhk9T+a3avCpcFPMUWm7gK3DypaEsUk= +github.com/richardlehane/msoleps v1.0.1/go.mod h1:BWev5JBpU9Ko2WAgmZEuiz4/u3ZYTKbjLycmwiWUfWg= +github.com/richardlehane/msoleps v1.0.4 h1:WuESlvhX3gH2IHcd8UqyCuFY5yiq/GR/yqaSM/9/g00= +github.com/richardlehane/msoleps v1.0.4/go.mod h1:BWev5JBpU9Ko2WAgmZEuiz4/u3ZYTKbjLycmwiWUfWg= github.com/smarty/assertions v1.15.0 h1:cR//PqUBUiQRakZWqBiFFQ9wb8emQGDb0HeGdqGByCY= github.com/smarty/assertions v1.15.0/go.mod h1:yABtdzeQs6l1brC900WlRNwj6ZR55d7B+E8C6HtKdec= github.com/smartystreets/goconvey v1.8.1 h1:qGjIddxOk4grTu9JPOU31tVfq3cNdBlNa5sSznIX1xY= github.com/smartystreets/goconvey v1.8.1/go.mod h1:+/u4qLyY6x1jReYOp7GOM2FSt8aP9CzCZL03bI28W60= -github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= -github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= +github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/tiendc/go-deepcopy v1.7.1 h1:LnubftI6nYaaMOcaz0LphzwraqN8jiWTwm416sitff4= +github.com/tiendc/go-deepcopy v1.7.1/go.mod h1:4bKjNC2r7boYOkD2IOuZpYjmlDdzjbpTRyCx+goBCJQ= +github.com/xuri/efp v0.0.1 h1:fws5Rv3myXyYni8uwj2qKjVaRP30PdjeYe2Y6FDsCL8= +github.com/xuri/efp v0.0.1/go.mod h1:ybY/Jr0T0GTCnYjKqmdwxyxn2BQf2RcQIIvex5QldPI= +github.com/xuri/excelize/v2 v2.10.0 h1:8aKsP7JD39iKLc6dH5Tw3dgV3sPRh8uRVXu/fMstfW4= +github.com/xuri/excelize/v2 v2.10.0/go.mod h1:SC5TzhQkaOsTWpANfm+7bJCldzcnU/jrhqkTi/iBHBU= +github.com/xuri/nfp v0.0.2-0.20250530014748-2ddeb826f9a9 h1:+C0TIdyyYmzadGaL/HBLbf3WdLgC29pgyhTjAT/0nuE= +github.com/xuri/nfp v0.0.2-0.20250530014748-2ddeb826f9a9/go.mod h1:WwHg+CVyzlv/TX9xqBFXEZAuxOPxn2k1GNHwG41IIUQ= github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= +go.opentelemetry.io/otel v1.28.0 h1:/SqNcYk+idO0CxKEUOtKQClMK/MimZihKYMruSMViUo= +go.opentelemetry.io/otel v1.28.0/go.mod h1:q68ijF8Fc8CnMHKyzqL6akLO46ePnjkgfIMIjUIX9z4= +go.opentelemetry.io/otel/metric v1.28.0 h1:f0HGvSl1KRAU1DLgLGFjrwVyismPlnuU6JD6bOeuA5Q= +go.opentelemetry.io/otel/metric v1.28.0/go.mod h1:Fb1eVBFZmLVTMb6PPohq3TO9IIhUisDsbJoL/+uQW4s= +go.opentelemetry.io/otel/sdk v1.21.0 h1:FTt8qirL1EysG6sTQRZ5TokkU8d0ugCj8htOgThZXQ8= +go.opentelemetry.io/otel/sdk v1.21.0/go.mod h1:Nna6Yv7PWTdgJHVRD9hIYywQBRx7pbox6nwBnZIxl/E= +go.opentelemetry.io/otel/trace v1.28.0 h1:GhQ9cUuQGmNDd5BTCP2dAvv75RdMxEfTmYejp+lkx9g= +go.opentelemetry.io/otel/trace v1.28.0/go.mod h1:jPyXzNPg6da9+38HEwElrQiHlVMTnVfM3/yv2OlIHaI= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= golang.org/x/crypto v0.13.0/go.mod h1:y6Z2r+Rw4iayiXXAIxJIDAJ1zMW4yaTpebo8fPOliYc= golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU= golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8= golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk= +golang.org/x/crypto v0.43.0 h1:dduJYIi3A3KOfdGOHX8AVZ/jGiyPa3IbBozJ5kNuE04= +golang.org/x/crypto v0.43.0/go.mod h1:BFbav4mRNlXJL4wNeejLpWxB7wMbc79PdRGhWKncxR0= +golang.org/x/image v0.0.0-20191009234506-e7c1f5e7dbb8/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +golang.org/x/image v0.25.0 h1:Y6uW6rH1y5y/LK1J8BPWZtr6yZ7hrsy6hFrXjgsc2fQ= +golang.org/x/image v0.25.0/go.mod h1:tCAmOEGthTtkalusGp1g3xa2gke8J6c2N565dTyl9Rs= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= @@ -70,8 +108,8 @@ golang.org/x/net v0.15.0/go.mod h1:idbUs1IY1+zTqbi8yxTbhexhEEk5ur9LInksu6HrEpk= golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44= golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM= golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4= -golang.org/x/net v0.39.0 h1:ZCu7HMWDxpXpaiKdhzIfaltL9Lp31x/3fCP11bc6/fY= -golang.org/x/net v0.39.0/go.mod h1:X7NRbYVEA+ewNkCNyJ513WmMdQ3BineSwVtN2zD/d+E= +golang.org/x/net v0.46.0 h1:giFlY12I07fugqwPuWJi68oOnpfqFnJIJzaIIm2JVV4= +golang.org/x/net v0.46.0/go.mod h1:Q9BGdFy1y4nkUwiLvT5qtyhAnEHgnQ/zd8PfU6nc210= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -91,8 +129,8 @@ golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/sys v0.34.0 h1:H5Y5sJ2L2JRdyv7ROF1he/lPdvFsd0mJHFw2ThKHxLA= -golang.org/x/sys v0.34.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= +golang.org/x/sys v0.37.0 h1:fdNQudmxPjkdUTPnLn5mdQv7Zwvbvpaxqs831goi9kQ= +golang.org/x/sys v0.37.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks= golang.org/x/telemetry v0.0.0-20240228155512-f48c80bd79b2/go.mod h1:TeRTkGYfJXctD9OcfyVLyj2J3IxLnKwHJR8f4D8a3YE= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= @@ -111,8 +149,8 @@ golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE= golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ= -golang.org/x/text v0.24.0 h1:dd5Bzh4yt5KYA8f9CJHCP4FB4D51c2c6JvN37xJJkJ0= -golang.org/x/text v0.24.0/go.mod h1:L8rBsPeo2pSS+xqN0d5u2ikmjtmoJbDBT1b7nHvFCdU= +golang.org/x/text v0.30.0 h1:yznKA/E9zq54KzlzBEAWn1NXSQ8DIp/NYMy88xJjl4k= +golang.org/x/text v0.30.0/go.mod h1:yDdHFIX9t+tORqspjENWgzaCVXgk0yYnYuSZ8UzzBVM= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= diff --git a/image/dll/image.dll b/image/dll/image.dll new file mode 100644 index 0000000..d1331d6 Binary files /dev/null and b/image/dll/image.dll differ diff --git a/image/dll/image.h b/image/dll/image.h new file mode 100644 index 0000000..f39459e --- /dev/null +++ b/image/dll/image.h @@ -0,0 +1,113 @@ +/* Code generated by cmd/cgo; DO NOT EDIT. */ + +/* package command-line-arguments */ + + +#line 1 "cgo-builtin-export-prolog" + +#include + +#ifndef GO_CGO_EXPORT_PROLOGUE_H +#define GO_CGO_EXPORT_PROLOGUE_H + +#ifndef GO_CGO_GOSTRING_TYPEDEF +typedef struct { const char *p; ptrdiff_t n; } _GoString_; +extern size_t _GoStringLen(_GoString_ s); +extern const char *_GoStringPtr(_GoString_ s); +#endif + +#endif + +/* Start of preamble from import "C" comments. */ + + +#line 3 "image.go" + #include + +#line 1 "cgo-generated-wrapper" + + +/* End of preamble from import "C" comments. */ + + +/* Start of boilerplate cgo prologue. */ +#line 1 "cgo-gcc-export-header-prolog" + +#ifndef GO_CGO_PROLOGUE_H +#define GO_CGO_PROLOGUE_H + +typedef signed char GoInt8; +typedef unsigned char GoUint8; +typedef short GoInt16; +typedef unsigned short GoUint16; +typedef int GoInt32; +typedef unsigned int GoUint32; +typedef long long GoInt64; +typedef unsigned long long GoUint64; +typedef GoInt64 GoInt; +typedef GoUint64 GoUint; +typedef size_t GoUintptr; +typedef float GoFloat32; +typedef double GoFloat64; +#ifdef _MSC_VER +#if !defined(__cplusplus) || _MSVC_LANG <= 201402L +#include +typedef _Fcomplex GoComplex64; +typedef _Dcomplex GoComplex128; +#else +#include +typedef std::complex GoComplex64; +typedef std::complex GoComplex128; +#endif +#else +typedef float _Complex GoComplex64; +typedef double _Complex GoComplex128; +#endif + +/* + static assertion to make sure the file is being used on architecture + at least with matching size of GoInt. +*/ +typedef char _check_for_64_bit_pointer_matching_GoInt[sizeof(void*)==64/8 ? 1:-1]; + +#ifndef GO_CGO_GOSTRING_TYPEDEF +typedef _GoString_ GoString; +#endif +typedef void *GoMap; +typedef void *GoChan; +typedef struct { void *t; void *v; } GoInterface; +typedef struct { void *data; GoInt len; GoInt cap; } GoSlice; + +#endif + +/* End of boilerplate cgo prologue. */ + +#ifdef __cplusplus +extern "C" { +#endif + + +// =================== C 导出函数 ======================= +// 处理图片成功 +// +extern __declspec(dllexport) char* ProcessImage(char* jsonConfig); + +// 根据原始图片生成新的白底图片 +// +extern __declspec(dllexport) char* CreateWhiteBottomCenteredImage(char* jsonConfig, int width, int height); + +// 根据高度生成等比例图片 +// +extern __declspec(dllexport) char* ResizeToHeightQuality(char* jsonConfig, int targetHeight); + +// 去掉白边并转PNG图片工具 +// +extern __declspec(dllexport) char* RemoveWhiteBorderAndPNG(char* jsonConfig); + +// 导出函数：释放C字符串内存 +// +extern __declspec(dllexport) void FreeCString(char* str); + +#ifdef __cplusplus +} +#endif diff --git a/image/image.go b/image/image.go new file mode 100644 index 0000000..348d712 --- /dev/null +++ b/image/image.go @@ -0,0 +1,590 @@ +package main + +// #include +import "C" +import ( + "encoding/json" + "fmt" + "github.com/disintegration/imaging" + "github.com/nfnt/resize" + "golang.org/x/image/draw" + "image" + "image/color" + "image/jpeg" + _ "image/jpeg" + "image/png" + _ "image/png" + "os" + "path/filepath" + "strings" + "unsafe" +) + +// Config 配置结构体 +type Config struct { + OutputDir string // 输出目录路径 + FileName string // 文件名 + MatchDir string // 满足条件的图片目录名 + UnmatchDir string // 不满足条件的图片目录名 + EqualHeightDir string // 等高的图片目录名 + WhiteDir string // 白色底图的图片目录名 + WhiteBorderPngDir string // 去白边转PNG的图片目录名 + MinWhitePct float64 // 纯白占比下限（0-1） + MaxWhitePct float64 // 纯白占比上限（0-1） + Extensions []string // 支持的图片扩展名 +} + +// 检查图片 +func validateConfig(config *Config) error { + // 检查百分比范围 + if config.MinWhitePct < 0 || config.MinWhitePct > 1 { + return fmt.Errorf("纯白占比下限必须在0-1之间") + } + + if config.MaxWhitePct < 0 || config.MaxWhitePct > 1 { + return fmt.Errorf("纯白占比上限必须在0-1之间") + } + + if config.MinWhitePct > config.MaxWhitePct { + return fmt.Errorf("下限不能大于上限") + } + + return nil +} + +func createDirs(config *Config) error { + // 创建输出根目录 + if err := os.MkdirAll(config.OutputDir, 0755); err != nil { + return err + } + + // 创建匹配目录 + matchPath := filepath.Join(config.OutputDir, config.MatchDir) + if err := os.MkdirAll(matchPath, 0755); err != nil { + return err + } + + // 创建不匹配目录 + unmatchPath := filepath.Join(config.OutputDir, config.UnmatchDir) + if err := os.MkdirAll(unmatchPath, 0755); err != nil { + return err + } + + equalHeightPath := filepath.Join(config.OutputDir, config.EqualHeightDir) + if err := os.MkdirAll(equalHeightPath, 0755); err != nil { + return err + } + + whitePath := filepath.Join(config.OutputDir, config.WhiteDir) + if err := os.MkdirAll(whitePath, 0755); err != nil { + return err + } + + whiteBorderPngPath := filepath.Join(config.OutputDir, config.WhiteBorderPngDir) + if err := os.MkdirAll(whiteBorderPngPath, 0755); err != nil { + return err + } + return nil +} + +// 计算纯白占比 +func calculateWhitePercentage(imagePath string) (float64, error) { + // 打开图片文件 + file, err := os.Open(imagePath) + if err != nil { + return 0, err + } + defer file.Close() + + // 解码图片 + img, _, err := image.Decode(file) + if err != nil { + return 0, err + } + + bounds := img.Bounds() + totalPixels := bounds.Dx() * bounds.Dy() + whitePixels := 0 + + // 遍历每个像素，判断是否为纯白色 + for y := bounds.Min.Y; y < bounds.Max.Y; y++ { + for x := bounds.Min.X; x < bounds.Max.X; x++ { + pixel := color.RGBAModel.Convert(img.At(x, y)).(color.RGBA) + + // 判断是否为纯白色 (R=255, G=255, B=255) + if pixel.R == 255 && pixel.G == 255 && pixel.B == 255 { + whitePixels++ + } + } + } + + return float64(whitePixels) / float64(totalPixels), nil +} + +// 复制文件到相应目录 +func copyToDestination(srcPath string, config *Config, isMatch bool) error { + filename := filepath.Base(srcPath) + + // 确定目标目录 + var destDir string + if isMatch { + destDir = filepath.Join(config.OutputDir, config.MatchDir) + } else { + destDir = filepath.Join(config.OutputDir, config.UnmatchDir) + } + + destPath := filepath.Join(destDir, filename) + + // 读取源文件 + data, err := os.ReadFile(srcPath) + if err != nil { + return err + } + + // 写入目标文件 + return os.WriteFile(destPath, data, 0644) +} + +// 保存文件 +func saveImage(outputPath string, img image.Image, format string) error { + // 创建输出文件 + outFile, err := os.Create(outputPath) + if err != nil { + return err + } + defer outFile.Close() + + // 根据原始格式保存图片 + switch format { + case "jpeg", "jpg": + // JPEG 格式可以设置质量参数 + return jpeg.Encode(outFile, img, &jpeg.Options{Quality: 95}) + case "png": + // PNG 格式通常不需要质量参数 + return png.Encode(outFile, img) + default: + // 默认使用 JPEG 格式 + return jpeg.Encode(outFile, img, &jpeg.Options{Quality: 95}) + } +} + +// 检测图片纯白占比 +func processImage(config *Config) error { + // 创建输出目录 + if err := createDirs(config); err != nil { + return fmt.Errorf("创建目录失败: %v\n", err) + } + + if err := validateConfig(config); err != nil { + return err + } + + // 计算纯白占比 + whitePct, err := calculateWhitePercentage(config.FileName) + if err != nil { + return fmt.Errorf("错误: %v\n", err) + } + // 判断是否在范围内 + isMatch := whitePct >= config.MinWhitePct && whitePct <= config.MaxWhitePct + status := "❌ 不满足" + if isMatch { + status = "✅ 满足" + } + fmt.Printf("纯白占比: %.2f%% %s\n", whitePct*100, status) + + // 复制文件到相应目录 + if err = copyToDestination(config.FileName, config, isMatch); err != nil { + return fmt.Errorf("复制失败: %v\n", err) + } + return nil +} + +// 根据原始图片生成新的白底图片 +func createWhiteBottomCenteredImage(config *Config, width, height int) (string, error) { + // 创建输出目录 + if err := createDirs(config); err != nil { + fmt.Printf("创建目录失败: %v\n", err) + os.Exit(1) + } + // 打开图片 + file, err := os.Open(config.FileName) + if err != nil { + return "", fmt.Errorf("打开图片失败: %v", err) + } + defer file.Close() + // 解码原始图片 + img, format, err := image.Decode(file) + if err != nil { + return "", fmt.Errorf("图片解码失败: %v", err) + } + + // 创建透明背景 + dst := image.NewRGBA(image.Rect(0, 0, width, height)) + + // 设置背景颜色 + var bgColor color.Color + + bgColor = color.RGBA{255, 255, 255, 255} // 白色 + + // 填充透明背景 + draw.Draw(dst, dst.Bounds(), &image.Uniform{bgColor}, image.Point{}, draw.Src) + + // 计算居中位置 + srcBounds := img.Bounds() + srcWidth := srcBounds.Dx() + srcHeight := srcBounds.Dy() + + x := (width - srcWidth) / 2 + y := (height - srcHeight) / 2 + + // 将原图绘制到中央 + draw.Draw(dst, image.Rect(x, y, x+srcWidth, y+srcHeight), img, image.Point{}, draw.Over) + + filename := filepath.Base(config.FileName) + destPath := filepath.Join(config.OutputDir, config.WhiteDir, filename) + saveImage(destPath, dst, format) + + return destPath, nil +} + +// 根据高度生成等比例图片 +func resizeToHeightQuality(config *Config, targetHeight int) (string, error) { + // 创建输出目录 + if err := createDirs(config); err != nil { + fmt.Printf("创建目录失败: %v\n", err) + os.Exit(1) + } + // 打开图片 + file, err := os.Open(config.FileName) + if err != nil { + return "", fmt.Errorf("打开图片失败: %v", err) + } + defer file.Close() + // 解码原始图片 + img, format, err := image.Decode(file) + if err != nil { + return "", fmt.Errorf("图片解码失败: %v", err) + } + + bounds := img.Bounds() + srcWidth := bounds.Dx() + srcHeight := bounds.Dy() + + // 计算等比例缩放后的宽度 + targetWidth := uint(float64(srcWidth) * float64(targetHeight) / float64(srcHeight)) + // 使用 Lanczos3 插值算法进行高质量缩放 + imageNew := resize.Resize(targetWidth, uint(targetHeight), img, resize.Lanczos3) + + // 保存图片到指定目录下 + filename := filepath.Base(config.FileName) + destPath := filepath.Join(config.OutputDir, config.EqualHeightDir, filename) + saveImage(destPath, imageNew, format) + + return destPath, nil +} + +// ImageToPNGConverter 图片去白边并转为PNG +type ImageToPNGConverter struct { + Threshold int + Margin int + BgColor color.RGBA + DetectColor *color.RGBA + KeepTransparent bool + PNGCompressLevel png.CompressionLevel + Quality int +} + +// 去掉白边并转PNG图片工具 +func removeWhiteBorderAndPNG(config *Config) (string, error) { + // 创建输出目录 + if err := createDirs(config); err != nil { + fmt.Printf("创建目录失败: %v\n", err) + os.Exit(1) + } + // 打开图片 + file, err := os.Open(config.FileName) + if err != nil { + return "", fmt.Errorf("打开图片失败: %v", err) + } + defer file.Close() + // 解码原始图片 + img, _, err := image.Decode(file) + if err != nil { + return "", fmt.Errorf("图片解码失败: %v", err) + } + + compressLevel := 6 + + // 创建转换器 + compressionLevel := png.DefaultCompression + switch { + case compressLevel <= 0: + compressionLevel = png.NoCompression + case compressLevel >= 9: + compressionLevel = png.BestCompression + default: + // 使用默认压缩级别 + } + + converter := newImageToPNGConverter( + 240, + 0, + &color.RGBA{R: 255, G: 255, B: 255, A: 255}, + nil, + false, + compressionLevel, + 95, + ) + + toPNG := converter.convertToPNG(img, true) + + // 保存图片到指定目录下 + filename := filepath.Base(config.FileName) + // 去除扩展名 + nameWithoutExt := strings.TrimSuffix(filename, filepath.Ext(filename)) + destPath := filepath.Join(config.OutputDir, config.WhiteBorderPngDir, nameWithoutExt+".png") + saveImage(destPath, toPNG, "png") + return destPath, nil +} + +// newImageToPNGConverter 创建新的转换器 +func newImageToPNGConverter(threshold, margin int, bgColor, detectColor *color.RGBA, + keepTransparent bool, compressLevel png.CompressionLevel, quality int) *ImageToPNGConverter { + + // 默认背景色为白色 + bg := color.RGBA{R: 255, G: 255, B: 255, A: 255} + if bgColor != nil { + bg = *bgColor + } + + return &ImageToPNGConverter{ + Threshold: threshold, + Margin: margin, + BgColor: bg, + DetectColor: detectColor, + KeepTransparent: keepTransparent, + PNGCompressLevel: compressLevel, + Quality: quality, + } +} + +// ConvertToPNG 转换图片为PNG格式 +func (c *ImageToPNGConverter) convertToPNG(img image.Image, addBackground bool) image.Image { + // 先裁剪白边 + trimmed := c.trimImage(img) + + // 检查是否有alpha通道 + _, hasAlpha := trimmed.(*image.NRGBA) + if !hasAlpha { + _, hasAlpha = trimmed.(*image.RGBA) + } + + if hasAlpha { + if c.KeepTransparent { + // 保持透明 + return trimmed + } else if addBackground { + // 添加背景色 + bg := image.NewRGBA(trimmed.Bounds()) + draw.Draw(bg, bg.Bounds(), &image.Uniform{C: c.BgColor}, image.Point{}, draw.Src) + draw.Draw(bg, bg.Bounds(), trimmed, trimmed.Bounds().Min, draw.Over) + return bg + } + } else { + // 非透明图像 + if c.KeepTransparent { + // 转换为RGBA + rgba := image.NewRGBA(trimmed.Bounds()) + draw.Draw(rgba, rgba.Bounds(), trimmed, trimmed.Bounds().Min, draw.Src) + return rgba + } + return trimmed + } + + return trimmed +} + +// TrimImage 裁剪图片白边 +func (c *ImageToPNGConverter) trimImage(img image.Image) image.Image { + borders := c.findBorders(img) + + // 创建一个新的图像并裁剪 + trimmed := imaging.Crop(img, borders) + return trimmed +} + +// FindBorders 查找图片的有效边界 +func (c *ImageToPNGConverter) findBorders(img image.Image) image.Rectangle { + bounds := img.Bounds() + width := bounds.Dx() + height := bounds.Dy() + + // 检查图像是否有alpha通道 + _, hasAlpha := img.(*image.NRGBA) + if !hasAlpha { + _, hasAlpha = img.(*image.RGBA) + } + + // 初始化边界 + left := width + top := height + right := 0 + bottom := 0 + + // 查找非背景区域 + for y := bounds.Min.Y; y < bounds.Max.Y; y++ { + for x := bounds.Min.X; x < bounds.Max.X; x++ { + pixel := img.At(x, y) + if !c.isBackgroundColor(pixel, hasAlpha) { + if x < left { + left = x + } + if x > right { + right = x + } + if y < top { + top = y + } + if y > bottom { + bottom = y + } + } + } + } + + // 如果没有找到非背景区域，返回整个图像 + if left > right || top > bottom { + return bounds + } + + // 添加边距 + left = max(bounds.Min.X, left-c.Margin) + top = max(bounds.Min.Y, top-c.Margin) + right = min(bounds.Max.X, right+c.Margin+1) + bottom = min(bounds.Max.Y, bottom+c.Margin+1) + + return image.Rect(left, top, right, bottom) +} + +// IsBackgroundColor 判断像素是否为背景色 +func (c *ImageToPNGConverter) isBackgroundColor(pixel color.Color, hasAlpha bool) bool { + r, g, b, a := pixel.RGBA() + + // 转换为8位值 + r8 := uint8(r >> 8) + g8 := uint8(g >> 8) + b8 := uint8(b >> 8) + a8 := uint8(a >> 8) + + // 检查透明度 + if hasAlpha && a8 < 25 { // 透明度 > 90% + return true + } + + // 如果指定了检测颜色 + if c.DetectColor != nil { + dr, dg, db, _ := c.DetectColor.RGBA() + dr8 := uint8(dr >> 8) + dg8 := uint8(dg >> 8) + db8 := uint8(db >> 8) + + // threshold 是 int 类型，需要转换为 uint8 比较 + threshold8 := uint8(255 - c.Threshold) + return absDiff(r8, dr8) <= threshold8 && + absDiff(g8, dg8) <= threshold8 && + absDiff(b8, db8) <= threshold8 + } + + // 自动检测白色/浅色背景 + // 注意：这里的 c.Threshold 是 int，需要转换为 uint8 + threshold8 := uint8(c.Threshold) + return r8 >= threshold8 && + g8 >= threshold8 && + b8 >= threshold8 +} + +// 辅助函数 +func absDiff(a, b uint8) uint8 { + if a > b { + return a - b + } + return b - a +} + +// =================== C 导出函数 ======================= +// 检测图片纯白占比 +// +//export ProcessImage +func ProcessImage(jsonConfig *C.char) *C.char { + configStr := C.GoString(jsonConfig) + var config *Config + if err := json.Unmarshal([]byte(configStr), &config); err != nil { + return C.CString(fmt.Sprintf("解析 config 失败: %v", err)) + } + if err := processImage(config); err != nil { + return C.CString(fmt.Sprintf("%v", err)) + } + return C.CString("成功") +} + +// 根据原始图片生成新的白底图片 +// +//export CreateWhiteBottomCenteredImage +func CreateWhiteBottomCenteredImage(jsonConfig *C.char, width, height C.int) *C.char { + configStr := C.GoString(jsonConfig) + widthInt := int(width) + heightInt := int(height) + var config *Config + if err := json.Unmarshal([]byte(configStr), &config); err != nil { + return C.CString(fmt.Sprintf("解析 config 失败: %v", err)) + } + fileName, err := createWhiteBottomCenteredImage(config, widthInt, heightInt) + if err != nil { + return C.CString(fmt.Sprintf("%v", err)) + } + return C.CString(fileName) +} + +// 根据高度生成等比例图片 +// +//export ResizeToHeightQuality +func ResizeToHeightQuality(jsonConfig *C.char, targetHeight C.int) *C.char { + configStr := C.GoString(jsonConfig) + targetHeightInt := int(targetHeight) + var config *Config + if err := json.Unmarshal([]byte(configStr), &config); err != nil { + return C.CString(fmt.Sprintf("解析 config 失败: %v", err)) + } + fileName, err := resizeToHeightQuality(config, targetHeightInt) + if err != nil { + return C.CString(fmt.Sprintf("%v", err)) + } + return C.CString(fileName) +} + +// 去掉白边并转PNG图片工具 +// +//export RemoveWhiteBorderAndPNG +func RemoveWhiteBorderAndPNG(jsonConfig *C.char) *C.char { + configStr := C.GoString(jsonConfig) + var config *Config + if err := json.Unmarshal([]byte(configStr), &config); err != nil { + return C.CString(fmt.Sprintf("解析 config 失败: %v", err)) + } + fileName, err := removeWhiteBorderAndPNG(config) + if err != nil { + return C.CString(fmt.Sprintf("%v", err)) + } + return C.CString(fileName) +} + +// 导出函数：释放C字符串内存 +// +//export FreeCString +func FreeCString(str *C.char) { + C.free(unsafe.Pointer(str)) +} + +//func main() { +// +//} diff --git a/image/imageDllTest.go b/image/imageDllTest.go new file mode 100644 index 0000000..07238bd --- /dev/null +++ b/image/imageDllTest.go @@ -0,0 +1,87 @@ +package main + +import ( + "encoding/json" + "fmt" + "os" + "path/filepath" + "syscall" + "unsafe" +) + +// ImageDLL 图片处理DLL结构 +type imageDLL struct { + dll *syscall.DLL + processImage *syscall.Proc + freeCString *syscall.Proc +} + +// 初始化imageDLL +func InitImageDll() (*imageDLL, error) { + dllPath := filepath.Join("image", "dll", "image.dll") + if _, err := os.Stat(dllPath); os.IsNotExist(err) { + return nil, fmt.Errorf("image DLL 不存在: %s", dllPath) + } + if dll, err := syscall.LoadDLL(dllPath); err != nil { + return nil, fmt.Errorf("加载image DLL 失败: %s", err) + } else { + return &imageDLL{ + dll: dll, + processImage: dll.MustFindProc("ProcessImage"), + freeCString: dll.MustFindProc("FreeCString"), + }, nil + } +} + +func (m *imageDLL) ProcessImage(config *Config) error { + marshal, err := json.Marshal(config) + if err != nil { + return fmt.Errorf("json转换失败: %s", err) + } + fromString, _ := syscall.BytePtrFromString(string(marshal)) + info, _, _ := m.processImage.Call(uintptr(unsafe.Pointer(fromString))) + cStr(info) + return nil +} + +// cStr 将 C 字符串指针转换为 Go 字符串 +func cStr(ptr uintptr) string { + if ptr == 0 { + return "" + } + var b []byte + for { + c := *(*byte)(unsafe.Pointer(ptr)) + if c == 0 { + break + } + b = append(b, c) + ptr++ + } + return string(b) +} + +// +//func main() { +// +// config := &Config{ +// InputDir: "D:\\www\\wwwroot\\imageTool\\img\\image", // 输入图片目录 +// OutputDir: "D:\\isbn_images\\result", // 输出根目录 +// FileName: "D:\\isbn_images\\result\\9771671688095.jpg", +// MatchDir: "matched", // 满足条件的图片目录 +// UnmatchDir: "unmatched", // 不满足条件的图片目录 +// EqualHeightDir: "equalHeight", +// MinWhitePct: 0.1, // 纯白占比下限 10% +// MaxWhitePct: 0.65, // 纯白占比上限 90% +// Extensions: []string{"jpg", "jpeg", "png", "gif", "bmp", "webp"}, +// } +// +// dll, err := InitImageDll() +// if err != nil { +// fmt.Println(err) +// } +// err = dll.ProcessImage(config) +// if err != nil { +// fmt.Println(err) +// } +//} diff --git a/image/imageTest.go b/image/imageTest.go new file mode 100644 index 0000000..ec43c2b --- /dev/null +++ b/image/imageTest.go @@ -0,0 +1,43 @@ +package main + +import "fmt" + +func main() { + // ==================== 在这里设置你的参数 ==================== + config := &Config{ + OutputDir: "D:\\isbn_images\\result", // 输出根目录 + FileName: "D:\\isbn_images\\result\\9771671688095.jpg", + MatchDir: "matched", // 满足条件的图片目录 + UnmatchDir: "unmatched", // 不满足条件的图片目录 + EqualHeightDir: "equalHeight", + WhiteDir: "white", + WhiteBorderPngDir: "whiteBorderPng", + MinWhitePct: 0.1, // 纯白占比下限 10% + MaxWhitePct: 0.65, // 纯白占比上限 90% + Extensions: []string{"jpg", "jpeg", "png", "gif", "bmp", "webp"}, + } + + //err := processImage(config) + //if err != nil { + // fmt.Println(err) + //} + // + //file, err := resizeToHeightQuality(config, 700) + //if err != nil { + // fmt.Println(err) + //} + //fmt.Println(file) + //config.FileName = file + //fmt.Println(config) + //file1, err := createWhiteBottomCenteredImage(config, 800, 800) + //if err != nil { + // fmt.Println(err) + //} + //fmt.Println(file1) + + png, err := removeWhiteBorderAndPNG(config) + if err != nil { + fmt.Println(err) + } + fmt.Println(png) +} diff --git a/image/imageTool.go b/image/imageTool.go new file mode 100644 index 0000000..7d7e3a4 --- /dev/null +++ b/image/imageTool.go @@ -0,0 +1,644 @@ +package main + +//import ( +// "fmt" +// "image" +// "image/color" +// "image/draw" +// "image/png" +// "io/ioutil" +// "os" +// "path/filepath" +// "strings" +// "sync" +// "time" +// +// "github.com/disintegration/imaging" +//) +// +////// ImageToPNGConverter 图片去白边并转为PNG +////type ImageToPNGConverter struct { +//// Threshold int +//// Margin int +//// BgColor color.RGBA +//// DetectColor *color.RGBA +//// KeepTransparent bool +//// PNGCompressLevel png.CompressionLevel +//// Quality int +////} +// +//// NewImageToPNGConverter 创建新的转换器 +//func NewImageToPNGConverter(threshold, margin int, bgColor, detectColor *color.RGBA, +// keepTransparent bool, compressLevel png.CompressionLevel, quality int) *ImageToPNGConverter { +// +// // 默认背景色为白色 +// bg := color.RGBA{R: 255, G: 255, B: 255, A: 255} +// if bgColor != nil { +// bg = *bgColor +// } +// +// return &ImageToPNGConverter{ +// Threshold: threshold, +// Margin: margin, +// BgColor: bg, +// DetectColor: detectColor, +// KeepTransparent: keepTransparent, +// PNGCompressLevel: compressLevel, +// Quality: quality, +// } +//} +// +//// IsBackgroundColor 判断像素是否为背景色 +//func (c *ImageToPNGConverter) IsBackgroundColor(pixel color.Color, hasAlpha bool) bool { +// r, g, b, a := pixel.RGBA() +// +// // 转换为8位值 +// r8 := uint8(r >> 8) +// g8 := uint8(g >> 8) +// b8 := uint8(b >> 8) +// a8 := uint8(a >> 8) +// +// // 检查透明度 +// if hasAlpha && a8 < 25 { // 透明度 > 90% +// return true +// } +// +// // 如果指定了检测颜色 +// if c.DetectColor != nil { +// dr, dg, db, _ := c.DetectColor.RGBA() +// dr8 := uint8(dr >> 8) +// dg8 := uint8(dg >> 8) +// db8 := uint8(db >> 8) +// +// // threshold 是 int 类型，需要转换为 uint8 比较 +// threshold8 := uint8(255 - c.Threshold) +// return absDiff(r8, dr8) <= threshold8 && +// absDiff(g8, dg8) <= threshold8 && +// absDiff(b8, db8) <= threshold8 +// } +// +// // 自动检测白色/浅色背景 +// // 注意：这里的 c.Threshold 是 int，需要转换为 uint8 +// threshold8 := uint8(c.Threshold) +// return r8 >= threshold8 && +// g8 >= threshold8 && +// b8 >= threshold8 +//} +// +//// FindBorders 查找图片的有效边界 +//func (c *ImageToPNGConverter) FindBorders(img image.Image) image.Rectangle { +// bounds := img.Bounds() +// width := bounds.Dx() +// height := bounds.Dy() +// +// // 检查图像是否有alpha通道 +// _, hasAlpha := img.(*image.NRGBA) +// if !hasAlpha { +// _, hasAlpha = img.(*image.RGBA) +// } +// +// // 初始化边界 +// left := width +// top := height +// right := 0 +// bottom := 0 +// +// // 查找非背景区域 +// for y := bounds.Min.Y; y < bounds.Max.Y; y++ { +// for x := bounds.Min.X; x < bounds.Max.X; x++ { +// pixel := img.At(x, y) +// if !c.IsBackgroundColor(pixel, hasAlpha) { +// if x < left { +// left = x +// } +// if x > right { +// right = x +// } +// if y < top { +// top = y +// } +// if y > bottom { +// bottom = y +// } +// } +// } +// } +// +// // 如果没有找到非背景区域，返回整个图像 +// if left > right || top > bottom { +// return bounds +// } +// +// // 添加边距 +// left = max(bounds.Min.X, left-c.Margin) +// top = max(bounds.Min.Y, top-c.Margin) +// right = min(bounds.Max.X, right+c.Margin+1) +// bottom = min(bounds.Max.Y, bottom+c.Margin+1) +// +// return image.Rect(left, top, right, bottom) +//} +// +//// TrimImage 裁剪图片白边 +//func (c *ImageToPNGConverter) TrimImage(img image.Image) image.Image { +// borders := c.FindBorders(img) +// +// // 创建一个新的图像并裁剪 +// trimmed := imaging.Crop(img, borders) +// return trimmed +//} +// +//// ConvertToPNG 转换图片为PNG格式 +//func (c *ImageToPNGConverter) ConvertToPNG(img image.Image, addBackground bool) image.Image { +// // 先裁剪白边 +// trimmed := c.TrimImage(img) +// +// // 检查是否有alpha通道 +// _, hasAlpha := trimmed.(*image.NRGBA) +// if !hasAlpha { +// _, hasAlpha = trimmed.(*image.RGBA) +// } +// +// if hasAlpha { +// if c.KeepTransparent { +// // 保持透明 +// return trimmed +// } else if addBackground { +// // 添加背景色 +// bg := image.NewRGBA(trimmed.Bounds()) +// draw.Draw(bg, bg.Bounds(), &image.Uniform{C: c.BgColor}, image.Point{}, draw.Src) +// draw.Draw(bg, bg.Bounds(), trimmed, trimmed.Bounds().Min, draw.Over) +// return bg +// } +// } else { +// // 非透明图像 +// if c.KeepTransparent { +// // 转换为RGBA +// rgba := image.NewRGBA(trimmed.Bounds()) +// draw.Draw(rgba, rgba.Bounds(), trimmed, trimmed.Bounds().Min, draw.Src) +// return rgba +// } +// return trimmed +// } +// +// return trimmed +//} +// +//// ProcessImageFile 处理单个图片文件 +//func (c *ImageToPNGConverter) ProcessImageFile(inputPath, outputPath string) map[string]interface{} { +// result := map[string]interface{}{ +// "success": false, +// "input_path": inputPath, +// "output_path": outputPath, +// } +// +// // 打开图片文件 +// file, err := os.Open(inputPath) +// if err != nil { +// result["error"] = err.Error() +// result["message"] = fmt.Sprintf("失败: %s - %s", filepath.Base(inputPath), err) +// return result +// } +// defer file.Close() +// +// // 解码图像 +// img, format, err := image.Decode(file) +// if err != nil { +// result["error"] = err.Error() +// result["message"] = fmt.Sprintf("失败: %s - %s", filepath.Base(inputPath), err) +// return result +// } +// +// // 获取原始信息 +// origBounds := img.Bounds() +// origSize := origBounds.Size() +// origArea := origSize.X * origSize.Y +// +// // 转换为PNG +// resultImg := c.ConvertToPNG(img, true) +// +// // 获取处理后的信息 +// newBounds := resultImg.Bounds() +// newSize := newBounds.Size() +// newArea := newSize.X * newSize.Y +// +// // 计算尺寸减少比例 +// sizeReduction := 0.0 +// if origArea > 0 { +// sizeReduction = 1 - float64(newArea)/float64(origArea) +// } +// +// // 获取原始文件大小 +// fileInfo, _ := os.Stat(inputPath) +// origFileSize := fileInfo.Size() +// +// // 保存为PNG +// outputFile, err := os.Create(outputPath) +// if err != nil { +// result["error"] = err.Error() +// result["message"] = fmt.Sprintf("失败: %s - %s", filepath.Base(inputPath), err) +// return result +// } +// defer outputFile.Close() +// +// encoder := png.Encoder{CompressionLevel: c.PNGCompressLevel} +// err = encoder.Encode(outputFile, resultImg) +// if err != nil { +// result["error"] = err.Error() +// result["message"] = fmt.Sprintf("失败: %s - %s", filepath.Base(inputPath), err) +// return result +// } +// +// // 获取新文件大小 +// newFileInfo, _ := os.Stat(outputPath) +// newFileSize := newFileInfo.Size() +// +// // 计算文件大小变化 +// fileSizeChange := 0.0 +// if origFileSize > 0 { +// fileSizeChange = float64(newFileSize) / float64(origFileSize) +// } +// +// result["success"] = true +// result["orig_format"] = format +// result["orig_size"] = origSize +// result["new_size"] = newSize +// result["size_reduction"] = sizeReduction +// result["orig_file_size"] = origFileSize +// result["new_file_size"] = newFileSize +// result["file_size_change"] = fileSizeChange +// result["message"] = fmt.Sprintf("成功: %s (%s→PNG, %dx%d→%dx%d)", +// filepath.Base(inputPath), format, origSize.X, origSize.Y, newSize.X, newSize.Y) +// +// return result +//} +// +//// BatchPNGConverter 批量PNG转换器 +//type BatchPNGConverter struct { +// converter *ImageToPNGConverter +// outputDir string +// statistics map[string]interface{} +// mu sync.Mutex +//} +// +//// NewBatchPNGConverter 创建批量转换器 +//func NewBatchPNGConverter(converter *ImageToPNGConverter, outputDir string) *BatchPNGConverter { +// os.MkdirAll(outputDir, 0755) +// return &BatchPNGConverter{ +// converter: converter, +// outputDir: outputDir, +// statistics: make(map[string]interface{}), +// } +//} +// +//// GetOutputPath 生成输出路径 +//func (b *BatchPNGConverter) GetOutputPath(inputPath, suffix string) string { +// baseName := filepath.Base(inputPath) +// ext := filepath.Ext(baseName) +// nameWithoutExt := strings.TrimSuffix(baseName, ext) +// +// outputFilename := nameWithoutExt + suffix + ".png" +// return filepath.Join(b.outputDir, outputFilename) +//} +// +//// ProcessSingle 处理单张图片 +//func (b *BatchPNGConverter) ProcessSingle(inputPath, outputPath, suffix string) map[string]interface{} { +// if outputPath == "" { +// outputPath = b.GetOutputPath(inputPath, suffix) +// } +// +// // 确保输出目录存在 +// os.MkdirAll(filepath.Dir(outputPath), 0755) +// +// return b.converter.ProcessImageFile(inputPath, outputPath) +//} +// +//// ProcessBatch 批量处理图片 +//func (b *BatchPNGConverter) ProcessBatch(inputPaths []string, suffix string, maxWorkers int) map[string]interface{} { +// startTime := time.Now() +// +// stats := map[string]interface{}{ +// "total": len(inputPaths), +// "success": 0, +// "failed": 0, +// "total_size_reduction": 0.0, +// "total_file_size_orig": int64(0), +// "total_file_size_new": int64(0), +// "results": []map[string]interface{}{}, +// } +// +// // 使用工作池 +// var wg sync.WaitGroup +// semaphore := make(chan struct{}, maxWorkers) +// resultsChan := make(chan map[string]interface{}, len(inputPaths)) +// +// for _, inputPath := range inputPaths { +// wg.Add(1) +// go func(path string) { +// defer wg.Done() +// semaphore <- struct{}{} +// defer func() { <-semaphore }() +// +// outputPath := b.GetOutputPath(path, suffix) +// result := b.ProcessSingle(path, outputPath, suffix) +// resultsChan <- result +// }(inputPath) +// } +// +// // 收集结果 +// go func() { +// wg.Wait() +// close(resultsChan) +// }() +// +// completed := 0 +// for result := range resultsChan { +// completed++ +// b.mu.Lock() +// stats["results"] = append(stats["results"].([]map[string]interface{}), result) +// +// if result["success"].(bool) { +// stats["success"] = stats["success"].(int) + 1 +// stats["total_size_reduction"] = stats["total_size_reduction"].(float64) + result["size_reduction"].(float64) +// stats["total_file_size_orig"] = stats["total_file_size_orig"].(int64) + result["orig_file_size"].(int64) +// stats["total_file_size_new"] = stats["total_file_size_new"].(int64) + result["new_file_size"].(int64) +// } else { +// stats["failed"] = stats["failed"].(int) + 1 +// } +// b.mu.Unlock() +// +// fmt.Printf("[%d/%d] %s\n", completed, len(inputPaths), result["message"]) +// } +// +// // 计算统计信息 +// stats["elapsed_time"] = time.Since(startTime).Seconds() +// if stats["success"].(int) > 0 { +// stats["avg_size_reduction"] = stats["total_size_reduction"].(float64) / float64(stats["success"].(int)) +// if stats["total_file_size_orig"].(int64) > 0 { +// stats["total_file_size_change"] = float64(stats["total_file_size_new"].(int64)) / float64(stats["total_file_size_orig"].(int64)) +// } else { +// stats["total_file_size_change"] = 1.0 +// } +// } +// +// return stats +//} +// +//// FindImageFiles 查找目录中的图片文件 +//func FindImageFiles(directory string, recursive bool) []string { +// supportedExtensions := map[string]bool{ +// ".jpg": true, +// ".jpeg": true, +// ".png": true, +// ".gif": true, +// ".bmp": true, +// ".tif": true, +// ".tiff": true, +// ".webp": true, +// ".jfif": true, +// ".ico": true, +// ".ppm": true, +// ".pgm": true, +// ".pbm": true, +// ".pnm": true, +// } +// +// var imagePaths []string +// +// if recursive { +// filepath.Walk(directory, func(path string, info os.FileInfo, err error) error { +// if err != nil { +// return err +// } +// if !info.IsDir() { +// ext := strings.ToLower(filepath.Ext(path)) +// if supportedExtensions[ext] { +// imagePaths = append(imagePaths, path) +// } +// } +// return nil +// }) +// } else { +// files, err := ioutil.ReadDir(directory) +// if err != nil { +// return imagePaths +// } +// +// for _, file := range files { +// if !file.IsDir() { +// ext := strings.ToLower(filepath.Ext(file.Name())) +// if supportedExtensions[ext] { +// imagePaths = append(imagePaths, filepath.Join(directory, file.Name())) +// } +// } +// } +// } +// +// return imagePaths +//} +// +//// PrintBanner 打印程序标题 +//func PrintBanner() { +// banner := ` +//╔══════════════════════════════════════════════════╗ +//║ 图片去白边转PNG工具 v1.0 ║ +//║ Image White Border Removal & PNG Converter ║ +//╚══════════════════════════════════════════════════╝ +//` +// fmt.Println(banner) +//} +// +//// PrintSummary 打印处理总结 +//func PrintSummary(stats map[string]interface{}) { +// fmt.Println("\n" + strings.Repeat("=", 60)) +// fmt.Println("📊 处理总结") +// fmt.Println(strings.Repeat("=", 60)) +// fmt.Printf("📁 总共处理: %d 张图片\n", stats["total"]) +// fmt.Printf("✅ 成功: %d 张\n", stats["success"]) +// fmt.Printf("❌ 失败: %d 张\n", stats["failed"]) +// +// if stats["success"].(int) > 0 { +// fmt.Printf("⏱️ 耗时: %.2f 秒\n", stats["elapsed_time"].(float64)) +// +// if avgReduction, ok := stats["avg_size_reduction"]; ok { +// fmt.Printf("📐 平均尺寸减少: %.1f%%\n", avgReduction.(float64)*100) +// } +// +// if change, ok := stats["total_file_size_change"]; ok { +// changeVal := change.(float64) +// if changeVal < 1 { +// fmt.Printf("💾 总文件大小减少: %.1f%%\n", (1-changeVal)*100) +// } else if changeVal > 1 { +// fmt.Printf("💾 总文件大小增加: %.1f%%\n", (changeVal-1)*100) +// } else { +// fmt.Println("💾 总文件大小基本不变") +// } +// } +// } +// fmt.Println(strings.Repeat("=", 60)) +//} +// +//// 辅助函数 +//func absDiff(a, b uint8) uint8 { +// if a > b { +// return a - b +// } +// return b - a +//} +// +//func max(a, b int) int { +// if a > b { +// return a +// } +// return b +//} +// +//func min(a, b int) int { +// if a < b { +// return a +// } +// return b +//} +// +//func main() { +// // 直接设置参数值，不需要命令行输入 +// +// // ============ 参数配置区 ============ +// // 基础参数 +// inputPath := "D:\\isbn_images\\result\\matched\\9771671688095.jpg" // 输入文件或目录路径 +// outputPath := "D:\\isbn_images\\result\\matched\\output.png" // 输出文件路径（单文件模式） +// outputDir := "D:\\isbn_images\\result\\matched\\" // 输出目录路径（批量模式） +// suffix := "_trimmed" // 输出文件名后缀 +// +// // 处理参数 +// threshold := 240 // 背景检测阈值 (0-255) +// margin := 0 // 保留边距像素 +// transparent := false // 保持透明背景 +// compressLevel := 6 // PNG压缩级别 (0-9) +// +// // 批量处理参数 +// recursive := false // 递归处理子目录 +// jobs := 4 // 并行处理数 +// force := true // 覆盖已存在的输出文件（设置为true不询问） +// verbose := true // 显示详细处理信息 +// showBanner := true // 显示标题横幅 +// // ============ 参数配置结束 ============ +// +// if showBanner { +// PrintBanner() +// } +// +// // 创建转换器 +// compressionLevel := png.DefaultCompression +// switch { +// case compressLevel <= 0: +// compressionLevel = png.NoCompression +// case compressLevel >= 9: +// compressionLevel = png.BestCompression +// default: +// // 使用默认压缩级别 +// } +// +// converter := NewImageToPNGConverter( +// threshold, +// margin, +// &color.RGBA{R: 255, G: 255, B: 255, A: 255}, +// nil, +// transparent, +// compressionLevel, +// 95, +// ) +// +// batchConverter := NewBatchPNGConverter(converter, outputDir) +// +// // 检查输入路径 +// info, err := os.Stat(inputPath) +// if err != nil { +// fmt.Printf("❌ 错误: 路径不存在 - %s\n", inputPath) +// return +// } +// +// if !info.IsDir() { +// // 单文件模式 +// fmt.Printf("📄 处理单文件: %s\n", inputPath) +// +// // 如果outputPath为空，则生成默认输出路径 +// if outputPath == "" { +// outputPath = batchConverter.GetOutputPath(inputPath, suffix) +// } +// +// // 检查输出文件是否存在，如果force为false则询问 +// if _, err := os.Stat(outputPath); err == nil && !force { +// fmt.Printf("⚠️ 警告: 输出文件已存在 - %s\n", outputPath) +// fmt.Println("已设置force=true，直接覆盖") +// } +// +// result := batchConverter.ProcessSingle(inputPath, outputPath, suffix) +// +// if result["success"].(bool) { +// fmt.Printf("\n✅ %s\n", result["message"]) +// fmt.Printf("💾 输出文件: %s\n", result["output_path"]) +// +// if reduction, ok := result["size_reduction"]; ok { +// reductionVal := reduction.(float64) +// if reductionVal > 0 { +// fmt.Printf("📐 尺寸减少: %.1f%%\n", reductionVal*100) +// } else if reductionVal < 0 { +// fmt.Printf("📐 尺寸增加: %.1f%%\n", -reductionVal*100) +// } +// } +// +// if change, ok := result["file_size_change"]; ok { +// changeVal := change.(float64) +// if changeVal < 1 { +// fmt.Printf("💿 文件大小减少: %.1f%%\n", (1-changeVal)*100) +// } else if changeVal > 1 { +// fmt.Printf("💿 文件大小增加: %.1f%%\n", (changeVal-1)*100) +// } +// } +// } else { +// fmt.Printf("\n❌ %s\n", result["message"]) +// } +// } else { +// // 批量模式 +// fmt.Printf("📁 扫描目录: %s\n", inputPath) +// imageFiles := FindImageFiles(inputPath, recursive) +// +// if len(imageFiles) == 0 { +// fmt.Println("未找到支持的图片文件") +// return +// } +// +// fmt.Printf("找到 %d 张图片\n", len(imageFiles)) +// +// // 检查输出目录，如果force为false则询问 +// if _, err := os.Stat(outputDir); err == nil && !force { +// files, _ := ioutil.ReadDir(outputDir) +// if len(files) > 0 { +// fmt.Printf("⚠️ 警告: 输出目录不为空 - %s\n", outputDir) +// fmt.Println("已设置force=true，直接继续处理") +// } +// } +// +// fmt.Printf("📂 输出目录: %s\n", outputDir) +// fmt.Printf("⚡ 并行处理: %d 个线程\n", jobs) +// fmt.Println(strings.Repeat("-", 60)) +// +// // 批量处理 +// stats := batchConverter.ProcessBatch(imageFiles, suffix, jobs) +// +// // 打印总结 +// PrintSummary(stats) +// +// // 显示失败详情 +// if stats["failed"].(int) > 0 && verbose { +// fmt.Println("\n❌ 失败详情:") +// for _, result := range stats["results"].([]map[string]interface{}) { +// if !result["success"].(bool) { +// fmt.Printf(" %s: %s\n", +// filepath.Base(result["input_path"].(string)), +// result["error"]) +// } +// } +// } +// } +//} diff --git a/kfzgw_so_linux b/kfzgw_so_linux index 25660e4..bb7da68 100644 Binary files a/kfzgw_so_linux and b/kfzgw_so_linux differ diff --git a/kfztp.go b/kfztp.go index b9fd946..b2a4fee 100644 --- a/kfztp.go +++ b/kfztp.go @@ -1,71 +1,80 @@ package main -import ( - "encoding/json" - "fmt" - "log" - "net/http" - "time" - - "github.com/parnurzeal/gorequest" -) - -// 获取商品模版 -func outGetGoodsTplMsgLinux(token, itemId, proxy string) (map[string]interface{}, error) { - if token == "" { - return nil, fmt.Errorf("请先登录获取Token") - } - - url := fmt.Sprintf("https://seller.kongfz.com/pc/itemInfo/getTplFields?itemId=%s&isClone=1&v=%d", - itemId, time.Now().Unix()) - - log.Printf("请求URL: %s", url) - - // 创建HTTP客户端 - request := gorequest.New() - - // 设置代理（如果有提供代理URL） - if proxy != "" { - request.Proxy(proxy) - log.Printf("使用代理: %s", proxy) - } - - resp, body, errs := request.Get(url). - Set("Cookie", fmt.Sprintf("PHPSESSID=%s", token)). - Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"). - Set("Accept", "application/json, text/plain, */*"). - Set("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8"). - Set("Referer", "https://seller.kongfz.com/"). - Set("Origin", "https://seller.kongfz.com"). - Timeout(30 * time.Second). - End() - - if len(errs) > 0 { - return nil, fmt.Errorf("请求失败: %v", errs) - } - - // 检查HTTP状态码 - if resp.StatusCode != http.StatusOK { - return nil, fmt.Errorf("HTTP错误: %d - %s", resp.StatusCode, resp.Status) - } - - var data map[string]interface{} - if err := json.Unmarshal([]byte(body), &data); err != nil { - return nil, fmt.Errorf("解析JSON失败: %w", err) - } - - // 检查API响应状态 - if val, ok := data["status"].(float64); ok && val == 1 { - return data, nil - } - - return nil, fmt.Errorf("API返回错误: %+v", data) -} - +//import ( +// "crypto/md5" +// "encoding/json" +// "fmt" +// "log" +// "math/rand" +// "net/http" +// "net/url" +// "regexp" +// "strconv" +// "strings" +// "sync" +// "time" +// +// "github.com/parnurzeal/gorequest" +//) +// +//// 获取商品模版 +//func outGetGoodsTplMsgLinux(token, itemId, proxy string) (map[string]interface{}, error) { +// if token == "" { +// return nil, fmt.Errorf("请先登录获取Token") +// } +// +// url := fmt.Sprintf("https://seller.kongfz.com/pc/itemInfo/getTplFields?itemId=%s&isClone=1&v=%d", +// itemId, time.Now().Unix()) +// +// log.Printf("请求URL: %s", url) +// +// // 创建HTTP客户端 +// request := gorequest.New() +// +// // 设置代理（如果有提供代理URL） +// if proxy != "" { +// request.Proxy(proxy) +// log.Printf("使用代理: %s", proxy) +// } +// +// resp, body, errs := request.Get(url). +// Set("Cookie", fmt.Sprintf("PHPSESSID=%s", token)). +// Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"). +// Set("Accept", "application/json, text/plain, */*"). +// Set("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8"). +// Set("Referer", "https://seller.kongfz.com/"). +// Set("Origin", "https://seller.kongfz.com"). +// Timeout(30 * time.Second). +// End() +// +// if len(errs) > 0 { +// return nil, fmt.Errorf("请求失败: %v", errs) +// } +// +// // 检查HTTP状态码 +// if resp.StatusCode != http.StatusOK { +// return nil, fmt.Errorf("HTTP错误: %d - %s", resp.StatusCode, resp.Status) +// } +// +// var data map[string]interface{} +// if err := json.Unmarshal([]byte(body), &data); err != nil { +// return nil, fmt.Errorf("解析JSON失败: %w", err) +// } +// +// // 检查API响应状态 +// if val, ok := data["status"].(float64); ok && val == 1 { +// return data, nil +// } +// +// return nil, fmt.Errorf("API返回错误: %+v", data) +//} +// //func main() { // fmt.Println("=== 孔夫子商品模板API服务 ===") // // http.HandleFunc("/api/goodsTemplate", getGoodsTemplateHandler) +// http.HandleFunc("/api/outGetImageByIsbn", getOutGetImageByIsbnHandler) +// // port := "8989" // server := &http.Server{ // Addr: ":" + port, @@ -76,60 +85,782 @@ func outGetGoodsTplMsgLinux(token, itemId, proxy string) (map[string]interface{} // fmt.Printf("服务器启动失败: %v\n", err) // } //} - -// 获取商品模板接口 -func getGoodsTemplateHandler(w http.ResponseWriter, r *http.Request) { - // 设置响应头 - w.Header().Set("Content-Type", "application/json") - - // 只处理GET请求 - if r.Method != http.MethodGet { - w.WriteHeader(http.StatusMethodNotAllowed) - json.NewEncoder(w).Encode(map[string]interface{}{ - "success": false, - "error": "只支持GET请求", - }) - return - } - - // 获取查询参数 - token := r.URL.Query().Get("token") - itemId := r.URL.Query().Get("itemId") - proxy := r.URL.Query().Get("proxy") - - // 验证必需参数 - if token == "" || itemId == "" { - w.WriteHeader(http.StatusBadRequest) - json.NewEncoder(w).Encode(map[string]interface{}{ - "success": false, - "error": "缺少必需参数: token 和 itemid", - "usage": map[string]string{ - "token": "登录Token (PHPSESSID)", - "itemid": "商品ID", - "proxy": "代理地址 (可选)", - }, - "example": "GET /api/goods-template?token=abc123&itemid=123456&proxy=http://proxy:8080", - }) - return - } - - log.Printf("收到请求 - 商品ID: %s", itemId) - - // 调用函数获取商品模板 - result, err := outGetGoodsTplMsgLinux(token, itemId, proxy) - if err != nil { - log.Printf("获取商品模板失败: %v", err) - w.WriteHeader(http.StatusInternalServerError) - json.NewEncoder(w).Encode(map[string]interface{}{ - "success": false, - "error": err.Error(), - }) - return - } - - // 返回成功响应 - json.NewEncoder(w).Encode(map[string]interface{}{ - "success": true, - "data": result, - }) -} +// +//// 获取商品模板接口 +//func getGoodsTemplateHandler(w http.ResponseWriter, r *http.Request) { +// // 设置响应头 +// w.Header().Set("Content-Type", "application/json") +// +// // 只处理GET请求 +// if r.Method != http.MethodGet { +// w.WriteHeader(http.StatusMethodNotAllowed) +// json.NewEncoder(w).Encode(map[string]interface{}{ +// "success": false, +// "error": "只支持GET请求", +// }) +// return +// } +// +// // 获取查询参数 +// token := r.URL.Query().Get("token") +// itemId := r.URL.Query().Get("itemId") +// proxy := r.URL.Query().Get("proxy") +// +// // 验证必需参数 +// if token == "" || itemId == "" { +// w.WriteHeader(http.StatusBadRequest) +// json.NewEncoder(w).Encode(map[string]interface{}{ +// "success": false, +// "error": "缺少必需参数: token 和 itemid", +// "usage": map[string]string{ +// "token": "登录Token (PHPSESSID)", +// "itemid": "商品ID", +// "proxy": "代理地址 (可选)", +// }, +// "example": "GET /api/goods-template?token=abc123&itemid=123456&proxy=http://proxy:8080", +// }) +// return +// } +// +// log.Printf("收到请求 - 商品ID: %s", itemId) +// +// // 调用函数获取商品模板 +// result, err := outGetGoodsTplMsgLinux(token, itemId, proxy) +// if err != nil { +// log.Printf("获取商品模板失败: %v", err) +// w.WriteHeader(http.StatusInternalServerError) +// json.NewEncoder(w).Encode(map[string]interface{}{ +// "success": false, +// "error": err.Error(), +// }) +// return +// } +// +// // 返回成功响应 +// json.NewEncoder(w).Encode(map[string]interface{}{ +// "success": true, +// "data": result, +// }) +//} +// +//func getOutGetImageByIsbnHandler(w http.ResponseWriter, r *http.Request) { +// // 设置响应头 +// w.Header().Set("Content-Type", "application/json") +// +// // 只处理GET请求 +// if r.Method != http.MethodGet { +// w.WriteHeader(http.StatusMethodNotAllowed) +// json.NewEncoder(w).Encode(map[string]interface{}{ +// "success": false, +// "error": "只支持GET请求", +// }) +// return +// } +// +// // 获取查询参数 +// token := r.URL.Query().Get("token") +// isbn := r.URL.Query().Get("isbn") +// proxyType := r.URL.Query().Get("proxyType") +// username := r.URL.Query().Get("username") +// password := r.URL.Query().Get("password") +// machineCode := r.URL.Query().Get("machineCode") +// //proxy := r.URL.Query().Get("proxy") +// +// // 验证必需参数 +// if token == "" || isbn == "" { +// w.WriteHeader(http.StatusBadRequest) +// json.NewEncoder(w).Encode(map[string]interface{}{ +// "success": false, +// "error": "缺少必需参数: token 和 isbn", +// "usage": map[string]string{ +// "token": "登录Token (PHPSESSID)", +// "isbn": "isbn", +// "proxy": "代理地址 (可选)", +// }, +// "example": "GET /api/goods-template?token=abc123&itemid=123456&proxy=http://proxy:8080", +// }) +// return +// } +// +// manager, err2 := proxyTypeManager(proxyType, username, password, machineCode) +// if err2 != nil { +// return +// } +// log.Printf("收到请求 - 商品ID: %s", isbn) +// +// // 调用函数获取商品模板 +// result, err := OutGetImageByIsbns(token, isbn, manager, 0, 0) +// if err != nil { +// log.Printf("获取商品模板失败: %v", err) +// w.WriteHeader(http.StatusInternalServerError) +// json.NewEncoder(w).Encode(map[string]interface{}{ +// "success": false, +// "error": err.Error(), +// }) +// return +// } +// // 返回成功响应 +// json.NewEncoder(w).Encode(map[string]interface{}{ +// "success": true, +// "data": result, +// }) +//} +// +//// 条目详情结构体 +//type BookInfo struct { +// BookName string `json:"book_name"` // 书名 +// Author string `json:"author"` // 作者 +// Publisher string `json:"publisher"` // 出版社 +// ISBN string `json:"isbn"` // ISBN +// PublicationTime int64 `json:"publication_time"` // 出版时间 +// Edition string `json:"edition"` // 版次 +// PrintTime string `json:"print_time"` // 印刷时间 +// FixPrice string `json:"fix_price"` // 定价 +// BindingLayout string `json:"binding_layout"` // 装帧 +// Format string `json:"format"` // 开本 +// Paper string `json:"paper"` // 纸张 +// Pages string `json:"pages"` // 页数 +// Wordage string `json:"wordage"` // 字数 +// Languages string `json:"languages"` // 语种 +// Era string `json:"era"` // 年代 +// EngravingMethod string `json:"engraving_method"` // 刻印方式 +// Dimensions string `json:"dimensions"` // 尺寸 +// VolumeNumber string `json:"volume_number"` // 册数 +// BookPic string `json:"book_pic"` // 图书封面图(官图) +// BookPicS string `json:"book_pic_s"` // 图书封面图(实拍图) +// SellingPrice string `json:"selling_price"` // 售价 +// Condition string `json:"condition"` // 品相 +// ExpressDeliveryFee string `json:"express_delivery_fee"` // 快递费 +// Editor string `json:"editor"` // 编辑 +// Category string `json:"category"` // 分类 +// BuyCount string `json:"buy_count"` // 买过 +// SellCount string `json:"sell_count"` // 在卖 +// Content string `json:"content"` // 内容 +// Mid int64 `json:"mid"` // 商家id +// ItemId int64 `json:"item_id"` // 商品id +// ShopId int64 `json:"shop_id"` // 店铺id +// DetailUrl string `json:"detail_url"` // 商品详情url +//} +// +//// 获取图片URL(官图和拍图) +//func OutGetImageByIsbns(token string, isbn string, proxy string, isLiveImage int, isReturnMsg int) (*BookInfo, error) { +// fmt.Println("[DEBUG] 使用的ISBN: ", isbn) +// // isLiveImage 1实拍图 0官图 ，isReturnMsg 0商品信息 +// bookInfo := &BookInfo{} +// //if isLiveImage == 0 { +// // 孔网官图请求 +// gtUrl := fmt.Sprintf("%s?keyword=%s", "https://search.kongfz.com/pc-gw/search-web/client/pc/bookLib/keyword/list", isbn) +// // 创建HTTP客户端 +// requestGt := gorequest.New() +// // 设置代理(如果有提供代理URL) +// if proxy != "" { +// requestGt.Proxy(proxy) +// } +// // 发送请求 +// respGt, bodyGt, errsGt := requestGt.Get(gtUrl). +// Set("Cookie", fmt.Sprintf("PHPSESSID=%s", token)). +// Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"). +// Set("Accept", "application/json, text/plain, */*"). +// Set("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8"). +// Set("Referer", "https://item.kongfz.com/"). +// Timeout(30 * time.Second). +// End() +// if len(errsGt) > 0 { +// // 检查是否是代理相关错误 +// var isProxyError bool +// var errorDetails []string +// for _, e := range errsGt { +// errorStr := e.Error() +// errorDetails = append(errorDetails, errorStr) +// if strings.Contains(errorStr, "Proxy Authentication Required") || +// strings.Contains(errorStr, "connectex: A connection attempt failed") || +// strings.Contains(errorStr, "connectex: No connection could be made") || +// strings.Contains(errorStr, "proxyconnect tcp") || +// strings.Contains(errorStr, "timeout") || +// strings.Contains(errorStr, "connection refused") { +// isProxyError = true +// } +// } +// log.Printf("[ERROR] 请求错误详情: %v", errorDetails) +// if isProxyError { +// // 处理代理失败 +// return nil, fmt.Errorf("代理连接失败") +// } +// return nil, fmt.Errorf("查询请求失败: %v", errsGt) +// } +// //检查HTTP状态码 +// if respGt.StatusCode != http.StatusOK { +// return nil, fmt.Errorf("HTTP错误: %s", respGt.Status) +// } +// // 解析响应 +// var apiGtResp struct { +// Status int `json:"status"` +// ErrType string `json:"errType"` +// Message string `json:"message"` +// SystemTime int64 `json:"systemTime"` +// Data struct { +// ItemResponse struct { +// Total int `json:"total"` +// List []struct { +// BookName string `json:"bookName"` +// Mid int64 `json:"mid"` +// ImgUrlEntity struct { +// BigImgUrl string `json:"bigImgUrl"` +// } `json:"imgUrlEntity"` +// Isbn string `json:"isbn"` +// BookShowInfo []string `json:"bookShowInfo"` +// } `json:"list"` +// } `json:"itemResponse"` +// } `json:"data"` +// } +// if err := json.Unmarshal([]byte(bodyGt), &apiGtResp); err != nil { +// return nil, fmt.Errorf("解析JSON失败: %w", err) +// } +// if apiGtResp.ErrType == "102" { +// return nil, fmt.Errorf("错误信息: %w，状态码: %s", apiGtResp.Message, apiGtResp.ErrType) +// } +// // 如果找到条目，返回图片URL +// if apiGtResp.Data.ItemResponse.Total > 0 && len(apiGtResp.Data.ItemResponse.List) > 0 { +// list := apiGtResp.Data.ItemResponse.List[0] +// bookShowInfo := list.BookShowInfo +// bookInfo.BookName = list.BookName +// bookInfo.BookPic = list.ImgUrlEntity.BigImgUrl +// bookInfo.ISBN = list.Isbn +// // 根据长度安全填充字段 +// if isReturnMsg == 0 { +// if len(bookShowInfo) > 0 { +// bookInfo.Author = bookShowInfo[0] +// } +// if len(bookShowInfo) > 1 { +// bookInfo.Publisher = bookShowInfo[1] +// } +// if len(bookShowInfo) > 2 { +// bookInfo.PublicationTime = validateDateFormat(bookShowInfo[2]) +// } +// if len(bookShowInfo) > 3 { +// bookInfo.BindingLayout = bookShowInfo[3] +// } +// if len(bookShowInfo) > 4 { +// bookInfo.FixPrice = bookShowInfo[4] +// } else { +// log.Printf("[WARN] BookShowInfo 长度不足 (仅 %d 项): %v", len(bookShowInfo), bookShowInfo) +// } +// } +// } +// //return bookInfo, nil +// +// //} +// //if isLiveImage == 1 { +// +// size := 10 +// // 实拍图 +// sptUrl := fmt.Sprintf("%s?dataType=0&keyword=%s&page=1&size=%d&sortType=7&actionPath=quality,sortType&quality=85~&quaSelect=2&userArea=13003000000", +// "https://search.kongfz.com/pc-gw/search-web/client/pc/product/keyword/list", isbn, size) +// //创建HTTP客户端 +// requestSpt := gorequest.New() +// //设置代理(如果有提供代理URL) +// if proxy != "" { +// requestSpt.Proxy(proxy) +// } +// // 发送请求 +// respSpt, bodySpt, errsSpt := requestSpt.Get(sptUrl). +// Proxy(proxy). +// Set("Cookie", token). +// Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"). +// Set("Accept", "application/json, text/plain, */*"). +// Set("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8"). +// Set("Referer", "https://item.kongfz.com/"). +// Timeout(30 * time.Second). +// End() +// // 错误处理 +// if len(errsSpt) > 0 { +// return nil, fmt.Errorf("请求失败: %v", errsSpt) +// } +// // 检查HTTP状态码 +// if respSpt.StatusCode != http.StatusOK { +// return nil, fmt.Errorf("HTTP错误: %s", respSpt.Status) +// } +// // 解析响应 +// var apiSptResp struct { +// Status int `json:"status"` +// ErrType string `json:"errType"` +// Message string `json:"message"` +// SystemTime int64 `json:"systemTime"` +// Data struct { +// ItemResponse struct { +// Total int `json:"total"` +// List []struct { +// ItemId int64 `json:"itemId"` +// Title string `json:"title"` +// ImgUrl string `json:"imgUrl"` +// ImgBigUrl string `json:"imgBigUrl"` +// Author string `json:"author"` +// PubDateText string `json:"pubDateText"` +// Isbn string `json:"isbn"` +// Press string `json:"press"` +// ShopId int64 `json:"shopId"` +// TplRecords []struct { +// Key string `json:"key"` +// Value string `json:"value"` +// } `json:"tplRecords"` +// } `json:"list"` +// } `json:"itemResponse"` +// } `json:"data"` +// } +// // 解析JSON +// if err := json.Unmarshal([]byte(bodySpt), &apiSptResp); err != nil { +// return nil, fmt.Errorf("解析JSON失败: %w", err) +// } +// if apiSptResp.ErrType == "102" { +// return nil, fmt.Errorf("错误信息: %w，状态码: %s", apiSptResp.Message, apiSptResp.ErrType) +// } +// if apiSptResp.Data.ItemResponse.Total > 0 && len(apiSptResp.Data.ItemResponse.List) > 0 { +// // 确定其实索引 +// var startIndex int +// if size >= apiSptResp.Data.ItemResponse.Total { +// startIndex = apiSptResp.Data.ItemResponse.Total - 1 +// } else { +// startIndex = size - 1 +// } +// for attempt := 0; attempt < 3; attempt++ { +// currentIndex := startIndex - attempt +// // 检查索引是否有效 +// if currentIndex < 0 || currentIndex >= len(apiSptResp.Data.ItemResponse.List) { +// log.Printf("[DEBUG] 索引 %d 超出范围，跳过", currentIndex) +// continue +// } +// randomNum := rand.Intn(currentIndex + 1) +// item := apiSptResp.Data.ItemResponse.List[randomNum] +// // 检查图片URL是否存在 +// if item.ImgBigUrl == "" { +// log.Printf("[DEBUG] 索引 %d 的图片URL为空，跳过", randomNum) +// continue +// } +// // 响应信息 +// bookInfo.BookPicS = item.ImgUrl +// bookInfo.ISBN = item.Isbn +// if bookInfo.BookName == "" { +// bookInfo.BookName = item.Title +// if isReturnMsg == 0 { +// // 安全地获取TplRecords中的值 +// if len(item.TplRecords) > 0 { +// bookInfo.Author = item.TplRecords[0].Value +// } +// if len(item.TplRecords) > 1 { +// bookInfo.Publisher = item.TplRecords[1].Value +// } +// if len(item.TplRecords) > 2 { +// bookInfo.PublicationTime = validateDateFormat(item.TplRecords[2].Value) +// } +// if len(item.TplRecords) > 3 { +// bookInfo.BindingLayout = item.TplRecords[3].Value +// } +// } +// } +// return bookInfo, nil +// } +// //} +// } +// return nil, fmt.Errorf("查询失败，没有数据！") +//} +// +//// 验证日期格式 +//func validateDateFormat(dateStr string) int64 { +// // 去除前后空格 +// dateStr = strings.TrimSpace(dateStr) +// +// // 替换各种分隔符为统一的分隔符"-" +// dateStr = regexp.MustCompile(`[/_\\.,\s]+`).ReplaceAllString(dateStr, "-") +// +// // 处理纯年份格式 (4位数字) +// if regexp.MustCompile(`^\d{4}$`).MatchString(dateStr) { +// dateStr += "-01-01" +// } +// +// // 处理年月格式 (4位数字-1或2位数字) +// if matches := regexp.MustCompile(`^(\d{4})-(\d{1,2})$`).FindStringSubmatch(dateStr); len(matches) == 3 { +// year := matches[1] +// month := matches[2] +// if len(month) == 1 { +// month = "0" + month +// } +// if monthNum, _ := strconv.Atoi(month); monthNum >= 1 && monthNum <= 12 { +// dateStr = year + "-" + month + "-01" +// } else { +// return 0 +// } +// } +// +// // 处理年月日格式 (4位数字-1或2位数字-1或2位数字) +// if matches := regexp.MustCompile(`^(\d{4})-(\d{1,2})-(\d{1,2})`).FindStringSubmatch(dateStr); len(matches) >= 4 { +// year := matches[1] +// month := matches[2] +// day := matches[3] +// +// // 标准化月份和日期为两位数 +// if len(month) == 1 { +// month = "0" + month +// } +// if len(day) == 1 { +// day = "0" + day +// } +// +// dateStr = year + "-" + month + "-" + day +// } +// +// // 加载上海时区 +// loc, err := time.LoadLocation("Asia/Shanghai") +// if err != nil { +// // 如果加载时区失败，使用UTC+8作为后备方案 +// loc = time.FixedZone("CST", 8*60*60) +// } +// +// // 尝试解析为标准日期格式，并指定上海时区 +// parsedTime, err := time.ParseInLocation("2006-01-02", dateStr, loc) +// if err != nil { +// return 0 +// } +// +// // 返回秒级时间戳（UTC时间，但解析时已经考虑了时区偏移） +// return parsedTime.Unix() +//} +// +//// 代理类型常量 +//const ( +// CalfElephantProxyType = "CALF_ELEPHANT_PROXY" +// TailProxyType = "TAIL_PROXY" +//) +// +//// 代理服务器列表 +//var ( +// servers = []string{ +// "http-dynamic.xiaoxiangdaili.com", +// "http-dynamic-S02.xiaoxiangdaili.com", +// "http-dynamic-S03.xiaoxiangdaili.com", +// "http-dynamic-S04.xiaoxiangdaili.com", +// } +// randMutex sync.Mutex +// globalRand *rand.Rand +// +// // 代理健康状态管理 +// proxyHealthMaps = make(map[string]*ProxyHealth) +// proxyHealthMutex sync.RWMutex +//) +// +//// ProxyManager 代理管理器结构体 +//type ProxyManager struct { +// servers []string `json:"servers"` // 代理服务器列表 +// username string `json:"username"` // 代理账号 +// password string `json:"password"` // 代理密码 +// tailCardSecret string `json:"tail_card_secret"` // 尾巴代理卡密 +// proxyType string `json:"proxy_type"` // 代理类型 CALF_ELEPHANT_PROXY/TAIL_PROXY +//} +// +//// 代理健康状态 +//type ProxyHealth struct { +// SuccessCount int // 成功次数 +// FailCount int // 失败次数 +// LastCheck time.Time // 最后检查时间 +// ResponseTime time.Duration // 响应时间 +// IsHealthy bool // 是否健康 +//} +// +//func init() { +// // 创建全局的随机数生成器 +// globalRand = rand.New(rand.NewSource(time.Now().UnixNano())) +//} +// +//// 获取代理URL +//func proxyTypeManager(proxyType, username, password, machineCode string) (string, error) { +// switch proxyType { +// case CalfElephantProxyType: +// return buildCalfElephantProxyURL(username, password) +// case TailProxyType: +// return buildTailProxyURL(machineCode) +// default: +// return "", fmt.Errorf("不支持的代理类型: %s", proxyType) +// } +//} +// +//// 构建小象代理URL +//func buildCalfElephantProxyURL(username, password string) (string, error) { +// server := randomServer() +// proxyURL := fmt.Sprintf("http://%s:%s@%s:%d", +// url.QueryEscape(username), +// url.QueryEscape(password), +// server, +// 10030) +// +// // 检测代理可用性 +// if err := checkProxyHealth(proxyURL); err != nil { +// log.Printf("[WARN] 代理 %s 检测失败: %v", server, err) +// // 尝试下一个代理服务器 +// return tryNextCalfElephantProxy(username, password, server) +// } +// +// log.Printf("[INFO] 使用小象代理: %s", server) +// return proxyURL, nil +//} +// +//// 尝试下一个小象代理服务器 +//func tryNextCalfElephantProxy(username, password, failedServer string) (string, error) { +// // 创建服务器副本并排除失败的服务器 +// availableServers := make([]string, 0) +// for _, server := range servers { +// if server != failedServer { +// availableServers = append(availableServers, server) +// } +// } +// +// if len(availableServers) == 0 { +// return "", fmt.Errorf("所有小象代理服务器都不可用") +// } +// +// // 随机尝试可用服务器 +// for _, server := range shuffleServers(availableServers) { +// proxyURL := fmt.Sprintf("http://%s:%s@%s:%d", +// url.QueryEscape(username), +// url.QueryEscape(password), +// server, +// 10030) +// +// if err := checkProxyHealth(proxyURL); err == nil { +// log.Printf("[INFO] 切换到可用代理: %s", server) +// return proxyURL, nil +// } +// log.Printf("[WARN] 代理 %s 检测失败", server) +// } +// +// return "", fmt.Errorf("所有可用的小象代理服务器都检测失败") +//} +// +//// 构建内置代理URL +//func buildTailProxyURL(machineCode string) (string, error) { +// proxies, err := getProxies(machineCode) +// if err != nil { +// return "", err +// } +// if len(proxies) == 0 { +// return "", fmt.Errorf("未获取到有效代理") +// } +// +// // 过滤并选择健康的代理 +// healthyProxies := filterHealthyProxies(proxies) +// if len(healthyProxies) > 0 { +// proxyURL := "http://" + randomElement(healthyProxies) +// log.Printf("[INFO] 使用健康尾巴代理: %s", proxyURL) +// return proxyURL, nil +// } +// +// // 如果没有健康代理，检测所有代理 +// log.Printf("[INFO] 未找到健康代理，开始检测代理可用性...") +// return findWorkingTailProxy(proxies) +//} +// +//// 获取代理服务器列表 +//func getProxies(machineCode string) ([]string, error) { +// log.Printf("[INFO] 开始获取代理列表: %s", machineCode) +// // 生成签名 +// sign := fmt.Sprintf("%x", md5.Sum([]byte(fmt.Sprintf("9999%s9999", machineCode)))) +// +// GetProxiesUrl := fmt.Sprintf("http://114.66.2.223:7842/api/proxies/get_proxy?machine_code=%s&sign=%s&agent_id=9999", +// machineCode, sign) +// +// req := gorequest.New().Get(GetProxiesUrl).Timeout(20 * time.Second) +// _, body, errs := req.End() +// if len(errs) > 0 { +// return nil, fmt.Errorf("获取代理失败: %v", errs) +// } +// +// // 检查是否为JSON错误响应 +// if strings.HasPrefix(strings.TrimSpace(body), "{") && strings.HasSuffix(strings.TrimSpace(body), "}") { +// // 尝试解析为JSON错误响应 +// var errorResp struct { +// Code int `json:"code"` +// Message string `json:"message"` +// } +// if err := json.Unmarshal([]byte(body), &errorResp); err == nil { +// return nil, fmt.Errorf("获取代理失败: %s (错误码: %d)", errorResp.Message, errorResp.Code) +// } +// } +// +// // 解析响应 +// lines := strings.Split(strings.TrimSpace(body), "\n") +// var proxies []string +// for _, line := range lines { +// line = strings.TrimSpace(line) +// if line != "" && !strings.HasPrefix(line, "{") { +// proxies = append(proxies, line) +// } +// } +// if len(proxies) == 0 { +// return nil, fmt.Errorf("未获取到有效代理") +// } +// +// log.Printf("[INFO] 获取到 %d 个代理", len(proxies)) +// return proxies, nil +//} +// +//// 过滤健康代理 +//func filterHealthyProxies(proxies []string) []string { +// proxyHealthMutex.RLock() +// defer proxyHealthMutex.RUnlock() +// +// var healthy []string +// for _, proxy := range proxies { +// if health, exists := proxyHealthMaps[proxy]; exists && health.IsHealthy { +// // 检查是否在最近检查过（5分钟内） +// if time.Since(health.LastCheck) < 5*time.Minute { +// healthy = append(healthy, proxy) +// } +// } +// } +// return healthy +//} +// +//// 查找可用的尾巴代理 +//func findWorkingTailProxy(proxies []string) (string, error) { +// // 打乱代理顺序 +// shuffledProxies := shuffleServers(proxies) +// +// // 并发检测代理 +// type proxyResult struct { +// proxy string +// err error +// } +// +// ch := make(chan proxyResult, len(shuffledProxies)) +// var wg sync.WaitGroup +// +// // 限制并发数 +// sem := make(chan struct{}, 5) +// +// for _, proxy := range shuffledProxies { +// wg.Add(1) +// go func(p string) { +// defer wg.Done() +// sem <- struct{}{} +// defer func() { <-sem }() +// +// proxyURL := "http://" + p +// err := checkProxyHealth(proxyURL) +// ch <- proxyResult{proxy: p, err: err} +// }(proxy) +// } +// +// wg.Wait() +// close(ch) +// +// // 收集结果 +// var workingProxies []string +// for result := range ch { +// if result.err == nil { +// workingProxies = append(workingProxies, result.proxy) +// // 更新健康状态 +// updateProxyHealth(result.proxy, true, 0) +// } else { +// updateProxyHealth(result.proxy, false, 0) +// } +// } +// +// if len(workingProxies) > 0 { +// selected := randomElement(workingProxies) +// log.Printf("[INFO] 找到可用代理: %s (共 %d 个可用)", selected, len(workingProxies)) +// return "http://" + selected, nil +// } +// +// return "", fmt.Errorf("所有尾巴代理都不可用") +//} +// +//// 检测代理健康状态 +//func checkProxyHealth(proxyURL string) error { +// start := time.Now() +// +// req := gorequest.New().Proxy(proxyURL).Timeout(10 * time.Second) +// resp, _, errs := req.Get("https://shop.kongfz.com/").End() +// +// responseTime := time.Since(start) +// +// if len(errs) > 0 { +// updateProxyHealth(proxyURL, false, responseTime) +// return fmt.Errorf("代理连接失败: %v", errs) +// } +// +// if resp.StatusCode != 200 { +// updateProxyHealth(proxyURL, false, responseTime) +// return fmt.Errorf("代理响应状态码错误: %d", resp.StatusCode) +// } +// +// updateProxyHealth(proxyURL, true, responseTime) +// log.Printf("[DEBUG] 代理 %s 检测成功, 响应时间: %v", getProxyHost(proxyURL), responseTime) +// return nil +//} +// +//// 更新代理健康状态 +//func updateProxyHealth(proxyURL string, success bool, responseTime time.Duration) { +// proxyHealthMutex.Lock() +// defer proxyHealthMutex.Unlock() +// +// host := getProxyHost(proxyURL) +// if _, exists := proxyHealthMaps[host]; !exists { +// proxyHealthMaps[host] = &ProxyHealth{} +// } +// +// health := proxyHealthMaps[host] +// health.LastCheck = time.Now() +// +// if success { +// health.SuccessCount++ +// health.FailCount = 0 +// health.ResponseTime = responseTime +// health.IsHealthy = true +// } else { +// health.FailCount++ +// health.SuccessCount = 0 +// // 连续失败3次标记为不健康 +// if health.FailCount >= 3 { +// health.IsHealthy = false +// } +// } +//} +// +//// 获取代理主机名 +//func getProxyHost(proxyURL string) string { +// if strings.HasPrefix(proxyURL, "http://") { +// proxyURL = proxyURL[7:] +// } +// // 去除认证信息 +// if atIndex := strings.Index(proxyURL, "@"); atIndex != -1 { +// proxyURL = proxyURL[atIndex+1:] +// } +// // 去除端口 +// if colonIndex := strings.Index(proxyURL, ":"); colonIndex != -1 { +// proxyURL = proxyURL[:colonIndex] +// } +// return proxyURL +//} +// +//// 随机代理服务器 +//func randomServer() string { +// return randomElement(servers) +//} +// +//// 线程安全的随机元素选择 +//func randomElement(slice []string) string { +// randMutex.Lock() +// defer randMutex.Unlock() +// return slice[globalRand.Intn(len(slice))] +//} +// +//// 打乱服务器顺序 +//func shuffleServers(servers []string) []string { +// randMutex.Lock() +// defer randMutex.Unlock() +// +// shuffled := make([]string, len(servers)) +// copy(shuffled, servers) +// globalRand.Shuffle(len(shuffled), func(i, j int) { +// shuffled[i], shuffled[j] = shuffled[j], shuffled[i] +// }) +// return shuffled +//} diff --git a/kongfz/dll/kongfz.dll b/kongfz/dll/kongfz.dll new file mode 100644 index 0000000..028fdc3 Binary files /dev/null and b/kongfz/dll/kongfz.dll differ diff --git a/kongfz/dll/kongfz.h b/kongfz/dll/kongfz.h new file mode 100644 index 0000000..263dd86 --- /dev/null +++ b/kongfz/dll/kongfz.h @@ -0,0 +1,145 @@ +/* Code generated by cmd/cgo; DO NOT EDIT. */ + +/* package command-line-arguments */ + + +#line 1 "cgo-builtin-export-prolog" + +#include + +#ifndef GO_CGO_EXPORT_PROLOGUE_H +#define GO_CGO_EXPORT_PROLOGUE_H + +#ifndef GO_CGO_GOSTRING_TYPEDEF +typedef struct { const char *p; ptrdiff_t n; } _GoString_; +extern size_t _GoStringLen(_GoString_ s); +extern const char *_GoStringPtr(_GoString_ s); +#endif + +#endif + +/* Start of preamble from import "C" comments. */ + + +#line 3 "kongfz.go" + +#include + +#line 1 "cgo-generated-wrapper" + + +/* End of preamble from import "C" comments. */ + + +/* Start of boilerplate cgo prologue. */ +#line 1 "cgo-gcc-export-header-prolog" + +#ifndef GO_CGO_PROLOGUE_H +#define GO_CGO_PROLOGUE_H + +typedef signed char GoInt8; +typedef unsigned char GoUint8; +typedef short GoInt16; +typedef unsigned short GoUint16; +typedef int GoInt32; +typedef unsigned int GoUint32; +typedef long long GoInt64; +typedef unsigned long long GoUint64; +typedef GoInt64 GoInt; +typedef GoUint64 GoUint; +typedef size_t GoUintptr; +typedef float GoFloat32; +typedef double GoFloat64; +#ifdef _MSC_VER +#if !defined(__cplusplus) || _MSVC_LANG <= 201402L +#include +typedef _Fcomplex GoComplex64; +typedef _Dcomplex GoComplex128; +#else +#include +typedef std::complex GoComplex64; +typedef std::complex GoComplex128; +#endif +#else +typedef float _Complex GoComplex64; +typedef double _Complex GoComplex128; +#endif + +/* + static assertion to make sure the file is being used on architecture + at least with matching size of GoInt. +*/ +typedef char _check_for_64_bit_pointer_matching_GoInt[sizeof(void*)==64/8 ? 1:-1]; + +#ifndef GO_CGO_GOSTRING_TYPEDEF +typedef _GoString_ GoString; +#endif +typedef void *GoMap; +typedef void *GoChan; +typedef struct { void *t; void *v; } GoInterface; +typedef struct { void *data; GoInt len; GoInt cap; } GoSlice; + +#endif + +/* End of boilerplate cgo prologue. */ + +#ifdef __cplusplus +extern "C" { +#endif + + +// 孔网登录 +// +extern __declspec(dllexport) char* OutLogin(char* username, char* password); + +// 获取孔网用户信息 +// +extern __declspec(dllexport) char* OutGetUserMsg(char* token); + +// 获取商品模版--已登的店铺 +// +extern __declspec(dllexport) char* OutGetGoodsTplMsg(char* token, char* proxy, char* itemId); + +// 获取商品列表-已登的店铺 +// +extern __declspec(dllexport) char* OutGetGoodsListMsgFromSelfShop(char* token, char* proxy, char* itemSn, char* priceMin, char* priceMax, char* startCreateTime, char* endCreateTime, char* requestType, int isItemSnEqual, int page, int size); + +// 新增商品-已登的店铺(带有Out的都非官方标准接口) +// +extern __declspec(dllexport) char* OutAddGoods(char* token, char* proxy, char* formData); + +// 删除商品-已登的店铺 +// +extern __declspec(dllexport) char* OutDelGoodsFromSelfShop(char* token, char* proxy, char* itemId); + +// 获取孔网商品图片和信息(官图和拍图)-带有店铺过滤 +// +extern __declspec(dllexport) char* OutGetImageFilterShopId(char* token, char* proxy, char* isbn, int shopId, int isLiveImage, int isReturnMsg); + +// 获取孔网商品图片和信息(官图和拍图) +// +extern __declspec(dllexport) char* OutGetImageByIsbn(char* token, char* isbn, char* proxy, int isLiveImage, int isReturnMsg); + +// 获取商品列表通过店铺ID +// +extern __declspec(dllexport) char* OutGetGoodsListMsgByShopId(int shopId, char* proxy, int retPrice, int isImage, char* sortType, char* sort, float priceMin, float priceMax, int pageNum, int returnNum); + +// 获取商品信息通过商品详情链接 +// +extern __declspec(dllexport) char* OutGetGoodsMsgByDetailUrl(char* detailUrl, char* proxy); + +// 获取销量榜商品列表 +// +extern __declspec(dllexport) char* OutGetTopGoodsListMsg(int catId, char* proxy); + +// 初始化配置 +// +extern __declspec(dllexport) char* Initialize(char* configJSON); + +// 释放C字符串内存 +// +extern __declspec(dllexport) void FreeCString(char* str); + +#ifdef __cplusplus +} +#endif diff --git a/kongfz/kongfz.go b/kongfz/kongfz.go new file mode 100644 index 0000000..2e5bcfe --- /dev/null +++ b/kongfz/kongfz.go @@ -0,0 +1,2089 @@ +package main + +/* +#include +*/ +import "C" +import ( + "encoding/json" + "fmt" + "io" + "log" + "math/rand" + "net/http" + "net/url" + "regexp" + "strconv" + "strings" + "time" + "unsafe" + + "github.com/PuerkitoBio/goquery" + _ "github.com/go-sql-driver/mysql" + "github.com/parnurzeal/gorequest" +) + +type Config struct { + App struct { + MaxRetryTimes int `ini:"app.max_retry_times" json:"max_retry_times" default:"3"` + RateLimitDelay time.Duration `ini:"app.rate_limit_delay" json:"rate_limit_delay" default:"500ms"` + Size int `ini:"app.size" json:"size" default:"5"` + DefaultUserAgent string `ini:"app.default_user_agent" json:"default_user_agent" default:"Mozilla/5.0"` + } `ini:"app" json:"app"` + + API struct { + LoginURL string `ini:"api.login_url" json:"login_url" default:"https://login.kongfz.com/Pc/Login/account"` + BookSearchURL string `ini:"api.book_search_url" json:"book_search_url" default:"https://search.kongfz.com/pc-gw/search-web/client/pc/bookLib/keyword/list"` + ProductSearchURL string `ini:"api.product_search_url" json:"product_search_url" default:"https://search.kongfz.com/pc-gw/search-web/client/pc/product/keyword/list"` + } `ini:"api" json:"api"` + + Proxy struct { + Servers string `ini:"proxy.servers" json:"servers" default:"http-dynamic.xiaoxiangdaili.com,http-dynamic-S02.xiaoxiangdaili.com,http-dynamic-S03.xiaoxiangdaili.com,http-dynamic-S04.xiaoxiangdaili.com"` + Username string `ini:"proxy.username" json:"username" default:"1297757178467602432"` + Password string `ini:"proxy.password" json:"password" default:"QgQBvP7f"` + TailMachineCode string `ini:"proxy.tail_machine_code" json:"tail_machine_code" default:"b7bf22a237ec692f13fcc2c43ee63252"` + TailCardKey string `ini:"proxy.tail_card_key" json:"tail_card_key" default:"DL_20_YK_1920acb2129844c2aabade3896560a9b"` + ProxyFilePath string `ini:"proxy.proxy_file_path" json:"proxy_file_path" default:"dll/proxyConfig.dll"` + } `ini:"proxy" json:"proxy"` +} + +// BookInfo 图书详情结构体 +type BookInfo struct { + BookName string `json:"book_name"` // 书名 + Author string `json:"author"` // 作者 + Publisher string `json:"publisher"` // 出版社 + ISBN string `json:"isbn"` // ISBN + PublicationTime int64 `json:"publication_time"` // 出版时间 + Edition string `json:"edition"` // 版次 + PrintTime string `json:"print_time"` // 印刷时间 + FixPrice string `json:"fix_price"` // 定价 + BindingLayout string `json:"binding_layout"` // 装帧 + Format string `json:"format"` // 开本 + Paper string `json:"paper"` // 纸张 + Pages string `json:"pages"` // 页数 + Wordage string `json:"wordage"` // 字数 + Languages string `json:"languages"` // 语种 + Era string `json:"era"` // 年代 + EngravingMethod string `json:"engraving_method"` // 刻印方式 + Dimensions string `json:"dimensions"` // 尺寸 + VolumeNumber string `json:"volume_number"` // 册数 + BookPic string `json:"book_pic"` // 图书封面图(官图) + BookPicS string `json:"book_pic_s"` // 图书封面图(实拍图) + SellingPrice string `json:"selling_price"` // 售价 + Condition string `json:"condition"` // 品相 + ExpressDeliveryFee string `json:"express_delivery_fee"` // 快递费 + Editor string `json:"editor"` // 编辑 + Category string `json:"category"` // 分类 + BuyCount string `json:"buy_count"` // 买过 + SellCount string `json:"sell_count"` // 在卖 + Content string `json:"content"` // 内容 + Mid int64 `json:"mid"` // 商家id + ItemId int64 `json:"item_id"` // 商品id + ShopId int64 `json:"shop_id"` // 店铺id + DetailUrl string `json:"detail_url"` // 商品详情url +} + +// APIResponse 响应结构体 +type APIResponse struct { + Success bool `json:"success"` + Message string `json:"message,omitempty"` + Data interface{} `json:"data,omitempty"` +} + +// 孔网用户信息响应结构体 +type UserInfo struct { + UserID int64 `json:"userId"` + Nickname string `json:"nickname"` + Mobile string `json:"mobile"` +} + +// 全局变量 +var ( + cf Config // 配置信息 +) + +// ProductInfo 商品信息结构 +type ProductInfo struct { + ItemID string `json:"itemId"` + BookName string `json:"bookName"` + Price string `json:"price"` + ShippingFee string `json:"shippingFee"` +} + +// 图书详情响应结构体 +type BookDetailResponse struct { + Status bool `json:"status"` + Result BookList `json:"result"` + ErrMessage string `json:"errMessage"` + ErrCode int `json:"errCode"` +} + +// 图书列表结构体 +type BookList struct { + Current int `json:"current"` + Data []BookInformation `json:"data"` + Total int `json:"total"` +} + +// 图书信息结构体 +type BookInformation struct { + Author string `json:"author"` + BookName string `json:"bookName"` + ContentIntroduction string `json:"contentIntroduction"` + ImgUrl string `json:"imgUrl"` + Isbn string `json:"isbn"` + ItemUrls ItemUrls `json:"itemUrls"` + Mid int `json:"mid"` + NewMinPrice string `json:"newMinPrice"` + OldMinPrice string `json:"oldMinPrice"` + Press string `json:"press"` + Price string `json:"price"` + PubDate string `json:"pubDate"` + RiseTag string `json:"riseTag"` + AuthorArr []AuthorInfo `json:"authorArr"` + PressUrl string `json:"pressUrl"` +} + +// 作者信息结构体 +type AuthorInfo struct { + Name string `json:"name"` + OriName string `json:"oriName"` + Nationality string `json:"nationality"` + Role string `json:"role"` + Url string `json:"url"` +} + +// 商品链接结构体 +type ItemUrls struct { + AppUrl string `json:"appUrl"` + MUrl string `json:"mUrl"` + MiniUrl string `json:"miniUrl"` + PcUrl string `json:"pcUrl"` +} + +// 店铺快递费参数 +type ParamsInfo struct { + Params []Param `json:"params"` + Area string `json:"area"` +} + +type Param struct { + UserId string `json:"userId"` + ItemId string `json:"itemId"` +} + +// 定义快递费用的响应结构体 +type DataItem struct { + Fee []FeeInfo `json:"fee"` + IsSeller bool `json:"isSeller"` + ItemID string `json:"itemId"` + UserID string `json:"userId"` +} + +type FeeInfo struct { + ShippingID string `json:"shippingId"` + ShippingName string `json:"shippingName"` + TotalFee string `json:"totalFee"` + ShippingText string `json:"shippingText"` + FilterTotalFee string `json:"filterTotalFee"` +} + +type ResponseStruct struct { + Status bool `json:"status"` + Data []DataItem `json:"data"` + Message string `json:"message"` + ErrType string `json:"errType"` +} + +// 获取店铺里商品的快递费(定位到河南) +func getGoodsListShippingFee(params ParamsInfo, proxy string) ([]DataItem, error) { + if params.Params == nil { + return nil, fmt.Errorf("没有商品信息！") + } + paramsJSON, err := json.Marshal(params) + if err != nil { + return nil, fmt.Errorf("参数序列化失败: %v", err) + } + // URL 编码参数 + encodedParams := url.QueryEscape(string(paramsJSON)) + url := fmt.Sprintf("https://shop.kongfz.com/book/shopsearch/getShippingFee?params=%s", encodedParams) + request := gorequest.New() + if proxy != "" { + request.Proxy(proxy) + } + // 发送请求 + resp, body, errs := request.Get(url). + Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"). + Set("Accept", "application/json, text/plain, */*"). + Set("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8"). + End() + // 错误处理 + if len(errs) > 0 { + return nil, fmt.Errorf("请求失败: %v", errs) + } + // 检查HTTP状态码 + if resp.StatusCode != http.StatusOK { + return nil, fmt.Errorf("HTTP错误: %s", resp.Status) + } + responseStruct := ResponseStruct{} + err = json.Unmarshal([]byte(body), &responseStruct) + if err != nil { + return nil, fmt.Errorf("解析JSON失败: %v", err) + } + var dataItem []DataItem + for i := range responseStruct.Data { + dataItem = append(dataItem, responseStruct.Data[i]) + } + return dataItem, nil +} + +// 孔网登录 +func outLogin(username, password string) (string, error) { + // 判断用户名和密码是否为空 + if username == "" || password == "" { + return "", fmt.Errorf("请输入用户名和密码!") + } + + // Post请求参数 + formData := map[string]string{ + "loginName": username, + "loginPass": password, + "returnUrl": "http://user.kongfz.com/", + } + // 孔网登录URL + loginUrl := "https://login.kongfz.com/Pc/Login/account" + + //发送请求 + resp, body, errs := gorequest.New(). + Post(loginUrl). + Set("Content-Type", "application/x-www-form-urlencoded"). + Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"). + Set("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8"). + Send(formData). + Timeout(15 * time.Second). + End() + + if len(errs) > 0 { + return "", fmt.Errorf("登录请求失败: %v", errs) + } + // 检查HTTP状态码 + if resp.StatusCode != http.StatusOK { + return "", fmt.Errorf("登录失败(HTTP状态码: %d)", resp.StatusCode) + } + + // 提取Cookie + cookie := resp.Header.Get("Set-Cookie") + if strings.Contains(body, "window.location.href='https://login.kongfz.cn/Pc/Session/rsync") { + if cookie == "" { + return "", fmt.Errorf("登录成功但未获取到Cookie") + } + + // 登录成功 + if strings.Contains(cookie, "PHPSESSID=") { + token := strings.Split(strings.Split(cookie, "PHPSESSID=")[1], ";")[0] + return token, nil + } + + return "", fmt.Errorf("登录失败: 未找到PHPSESSID") + } + + // 错误信息 + var res struct { + Status bool `json:"status"` + ErrCode int `json:"errCode"` + ErrInfo string `json:"errInfo"` + } + // 解析json + if err := json.Unmarshal([]byte(body), &res); err == nil { + if res.ErrCode == 1001 || res.ErrCode == 1005 { + return "", fmt.Errorf("账号或密码错误！") + } + + if res.ErrInfo != "" { + return "", fmt.Errorf("登录失败: %s", res.ErrInfo) + } + } + + return "", fmt.Errorf("登录失败，未知错误！") +} + +// 获取孔网用户信息 +func outGetUserMsg(token string) (*UserInfo, error) { + // 用户信息URL + url := "https://user.kongfz.com/User/Index/getUserInfo/" + + // 发送请求 + resp, body, errs := gorequest.New(). + Get(url). + Set("Cookie", fmt.Sprintf("PHPSESSID=%s", token)). + Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"). + Set("Accept", "application/json, text/plain, */*"). + Set("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8"). + Timeout(15 * time.Second). + End() + if len(errs) > 0 { + return nil, fmt.Errorf("查询请求失败: %v", errs) + } + + //检查HTTP状态码 + if resp.StatusCode != http.StatusOK { + return nil, fmt.Errorf("HTTP错误: %s", resp.Status) + } + + // 响应数据 + var userInfo struct { + Status bool `json:"status"` + Data struct { + UserID int64 `json:"userId"` + Nickname string `json:"nickname"` + Mobile string `json:"mobile"` + } + } + // 解析json + if err := json.Unmarshal([]byte(body), &userInfo); err != nil { + return nil, fmt.Errorf("解析JSON失败: %w", err) + } + + user := &UserInfo{} + if !userInfo.Status { + return nil, fmt.Errorf("获取用户失败！") + } + user.UserID = userInfo.Data.UserID + user.Nickname = userInfo.Data.Nickname + user.Mobile = userInfo.Data.Mobile + return user, nil +} + +// 获取商品模版-已登的店铺 +func outGetGoodsTplMsg(token, proxy, itemId string) (map[string]interface{}, error) { + // 判断登录token + if token == "" { + return nil, fmt.Errorf("请先登录获取Token") + } + // 商品模板URL + url := fmt.Sprintf("https://seller.kongfz.com/pc/itemInfo/getTplFields?itemId=%s&isClone=1&v=%d", + itemId, time.Now().Unix()) + + // 创建请求 + request := gorequest.New() + + // 设置代理（如果有提供代理URL） + if proxy != "" { + request.Proxy(proxy) + } + resp, body, errs := request.Get(url). + Set("Cookie", fmt.Sprintf("PHPSESSID=%s", token)). + Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"). + Set("Accept", "application/json, text/plain, */*"). + Set("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8"). + Set("Referer", "https://seller.kongfz.com/"). + Set("Origin", "https://seller.kongfz.com"). + Timeout(15 * time.Second). + End() + if errs != nil { + // 检查是否是代理相关错误 + var isProxyError bool + var errorDetails []string + for _, e := range errs { + errorStr := e.Error() + errorDetails = append(errorDetails, errorStr) + if strings.Contains(errorStr, "Proxy Authentication Required") || + strings.Contains(errorStr, "connectex: A connection attempt failed") || + strings.Contains(errorStr, "connectex: No connection could be made") || + strings.Contains(errorStr, "proxyconnect tcp") || + strings.Contains(errorStr, "timeout") || + strings.Contains(errorStr, "connection refused") { + isProxyError = true + } + } + log.Printf("[ERROR] 请求错误详情: %v", errorDetails) + + if isProxyError { + // 处理代理失败 + return nil, fmt.Errorf("代理连接失败") + } + + return nil, fmt.Errorf("查询请求失败: %v", errs) + } + + // 检查HTTP状态码 + if resp.StatusCode != http.StatusOK { + return nil, fmt.Errorf("HTTP错误: %s", resp.Status) + } + + // 解析json + var data map[string]interface{} + if err := json.Unmarshal([]byte(body), &data); err != nil { + return nil, fmt.Errorf("解析JSON失败: %w", err) + } + + // 检查status状态 + if val, ok := data["status"].(float64); ok && val == 1 { + return data, nil + } + return nil, fmt.Errorf("API返回错误: %+v", data) +} + +// 获取商品列表-已登的店铺 +func outGetGoodsListMsgFromSelfShop(token string, proxy string, itemSn string, priceMin string, priceMax string, + startCreateTime string, endCreateTime string, requestType string, + isItemSnEqual int, page int, size int) (map[string]interface{}, error) { + // 判断登录token + if token == "" { + return nil, fmt.Errorf("请先登录获取Token") + } + + // 已登店铺的商品信息URL + url := "https://seller.kongfz.com/pc-gw/book-manage-service/client/pc/goods/unSold/list" + + // 请求参数 + formData := struct { + ItemSn string `json:"itemSn"` + PriceMin string `json:"priceMin"` + PriceMax string `json:"priceMax"` + StartCreateTime string `json:"startCreateTime"` + EndCreateTime string `json:"endCreateTime"` + RequestType string `json:"requestType,omitempty"` + IsItemSnEqual int `json:"isItemSnEqual,omitempty"` + Page int `json:"page,omitempty"` + Size int `json:"size,omitempty"` + }{ + ItemSn: itemSn, + PriceMin: priceMin, + PriceMax: priceMax, + StartCreateTime: startCreateTime, + EndCreateTime: endCreateTime, + RequestType: requestType, + IsItemSnEqual: isItemSnEqual, + Page: page, + Size: size, + } + // 创建请求 + request := gorequest.New() + + // 设置代理（如果有提供代理URL） + if proxy != "" { + request.Proxy(proxy) + } + resp, body, errs := request.Post(url). + Set("Cookie", fmt.Sprintf("PHPSESSID=%s", token)). + Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"). + Set("Accept", "application/json, text/plain, */*"). + Send(formData). + Timeout(15 * time.Second). + End() + if errs != nil { + // 检查是否是代理相关错误 + var isProxyError bool + var errorDetails []string + for _, e := range errs { + errorStr := e.Error() + errorDetails = append(errorDetails, errorStr) + if strings.Contains(errorStr, "Proxy Authentication Required") || + strings.Contains(errorStr, "connectex: A connection attempt failed") || + strings.Contains(errorStr, "connectex: No connection could be made") || + strings.Contains(errorStr, "proxyconnect tcp") || + strings.Contains(errorStr, "timeout") || + strings.Contains(errorStr, "connection refused") { + isProxyError = true + } + } + log.Printf("[ERROR] 请求错误详情: %v", errorDetails) + if isProxyError { + // 处理代理失败 + return nil, fmt.Errorf("代理连接失败") + } + return nil, fmt.Errorf("查询请求失败: %v", errs) + } + + //检查HTTP状态码 + if resp.StatusCode != http.StatusOK { + return nil, fmt.Errorf("HTTP错误: %s", resp.Status) + } + + // 解析json + var data map[string]interface{} + if err := json.Unmarshal([]byte(body), &data); err != nil { + return nil, fmt.Errorf("解析JSON失败: %w", err) + } + + if _, ok := data["status"]; ok { + return data, nil + } + return nil, fmt.Errorf("API返回错误: %+v", data) +} + +// 新增商品-已登的店铺 +func outAddGoods(token, proxy, formData string) (map[string]interface{}, error) { + // 判断登录token + if token == "" { + return nil, fmt.Errorf("请先登录获取Token") + } + // 新增商品的URL + url := "https://seller.kongfz.com/pc/itemInfo/add" + // 创建请求 + request := gorequest.New() + // 设置代理（如果有提供代理URL） + if proxy != "" { + request.Proxy(proxy) + } + resp, body, errs := request.Post(url). + Set("Cookie", fmt.Sprintf("PHPSESSID=%s", token)). + Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"). + Set("Accept", "application/json, text/plain, */*"). + Send(formData). + Timeout(15 * time.Second). + End() + if errs != nil { + // 检查是否是代理相关错误 + var isProxyError bool + var errorDetails []string + for _, e := range errs { + errorStr := e.Error() + errorDetails = append(errorDetails, errorStr) + if strings.Contains(errorStr, "Proxy Authentication Required") || + strings.Contains(errorStr, "connectex: A connection attempt failed") || + strings.Contains(errorStr, "connectex: No connection could be made") || + strings.Contains(errorStr, "proxyconnect tcp") || + strings.Contains(errorStr, "timeout") || + strings.Contains(errorStr, "connection refused") { + isProxyError = true + } + } + log.Printf("[ERROR] 请求错误详情: %v", errorDetails) + if isProxyError { + // 处理代理失败 + return nil, fmt.Errorf("代理连接失败: %s", errs) + } + return nil, fmt.Errorf("查询请求失败: %v", errs) + } + //检查HTTP状态码 + if resp.StatusCode != http.StatusOK { + return nil, fmt.Errorf("HTTP错误: %s", resp.Status) + } + var data map[string]interface{} + if err := json.Unmarshal([]byte(body), &data); err != nil { + return nil, fmt.Errorf("解析JSON失败: %w", err) + } + if val, ok := data["status"]; ok && val == 1 { + return data, nil + } + return nil, fmt.Errorf("API返回错误: %+v", data) +} + +// 删除商品-已登的店铺 +func outDelGoodsFromSelfShop(token, proxy, itemId string) (map[string]interface{}, error) { + // 判断登录token + if token == "" { + return nil, fmt.Errorf("请先登录获取Token") + } + // 删除商品的URL + url := "https://seller.kongfz.com/pc-gw/book-manage-service/client/pc/goods/quickUpdate" + formData := map[string]string{ + "itemId": itemId, + "updateType": "delete", + "value": "1", + } + // 创建请求 + request := gorequest.New() + if proxy != "" { + request.Proxy(proxy) + } + resp, body, errs := request.Post(url). + Set("Cookie", fmt.Sprintf("PHPSESSID=%s", token)). + Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"). + Set("Accept", "application/json, text/plain, */*"). + Send(formData). + Timeout(15 * time.Second). + End() + if errs != nil { + // 检查是否是代理相关错误 + var isProxyError bool + var errorDetails []string + for _, e := range errs { + errorStr := e.Error() + errorDetails = append(errorDetails, errorStr) + if strings.Contains(errorStr, "Proxy Authentication Required") || + strings.Contains(errorStr, "connectex: A connection attempt failed") || + strings.Contains(errorStr, "connectex: No connection could be made") || + strings.Contains(errorStr, "proxyconnect tcp") || + strings.Contains(errorStr, "timeout") || + strings.Contains(errorStr, "connection refused") { + isProxyError = true + } + } + log.Printf("[ERROR] 请求错误详情: %v", errorDetails) + if isProxyError { + // 处理代理失败 + return nil, fmt.Errorf("代理连接失败") + } + return nil, fmt.Errorf("查询请求失败: %v", errs) + } + // 检查HTTP状态码 + if resp.StatusCode != http.StatusOK { + return nil, fmt.Errorf("HTTP错误: %s", resp.Status) + } + // 解析json + var data map[string]interface{} + if err := json.Unmarshal([]byte(body), &data); err != nil { + return nil, fmt.Errorf("解析JSON失败: %w", err) + } + // 判断是否响应成功 + if status, ok := data["status"].(bool); ok && status { + return data, nil + } + // 判断是否响应成功 + if status, ok := data["status"].(float64); ok && status == 1 { + return data, nil + } + + return nil, fmt.Errorf("API返回错误: %+v", data) +} + +// 获取孔网商品图片(官图和拍图)-带有店铺过滤 +func outGetImageFilterShopId(token string, proxy string, isbn string, shopId int, isLiveImage int, isReturnMsg int) (map[string]string, error) { + if isLiveImage == 0 { + // 图书条目URL + gtUrl := fmt.Sprintf("%s?keyword=%s", + "https://search.kongfz.com/pc-gw/search-web/client/pc/bookLib/keyword/list", isbn) + request := gorequest.New() + if proxy != "" { + request.Proxy(proxy) + } + resp, body, errs := request.Get(gtUrl). + Set("Cookie", fmt.Sprintf("PHPSESSID=%s", token)). + Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"). + Set("Accept", "application/json, text/plain, */*"). + Set("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8"). + Set("Referer", "https://item.kongfz.com/"). + Timeout(30 * time.Second). + End() + if len(errs) > 0 { + // 检查是否是代理相关错误 + var isProxyError bool + var errorDetails []string + for _, e := range errs { + errorStr := e.Error() + errorDetails = append(errorDetails, errorStr) + if strings.Contains(errorStr, "Proxy Authentication Required") || + strings.Contains(errorStr, "connectex: A connection attempt failed") || + strings.Contains(errorStr, "connectex: No connection could be made") || + strings.Contains(errorStr, "proxyconnect tcp") || + strings.Contains(errorStr, "timeout") || + strings.Contains(errorStr, "connection refused") { + isProxyError = true + } + } + log.Printf("[ERROR] 请求错误详情: %v", errorDetails) + if isProxyError { + // 处理代理失败 + return nil, fmt.Errorf("代理连接失败") + } + return nil, fmt.Errorf("查询请求失败: %v", errs) + } + //检查HTTP状态码 + if resp.StatusCode != http.StatusOK { + return nil, fmt.Errorf("HTTP错误: %s", resp.Status) + } + // 解析响应 + var apiGtResp struct { + Status int `json:"status"` + ErrType string `json:"errType"` + Message string `json:"message"` + SystemTime int64 `json:"systemTime"` + Data struct { + ItemResponse struct { + Total int `json:"total"` + List []struct { + BookName string `json:"bookName"` + Mid int64 `json:"mid"` + ImgUrlEntity struct { + BigImgUrl string `json:"bigImgUrl"` + } `json:"imgUrlEntity"` + Isbn string `json:"isbn"` + BookShowInfo []string `json:"bookShowInfo"` + } `json:"list"` + } `json:"itemResponse"` + } `json:"data"` + } + if err := json.Unmarshal([]byte(body), &apiGtResp); err != nil { + return nil, fmt.Errorf("解析JSON失败: %w", err) + } + if apiGtResp.ErrType == "102" { + return nil, fmt.Errorf("错误信息: %w，状态码: %s", apiGtResp.Message, apiGtResp.ErrType) + } + var info map[string]string + // 如果找到条目，返回图片URL + if apiGtResp.Data.ItemResponse.Total > 0 && len(apiGtResp.Data.ItemResponse.List) > 0 { + list := apiGtResp.Data.ItemResponse.List[0] + info = map[string]string{ + "book_name": list.BookName, + "book_pic": list.ImgUrlEntity.BigImgUrl, + "isbn": list.Isbn, + } + } + return info, nil + } + if isLiveImage == 1 { + size := 10 + // 实拍图 + sptUrl := fmt.Sprintf("%s?dataType=0&keyword=%s&page=1&size=%d&sortType=7&actionPath=quality,sortType&quality=85~&quaSelect=2&userArea=13003000000", + "https://search.kongfz.com/pc-gw/search-web/client/pc/product/keyword/list", isbn, size) + //创建HTTP客户端 + requestSpt := gorequest.New() + //设置代理(如果有提供代理URL) + if proxy != "" { + requestSpt.Proxy(proxy) + } + // 发送请求 + respSpt, bodySpt, errsSpt := requestSpt.Get(sptUrl). + Proxy(proxy). + Set("Cookie", token). + Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"). + Set("Accept", "application/json, text/plain, */*"). + Set("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8"). + Set("Referer", "https://item.kongfz.com/"). + Timeout(30 * time.Second). + End() + // 错误处理 + if len(errsSpt) > 0 { + return nil, fmt.Errorf("请求失败: %v", errsSpt) + } + + // 检查HTTP状态码 + if respSpt.StatusCode != http.StatusOK { + return nil, fmt.Errorf("HTTP错误: %s", respSpt.Status) + } + + // 解析响应 + var apiSptResp struct { + Status int `json:"status"` + ErrType string `json:"errType"` + Message string `json:"message"` + SystemTime int64 `json:"systemTime"` + Data struct { + ItemResponse struct { + Total int `json:"total"` + List []struct { + ItemId int64 `json:"itemId"` + Title string `json:"title"` + ImgUrl string `json:"imgUrl"` + ImgBigUrl string `json:"imgBigUrl"` + Author string `json:"author"` + PubDateText string `json:"pubDateText"` + Isbn string `json:"isbn"` + Press string `json:"press"` + ShopId int64 `json:"shopId"` + TplRecords []struct { + Key string `json:"key"` + Value string `json:"value"` + } `json:"tplRecords"` + } `json:"list"` + } `json:"itemResponse"` + } `json:"data"` + } + // 解析JSON + if err := json.Unmarshal([]byte(bodySpt), &apiSptResp); err != nil { + return nil, fmt.Errorf("解析JSON失败: %w", err) + } + if apiSptResp.ErrType == "102" { + return nil, fmt.Errorf("错误信息: %w，状态码: %s", apiSptResp.Message, apiSptResp.ErrType) + } + var info map[string]string + if apiSptResp.Data.ItemResponse.Total > 0 && len(apiSptResp.Data.ItemResponse.List) > 0 { + // 确定起始索引 + var startIndex int + if size >= apiSptResp.Data.ItemResponse.Total { + startIndex = apiSptResp.Data.ItemResponse.Total - 1 + } else { + startIndex = size - 1 + } + for attempt := 0; attempt < 3; attempt++ { + currentIndex := startIndex - attempt + // 检查索引是否有效 + if currentIndex < 0 || currentIndex >= len(apiSptResp.Data.ItemResponse.List) { + log.Printf("[DEBUG] 索引 %d 超出范围，跳过", currentIndex) + continue + } + randomNum := rand.Intn(currentIndex + 1) + item := apiSptResp.Data.ItemResponse.List[randomNum] + // 检查图片URL是否存在 + if item.ImgBigUrl == "" { + log.Printf("[DEBUG] 索引 %d 的图片URL为空，跳过", randomNum) + continue + } + // 过滤店铺 + if item.ShopId == int64(shopId) { + log.Printf("[DEBUG] 索引 %d 的店铺ID需要过滤，跳过", randomNum) + continue + } + info = map[string]string{ + "book_name": item.Title, + "book_pic_s": item.ImgUrl, + "isbn": item.Isbn, + } + return info, nil + } + } + } + return nil, nil +} + +// 获取孔网商品图片和信息(官图和拍图) +func outGetImageByIsbn(token string, proxy string, isbn string, isLiveImage int, isReturnMsg int) (*BookInfo, error) { + // isLiveImage 1实拍图 0官图 ，isReturnMsg 0商品信息 + bookInfo := &BookInfo{} + if isLiveImage == 0 { + // 孔网官图请求 + gtUrl := fmt.Sprintf("%s?keyword=%s", + "https://search.kongfz.com/pc-gw/search-web/client/pc/bookLib/keyword/list", isbn) + // 创建HTTP客户端 + requestGt := gorequest.New() + // 设置代理(如果有提供代理URL) + if proxy != "" { + requestGt.Proxy(proxy) + } + // 发送请求 + respGt, bodyGt, errsGt := requestGt.Get(gtUrl). + Set("Cookie", fmt.Sprintf("PHPSESSID=%s", token)). + Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"). + Set("Accept", "application/json, text/plain, */*"). + Set("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8"). + Set("Referer", "https://item.kongfz.com/"). + Timeout(30 * time.Second). + End() + if len(errsGt) > 0 { + // 检查是否是代理相关错误 + var isProxyError bool + var errorDetails []string + for _, e := range errsGt { + errorStr := e.Error() + errorDetails = append(errorDetails, errorStr) + if strings.Contains(errorStr, "Proxy Authentication Required") || + strings.Contains(errorStr, "connectex: A connection attempt failed") || + strings.Contains(errorStr, "connectex: No connection could be made") || + strings.Contains(errorStr, "proxyconnect tcp") || + strings.Contains(errorStr, "timeout") || + strings.Contains(errorStr, "connection refused") { + isProxyError = true + } + } + log.Printf("[ERROR] 请求错误详情: %v", errorDetails) + if isProxyError { + // 处理代理失败 + return nil, fmt.Errorf("代理连接失败") + } + return nil, fmt.Errorf("查询请求失败: %v", errsGt) + } + //检查HTTP状态码 + if respGt.StatusCode != http.StatusOK { + return nil, fmt.Errorf("HTTP错误: %s", respGt.Status) + } + // 解析响应 + var apiGtResp struct { + Status int `json:"status"` + ErrType string `json:"errType"` + Message string `json:"message"` + SystemTime int64 `json:"systemTime"` + Data struct { + ItemResponse struct { + Total int `json:"total"` + List []struct { + BookName string `json:"bookName"` + Mid int64 `json:"mid"` + ImgUrlEntity struct { + BigImgUrl string `json:"bigImgUrl"` + } `json:"imgUrlEntity"` + Isbn string `json:"isbn"` + BookShowInfo []string `json:"bookShowInfo"` + } `json:"list"` + } `json:"itemResponse"` + } `json:"data"` + } + if err := json.Unmarshal([]byte(bodyGt), &apiGtResp); err != nil { + return nil, fmt.Errorf("解析JSON失败: %w", err) + } + if apiGtResp.ErrType == "102" { + return nil, fmt.Errorf("错误信息: %w，状态码: %s", apiGtResp.Message, apiGtResp.ErrType) + } + // 如果找到条目，返回图片URL + if apiGtResp.Data.ItemResponse.Total > 0 && len(apiGtResp.Data.ItemResponse.List) > 0 { + list := apiGtResp.Data.ItemResponse.List[0] + bookShowInfo := list.BookShowInfo + bookInfo.BookName = list.BookName + bookInfo.BookPic = list.ImgUrlEntity.BigImgUrl + bookInfo.ISBN = list.Isbn + // 根据长度安全填充字段 + if isReturnMsg == 0 { + if len(bookShowInfo) > 0 { + bookInfo.Author = bookShowInfo[0] + } + if len(bookShowInfo) > 1 { + bookInfo.Publisher = bookShowInfo[1] + } + if len(bookShowInfo) > 2 { + bookInfo.PublicationTime = validateDateFormat(bookShowInfo[2]) + } + if len(bookShowInfo) > 3 { + bookInfo.BindingLayout = bookShowInfo[3] + } + if len(bookShowInfo) > 4 { + bookInfo.FixPrice = bookShowInfo[4] + } else { + log.Printf("[WARN] BookShowInfo 长度不足 (仅 %d 项): %v", len(bookShowInfo), bookShowInfo) + } + } + } + return bookInfo, nil + } + if isLiveImage == 1 { + size := 10 + // 实拍图 + sptUrl := fmt.Sprintf("%s?dataType=0&keyword=%s&page=1&size=%d&sortType=7&actionPath=quality,sortType&quality=85~&quaSelect=2&userArea=13003000000", + "https://search.kongfz.com/pc-gw/search-web/client/pc/product/keyword/list", isbn, size) + //创建HTTP客户端 + requestSpt := gorequest.New() + //设置代理(如果有提供代理URL) + if proxy != "" { + requestSpt.Proxy(proxy) + } + // 发送请求 + respSpt, bodySpt, errsSpt := requestSpt.Get(sptUrl). + Proxy(proxy). + Set("Cookie", token). + Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"). + Set("Accept", "application/json, text/plain, */*"). + Set("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8"). + Set("Referer", "https://item.kongfz.com/"). + Timeout(30 * time.Second). + End() + // 错误处理 + if len(errsSpt) > 0 { + return nil, fmt.Errorf("请求失败: %v", errsSpt) + } + // 检查HTTP状态码 + if respSpt.StatusCode != http.StatusOK { + return nil, fmt.Errorf("HTTP错误: %s", respSpt.Status) + } + // 解析响应 + var apiSptResp struct { + Status int `json:"status"` + ErrType string `json:"errType"` + Message string `json:"message"` + SystemTime int64 `json:"systemTime"` + Data struct { + ItemResponse struct { + Total int `json:"total"` + List []struct { + ItemId int64 `json:"itemId"` + Title string `json:"title"` + ImgUrl string `json:"imgUrl"` + ImgBigUrl string `json:"imgBigUrl"` + Author string `json:"author"` + PubDateText string `json:"pubDateText"` + Isbn string `json:"isbn"` + Press string `json:"press"` + ShopId int64 `json:"shopId"` + TplRecords []struct { + Key string `json:"key"` + Value string `json:"value"` + } `json:"tplRecords"` + } `json:"list"` + } `json:"itemResponse"` + } `json:"data"` + } + // 解析JSON + if err := json.Unmarshal([]byte(bodySpt), &apiSptResp); err != nil { + return nil, fmt.Errorf("解析JSON失败: %w", err) + } + if apiSptResp.ErrType == "102" { + return nil, fmt.Errorf("错误信息: %w，状态码: %s", apiSptResp.Message, apiSptResp.ErrType) + } + if apiSptResp.Data.ItemResponse.Total > 0 && len(apiSptResp.Data.ItemResponse.List) > 0 { + // 确定其实索引 + var startIndex int + if size >= apiSptResp.Data.ItemResponse.Total { + startIndex = apiSptResp.Data.ItemResponse.Total - 1 + } else { + startIndex = size - 1 + } + for attempt := 0; attempt < 3; attempt++ { + currentIndex := startIndex - attempt + // 检查索引是否有效 + if currentIndex < 0 || currentIndex >= len(apiSptResp.Data.ItemResponse.List) { + log.Printf("[DEBUG] 索引 %d 超出范围，跳过", currentIndex) + continue + } + randomNum := rand.Intn(currentIndex + 1) + item := apiSptResp.Data.ItemResponse.List[randomNum] + // 检查图片URL是否存在 + if item.ImgBigUrl == "" { + log.Printf("[DEBUG] 索引 %d 的图片URL为空，跳过", randomNum) + continue + } + // 响应信息 + bookInfo.BookPicS = item.ImgUrl + bookInfo.ISBN = item.Isbn + if bookInfo.BookName == "" { + bookInfo.BookName = item.Title + if isReturnMsg == 0 { + // 安全地获取TplRecords中的值 + if len(item.TplRecords) > 0 { + bookInfo.Author = item.TplRecords[0].Value + } + if len(item.TplRecords) > 1 { + bookInfo.Publisher = item.TplRecords[1].Value + } + if len(item.TplRecords) > 2 { + bookInfo.PublicationTime = validateDateFormat(item.TplRecords[2].Value) + } + if len(item.TplRecords) > 3 { + bookInfo.BindingLayout = item.TplRecords[3].Value + } + } + } + return bookInfo, nil + } + } + } + return nil, fmt.Errorf("查询失败，没有数据！") +} + +// 获取商品列表通过店铺ID +func outGetGoodsListMsgByShopId(shopId int, proxy string, retPrice int, isImage int, sortType string, + sort string, priceMin float32, priceMax float32, + pageNum, returnNum int) (books []BookInfo, goodsNum string, pNum string, err error) { + // 判断店铺ID + if shopId == 0 { + return nil, "", "", fmt.Errorf("店铺编码为空!") + } + // 判断是否有图片，设置默认值0 + var isImageStr string + if isImage == 0 { + isImageStr = "0" + } else { + isImageStr = "1" + } + // 判断一页图书数量，设置默认值100 + if returnNum == 0 { + returnNum = 100 + } + // 判断页数，设置默认值1 + if pageNum == 0 { + pageNum = 1 + } + // 判断排序类型，设置默认值sort + if sortType == "" { + sortType = "sort" + } else { + validSortTypes := map[string]bool{ + "sort": true, + "putDate": true, + "newItem": true, + "price": true, + } + if !validSortTypes[sortType] { + return nil, "", "", fmt.Errorf("无效的排序类型: %s，可选值: sort, putDate, newItem, price", sortType) + } + } + // 判断排序，设置默认值desc + if sort == "" { + sort = "desc" + } else { + validSorts := map[string]bool{ + "desc": true, + "asc": true, + } + if !validSorts[sort] { + return nil, "", "", fmt.Errorf("无效的排序类型: %s，可选值: desc, asc", sort) + } + } + var url string + var pMin int + pMin = 0 + var pMax int + pMax = 0 + // 判断价格下限，设置默认值0 + if priceMin == 0 && priceMax == 0 { + // 调用的url + url = fmt.Sprintf("https://shop.kongfz.com/%d/all/%s_%d_0_0_%d_%s_%s_%d_%d", + shopId, isImageStr, returnNum, pageNum, sortType, sort, pMin, pMax) + } else if priceMin == 0 { + url = fmt.Sprintf("https://shop.kongfz.com/%d/all/%s_%d_0_0_%d_%s_%s_%d_%.2f", + shopId, isImageStr, returnNum, pageNum, sortType, sort, pMin, priceMax) + } else if priceMax == 0 { + url = fmt.Sprintf("https://shop.kongfz.com/%d/all/%s_%d_0_0_%d_%s_%s_%.2f_%d", + shopId, isImageStr, returnNum, pageNum, sortType, sort, priceMin, pMax) + } else { + url = fmt.Sprintf("https://shop.kongfz.com/%d/all/%s_%d_0_0_%d_%s_%s_%.2f_%.2f", + shopId, isImageStr, returnNum, pageNum, sortType, sort, priceMin, priceMax) + } + // 发送请求 + response, err := fetchResponse(url, proxy) + if err != nil { + return nil, "", "", err + } + body, err := io.ReadAll(response.Body) + if err != nil { + return nil, "", "", err + } + doc, err := goquery.NewDocumentFromReader(strings.NewReader(string(body))) + // 全部商品数量 + num := doc.Find("div.crumbs-nav-main.clearfix").Find("span") + if match := regexp.MustCompile(`\d+`).FindString(num.Text()); match != "" { + goodsNum = match + } + // 商品页数 + pg := doc.Find("li.pull-right.page_num").Find("span") + _, split, found := strings.Cut(strings.TrimSpace(pg.Text()), "/") + if found { + pNum = split + } else { + log.Printf("未找到页数！") + } + infoDiv := doc.Find("div.list-content") + var params ParamsInfo + if infoDiv.Length() > 0 { + item := infoDiv.Find("div.item.clearfix") + for i := 0; i < item.Length(); i++ { + s := item.Eq(i) + book := BookInfo{} + // 书名 + book.BookName = strings.TrimSpace(s.Find("div.title a.link").Text()) + // 提取ISBN + book.ISBN = strings.TrimSpace(s.AttrOr("isbn", "")) + // 店铺ID + shopid, _ := strconv.Atoi(strings.TrimSpace(s.AttrOr("shopid", ""))) + book.ShopId = int64(shopid) + // 商品ID + itemid, _ := strconv.Atoi(strings.TrimSpace(s.AttrOr("itemid", ""))) + book.ItemId = int64(itemid) + // 详情URL + book.DetailUrl = s.Find("div.item-img a.img-box").AttrOr("href", "") + // 价格 + if retPrice == 0 { + book.SellingPrice = s.Find("div.f_right.red.price").Find("span.bold").Text() + params.Params = append(params.Params, struct { + UserId string `json:"userId"` + ItemId string `json:"itemId"` + }{UserId: strings.TrimSpace(s.AttrOr("userid", "")), ItemId: strings.TrimSpace(s.AttrOr("itemid", ""))}) + } + books = append(books, book) + } + if params.Params != nil { + params.Area = "13003000000" + dataItem, err := getGoodsListShippingFee(params, proxy) + if err != nil { + return nil, "", "", err + } + for i := 0; i < len(books); i++ { + itemId := fmt.Sprintf("%d", books[i].ItemId) + for _, data := range dataItem { + if itemId == data.ItemID { + books[i].ExpressDeliveryFee = data.Fee[0].TotalFee + } + } + } + } + } + return books, goodsNum, pNum, nil +} + +// 获取商品信息通过商品详情链接 +func outGetGoodsMsgByDetailUrl(detailUrl, proxy string) (*BookInfo, error) { + response, err := fetchResponse(detailUrl, proxy) + if err != nil { + return nil, err + } + body, err := io.ReadAll(response.Body) + if err != nil { + return nil, err + } + // 解析HTML文档 + document, err := goquery.NewDocumentFromReader(strings.NewReader(string(body))) + if err != nil { + return nil, err + } + // 获取商品信息的快递费 + fee, err := getBookDetailShippingFee(detailUrl, proxy) + if err != nil { + return nil, err + } + book := BookInfo{} + //书名 + book.BookName = strings.TrimSpace(document.Find("h1.title").Text()) + //作者等信息 + topDiv := document.Find("div.keywords-define.keywords-define-1000.clear-fix") + if topDiv.Length() > 0 { + topDiv.Find("li").Each(func(i int, li *goquery.Selection) { + titleSpan := li.Find("span.keywords-define-title") + contentSpan := li.Find("span.keywords-define-txt") + if contentSpan.Length() == 0 { + fmt.Printf("未找到指定的contentSpan信息") + } + titleText := strings.TrimSpace(titleSpan.Text()) + contentText := strings.TrimSpace(contentSpan.Text()) + titleText = strings.TrimSpace(titleText) + if strings.Contains(titleText, "作者") { + book.Author = cleanString(contentText) + } + if strings.Contains(titleText, "出版社") { + book.Publisher = contentText + } + if strings.Contains(titleText, "出版人") { + book.Publisher = contentText + } + if strings.Contains(titleText, "ISBN") { + book.ISBN = contentText + } + if strings.Contains(titleText, "出版时间") { + book.PublicationTime = validateDateFormat(contentText) + } + if strings.Contains(titleText, "版次") { + book.Edition = contentText + } + if strings.Contains(titleText, "装帧") { + book.BindingLayout = contentText + } + if strings.Contains(titleText, "开本") { + book.Format = contentText + } + if strings.Contains(titleText, "页数") { + book.Pages = contentText + } + if strings.Contains(titleText, "字数") { + book.Wordage = contentText + } + if strings.Contains(titleText, "纸张") { + book.Paper = contentText + } + if strings.Contains(titleText, "年代") { + book.Era = contentText + } + if strings.Contains(titleText, "刻印方式") { + book.EngravingMethod = contentText + } + if strings.Contains(titleText, "尺寸") { + book.Dimensions = contentText + } + if strings.Contains(titleText, "册数") { + book.VolumeNumber = contentText + } + }) + } else { + botDiv := document.Find("div.detail-lists.clear-fix") + botDiv.Find("li").Each(func(i int, li *goquery.Selection) { + spanText := strings.TrimSpace(li.Find("span").Text()) + spanText = strings.TrimSpace(spanText) + if strings.Contains(li.Text(), "作者") { + book.Author = cleanString(li.Text()) + book.Author = strings.ReplaceAll(book.Author, "作者:", "") + book.Author = strings.ReplaceAll(book.Author, "著", "") + } + if strings.Contains(li.Text(), "出版社") { + book.Publisher = spanText + } + if strings.Contains(li.Text(), "出版时间") { + book.PublicationTime = validateDateFormat(spanText) + } + if strings.Contains(li.Text(), "ISBN") { + book.ISBN = spanText + } + if strings.Contains(li.Text(), "装帧") { + book.BindingLayout = spanText + } + if strings.Contains(li.Text(), "开本") { + book.Format = spanText + } + if strings.Contains(li.Text(), "纸张") { + book.Paper = spanText + } + if strings.Contains(li.Text(), "版次") { + book.Edition = spanText + } + if strings.Contains(li.Text(), "页数") { + book.Pages = spanText + } + if strings.Contains(li.Text(), "字数") { + book.Wordage = spanText + } + }) + } + + //图片 + var imgUrls []string + tpUl := document.Find("ul.lg-list") + tpUl.Find("img").Each(func(i int, s *goquery.Selection) { + dataImgUrl, exists := s.Attr("data-imgurl") + if exists && dataImgUrl != "" { + imgUrls = append(imgUrls, dataImgUrl) + } + }) + book.BookPicS = strings.Join(imgUrls, ",") + // 售价 + price := document.Find("i.now-price-text").Text() + priceN := regexp.MustCompile(`(\d+\.?\d*)`) + if match := priceN.FindStringSubmatch(price); len(match) > 0 { + book.SellingPrice = match[1] + } + // 定价价 + fixPrice := document.Find("span.origin-price-text.clearfix").Text() + fixPriceN := regexp.MustCompile(`(\d+\.?\d*)`) + if match := fixPriceN.FindStringSubmatch(fixPrice); len(match) > 0 { + book.FixPrice = match[1] + } + // 品相 + text := document.Find("span.quality-text-cot.clearfix i").Text() + book.Condition = strings.TrimSpace(text) + // 快递费 + book.ExpressDeliveryFee = fee + return &book, nil +} + +// 获取商品信息的快递费(定位到河南) +func getBookDetailShippingFee(url, proxy string) (string, error) { + compile := regexp.MustCompile(`kongfz\.com/(\d+)/(\d+)`) + match := compile.FindStringSubmatch(url) + var shippingFee string + var shopId int + var itemId int + if len(match) == 3 { + firstNum, err := strconv.Atoi(match[1]) // 店铺ID + if err != nil { + return "", fmt.Errorf("无效的店铺编码: %s", match[1]) + } + shopId = firstNum + secondNum, err := strconv.Atoi(match[2]) // 图书ID + if err != nil { + return "", fmt.Errorf("无效的图书编码: %s", match[2]) + } + itemId = secondNum + } + shippingFeeUrl := fmt.Sprintf("https://book.kongfz.com/store-web/pc/v1/mould/calculateFee?area=13003000000&itemId=%d&shopId=%d", itemId, shopId) + // 创建HTTP客户端 + request := gorequest.New() + // 设置代理（如果有提供代理URL） + if proxy != "" { + request.Proxy(proxy) + } + // 设置超时和其他配置 + request.Timeout(30 * time.Second) + // 发送请求 + resp, body, errs := request.Get(shippingFeeUrl). + Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"). + Set("Accept", "application/json, text/plain, */*"). + Set("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8"). + End() + // 错误处理 + if len(errs) > 0 { + return "", fmt.Errorf("请求失败: %v", errs) + } + // 检查HTTP状态码 + if resp.StatusCode != http.StatusOK { + return "", fmt.Errorf("HTTP错误: %s", resp.Status) + } + calculateFee := struct { + ErrCode int `json:"errCode"` + ErrMessage string `json:"errMessage"` + Result struct { + FeeList []struct { + FreeCondition string `json:"freeCondition"` + ShippingID string `json:"shippingId"` + ShippingName string `json:"shippingName"` + ShippingValue string `json:"shippingValue"` + } `json:"feeList"` + FeeText string `json:"feeText"` + } `json:"result"` + Status bool `json:"status"` + }{} + + err := json.Unmarshal([]byte(body), &calculateFee) + if err != nil { + return "", fmt.Errorf("解析JSON失败: %v", err) + } + for _, fee := range calculateFee.Result.FeeList { + shippingFee = fee.ShippingValue + } + return shippingFee, nil +} + +// 公用发送请求方法 +func fetchResponse(url, proxy string) (*http.Response, error) { + log.Printf("调用的URL: %s", url) + maxRetries := 3 + var detailsResp *http.Response + var errors []error + for attempt := 0; attempt < maxRetries; attempt++ { + if attempt > 0 { + log.Printf("第 %d 次重试请求...", attempt) + // 重试前等待，使用指数退避策略 + waitTime := time.Duration(attempt*attempt) * 1000 // 平方退避 + log.Printf("等待 %v 后重试", waitTime) + time.Sleep(waitTime) + } + if proxy != "" { + detailsResp, _, errors = gorequest.New(). + Get(url). + Proxy(proxy). + Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"). + Set("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"). + Set("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8"). + Timeout(120 * time.Second). + End() + } + if proxy == "" { + detailsResp, _, errors = gorequest.New(). + Get(url). + Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"). + Set("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"). + Set("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8"). + Timeout(120 * time.Second). + End() + } + // 检查是否需要重试 + shouldRetry := false + if len(errors) > 0 { + shouldRetry = true + log.Printf("请求失败 (尝试 %d/%d): %v", attempt+1, maxRetries+1, errors) + } else if detailsResp == nil { + shouldRetry = true + log.Printf("响应为空 (尝试 %d/%d)", attempt+1, maxRetries+1) + } else if detailsResp.StatusCode != http.StatusOK { + // 只对服务器错误进行重试，不对客户端错误重试 + if detailsResp.StatusCode >= 500 { + shouldRetry = true + } + log.Printf("HTTP状态码: %d,HTTP请求失败: %s (尝试 %d/%d)", detailsResp.StatusCode, detailsResp.Body, attempt+1, maxRetries+1) + } + // 如果不需要重试，跳出循环 + if !shouldRetry { + break + } + // 如果是最后一次尝试，不继续重试 + if attempt == maxRetries { + break + } + // 关闭响应体（如果存在） + if detailsResp != nil && detailsResp.Body != nil { + detailsResp.Body.Close() + } + } + // 检测请求是否错误 + if len(errors) > 0 { + var proxyAuthFailed bool + var timeoutError bool + var connectionError bool + for _, e := range errors { + errStr := e.Error() + if strings.Contains(errStr, "Proxy Authentication Required") { + proxyAuthFailed = true + } + if strings.Contains(errStr, "timeout") || strings.Contains(errStr, "i/o timeout") { + timeoutError = true + } + if strings.Contains(errStr, "connection") || strings.Contains(errStr, "connect") { + connectionError = true + } + } + if proxyAuthFailed { + return nil, fmt.Errorf("代理认证失败") + } + if timeoutError { + return nil, fmt.Errorf("请求超时，经过 %d 次尝试，超时网址:%s", maxRetries+1, url) + } + if connectionError { + return nil, fmt.Errorf("网络连接错误，经过 %d 次尝试，错误网址:%s", maxRetries+1, url) + } + return nil, fmt.Errorf("查询请求失败，经过 %d 次尝试: %v，失败网址:%s", maxRetries+1, errors, url) + } + if detailsResp.StatusCode != http.StatusOK { + return nil, fmt.Errorf("HTTP错误: %s", detailsResp.Status) + } + return detailsResp, nil +} + +// 获取销量榜商品列表(带有Out的都非官放标准接口) +func outGetTopGoodsListMsg(catId int, proxy string) ([]string, error) { + // 构建请求URL + url := fmt.Sprintf("https://item.kongfz.com/api/pc/getSellWellListDetail?page=1&pageSize=100&timeRank=2&catId=%d", catId) + // 创建HTTP客户端 + request := gorequest.New() + // 设置代理（如果有提供代理URL） + if proxy != "" { + request.Proxy(proxy) + } + // 设置超时和其他配置 + request.Timeout(30 * time.Second) + // 发送请求 + resp, body, errs := request.Get(url). + Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"). + Set("Accept", "application/json, text/plain, */*"). + Set("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8"). + Set("Referer", "https://item.kongfz.com/"). + End() + // 错误处理 + if len(errs) > 0 { + return nil, fmt.Errorf("请求失败: %v", errs) + } + // 检查HTTP状态码 + if resp.StatusCode != http.StatusOK { + return nil, fmt.Errorf("HTTP错误: %s", resp.Status) + } + var bookDetailResponse BookDetailResponse + err := json.Unmarshal([]byte(body), &bookDetailResponse) + if err != nil { + return nil, fmt.Errorf("解析JSON失败: %v", err) + } + if !bookDetailResponse.Status { + return nil, fmt.Errorf("API返回错误: %s (代码: %d)", bookDetailResponse.ErrMessage, bookDetailResponse.ErrCode) + } + + var isbnList []string + for _, item := range bookDetailResponse.Result.Data { + if item.Isbn != "" { + isbnList = append(isbnList, item.Isbn) + } + } + isbnList = removeDuplicateISBNs(isbnList) + return isbnList, nil +} + +// 去除重复的ISBN +func removeDuplicateISBNs(isbns []string) []string { + seen := make(map[string]bool) + var result []string + for _, isbn := range isbns { + if !seen[isbn] { + seen[isbn] = true + result = append(result, isbn) + } + } + return result +} + +// =============== 辅助函数 ============== +// 替换所有空白字符为空格 +func cleanString(s string) string { + s = strings.ReplaceAll(s, "\n", "") + s = strings.ReplaceAll(s, "\r", "") + s = strings.ReplaceAll(s, "\t", "") + s = strings.ReplaceAll(s, " ", "") + return removeDuplicates(s) +} + +// 字符串去重 +func removeDuplicates(s string) string { + seen := make(map[rune]bool) + var result strings.Builder + for _, r := range s { + if !seen[r] { + seen[r] = true + result.WriteRune(r) + } + } + return result.String() +} + +// 验证日期格式 +func validateDateFormat(dateStr string) int64 { + // 去除前后空格 + dateStr = strings.TrimSpace(dateStr) + + // 替换各种分隔符为统一的分隔符"-" + dateStr = regexp.MustCompile(`[/_\\.,\s]+`).ReplaceAllString(dateStr, "-") + + // 处理纯年份格式 (4位数字) + if regexp.MustCompile(`^\d{4}$`).MatchString(dateStr) { + dateStr += "-01-01" + } + + // 处理年月格式 (4位数字-1或2位数字) + if matches := regexp.MustCompile(`^(\d{4})-(\d{1,2})$`).FindStringSubmatch(dateStr); len(matches) == 3 { + year := matches[1] + month := matches[2] + if len(month) == 1 { + month = "0" + month + } + if monthNum, _ := strconv.Atoi(month); monthNum >= 1 && monthNum <= 12 { + dateStr = year + "-" + month + "-01" + } else { + return 0 + } + } + + // 处理年月日格式 (4位数字-1或2位数字-1或2位数字) + if matches := regexp.MustCompile(`^(\d{4})-(\d{1,2})-(\d{1,2})`).FindStringSubmatch(dateStr); len(matches) >= 4 { + year := matches[1] + month := matches[2] + day := matches[3] + + // 标准化月份和日期为两位数 + if len(month) == 1 { + month = "0" + month + } + if len(day) == 1 { + day = "0" + day + } + + dateStr = year + "-" + month + "-" + day + } + + // 加载上海时区 + loc, err := time.LoadLocation("Asia/Shanghai") + if err != nil { + // 如果加载时区失败，使用UTC+8作为后备方案 + loc = time.FixedZone("CST", 8*60*60) + } + + // 尝试解析为标准日期格式，并指定上海时区 + parsedTime, err := time.ParseInLocation("2006-01-02", dateStr, loc) + if err != nil { + return 0 + } + + // 返回秒级时间戳（UTC时间，但解析时已经考虑了时区偏移） + return parsedTime.Unix() +} + +// 初始化 +func initializeConfig(config Config) { + // 设置全局配置 + cf = config +} + +// =================== C 导出函数 ======================= + +// 孔网登录 +// +//export OutLogin +func OutLogin(username, password *C.char) *C.char { + goUsername := C.GoString(username) + goPassword := C.GoString(password) + respToken, err := outLogin(goUsername, goPassword) + resp := struct { + Token string `json:"token"` + }{ + Token: respToken, + } + var apiResponse APIResponse + if err != nil { + apiResponse = APIResponse{ + Success: false, + Message: err.Error(), + } + } else { + apiResponse = APIResponse{ + Success: true, + Data: resp, + } + } + // 转换为JSON字符串 + jsonData, marshalErr := json.Marshal(apiResponse) + if marshalErr != nil { + // 如果JSON序列化失败，返回错误信息 + apiResponse = APIResponse{ + Success: false, + Message: fmt.Sprintf("JSON序列化失败: %v", marshalErr), + } + errorJson, _ := json.Marshal(apiResponse) + return C.CString(string(errorJson)) + } + return C.CString(string(jsonData)) +} + +// 获取孔网用户信息 +// +//export OutGetUserMsg +func OutGetUserMsg(token *C.char) *C.char { + goToken := C.GoString(token) + userInfo, err := outGetUserMsg(goToken) + var apiResponse APIResponse + if err != nil { + apiResponse = APIResponse{ + Success: false, + Message: err.Error(), + } + } else { + apiResponse = APIResponse{ + Success: true, + Data: userInfo, + } + } + // 转换为JSON字符串 + jsonData, marshalErr := json.Marshal(apiResponse) + if marshalErr != nil { + // 如果JSON序列化失败，返回错误信息 + apiResponse = APIResponse{ + Success: false, + Message: fmt.Sprintf("JSON序列化失败: %v", marshalErr), + } + errorJson, _ := json.Marshal(apiResponse) + return C.CString(string(errorJson)) + } + return C.CString(string(jsonData)) +} + +// 获取商品模版--已登的店铺 +// +//export OutGetGoodsTplMsg +func OutGetGoodsTplMsg(token, proxy, itemId *C.char) *C.char { + goToken := C.GoString(token) + goProxy := C.GoString(proxy) + goItemId := C.GoString(itemId) + info, err := outGetGoodsTplMsg(goToken, goProxy, goItemId) + var apiResponse APIResponse + if err != nil { + apiResponse = APIResponse{ + Success: false, + Message: err.Error(), + } + } else { + apiResponse = APIResponse{ + Success: true, + Data: info, + } + } + // 转换为JSON字符串 + jsonData, marshalErr := json.Marshal(apiResponse) + if marshalErr != nil { + // 如果JSON序列化失败，返回错误信息 + apiResponse = APIResponse{ + Success: false, + Message: fmt.Sprintf("JSON序列化失败: %v", marshalErr), + } + errorJson, _ := json.Marshal(apiResponse) + return C.CString(string(errorJson)) + } + return C.CString(string(jsonData)) +} + +// 获取商品列表-已登的店铺 +// +//export OutGetGoodsListMsgFromSelfShop +func OutGetGoodsListMsgFromSelfShop(token, proxy, itemSn, priceMin, priceMax *C.char, startCreateTime *C.char, + endCreateTime *C.char, requestType *C.char, isItemSnEqual C.int, page C.int, size C.int) *C.char { + goToken := C.GoString(token) + goProxy := C.GoString(proxy) + goItemSn := C.GoString(itemSn) + goPriceMin := C.GoString(priceMin) + goPriceMax := C.GoString(priceMax) + goStartCreateTime := C.GoString(startCreateTime) + goEndCreateTime := C.GoString(endCreateTime) + goRequestType := C.GoString(requestType) + goIsItemSnEqual := int(isItemSnEqual) + goPage := int(page) + goSize := int(size) + info, err := outGetGoodsListMsgFromSelfShop(goToken, goProxy, goItemSn, goPriceMin, goPriceMax, goStartCreateTime, goEndCreateTime, goRequestType, goIsItemSnEqual, goPage, goSize) + var apiResponse APIResponse + if err != nil { + apiResponse = APIResponse{ + Success: false, + Message: err.Error(), + } + } else { + apiResponse = APIResponse{ + Success: true, + Data: info, + } + } + // 转换为JSON字符串 + jsonData, marshalErr := json.Marshal(apiResponse) + if marshalErr != nil { + // 如果JSON序列化失败，返回错误信息 + apiResponse = APIResponse{ + Success: false, + Message: fmt.Sprintf("JSON序列化失败: %v", marshalErr), + } + errorJson, _ := json.Marshal(apiResponse) + return C.CString(string(errorJson)) + } + return C.CString(string(jsonData)) +} + +// 新增商品-已登的店铺(带有Out的都非官方标准接口) +// +//export OutAddGoods +func OutAddGoods(token, proxy, formData *C.char) *C.char { + goToken := C.GoString(token) + goProxy := C.GoString(proxy) + goFormData := C.GoString(formData) + info, err := outAddGoods(goToken, goProxy, goFormData) + var apiResponse APIResponse + if err != nil { + apiResponse = APIResponse{ + Success: false, + Message: err.Error(), + } + } else { + apiResponse = APIResponse{ + Success: true, + Data: info, + } + } + // 转换为JSON字符串 + jsonData, marshalErr := json.Marshal(apiResponse) + if marshalErr != nil { + // 如果JSON序列化失败，返回错误信息 + apiResponse = APIResponse{ + Success: false, + Message: fmt.Sprintf("JSON序列化失败: %v", marshalErr), + } + errorJson, _ := json.Marshal(apiResponse) + return C.CString(string(errorJson)) + } + return C.CString(string(jsonData)) +} + +// 删除商品-已登的店铺 +// +//export OutDelGoodsFromSelfShop +func OutDelGoodsFromSelfShop(token, proxy, itemId *C.char) *C.char { + goToken := C.GoString(token) + goProxy := C.GoString(proxy) + goItemId := C.GoString(itemId) + info, err := outDelGoodsFromSelfShop(goToken, goProxy, goItemId) + var apiResponse APIResponse + if err != nil { + apiResponse = APIResponse{ + Success: false, + Message: err.Error(), + } + } else { + apiResponse = APIResponse{ + Success: true, + Data: info, + } + } + // 转换为JSON字符串 + jsonData, marshalErr := json.Marshal(apiResponse) + if marshalErr != nil { + // 如果JSON序列化失败，返回错误信息 + apiResponse = APIResponse{ + Success: false, + Message: fmt.Sprintf("JSON序列化失败: %v", marshalErr), + } + errorJson, _ := json.Marshal(apiResponse) + return C.CString(string(errorJson)) + } + return C.CString(string(jsonData)) +} + +// 获取孔网商品图片和信息(官图和拍图)-带有店铺过滤 +// +//export OutGetImageFilterShopId +func OutGetImageFilterShopId(token, proxy, isbn *C.char, shopId C.int, isLiveImage C.int, isReturnMsg C.int) *C.char { + goToken := C.GoString(token) + goProxy := C.GoString(proxy) + goIsbn := C.GoString(isbn) + goShopId := int(shopId) + goIsLiveImage := int(isLiveImage) + goIsReturnMsg := int(isReturnMsg) + info, err := outGetImageFilterShopId(goToken, goProxy, goIsbn, goShopId, goIsLiveImage, goIsReturnMsg) + var apiResponse APIResponse + if err != nil { + apiResponse = APIResponse{ + Success: false, + Message: err.Error(), + } + } else { + apiResponse = APIResponse{ + Success: true, + Data: info, + } + } + // 转换为JSON字符串 + jsonData, marshalErr := json.Marshal(apiResponse) + if marshalErr != nil { + // 如果JSON序列化失败，返回错误信息 + apiResponse = APIResponse{ + Success: false, + Message: fmt.Sprintf("JSON序列化失败: %v", marshalErr), + } + errorJson, _ := json.Marshal(apiResponse) + return C.CString(string(errorJson)) + } + return C.CString(string(jsonData)) +} + +// 获取孔网商品图片和信息(官图和拍图) +// +//export OutGetImageByIsbn +func OutGetImageByIsbn(token, isbn, proxy *C.char, isLiveImage C.int, isReturnMsg C.int) *C.char { + goToken := C.GoString(token) + goIsbn := C.GoString(isbn) + goProxy := C.GoString(proxy) + goIsLiveImage := int(isLiveImage) + goIsReturnMsg := int(isReturnMsg) + bookInfo, err := outGetImageByIsbn(goToken, goIsbn, goProxy, goIsLiveImage, goIsReturnMsg) + var apiResponse APIResponse + if err != nil { + apiResponse = APIResponse{ + Success: false, + Message: err.Error(), + } + } else { + apiResponse = APIResponse{ + Success: true, + Data: bookInfo, + } + } + // 转换为JSON字符串 + jsonData, marshalErr := json.Marshal(apiResponse) + if marshalErr != nil { + // 如果JSON序列化失败，返回错误信息 + apiResponse = APIResponse{ + Success: false, + Message: fmt.Sprintf("JSON序列化失败: %v", marshalErr), + } + errorJson, _ := json.Marshal(apiResponse) + return C.CString(string(errorJson)) + } + return C.CString(string(jsonData)) +} + +// 获取商品列表通过店铺ID +// +//export OutGetGoodsListMsgByShopId +func OutGetGoodsListMsgByShopId(shopId C.int, proxy *C.char, retPrice C.int, isImage C.int, sortType *C.char, sort *C.char, priceMin C.float, priceMax C.float, pageNum, returnNum C.int) *C.char { + goShopId := int(shopId) + goProxy := C.GoString(proxy) + goRetPrice := int(retPrice) + goIsImage := int(isImage) + goSortType := C.GoString(sortType) + goSort := C.GoString(sort) + goPriceMin := float32(priceMin) + goPriceMax := float32(priceMax) + goPageNum := int(pageNum) + goReturnNum := int(returnNum) + books, num, pNum, err := outGetGoodsListMsgByShopId(goShopId, goProxy, goRetPrice, goIsImage, + goSortType, goSort, goPriceMin, goPriceMax, goPageNum, goReturnNum) + // 构建统一格式的响应 + bookInfo := struct { + GoodsNum string `json:"goods_num,omitempty"` + PNum string `json:"pnum,omitempty"` + BookInfo interface{} `json:"book_info,omitempty"` + }{ + GoodsNum: num, + PNum: pNum, + BookInfo: books, + } + var apiResponse APIResponse + if err != nil { + apiResponse = APIResponse{ + Success: false, + Message: err.Error(), + } + } else { + apiResponse = APIResponse{ + Success: true, + Data: bookInfo, + } + } + // 转换为JSON字符串 + jsonData, marshalErr := json.Marshal(apiResponse) + if marshalErr != nil { + // 如果JSON序列化失败，返回错误信息 + apiResponse = APIResponse{ + Success: false, + Message: fmt.Sprintf("JSON序列化失败: %v", marshalErr), + } + errorJson, _ := json.Marshal(apiResponse) + return C.CString(string(errorJson)) + } + return C.CString(string(jsonData)) +} + +// 获取商品信息通过商品详情链接 +// +//export OutGetGoodsMsgByDetailUrl +func OutGetGoodsMsgByDetailUrl(detailUrl, proxy *C.char) *C.char { + goDetailUrl := C.GoString(detailUrl) + goProxy := C.GoString(proxy) + response, err := outGetGoodsMsgByDetailUrl(goDetailUrl, goProxy) + // 构建统一格式的响应 + var apiResponse APIResponse + if err != nil { + apiResponse = APIResponse{ + Success: false, + Message: err.Error(), + } + } else { + apiResponse = APIResponse{ + Success: true, + Data: response, + } + } + // 转换为JSON字符串 + jsonData, marshalErr := json.Marshal(apiResponse) + if marshalErr != nil { + // 如果JSON序列化失败，返回错误信息 + apiResponse = APIResponse{ + Success: false, + Message: fmt.Sprintf("JSON序列化失败: %v", marshalErr), + } + errorJson, _ := json.Marshal(apiResponse) + return C.CString(string(errorJson)) + } + return C.CString(string(jsonData)) +} + +// 获取销量榜商品列表 +// +//export OutGetTopGoodsListMsg +func OutGetTopGoodsListMsg(catId C.int, proxy *C.char) *C.char { + goCatId := int(catId) + goProxy := C.GoString(proxy) + response, err := outGetTopGoodsListMsg(goCatId, goProxy) + // 构建统一格式的响应 + var apiResponse APIResponse + if err != nil { + apiResponse = APIResponse{ + Success: false, + Message: err.Error(), + } + } else { + apiResponse = APIResponse{ + Success: true, + Data: response, + } + } + // 转换为JSON字符串 + jsonData, marshalErr := json.Marshal(apiResponse) + if marshalErr != nil { + // 如果JSON序列化失败，返回错误信息 + apiResponse = APIResponse{ + Success: false, + Message: fmt.Sprintf("JSON序列化失败: %v", marshalErr), + } + errorJson, _ := json.Marshal(apiResponse) + return C.CString(string(errorJson)) + } + return C.CString(string(jsonData)) +} + +// 初始化配置 +// +//export Initialize +func Initialize(configJSON *C.char) *C.char { + configStr := C.GoString(configJSON) + log.Printf("[DEBUG] 接收到的配置JSON: %s", configStr) + + var config Config + if err := json.Unmarshal([]byte(configStr), &config); err != nil { + return C.CString(fmt.Sprintf(`{"success":false,"message":"配置解析失败: %v"}`, err)) + } + initializeConfig(config) + + return C.CString(`{"success":true,"message":"初始化成功"}`) +} + +// 释放C字符串内存 +// +//export FreeCString +func FreeCString(str *C.char) { + C.free(unsafe.Pointer(str)) +} + +// 空main函数，编译DLL时需要 +func main() { +} diff --git a/kfzgw_linux b/linux/kfzgw_linux similarity index 60% rename from kfzgw_linux rename to linux/kfzgw_linux index f74c2c0..4fa795a 100644 Binary files a/kfzgw_linux and b/linux/kfzgw_linux differ diff --git a/main.go b/main.go index aebae34..65910f0 100644 --- a/main.go +++ b/main.go @@ -461,9 +461,9 @@ func outGetGoodsTplMsg(token, itemId, proxy string) (map[string]interface{}, err return nil, fmt.Errorf("API返回错误: %+v", data) } -// 获取商品列表 -func outGetGoodsListMsgFromSelfShop(token string, proxy string, itemSn string, priceMin string, priceMax string, startCreateTime int, - endCreateTime int, requestType string, isItemSnEqual int, page int, size int) (map[string]interface{}, error) { +// 获取商品列表-已登的店铺 +func outGetGoodsListMsgFromSelfShop(token string, proxy string, itemSn string, priceMin string, priceMax string, startCreateTime string, + endCreateTime string, requestType string, isItemSnEqual int, page int, size int) (map[string]interface{}, error) { if token == "" { return nil, fmt.Errorf("请先登录获取Token") } @@ -472,8 +472,8 @@ func outGetGoodsListMsgFromSelfShop(token string, proxy string, itemSn string, p ItemSn string `json:"itemSn"` PriceMin string `json:"priceMin"` PriceMax string `json:"priceMax"` - StartCreateTime int `json:"startCreateTime"` - EndCreateTime int `json:"endCreateTime"` + StartCreateTime string `json:"startCreateTime"` + EndCreateTime string `json:"endCreateTime"` RequestType string `json:"requestType,omitempty"` IsItemSnEqual int `json:"isItemSnEqual,omitempty"` Page int `json:"page,omitempty"` @@ -655,7 +655,6 @@ func outAddGoods(token, proxy, formData string) (map[string]interface{}, error) // 获取图片URL(官图和拍图)带有店铺过滤 func outGetImageFilterShopId(token string, isbn string, shopId int, proxy string, isLiveImage int, isReturnMsg int) (map[string]string, error) { - fmt.Println("[DEBUG] 使用的ISBN: ", isbn) if isLiveImage == 0 { gtUrl := fmt.Sprintf("%s?keyword=%s", cf.API.BookSearchURL, isbn) request := gorequest.New() @@ -2873,6 +2872,7 @@ func updateAccountToken(id int64, token string) error { return err } +// =================== C 导出函数 ======================= // 登录(带有Out的都非官方标准接口) // //export OutLogin @@ -2980,15 +2980,15 @@ func OutGetGoodsTplMsg(token, itemId, proxy *C.char) *C.char { // 获取商品列表-已登的店铺(带有Out的都非官方标准接口) // //export OutGetGoodsListMsgFromSelfShop -func OutGetGoodsListMsgFromSelfShop(token, proxy, itemSn, priceMin, priceMax *C.char, startCreateTime C.int, - endCreateTime C.int, requestType *C.char, isItemSnEqual C.int, page C.int, size C.int) *C.char { +func OutGetGoodsListMsgFromSelfShop(token, proxy, itemSn, priceMin, priceMax *C.char, startCreateTime *C.char, + endCreateTime *C.char, requestType *C.char, isItemSnEqual C.int, page C.int, size C.int) *C.char { goToken := C.GoString(token) goProxy := C.GoString(proxy) goItemSn := C.GoString(itemSn) goPriceMin := C.GoString(priceMin) goPriceMax := C.GoString(priceMax) - goStartCreateTime := int(startCreateTime) - goEndCreateTime := int(endCreateTime) + goStartCreateTime := C.GoString(startCreateTime) + goEndCreateTime := C.GoString(endCreateTime) goRequestType := C.GoString(requestType) goIsItemSnEqual := int(isItemSnEqual) goPage := int(page) @@ -3054,7 +3054,7 @@ func OutDelGoodsFromSelfShop(token, proxy, itemId *C.char) *C.char { return C.CString(string(jsonData)) } -// 新增商品(带有Out的都非官方标准接口) +// 新增商品-已登的店铺(带有Out的都非官方标准接口) // //export OutAddGoods func OutAddGoods(token, proxy, formData *C.char) *C.char { @@ -3280,6 +3280,8 @@ func OutGetTopGoodsListMsg(catId C.int, proxy *C.char) *C.char { return C.CString(string(jsonData)) } +// 初始化配置 +// //export Initialize func Initialize(configJSON *C.char) *C.char { configStr := C.GoString(configJSON) diff --git a/md/csv.md b/md/csv.md new file mode 100644 index 0000000..6268a47 --- /dev/null +++ b/md/csv.md @@ -0,0 +1,249 @@ +# csv.dll 使用教程 +## 1.创建DLL工具实例 +### 加载DLL文件 +```gotemplate +// CsvDLL CSV文件工具DLL结构 +type csvDLL struct { + dll *syscall.DLL + openCSVFile *syscall.Proc // 打开/创建CSV文件 + readRows *syscall.Proc // 读取多行数据 + writeRows *syscall.Proc // 写入/覆盖行数据 + appendRows *syscall.Proc // 追加行数据 + getRowCount *syscall.Proc // 获取总行数 + findRows *syscall.Proc // 搜索行 + closeCSVFile *syscall.Proc // 关闭CSV文件 + mergeCSVFiles *syscall.Proc // 合并多个CSV文件 + getError *syscall.Proc // 获取错误信息 + freeCString *syscall.Proc // 释放C字符串 +} + +// 初始化csvDLL +func InitCsvDLL() (*csvDLL, error) { + dllPath := filepath.Join("dll", "csv.dll") + if _, err := os.Stat(dllPath); os.IsNotExist(err) { + return nil, fmt.Errorf("csv DLL 不存在: %s", dllPath) + } + if dll, err := syscall.LoadDLL(dllPath); err != nil { + return nil, fmt.Errorf("加载csv DLL 失败: %s", err) + } else { + return &csvDLL{ + dll: dll, + openCSVFile: dll.MustFindProc("OpenCSVFile"), + readRows: dll.MustFindProc("ReadRows"), + writeRows: dll.MustFindProc("WriteRows"), + appendRows: dll.MustFindProc("AppendRows"), + getRowCount: dll.MustFindProc("GetRowCount"), + findRows: dll.MustFindProc("FindRows"), + closeCSVFile: dll.MustFindProc("CloseCSVFile"), + mergeCSVFiles: dll.MustFindProc("MergeCSVFiles"), + getError: dll.MustFindProc("GetError"), + freeCString: dll.MustFindProc("FreeCString"), + }, nil + } +} + +dll,err := InitCsvDLL() +``` + +### 获取C字符串 +```gotemplate +// cStr 获取C字符串 +func (m *csvDLL) cStr(p uintptr) string { + if p == 0 { + return "" + } + b := []byte{} + for i := uintptr(0); ; i++ { + c := *(*byte)(unsafe.Pointer(p + i)) + if c == 0 { + break + } + b = append(b, c) + } + s := string(b) + if m.freeCString != nil { + m.freeCString.Call(p) + } + return s +} +``` + +## 2.使用dll函数示例 +```gotemplate +// 打开/创建CSV文件 +func (m *csvDLL) OpenCSVFile(filePath string, delimiter byte, hasHeader bool) (int64, error) { + proc, err := m.dll.FindProc("OpenCSVFile") + if err != nil { + return -1, fmt.Errorf("找不到函数 OpenCSVFile: %v", err) + } + filePathPtr, _ := syscall.BytePtrFromString(filePath) + hasHeaderInt := 0 + if hasHeader { + hasHeaderInt = 1 + } + info, _, _ := proc.Call( + uintptr(unsafe.Pointer(filePathPtr)), + uintptr(delimiter), + uintptr(hasHeaderInt)) + return int64(info), nil +} +``` + +# 接口详情 +## 1.打开/创建CSV文件(句柄)--OpenCSVFile +### 请求信息 +```gotemplate +dll.OpenCSVFile(filename,delimiter,hasHeader) +``` +### 请求参数 +| 参数名 | 类型 | 必填 | 说明 | +|--|--|--|----------| +| filename | string | 是 | 文件名称(带路径) | +| delimiter | string | 是 | 分隔符(如 ',') | +| hasHeader | string | 是 | 是否有标题行 | +### 响应示例 +``` +句柄：int64 +``` + +## 2.读取多行数据--ReadRows +### 请求信息 +```gotemplate +dll.ReadRows(handle,startRow,count,buffer) +``` +### 请求参数 +| 参数名 | 类型 | 必填 | 说明 | +|--|--------|--|---------------| +| handle | int64 | 是 | 文件句柄 | +| startRow | int64 | 是 | 起始行 | +| count | int64 | 是 | 总数 | +| buffer | []byte | 是 | 返回的文件数据信息byte | +### 响应示例 +``` +句柄：int64 +``` + +## 3.写入/覆盖行数据--WriteRows +### 请求信息 +```gotemplate +dll.WriteRows(handle,rowsData,header) +``` +### 请求参数 +| 参数名 | 类型 | 必填 | 说明 | +|--|--------|--|-----------------------| +| handle | int64 | 是 | 文件句柄 | +| rowsData | string | 是 | 写入的数据，[][]string转换成字符串 | +| header | int | 是 | 是否有文件头，0:有 | +### 响应示例 +``` +文件数据行数：int64 +``` + +## 4.追加行数据--AppendRows +### 请求信息 +```gotemplate +dll.AppendRows(handle,rowsData,rowCount) +``` +### 请求参数 +| 参数名 | 类型 | 必填 | 说明 | +|--|--------|--|----------------------------| +| handle | int64 | 是 | 文件句柄 | +| rowsData | []byte | 是 | 写入的数据，将[][]string转换成[]byte | +| rowCount | int | 是 | 数据行数 | +### 响应示例 +``` +文件数据行数：int64 +``` + +## 5.获取总行数--GetRowCount +### 请求信息 +```gotemplate +dll.GetRowCount(handle) +``` +### 请求参数 +| 参数名 | 类型 | 必填 | 说明 | +|--|--------|--|----------------------------| +| handle | int64 | 是 | 文件句柄 | +### 响应示例 +``` +文件总行数：int64 +``` + +## 6.搜索行--FindRows +### 请求信息 +```gotemplate +dll.FindRows(handle,searchText,columnIndex,resultBuffer,maxResults) +``` +### 请求参数 +| 参数名 | 类型 | 必填 | 说明 | +|--|--------|--|----------------------| +| handle | int64 | 是 | 文件句柄 | +| searchText | string | 是 | 要搜索的文本内容 | +| columnIndex | int64 | 是 | 指定搜索的列索引,索引从0开始 -1:表示搜索所有列 | +| resultBuffer | []byte | 是 | 结果缓冲区，用于存储找到的行索引 | +| maxResults | int64 | 是 | 限制最大返回结果数量 | +### 响应示例 +``` +实际找到的匹配行数：int64 +``` + +## 7.合并多个CSV文件(线程安全)--MergeCSVFiles +### 请求信息 +```gotemplate +dll.MergeCSVFiles(handlesPtr,handlesCount,outputFilename,delimiter,hasHeader) +``` +### 请求参数 +| 参数名 | 类型 | 必填 | 说明 | +|--|---------|--|----------------------------| +| handlesPtr | []int64 | 是 | 文件句柄数组 | +| handlesCount | string | 是 | 文件句柄数组长度 | +| columnIndex | int64 | 是 | 指定搜索的列索引,索引从0开始 -1:表示搜索所有列 | +| resultBuffer | []byte | 是 | 结果缓冲区，用于存储找到的行索引 | +| maxResults | int64 | 是 | 限制最大返回结果数量 | +### 响应示例 +``` +文件句柄：int64 +``` + +## 8.关闭文件--CloseCSVFile +### 请求信息 +```gotemplate +dll.MergeCSVFiles(handle) +``` +### 请求参数 +| 参数名 | 类型 | 必填 | 说明 | +|--|---------|--|-------------------------| +| handle | []int64 | 是 | 文件句柄 | +### 响应示例 +``` +结果：int64 0:表示成功 +``` + +## 8.获取错误信息--GetError +### 请求信息 +```gotemplate +dll.GetError(buffer) +``` +### 请求参数 +| 参数名 | 类型 | 必填 | 说明 | +|--|---------|--|-------------------------| +| buffer | []byte | 是 | 结果缓冲区，用于存储找到的行索引 | +### 响应示例 +``` +结果:int +``` + +## 9.释放C字符串内存--FreeCString +### 请求信息 +```gotemplate +dll.FreeCString(str) +``` +### 请求参数 +| 参数名 | 类型 | 必填 | 说明 | +|--|--|--|----------| +| str | string | 是 | 需要释放的字符串 | + + + + + diff --git a/md/image.md b/md/image.md new file mode 100644 index 0000000..9e19218 --- /dev/null +++ b/md/image.md @@ -0,0 +1,199 @@ +# image.dll 使用教程 +## 1.创建DLL工具实例 +### 加载DLL文件 +```gotemplate +// ImageDLL 图片处理DLL结构 +type imageDLL struct { + dll *syscall.DLL + processImage *syscall.Proc + freeCString *syscall.Proc +} + +// 初始化imageDLL +func InitImageDll() (*imageDLL, error) { + dllPath := filepath.Join("image", "dll", "image.dll") + if _, err := os.Stat(dllPath); os.IsNotExist(err) { + return nil, fmt.Errorf("image DLL 不存在: %s", dllPath) + } + if dll, err := syscall.LoadDLL(dllPath); err != nil { + return nil, fmt.Errorf("加载image DLL 失败: %s", err) + } else { + return &imageDLL{ + dll: dll, + processImage: dll.MustFindProc("ProcessImage"), + freeCString: dll.MustFindProc("FreeCString"), + }, nil + } +} + +dll,err := InitImageDll() +``` + +### 获取C字符串 +```gotemplate +// cStr 将 C 字符串指针转换为 Go 字符串 +func cStr(ptr uintptr) string { + if ptr == 0 { + return "" + } + var b []byte + for { + c := *(*byte)(unsafe.Pointer(ptr)) + if c == 0 { + break + } + b = append(b, c) + ptr++ + } + return string(b) +} +``` + +## 2.使用dll函数示例 +```gotemplate +func (m *imageDLL) ProcessImage(config *Config) error { + marshal, err := json.Marshal(config) + if err != nil { + return fmt.Errorf("json转换失败: %s", err) + } + fromString, _ := syscall.BytePtrFromString(string(marshal)) + info, _, _ := m.processImage.Call(uintptr(unsafe.Pointer(fromString))) + cStr(info) + return nil +} +``` + +# 接口详情 +## 1.检测图片纯白占比--ProcessImage +### 请求信息 +```gotemplate +dll.ProcessImage(jsonConfig) +``` +### 请求参数 +| 参数名 | 类型 | 必填 | 说明 | +|--|--|--|------------| +| jsonConfig | string | 是 | json字符串 | +### json字符串结构体 +```gotemplate +// Config 配置结构体 +type Config struct { + OutputDir string // 输出目录路径 + FileName string // 文件名 + MatchDir string // 满足条件的图片目录名 + UnmatchDir string // 不满足条件的图片目录名 + EqualHeightDir string // 等高的图片目录名 + WhiteDir string // 白色底图的图片目录名 + WhiteBorderPngDir string // 去白边转PNG的图片目录名 + MinWhitePct float64 // 纯白占比下限（0-1） + MaxWhitePct float64 // 纯白占比上限（0-1） + Extensions []string // 支持的图片扩展名 +} +``` +### 响应示例 +``` +string +``` + +## 2.根据原始图片生成新的白底图片--CreateWhiteBottomCenteredImage +### 请求信息 +```gotemplate +dll.CreateWhiteBottomCenteredImage(jsonConfig,width,height) +``` +### 请求参数 +| 参数名 | 类型 | 必填 | 说明 | +|--|--------|--|---------| +| jsonConfig | string | 是 | json字符串 | +| width | int | 是 | 宽度 | +| height | int | 是 | 高度 | +### json字符串结构体 +```gotemplate +// Config 配置结构体 +type Config struct { + OutputDir string // 输出目录路径 + FileName string // 文件名 + MatchDir string // 满足条件的图片目录名 + UnmatchDir string // 不满足条件的图片目录名 + EqualHeightDir string // 等高的图片目录名 + WhiteDir string // 白色底图的图片目录名 + WhiteBorderPngDir string // 去白边转PNG的图片目录名 + MinWhitePct float64 // 纯白占比下限（0-1） + MaxWhitePct float64 // 纯白占比上限（0-1） + Extensions []string // 支持的图片扩展名 +} +``` +### 响应示例 +``` +文件名称:string +``` + +## 3.根据高度生成等比例图片--ResizeToHeightQuality +### 请求信息 +```gotemplate +dll.ResizeToHeightQuality(jsonConfig,targetHeight) +``` +### 请求参数 +| 参数名 | 类型 | 必填 | 说明 | +|--|--------|--|---------| +| jsonConfig | string | 是 | json字符串 | +| targetHeight | int | 是 | 等比例高度 | +### json字符串结构体 +```gotemplate +// Config 配置结构体 +type Config struct { + OutputDir string // 输出目录路径 + FileName string // 文件名 + MatchDir string // 满足条件的图片目录名 + UnmatchDir string // 不满足条件的图片目录名 + EqualHeightDir string // 等高的图片目录名 + WhiteDir string // 白色底图的图片目录名 + WhiteBorderPngDir string // 去白边转PNG的图片目录名 + MinWhitePct float64 // 纯白占比下限（0-1） + MaxWhitePct float64 // 纯白占比上限（0-1） + Extensions []string // 支持的图片扩展名 +} +``` +### 响应示例 +``` +文件名称:string +``` + +## 4.去掉白边并转PNG图片工具--RemoveWhiteBorderAndPNG +### 请求信息 +```gotemplate +dll.RemoveWhiteBorderAndPNG(jsonConfig) +``` +### 请求参数 +| 参数名 | 类型 | 必填 | 说明 | +|--|--------|--|---------| +| jsonConfig | string | 是 | json字符串 | +### json字符串结构体 +```gotemplate +// Config 配置结构体 +type Config struct { + OutputDir string // 输出目录路径 + FileName string // 文件名 + MatchDir string // 满足条件的图片目录名 + UnmatchDir string // 不满足条件的图片目录名 + EqualHeightDir string // 等高的图片目录名 + WhiteDir string // 白色底图的图片目录名 + WhiteBorderPngDir string // 去白边转PNG的图片目录名 + MinWhitePct float64 // 纯白占比下限（0-1） + MaxWhitePct float64 // 纯白占比上限（0-1） + Extensions []string // 支持的图片扩展名 +} +``` +### 响应示例 +``` +文件名称:string +``` + +## 9.释放C字符串内存--FreeCString +### 请求信息 +```gotemplate +dll.FreeCString(str) +``` +### 请求参数 +| 参数名 | 类型 | 必填 | 说明 | +|--|--|--|----------| +| str | string | 是 | 需要释放的字符串 | + diff --git a/md/kongfz.md b/md/kongfz.md new file mode 100644 index 0000000..c53c06d --- /dev/null +++ b/md/kongfz.md @@ -0,0 +1,1597 @@ +# kongfz.dll 使用教程 + +## 1.创建DLL工具实例 + +### 加载DLL文件 +```gotemplate +// 加载DLL的函数 +type kongfzDLL struct { + dll *syscall.DLL + outLogin *syscall.Proc // 孔网登录 + outGetUserMsg *syscall.Proc // 获取孔网用户信息 + outGetGoodsTplMsg *syscall.Proc // 获取商品模版-已登的店铺 + outGetGoodsListMsgFromSelfShop *syscall.Proc // 获取商品列表-已登的店铺 + outAddGoods *syscall.Proc // 新增商品-已登的店铺 + outDelGoodsFromSelfShop *syscall.Proc // 删除商品-已登的店铺 + outGetImageFilterShopId *syscall.Proc // 获取孔网商品图片(官图和拍图)-带有店铺过滤 + outGetImageByIsbn *syscall.Proc // 获取孔网商品图片和信息(官图和拍图) + outGetGoodsListMsgByShopId *syscall.Proc // 获取商品列表通过店铺ID + outGetGoodsMsgByDetailUrl *syscall.Proc // 获取商品信息通过商品详情链接 + outGetTopGoodsListMsg *syscall.Proc // 获取销量榜商品列表 + freeCString *syscall.Proc // 释放C字符串内存 +} + +// 初始化kongfzDLL +func InitKongfzDLL() (*kongfzDLL, error) { + dllPath := filepath.Join("dll", "kongfz.dll") + if _, err := os.Stat(dllPath); os.IsNotExist(err) { + return nil, fmt.Errorf("kongfz DLL 不存在: %s", dllPath) + } + if dll, err := syscall.LoadDLL(dllPath); err != nil { + return nil, fmt.Errorf("加载 kongfz DLL 失败: %v", err) + } else { + return &kongfzDLL{ + dll: dll, + outLogin: dll.MustFindProc("OutLogin"), + outGetUserMsg: dll.MustFindProc("OutGetUserMsg"), + outGetGoodsTplMsg: dll.MustFindProc("OutGetGoodsTplMsg"), + outGetGoodsListMsgFromSelfShop: dll.MustFindProc("OutGetGoodsListMsgFromSelfShop"), + outAddGoods: dll.MustFindProc("OutAddGoods"), + outDelGoodsFromSelfShop: dll.MustFindProc("OutDelGoodsFromSelfShop"), + outGetImageFilterShopId: dll.MustFindProc("OutGetImageFilterShopId"), + outGetImageByIsbn: dll.MustFindProc("OutGetImageByIsbn"), + outGetGoodsListMsgByShopId: dll.MustFindProc("OutGetGoodsListMsgByShopId"), + outGetGoodsMsgByDetailUrl: dll.MustFindProc("OutGetGoodsMsgByDetailUrl"), + outGetTopGoodsListMsg: dll.MustFindProc("OutGetTopGoodsListMsg"), + freeCString: dll.MustFindProc("FreeCString"), + }, nil + } +} + +// main函数调用 +dll, err := InitKongfzDLL() +if err != nil { + fmt.Println(err) +} +``` + +### 获取C字符串 +```gotemplate +// cStr 获取C字符串 +func (m *kongfzDLL) cStr(p uintptr) string { + if p == 0 { + return "" + } + b := []byte{} + for i := uintptr(0); ; i++ { + c := *(*byte)(unsafe.Pointer(p + i)) + if c == 0 { + break + } + b = append(b, c) + } + s := string(b) + if m.freeCString != nil { + m.freeCString.Call(p) + } + return s +} +``` + +### 2.使用dll函数示例 +```gotemplate +// 获取商品模版 +func (m *kongfzDLL) OutGetGoodsTplMsg(token, itemId, proxy string) (string, error) { + proc, err := m.dll.FindProc("OutGetGoodsTplMsg") + if err != nil { + return "", fmt.Errorf("找不到函数 OutGetGoodsTplMsg 函数: %v", err) + } + tokenPtr, _ := syscall.BytePtrFromString(token) + itemIdPtr, _ := syscall.BytePtrFromString(itemId) + proxyPtr, _ := syscall.BytePtrFromString(proxy) + info, _, err := proc.Call( + uintptr(unsafe.Pointer(tokenPtr)), + uintptr(unsafe.Pointer(itemIdPtr)), + uintptr(unsafe.Pointer(proxyPtr))) + if err != nil && err.Error() != "The operation completed successfully." { + return "", fmt.Errorf("调用函数 OutGetGoodsTplMsg 失败: %v", err) + } + return m.cStr(info), nil +} +``` + +### 初始化配置信息(可以不调用) +```gotemplate +func main() { + // 使用默认配置初始化 + config := createDefaultConfig() + configJSON, err := json.Marshal(config) + if err != nil { + log.Fatalf("序列化配置失败: %v", err) + } + + result, err := manager.Initialize(string(configJSON)) + if err != nil { + log.Fatalf("初始化失败: %v", err) + } + + var initResp APIResponse + if err := json.Unmarshal([]byte(result), &initResp); err != nil { + log.Fatalf("解析初始化响应失败: %v", err) + } + + if !initResp.Success { + log.Fatalf("初始化失败: %s", initResp.Message) + } +} + +// 创建默认配置 +func createDefaultConfig() Config { + var config Config + // App配置 + config.App.MaxRetryTimes = 3 + config.App.RateLimitDelay = 1000 + config.App.Size = 10 + config.App.DefaultUserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36" + + // API配置 + config.API.LoginURL = "https://login.kongfz.com/Pc/Login/account" + config.API.BookSearchURL = "https://search.kongfz.com/pc-gw/search-web/client/pc/bookLib/keyword/list" + config.API.ProductSearchURL = "https://search.kongfz.com/pc-gw/search-web/client/pc/product/keyword/list" + + // 代理配置（需要根据实际情况修改） + config.Proxy.Servers = "http-dynamic.xiaoxiangdaili.com,http-dynamic-S02.xiaoxiangdaili.com,http-dynamic-S03.xiaoxiangdaili.com,http-dynamic-S04.xiaoxiangdaili.com" + config.Proxy.Username = "1297757178467602432" + config.Proxy.Password = "QgQBvP7f" + config.Proxy.TailMachineCode = "b7bf22a237ec692f13fcc2c43ee63252" + config.Proxy.TailCardKey = "DL_20_YK_1920acb2129844c2aabade3896560a9b" + config.Proxy.ProxyFilePath = "dll/proxyConfig.dll" + + config.Database.Username = "newAdmin" + config.Database.Password = "bYPp8SbBe5F7nz2i" + config.Database.Host = "146.56.227.42:3306" + config.Database.Name = "newadmin" + return config +} +``` + +## 2.配置结构体(可以不调用) +```gotemplate +type Config struct { + App struct { + MaxRetryTimes int `json:"max_retry_times"` + RateLimitDelay int `json:"rate_limit_delay"` + Size int `json:"size"` + DefaultUserAgent string `json:"default_user_agent"` + } `json:"app"` + + API struct { + LoginURL string `json:"login_url"` + BookSearchURL string `json:"book_search_url"` + ProductSearchURL string `json:"product_search_url"` + } `json:"api"` + + Proxy struct { + Servers string `json:"servers"` + Username string `json:"username"` + Password string `json:"password"` + TailMachineCode string `json:"tail_machine_code"` + TailCardKey string `json:"tail_card_key"` + ProxyFilePath string `json:"proxy_file_path"` + } `json:"proxy"` +} +``` + +# 接口详情 +## 1.孔网登录--OutLogin +### 请求信息 +```gotemplate +dll.OutLogin(username, password) +``` +### 请求参数 +| 参数名 | 类型 | 必填 | 说明 | +|--|--|--|--| +| username | string | 是 | 登录用户名 | +| password | string | 是 | 登录密码 | +### 响应示例 +```json +{ + "success": true, + "message": "", + "data": { + "token": "abc123def456" + } +} +``` + +## 2.获取孔网用户信息--OutGetUserMsg +### 请求信息 +```gotemplate +dll.OutGetUserMsg(token) +``` +### 请求参数 +| 参数名 | 类型 | 必填 | 说明 | +|--|--|--|--| +| token | string | 是 | 登录凭证 | +### 响应示例 +```json +{ + "success": true, + "message": "", + "data": { + "userId": 123456, + "nickname": "用户昵称", + "mobile": "13800138000" + } +} +``` + +## 3.获取商品模版-已登的店铺--OutGetGoodsTplMsg +### 请求信息 +```gotemplate +dll.OutGetGoodsTplMsg(token, proxy, itemId) +``` +### 请求参数 +| 参数名 | 类型 | 必填 | 说明 | +|--|--|----|--| +| token | string | 是 | 登录凭证 | +| proxy | string | 否 | 代理地址 | +| itemId | string | 是 | 商品ID | +### 响应示例 +```json +{ + "success": true, + "message": "", + "data": { + "status": 1, + "data": { + "categorySection": { + "key": "catId", + "name": "分类", + "value": "58012000000000000", + "catName": "收藏杂项 > 其他杂项", + "inputType": "other", + "title": "", + "tips": "", + "unit": "", + "check": { + "type": "categorySelect", + "status": 0, + "isRequired": 1 + }, + "isValid": true + }, + "goodsSection": [ + { + "key": "itemName", + "name": "商品名称", + "value": "鎏金降魔杵 全品", + "inputType": "textarea", + "title": "请填写商品名称", + "tips": "请填写商品名称", + "unit": "", + "explain": "", + "check": { + "type": "string", + "status": 0, + "isRequired": 1, + "maxLen": 200 + } + }, + { + "key": "author", + "name": "制作者", + "value": "未知", + "inputType": "text", + "title": "请填写制作者", + "tips": "请填写制作者", + "unit": "", + "explain": "", + "check": { + "type": "string", + "status": 0, + "isRequired": 0, + "maxLen": 120 + } + }, + { + "key": "yearsGroup", + "name": "年代", + "value": "2", + "inputType": "yearsGroup", + "title": "请填写时间或选择年代", + "tips": "", + "unit": "", + "check": { + "type": "radio", + "status": 0, + "isRequired": 0 + }, + "options": [ + { + "name": "填写时间", + "value": "1", + "group": [ + { + "key": "pubDate", + "name": "年代", + "value": "", + "inputType": "dateGroup", + "title": "请填写年代", + "tips": "请填写年代", + "unit": "", + "check": { + "type": "date", + "status": 0, + "isRequired": 0, + "enableUnknow": false, + "maxDate": "2026-12" + }, + "group": [ + { + "key": "pubDateYear", + "name": "年份", + "value": "", + "leftWords": "hidden", + "inputType": "int", + "title": "请填写年份", + "tips": "请填写年份", + "unit": "年", + "explain": "", + "check": { + "type": "int", + "status": 0, + "isRequired": 0, + "min": 0, + "max": 2026 + } + }, + { + "key": "pubDateMonth", + "name": "月份", + "value": "", + "leftWords": "hidden", + "inputType": "int", + "title": "请填写月份", + "tips": "请填写月份", + "unit": "月", + "explain": "", + "check": { + "type": "int", + "status": 0, + "isRequired": 0, + "min": 1, + "max": 12 + } + } + ] + } + ] + }, + { + "name": "选择年代", + "value": "2", + "group": [ + { + "key": "years", + "name": "年代", + "value": 0, + "inputType": "yearsSelect", + "title": "请选择年代", + "tips": "", + "unit": "", + "check": { + "type": "yearsSelect", + "status": 0, + "isRequired": 0 + } + } + ] + } + ] + }, + { + "key": "material", + "name": "材质", + "value": "金属", + "inputType": "text", + "title": "请填写材质", + "tips": "请填写材质", + "unit": "", + "explain": "", + "check": { + "type": "string", + "status": 0, + "isRequired": 0, + "maxLen": 10 + } + }, + { + "key": "size", + "name": "尺寸", + "value": "", + "inputType": "row", + "isRequired": 0, + "title": "请填写尺寸", + "tips": "请填写尺寸", + "group": [ + { + "key": "sizeLength", + "name": "长度", + "value": "6", + "leftWords": "长", + "inputType": "float", + "title": "请填写长度", + "tips": "请填写长度", + "unit": "cm", + "check": { + "type": "float", + "status": 0, + "isRequired": 1, + "min": 0.01, + "max": 99999.99, + "decimals": 2 + } + }, + { + "key": "sizeWidth", + "name": "宽度", + "value": "2", + "leftWords": "宽", + "inputType": "float", + "title": "请填写宽度", + "tips": "请填写宽度", + "unit": "cm", + "check": { + "type": "float", + "status": 0, + "isRequired": 1, + "min": 0.01, + "max": 99999.99, + "decimals": 2 + } + }, + { + "key": "sizeHeight", + "name": "高度", + "value": "3", + "leftWords": "高", + "inputType": "float", + "title": "请填写高度", + "tips": "请填写高度", + "unit": "cm", + "check": { + "type": "float", + "status": 0, + "isRequired": 0, + "min": 0.01, + "max": 99999.99, + "decimals": 2 + } + } + ] + }, + { + "key": "quality", + "name": "品相", + "value": "95", + "inputType": "select", + "options": [ + { + "name": "全新", + "value": 100 + }, + { + "name": "九五品", + "value": 95 + }, + { + "name": "九品", + "value": 90 + }, + { + "name": "八五品", + "value": 85 + }, + { + "name": "八品", + "value": 80 + }, + { + "name": "七五品", + "value": 75 + }, + { + "name": "七品", + "value": 70 + }, + { + "name": "六五品", + "value": 65 + }, + { + "name": "六品", + "value": 60 + }, + { + "name": "五品", + "value": 50 + }, + { + "name": "四品", + "value": 40 + }, + { + "name": "三品", + "value": 30 + }, + { + "name": "二品", + "value": 20 + }, + { + "name": "一品", + "value": 10 + } + ], + "title": "请选择品相", + "tips": "", + "unit": "", + "check": { + "type": "select", + "status": 0, + "isRequired": 1 + } + }, + { + "key": "qualityDesc", + "name": "品相描述", + "value": "老好了", + "inputType": "textarea", + "title": "请填写品相描述", + "tips": "请填写品相描述", + "unit": "", + "explain": "", + "check": { + "type": "string", + "status": 0, + "isRequired": 0, + "maxLen": 400 + } + }, + { + "key": "price", + "name": "售价", + "value": "1467.00", + "leftWords": "", + "inputType": "float", + "title": "请填写售价", + "tips": "请填写售价", + "unit": "元", + "check": { + "type": "float", + "status": 0, + "isRequired": 1, + "min": 0.01, + "max": 99999999.99, + "decimals": 2 + } + }, + { + "key": "number", + "name": "库存数量", + "value": "1", + "leftWords": "", + "inputType": "int", + "title": "请填写库存数量", + "tips": "请填写库存数量", + "unit": "件", + "explain": "", + "check": { + "type": "int", + "status": 0, + "isRequired": 0, + "min": 0, + "max": 9999 + } + }, + { + "key": "itemSn", + "name": "货号", + "value": "", + "inputType": "text", + "title": "请填写货号", + "tips": "请填写货号", + "unit": "", + "explain": "", + "check": { + "type": "string", + "status": 0, + "isRequired": 0, + "maxLen": 20 + } + }, + { + "key": "myCatId", + "name": "本店分类", + "value": "", + "inputType": "select", + "options": [], + "title": "请选择本店分类", + "tips": "", + "unit": "", + "check": { + "type": "select", + "status": 0, + "isRequired": 0 + } + }, + { + "key": "itemDesc", + "name": "详细描述", + "value": "", + "inputType": "textarea", + "title": "请填写详细描述", + "tips": "请填写详细描述", + "unit": "", + "explain": "", + "check": { + "type": "string", + "status": 0, + "isRequired": 0, + "maxLen": 10000 + } + }, + { + "key": "images", + "name": "图片", + "inputType": "images", + "title": "请填写图片", + "tips": "图片格式为jpg、png、gif、jpeg，图片大小不能超过10M，一次可以选择多张上传，最多上传30张，拖拽调整顺序。", + "unit": "", + "value": "", + "images": [ + { + "imgId": 239722, + "imgType": 0, + "isMain": 1, + "imgUrl": "sw/kfz-cos/kfzimg/24175337/00fff0d9a9dbb89c_s.jpg", + "imgSrc": "https://www0.kfzimg.com/sw/kfz-cos/kfzimg/24175337/00fff0d9a9dbb89c_s.jpg", + "imgSrcMiddle": "https://www0.kfzimg.com/sw/kfz-cos/kfzimg/24175337/00fff0d9a9dbb89c_n.jpg", + "imgSrcBig": "https://www0.kfzimg.com/sw/kfz-cos/kfzimg/24175337/00fff0d9a9dbb89c_b.jpg", + "imgDesc": "", + "imgTag": [] + } + ], + "batchKey": "img", + "check": { + "type": "images", + "status": 0, + "isRequired": 1, + "descMaxLen": 300, + "minNum": 1, + "maxNum": 30, + "appMaxSize": "2MB", + "appMaxWidth": "1200", + "pcMaxSize": "10MB" + } + }, + { + "key": "isOnSale", + "name": "货架状态", + "value": "1", + "inputType": "radio", + "title": "", + "tips": "", + "unit": "", + "check": { + "type": "radio", + "status": -1, + "isRequired": 1 + }, + "options": [ + { + "name": "直接上架", + "value": "1" + }, + { + "name": "暂时下架", + "value": "0" + } + ] + }, + { + "key": "itemId", + "name": "商品编号", + "value": 9250897118, + "inputType": "hidden", + "title": "", + "tips": "", + "unit": "" + }, + { + "key": "oldCatId", + "name": "原商品分类", + "value": "58012000000000000", + "inputType": "hidden", + "title": "", + "tips": "", + "unit": "" + }, + { + "key": "oldPrice", + "name": "原商品价格", + "value": "1467.00", + "inputType": "hidden", + "title": "", + "tips": "", + "unit": "" + }, + { + "key": "tpl", + "name": "模板编号", + "value": 12, + "inputType": "hidden", + "title": "", + "tips": "", + "unit": "" + } + ], + "deliverSection": [ + { + "key": "deliverTimeGroup", + "name": "发货模式", + "value": "1", + "inputType": "ridio", + "title": "发货模式", + "tips": "", + "unit": "", + "check": { + "type": "radio", + "status": 0, + "isRequired": 1 + }, + "options": [ + { + "name": "现货模式", + "value": "1", + "key": "deliverTypeInStock", + "group": [ + { + "key": "deliverTime", + "name": "发货时间", + "value": "48h", + "inputType": "radio", + "title": "发货时间", + "tips": "", + "unit": "", + "check": { + "type": "radio", + "status": 0, + "isRequired": 1 + }, + "options": [ + { + "name": "当日发", + "value": "today", + "tips": "买家在16点前付款当日24点前发货；16点后付款次日24点前发货；且在发货24小时内返回物流轨迹。" + }, + { + "name": "24小时", + "value": "24h", + "tips": "买家付款后24小时内发货，且在发货24小时内返回物流轨迹。" + }, + { + "name": "48小时", + "value": "48h" + } + ] + } + ] + } + ] + }, + { + "key": "isDeliverTimeDefault", + "name": "设为默认发货时间", + "value": "48h", + "inputType": "hidden" + } + ], + "shippingSection": [ + { + "key": "bearShipping", + "name": "", + "value": "buyer", + "inputType": "radio", + "options": [ + { + "name": "卖家承担运费", + "tips": "(必须支持快递)", + "value": "seller" + }, + { + "name": "运费模板", + "value": "buyer" + } + ], + "title": "请选择", + "tips": "", + "unit": "", + "check": { + "type": "radio", + "status": 0, + "isRequired": 1 + } + }, + { + "key": "isUseMould", + "name": "是否使用运费模板", + "value": "1", + "inputType": "hidden", + "title": "", + "tips": "", + "unit": "" + }, + { + "key": "mouldId", + "name": "运费模板", + "value": 975623, + "inputType": "select", + "title": "请选择运费模板", + "tips": "为了提升消费者购物体验，方便您计算运费，买家承担运费的商品均需使用运费模板，如何使用模板，[url=]查看视频教程[/url]", + "unit": "", + "check": { + "type": "shippingMouldSelect", + "status": 0, + "isRequired": 1 + }, + "shipping": [], + "shopProductArea": 1001000000, + "mouldList": [ + { + "mouldId": "975623", + "mouldName": "模板1", + "isTransfer": "0", + "isDefault": "0", + "isAppMould": "0", + "feeManner": "weight", + "productArea": "1001000000", + "mouldInfo": { + "mouldId": "975623", + "userId": "24175337", + "mouldName": "模板1", + "productArea": "1001000000", + "feeManner": "weight", + "sortOrder": [ + "express" + ], + "enableShipping": "express", + "dataMd5": "", + "isDefault": "0", + "isAppMould": "0", + "description": "", + "smartMouldId": "0", + "shipmentType": "0", + "provId": "1000000000", + "provName": "北京", + "cityId": "1001000000", + "cityName": "东城", + "feeList": { + "express": { + "enabled": true, + "name": "快递", + "special": [ + { + "feeId": 8587228, + "area": [ + { + "provId": "1000000000", + "provName": "北京", + "cities": [] + } + ], + "areaDivide": "china", + "initialNum": 1, + "addNum": 1, + "addFee": "5.00", + "initialFee": "5.00", + "registerFee": "0.00" + }, + { + "feeId": 8587229, + "area": [ + { + "provId": "3000000000", + "provName": "天津", + "cities": [] + }, + { + "provId": "12000000000", + "provName": "河北", + "cities": [] + } + ], + "areaDivide": "china", + "initialNum": 1, + "addNum": 1, + "addFee": "5.00", + "initialFee": "5.00", + "registerFee": "0.00" + }, + { + "feeId": 8587230, + "area": [ + { + "provId": "2000000000", + "provName": "上海", + "cities": [] + }, + { + "provId": "18000000000", + "provName": "江苏", + "cities": [] + }, + { + "provId": "31000000000", + "provName": "浙江", + "cities": [] + }, + { + "provId": "5000000000", + "provName": "安徽", + "cities": [] + }, + { + "provId": "19000000000", + "provName": "江西", + "cities": [] + }, + { + "provId": "25000000000", + "provName": "山西", + "cities": [] + }, + { + "provId": "24000000000", + "provName": "山东", + "cities": [] + }, + { + "provId": "21000000000", + "provName": "内蒙古", + "cities": [] + }, + { + "provId": "16000000000", + "provName": "湖南", + "cities": [] + }, + { + "provId": "15000000000", + "provName": "湖北", + "cities": [] + }, + { + "provId": "13000000000", + "provName": "河南", + "cities": [] + }, + { + "provId": "8000000000", + "provName": "广东", + "cities": [] + }, + { + "provId": "9000000000", + "provName": "广西", + "cities": [] + }, + { + "provId": "6000000000", + "provName": "福建", + "cities": [] + }, + { + "provId": "11000000000", + "provName": "海南", + "cities": [] + }, + { + "provId": "20000000000", + "provName": "辽宁", + "cities": [] + }, + { + "provId": "17000000000", + "provName": "吉林", + "cities": [] + }, + { + "provId": "14000000000", + "provName": "黑龙江", + "cities": [] + }, + { + "provId": "26000000000", + "provName": "陕西", + "cities": [] + }, + { + "provId": "7000000000", + "provName": "甘肃", + "cities": [] + }, + { + "provId": "22000000000", + "provName": "宁夏", + "cities": [] + }, + { + "provId": "23000000000", + "provName": "青海", + "cities": [] + }, + { + "provId": "4000000000", + "provName": "重庆", + "cities": [] + }, + { + "provId": "30000000000", + "provName": "云南", + "cities": [] + }, + { + "provId": "10000000000", + "provName": "贵州", + "cities": [] + }, + { + "provId": "27000000000", + "provName": "四川", + "cities": [] + } + ], + "areaDivide": "china", + "initialNum": 1, + "addNum": 1, + "addFee": "5.00", + "initialFee": "5.00", + "registerFee": "0.00" + }, + { + "feeId": 8587231, + "area": [ + { + "provId": "29000000000", + "provName": "新疆", + "cities": [] + }, + { + "provId": "28000000000", + "provName": "西藏", + "cities": [] + } + ], + "areaDivide": "china", + "initialNum": 1, + "addNum": 1, + "addFee": "30.00", + "initialFee": "30.00", + "registerFee": "0.00" + }, + { + "feeId": 8587232, + "area": [ + { + "provId": "34000000000", + "provName": "香港", + "cities": [] + }, + { + "provId": "32000000000", + "provName": "澳门", + "cities": [] + }, + { + "provId": "33000000000", + "provName": "台湾", + "cities": [] + }, + { + "provId": "40000000000", + "provName": "海外", + "cities": [] + } + ], + "areaDivide": "outChinaDefault", + "initialNum": 0, + "addNum": 0, + "addFee": "0.00", + "initialFee": "0.00", + "registerFee": 0 + } + ] + } + } + }, + "shipmentType": "0" + } + ] + }, + { + "key": "weight", + "name": "物流重量", + "value": "0.5", + "leftWords": "", + "inputType": "float", + "title": "请填写物流重量", + "tips": "请填写物流重量", + "unit": "千克", + "check": { + "type": "float", + "status": 0, + "isRequired": 1, + "min": 0.01, + "max": 9999.99, + "decimals": 2 + } + }, + { + "key": "weightPiece", + "name": "物流标准本数", + "value": "1", + "leftWords": "", + "inputType": "float", + "title": "请填写物流标准本数", + "tips": "请填写物流标准本数", + "unit": "本", + "check": { + "type": "float", + "status": 0, + "isRequired": 1, + "min": 0.01, + "max": 9999.99, + "decimals": 2 + } + } + ], + "isDraft": 0 + }, + "message": "", + "errType": "" + } +} +``` + +## 4.获取商品列表-已登的店铺--OutGetGoodsListMsgFromSelfShop +### 请求信息 +```gotemplate +dll.OutGetGoodsListMsgFromSelfShop(token, proxy, itemSn, priceMin, priceMax, +startCreateTime, endCreateTime, requestType, +isItemSnEqual, page, size) +``` +### 请求参数 + +| 参数名 | 类型 | 必填 | 说明 | +|--|--------|----|-----------------| +| token | string | 是 | 登录凭证 | +| proxy | string | 否 | 代理地址 | +| itemSn | string | 是 | 店铺货号 | +| priceMin | string | 否 | 最低价格 | +| priceMax | string | 否 | 最高价格 | +| startCreateTime | string | 否 | 上书开始时间 | +| endCreateTime | string | 否 | 上书结束时间 | +| requestType | string | 是 | 请求类型 onSale:出售中 | +| isItemSnEqual | int | 是 | 验证货号 填 0 就行 | +| page | int | 是 | 页码 | +| size | int | 是 | 每页数量 | +### 响应示例 +```json +{ + "success": true, + "message": "", + "data": { + "status": true, + "errCode": 0, + "errMessage": "", + "result": { + "productInfoPageResult": { + "list": [ + { + "name": "鎏金降魔杵 全品", + "qualityName": "九五品", + "quality": 95, + "price": 1467.00, + "realPrice": 1467.00, + "number": 1, + "mouldName": "模板1", + "feeManner": "0.5千克", + "weight": 0.5, + "weightPiece": 0.0, + "mouldId": 975623, + "imageUrl": "https://www0.kfzimg.com/sw/kfz-cos/kfzimg/24175337/00fff0d9a9dbb89c_s.jpg", + "imageSrc": "https://www0.kfzimg.com/sw/kfz-cos/kfzimg/24175337/00fff0d9a9dbb89c_s.jpg", + "createTime": "2025-12-11 11:42", + "updateTime": "2025-12-11 11:43", + "itemId": 9250897118, + "catId": 58012000000000000, + "catName": "收藏杂项 > 其他杂项", + "tpl": 12, + "itemSn": "", + "discount": 100, + "certifyStatus": "certified", + "isOnSale": 1, + "certifyStatusName": "出售中", + "soldNumber": null, + "soldAmount": null, + "soldTime": null, + "operateList": null, + "shareInfo": null, + "isSyncISBN": 0, + "deliverType": 1, + "deliverTime": "48h", + "isDraft": 0 + } + ], + "pager": { + "page": 1, + "size": 100, + "total": 1, + "pages": 1 + } + }, + "productStatCount": { + "allUnSold": 3, + "onSale": 1, + "zeroStock": 0, + "offSale": 2, + "needApproved": 0, + "soldCount": null + }, + "productListStat": { + "count": 1, + "itemNum": 1, + "amount": "1467.00" + } + } + } +} +``` + +## 5.新增商品-已登的店铺--OutAddGoods +### 请求信息 +```gotemplate +dll.OutAddGoods(token, proxy, formData) +``` +### 请求参数 +| 参数名 | 类型 | 必填 | 说明 | +|--|--------|----|----------------| +| token | string | 是 | 登录凭证 | +| proxy | string | 否 | 代理地址 | +| formData | string | 是 | 新增商品信息的json字符串 | +### 响应示例 +```json +{ + "success": true, + "message": "", + "data": { + "status":1, + "data":9279010923, + "message":"", + "errType":"" + } +} +``` + +## 6.删除商品-已登的店铺--OutDelGoodsFromSelfShop +### 请求信息 +```gotemplate +dll.OutDelGoodsFromSelfShop(token, proxy, itemId) +``` +### 请求参数 +| 参数名 | 类型 | 必填 | 说明 | +|--|--------|----|------| +| token | string | 是 | 登录凭证 | +| proxy | string | 否 | 代理地址 | +| itemId | string | 是 | 店铺ID | +### 响应示例 +```json +{ + "success": true, + "message": "", + "data": { + "status":true, + "errCode":0, + "errMessage":"", + "result":true + } +} +``` + +## 7.获取孔网商品图片(官图和拍图)-带有店铺过滤--OutGetImageFilterShopId +### 请求信息 +```gotemplate +dll.OutGetImageFilterShopId(token, proxy, isbn, shopId, isLiveImage, isReturnMsg) +``` +### 请求参数 +| 参数名 | 类型 | 必填 | 说明 | +|--|--------|----|----------------------| +| token | string | 是 | 登录凭证 | +| proxy | string | 否 | 代理地址 | +| isbn | string | 是 | ISBN | +| shopId | int | 是 | 店铺ID | +| isLiveImage | int | 是 | 需要官图还是实拍图 0:官图 1:实拍图 | +| isReturnMsg | int | 否 | 是否需要详细信息 0:是 1:否 | +### 响应示例 +```json +{ + "success": true, + "message": "", + "data": { + "book_name": "", + "book_pic": "", + "book_pic_s": "", + "isbn": "" + } +} +``` + +## 8.获取孔网商品图片和信息(官图和拍图)--OutGetImageByIsbn +### 请求信息 +```gotemplate +dll.OutGetImageByIsbn(token, proxy,isbn, isLiveImage, isReturnMsg) +``` +### 请求参数 +| 参数名 | 类型 | 必填 | 说明 | +|--|--------|----|----------------------| +| token | string | 是 | 登录凭证 | +| proxy | string | 否 | 代理地址 | +| isbn | string | 是 | ISBN | +| isLiveImage | int | 是 | 需要官图还是实拍图 0:官图 1:实拍图 | +| isReturnMsg | int | 是 | 是否需要详细信息 0:是 1:否 | +### 响应示例 +```json +{ + "success": true, + "message": "", + "data": { + "author": "", + "publisher": "", + "isbn": "", + "publication_time": 0, + "edition": "", + "print_time": "", + "fix_price": "", + "binding_layout": "", + "format": "", + "paper": "", + "pages": "", + "wordage": "", + "languages": "", + "era": "", + "engraving_method": "", + "dimensions": "", + "volume_number": "", + "book_pic": "", + "book_pic_s": "", + "selling_price": "", + "condition": "", + "express_delivery_fee": "", + "editor": "", + "category": "", + "buy_count": "", + "sell_count": "", + "content": "", + "mid": 0, + "item_id": 0, + "shop_id": 0, + "detail_url": "" + } +} +``` + +## 9.获取商品列表通过店铺ID--OutGetGoodsListMsgByShopId +### 请求信息 +```gotemplate +dll.OutGetGoodsListMsgByShopId( +shopId, proxy, retPrice, isImage, sortType, +sort, priceMin, priceMax, pageNum, returnNum) +``` +### 请求参数 +| 参数名 | 类型 | 必填 | 说明 | +|--|--|---|--| +| shopId | int | 是 | 店铺ID | +| proxy | string | 否 | 代理地址 | +| retPrice | int | 否 | 是否返回价格 | +| isImage | int | 否 | 是否有图片 | +| sortType | string | 否 | 排序类型 | +| sort | string | 否 | 排序方式 | +| priceMin | float | 否 | 最低价格 | +| priceMax | float | 否 | 最高价格 | +| pageNum | int | 否 | 页码 | +| returnNum | int | 否 | 每页数量 | +### 响应示例 +```json +{ + "success": true, + "message": "", + "data": { + "goods_num": "", + "pnum": "", + "book_info": [{ + "author": "", + "publisher": "", + "isbn": "", + "publication_time": 0, + "edition": "", + "print_time": "", + "fix_price": "", + "binding_layout": "", + "format": "", + "paper": "", + "pages": "", + "wordage": "", + "languages": "", + "era": "", + "engraving_method": "", + "dimensions": "", + "volume_number": "", + "book_pic": "", + "book_pic_s": "", + "selling_price": "", + "condition": "", + "express_delivery_fee": "", + "editor": "", + "category": "", + "buy_count": "", + "sell_count": "", + "content": "", + "mid": 0, + "item_id": 0, + "shop_id": 0, + "detail_url": "" + }] + } +} +``` + +## 10.获取商品信息通过商品详情链接--OutGetGoodsMsgByDetailUrl +### 请求信息 +```gotemplate +dll.OutGetGoodsMsgByDetailUrl(detailUrl,proxy) +``` +### 请求参数 +| 参数名 | 类型 | 必填 | 说明 | +|--|--------|---|-----------| +| detailUrl | string | 是 | 请求详情页的url | +| proxy | string | 否 | 代理地址 | +### 响应示例 +```json +{ + "success": true, + "message": "", + "data": { + "author": "", + "publisher": "", + "isbn": "", + "publication_time": 0, + "edition": "", + "print_time": "", + "fix_price": "", + "binding_layout": "", + "format": "", + "paper": "", + "pages": "", + "wordage": "", + "languages": "", + "era": "", + "engraving_method": "", + "dimensions": "", + "volume_number": "", + "book_pic": "", + "book_pic_s": "", + "selling_price": "", + "condition": "", + "express_delivery_fee": "", + "editor": "", + "category": "", + "buy_count": "", + "sell_count": "", + "content": "", + "mid": 0, + "item_id": 0, + "shop_id": 0, + "detail_url": "" + } +} +``` + +## 11.获取销量榜商品列表--OutGetTopGoodsListMsg +### 请求信息 +```gotemplate +dll.OutGetTopGoodsListMsg(catId,proxy) +``` +### 请求参数 +| 参数名 | 类型 | 必填 | 说明 | +|--|--------|---|---------| +| catId | int | 是 | 销量榜类型ID | +| proxy | string | 否 | 代理地址 | +### 响应示例 +```json +{ + "success": true, + "message": "", + "data": { + "status": true, + "result": { + "current": 1, + "data": [ + { + "author": "吴承恩 著", + "bookName": "西游记", + "contentIntroduction": "在中国古代小说中，《西游记（评注本）》是一部思想性和艺术性都臻于第一流的伟大作品。它也是明代长篇小说的重要流派之一神魔小说的代表作，是中国古代神魔小说的翘楚、浪漫文学的代表，作者以其丰富的艺术想象力建构了一个光怪陆离的神话世界，并塑造出以孙悟空、猪八戒为代表的一批性格鲜明、影响深远的文学形象，数百年来一直为人们所喜闻乐见。《西游记（评注本）》主要描写的是孙悟空保唐僧西天取经，历经九九八十一难的故事", + "imgUrl": "https://booklibimg.kfzimg.com/data/book_lib_img_v2/isbn/1/536c/536c60e36e75bf67f43d790901fc0fe2_0_1_300_300.jpg", + "isbn": "9787540310097", + "itemUrls": { + "appUrl": "kongfz://app.kongfz.com?page=isbnDetail&mid=52528207", + "mUrl": "https://m.kongfz.com/item/52528207/", + "miniUrl": "/pages/bookdetail/bookdetail?mid=52528207", + "pcUrl": "https://item.kongfz.com/book/52528207.html" + }, + "mid": 52528207, + "newMinPrice": "3.45", + "oldMinPrice": "0.20", + "press": "崇文书局", + "price": "15.00", + "pubDate": "2006-05", + "riseTag": "", + "authorArr": [ + { + "name": "吴承恩", + "oriName": "", + "nationality": "", + "role": "著", + "url": "https://search.kongfz.com/item_result/?status=0&select=2&author=hk5434k627fk6069" + } + ], + "pressUrl": "https://search.kongfz.com/item_result/?status=0&press=hk5d07k6587k4e66k5c40" + } + ], + "total": 100 + }, + "errMessage": "", + "errCode": 0 + } +} +``` + +## 12.初始化--Initialize(可以不调用) +### 请求信息 +```gotemplate +result, err := dll.Initialize(configJSON) +``` +### 请求参数 + +| 参数名 | 类型 | 必填 | 说明 | +|--|--|--|----------------| +| configJSON | string | 是 | 配置信息的 JSON 字符串 | + +### 响应示例 +```json +{ + "success": true, + "message": "初始化成功" +} +``` + +## 12.释放C字符串内存--FreeCString +### 请求信息 +```gotemplate +dll.FreeCString(str) +``` +### 请求参数 +| 参数名 | 类型 | 必填 | 说明 | +|--|--|--|----------| +| str | string | 是 | 需要释放的字符串 | diff --git a/md/main.md b/md/main.md deleted file mode 100644 index dd79989..0000000 --- a/md/main.md +++ /dev/null @@ -1,736 +0,0 @@ -# 针对kongfz.dll文件使用教程 -## 1.需要先创建dll工具实例 - -### 1. 加载DLL，用于调用dll文件，代码示例： -```go -func main(){ - // 加载DLL - manager, err := NewDLLManager("main.dll") - if err != nil { - log.Fatalf("初始化DLL管理器失败: %v", err) - } - // 确保字段被释放，但是需要注意，如果加这个，可能把你的dll文件释放掉了，导致程序崩溃 - defer manager.Close() -} - - -type DLLManager struct { - dll *syscall.DLL -} - -func NewDLLManager(dllPath string) (*DLLManager, error) { - dll, err := syscall.LoadDLL(dllPath) - if err != nil { - return nil, fmt.Errorf("加载DLL失败: %v", err) - } - return &DLLManager{dll: dll}, nil -} - -func (m *DLLManager) Close() { - if m.dll != nil { - m.dll.Release() - } -} -func (m *DLLManager) Initialize(configJSON string) (string, error) { - return m.callFunction("Initialize", configJSON) -} - -// 修改后的 GetKFZGTImageURL - 需要5个参数 -func (m *DLLManager) GetKFZGTImageURL(proxyType, username, password, machineCode, isbn string) (string, error) { - return m.callFunctionFiveArgs("GetKFZGTImageURL", - proxyType, username, password, machineCode, isbn) -} - -// 修改后的 GetKFZSPTImageURL - 需要5个参数 -func (m *DLLManager) GetKFZSPTImageURL(proxyType, username, password, machineCode, isbn string) (string, error) { - return m.callFunctionFiveArgs("GetKFZSPTImageURL", - proxyType, username, password, machineCode, isbn) -} - -// 修改后的 GetKFZShopBookInfo - 需要12个参数 -func (m *DLLManager) GetKFZShopBookInfo(proxyType, username, password, machineCode, shopId, isImage, bookNum, pageNum, sortType, sort, priceDown, priceUp string) (string, error) { - return m.callFunctionTwelveArgs("GetKFZShopBookInfo", - proxyType, username, password, machineCode, shopId, isImage, bookNum, pageNum, sortType, sort, priceDown, priceUp) -} -``` - -### 2.初始化配置信息，代码示例： -````go -func main(){ - // 使用默认配置初始化 - config := createDefaultConfig() - configJSON, err := json.Marshal(config) - if err != nil { - log.Fatalf("序列化配置失败: %v", err) - } - - result, err := manager.Initialize(string(configJSON)) - if err != nil { - log.Fatalf("初始化失败: %v", err) - } - - var initResp APIResponses - if err := json.Unmarshal([]byte(result), &initResp); err != nil { - log.Fatalf("解析初始化响应失败: %v", err) - } - - if !initResp.Success { - log.Fatalf("初始化失败: %s", initResp.Message) - } -} -// 创建默认配置示例 -func createDefaultConfig() Configs { - var configs Configs - - // App配置 - configs.App.MaxRetryTimes = 3 - configs.App.RateLimitDelay = 1000 - configs.App.Size = 10 - configs.App.DefaultUserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36" - - // API配置 - configs.API.LoginURL = "https://login.kongfz.com/Pc/Login/account" - configs.API.BookSearchURL = "https://search.kongfz.com/pc-gw/search-web/client/pc/bookLib/keyword/list" - configs.API.ProductSearchURL = "https://search.kongfz.com/pc-gw/search-web/client/pc/product/keyword/list" - - // 代理配置（需要根据实际情况修改） - configs.Proxy.Servers = "http-dynamic.xiaoxiangdaili.com,http-dynamic-S02.xiaoxiangdaili.com,http-dynamic-S03.xiaoxiangdaili.com,http-dynamic-S04.xiaoxiangdaili.com" - configs.Proxy.Username = "1297757178467602432" - configs.Proxy.Password = "QgQBvP7f" - configs.Proxy.TailMachineCode = "b7bf22a237ec692f13fcc2c43ee63252" - configs.Proxy.TailCardKey = "DL_20_YK_1920acb2129844c2aabade3896560a9b" - configs.Proxy.ProxyFilePath = "dll/proxyConfig.dll" - - return configs -} - -// 配置结构 -type Configs struct { - App struct { - MaxRetryTimes int `json:"max_retry_times"` - RateLimitDelay int `json:"rate_limit_delay"` - Size int `json:"size"` - DefaultUserAgent string `json:"default_user_agent"` - } `json:"app"` - - API struct { - LoginURL string `json:"login_url"` - BookSearchURL string `json:"book_search_url"` - ProductSearchURL string `json:"product_search_url"` - } `json:"api"` - - Proxy struct { - Servers string `json:"servers"` - Username string `json:"username"` - Password string `json:"password"` - TailMachineCode string `json:"tail_machine_code"` - TailCardKey string `json:"tail_card_key"` - ProxyFilePath string `json:"proxy_file_path"` - } `json:"proxy"` -} -```` - -### 直接调用接口，代码示例：入参、返回参数都在下面 -```go -func main() { - // 调用方法示例 - shopResult, err := manager.GetKFZShopBookInfo( - proxyType, username, password, machineCode, - shopId, isImage, bookNum, pageNum, sortType, sort, priceDown, priceUp, - ) -} -``` - ---- -## 接口详情 - -### 1. 获取孔网官图 - -**请求信息** - -gtResult, err := manager.GetKFZGTImageURL(testCase.isbn) - - -**请求参数** - -| 参数名 | 类型 | 必填 | 说明 | -|------|--------|----|-----------| -| proxyType | string | 是 | 代理类型(小象代理：CALF_ELEPHANT_PROXY,内置代理：TAIL_PROXY) | -| username | string | 是 | 小象代理账号 | -| password | string | 是 | 小象代理密码 | -| machineCode | string | 是 | 内置代理机械码 | -| isbn | string | 是 | 图书的 ISBN 号 | - -**响应数据** - -| 字段名 | 类型 | 说明 | 示例值 | -|--------|------|------|---------| -| `success` | boolean | 请求是否成功 | `true` | -| `message` | string | 响应消息 | `"查询成功"` | -| `data` | array | 图书信息列表 | - | - -**图书信息字段说明(data数据)** - -| 字段名 | 类型 | 说明 | -|--------|------|------| -| `author` | string | 作者 | -| `binding_layout` | string | 装帧布局 | -| `book_name` | string | 图书名称 | -| `book_pic` | string | 图书图片（大图） | -| `book_pic_s` | string | 图书图片（小图） | -| `buyCount` | string | 购买数量 | -| `category` | string | 分类 | -| `condition` | string | 图书状况 | -| `content` | string | 内容简介 | -| `edition` | string | 版次 | -| `editor` | string | 编者 | -| `express_delivery_fee` | string | 快递费用 | -| `fix_price` | string | 定价 | -| `format` | string | 开本 | -| `isbn` | string | ISBN号 | -| `item_id` | number | 商品ID | -| `languages` | string | 语言 | -| `mid` | number | 商家ID | -| `pages` | string | 页数 | -| `paper` | string | 纸张 | -| `print_time` | string | 印刷时间 | -| `publication_time` | number | 出版时间（时间戳） | -| `publisher` | string | 出版社 | -| `sellCount` | string | 销售数量 | -| `shop_id` | number | 店铺ID | -| `wordage` | string | 字数 | - -**响应示例** - -```json -{ - "success": true, - "message": "查询成功", - "data": { - "author": "", - "binding_layout": "", - "book_name": "", - "book_pic": "", - "book_pic_s": "", - "buyCount": "", - "category": "", - "condition": "", - "content": "", - "edition": "", - "editor": "", - "express_delivery_fee": "", - "fix_price": "", - "format": "", - "isbn": "", - "item_id": 0, - "languages": "", - "mid": 0, - "pages": "", - "paper": "", - "print_time": "", - "publication_time": 0, - "publisher": "", - "sellCount": "", - "shop_id": 0, - "wordage": "" - } -} -``` - -### 2. 获取孔网实拍图 - -**请求信息** - -sptResult, err := manager.GetKFZSPTImageURL(testCase.isbn) - -**请求参数** - -| 参数名 | 类型 | 必填 | 说明 | -|------|--------|----|------------| -| proxyType | string | 是 | 代理类型(小象代理：CALF_ELEPHANT_PROXY,内置代理：TAIL_PROXY) | -| username | string | 是 | 小象代理账号 | -| password | string | 是 | 小象代理密码 | -| machineCode | string | 是 | 内置代理机械码 | -| isbn | string | 是 | 图书的 ISBN 号 | - -**响应数据** - -| 字段名 | 类型 | 说明 | 示例值 | -|--------|------|------|---------| -| `success` | boolean | 请求是否成功 | `true` | -| `message` | string | 响应消息 | `"查询成功"` | -| `data` | array | 图书信息列表 | - | - -**图书信息字段说明(data数据)** - -| 字段名 | 类型 | 说明 | -|--------|------|------| -| `author` | string | 作者 | -| `binding_layout` | string | 装帧布局 | -| `book_name` | string | 图书名称 | -| `book_pic` | string | 图书图片（大图） | -| `book_pic_s` | string | 图书图片（小图） | -| `buyCount` | string | 购买数量 | -| `category` | string | 分类 | -| `condition` | string | 图书状况 | -| `content` | string | 内容简介 | -| `edition` | string | 版次 | -| `editor` | string | 编者 | -| `express_delivery_fee` | string | 快递费用 | -| `fix_price` | string | 定价 | -| `format` | string | 开本 | -| `isbn` | string | ISBN号 | -| `item_id` | number | 商品ID | -| `languages` | string | 语言 | -| `mid` | number | 商家ID | -| `pages` | string | 页数 | -| `paper` | string | 纸张 | -| `print_time` | string | 印刷时间 | -| `publication_time` | number | 出版时间（时间戳） | -| `publisher` | string | 出版社 | -| `sellCount` | string | 销售数量 | -| `shop_id` | number | 店铺ID | -| `wordage` | string | 字数 | - -**响应示例** - -```json -{ - "success": true, - "message": "查询成功", - "data": { - "author": "", - "binding_layout": "", - "book_name": "", - "book_pic": "", - "book_pic_s": "https://www0.kfzimg.com/sw/kfz-cos/kfzimg/adaaecbf/a1e5df0a21cfdbba_s.jpg", - "buyCount": "", - "category": "", - "condition": "", - "content": "", - "edition": "", - "editor": "", - "express_delivery_fee": "", - "fix_price": "", - "format": "", - "isbn": "", - "item_id": 0, - "languages": "", - "mid": 0, - "pages": "", - "paper": "", - "print_time": "", - "publication_time": 0, - "publisher": "", - "sellCount": "", - "shop_id": 0, - "wordage": "" - } -} -``` - -### 3. 获取店铺图书信息 - -**请求信息** - -shopResult, err := manager.GetKFZShopBookInfo( - proxyType, //代理类型 - username, //小象代理账号 - password, //小象代理密码 - machineCode, //内置代理机械码 - shopId, - isImage, - bookNum, - pageNum, - sortType, - sort, - priceDown, - priceUp, -) - -**请求参数** - -| 参数名 | 类型 | 必填 | 说明 | -|--------|--------|----|------------------------------------------------| -| fetchMode | string | 是 | 是否使用代理 (使用代理：proxy 不使用代理：direct) | -| proxyType | string | 是 | 代理类型(小象代理：CALF_ELEPHANT_PROXY,内置代理：TAIL_PROXY) | -| username | string | 是 | 小象代理账号 | -| password | string | 是 | 小象代理密码 | -| machineCode | string | 是 | 内置代理机械码 | -| shopId | string | 是 | 店铺编号 | -| isImage | string | 否 | 是否有图片 | -| bookNum | string | 否 | 图书数量 | -| pageNum | string | 否 | 页数 | -| sortType | string | 否 | 排序类型(sort,putDate,newItem,price只有这四种) | -| sort | string | 否 | 排序方式(asc,desc) | -| priceUp | string | 否 | 最低价格 | -| priceDown | string | 否 | 最高价格 | - - -**响应数据** - -| 字段名 | 类型 | 说明 | 示例值 | -|--------|------|--------|---------| -| `success` | boolean | 请求是否成功 | `true` | -| `message` | string | 响应消息 | `"查询成功"` | -| `goods_num` | string | 商品数量 | `"查询成功"` | -| `pnum` | string | 店铺商品页数 | `"查询成功"` | -| `data` | array | 图书信息列表 | - | - -**图书信息字段说明(data数据)** - -| 字段名 | 类型 | 说明 | -|--------|------|--------| -| `book_name` | string | 书名 | -| `author` | string | 作者 | -| `publisher` | string | 出版社 | -| `isbn` | string | ISBN号 | -| `publication_time` | number | 出版时间（时间戳） | -| `edition` | string | 版次 | -| `print_time` | string | 印刷时间 | -| `fix_price` | string | 定价 | -| `binding_layout` | string | 装帧 | -| `format` | string | 开本 | -| `paper` | string | 纸张 | -| `pages` | string | 页数 | -| `wordage` | string | 字数 | -| `languages` | string | 语种 | -| `era` | string | 年代 | -| `engraving_method` | string | 刻印方式 | -| `dimensions` | string | 尺寸 | -| `volume_number` | string | 册数 | -| `book_pic` | string | 图书图片（官图） | -| `book_pic_s` | string | 图书图片（实拍图） | -| `selling_price` | string | 售价 | -| `condition` | string | 品相 | -| `express_delivery_fee` | string | 快递费 | -| `editor` | string | 编辑 | -| `category` | string | 分类 | -| `buy_count` | string | 买过 | -| `sell_count` | string | 买过 | -| `content` | string | 内容 | -| `mid` | number | 商家ID | -| `item_id` | number | 商品ID | -| `shop_id` | number | 店铺ID | - -**响应示例** - -```json -{ - "success": true, - "message": "查询成功", - "goods_num": "", - "pnum": "", - "data": [ - { - "author": "", - "binding_layout": "", - "book_name": "", - "book_pic": "", - "book_pic_s": "https://www0.kfzimg.com/sw/kfz-cos/kfzimg/cddbcbda/6833c1d27437d121_s.jpg", - "buyCount": "", - "category": "", - "condition": "", - "content": "", - "edition": "", - "editor": "", - "express_delivery_fee": "", - "fix_price": "", - "format": "", - "isbn": "", - "item_id": 0, - "languages": "", - "mid": 0, - "pages": "", - "paper": "", - "print_time": "", - "publication_time": 0, - "publisher": "", - "sellCount": "", - "shop_id": 0, - "wordage": "" - } - ] -} -``` - -### 4. 根据url获取单个图书详情信息 - -**请求信息** - -shopResult, err := manager.GetUrlBookDetails( - fetchMode, - proxyType, - username, - password, - machineCode, - url -) - -**请求参数** - -| 参数名 | 类型 | 必填 | 说明 | -|--------|--------|----|------------------------------------------------| -| fetchMode | string | 是 | 是否使用代理 (使用代理：proxy 不使用代理：direct) | -| proxyType | string | 是 | 代理类型(小象代理：CALF_ELEPHANT_PROXY,内置代理：TAIL_PROXY) | -| username | string | 是 | 小象代理账号 | -| password | string | 是 | 小象代理密码 | -| machineCode | string | 是 | 内置代理机械码 | -| url | string | 是 | 传入详情页的url | - - -**响应数据** - -| 字段名 | 类型 | 说明 | 示例值 | -|--------|------|--------|---------| -| `success` | boolean | 请求是否成功 | `true` | -| `message` | string | 响应消息 | `"查询成功"` | -| `goods_num` | string | 商品数量 | `"查询成功"` | -| `pnum` | string | 店铺商品页数 | `"查询成功"` | -| `data` | array | 图书信息列表 | - | - -**图书信息字段说明(data数据)** - -| 字段名 | 类型 | 说明 | -|--------|------|--------| -| `book_name` | string | 书名 | -| `author` | string | 作者 | -| `publisher` | string | 出版社 | -| `isbn` | string | ISBN号 | -| `publication_time` | number | 出版时间（时间戳） | -| `edition` | string | 版次 | -| `print_time` | string | 印刷时间 | -| `fix_price` | string | 定价 | -| `binding_layout` | string | 装帧 | -| `format` | string | 开本 | -| `paper` | string | 纸张 | -| `pages` | string | 页数 | -| `wordage` | string | 字数 | -| `languages` | string | 语种 | -| `era` | string | 年代 | -| `engraving_method` | string | 刻印方式 | -| `dimensions` | string | 尺寸 | -| `volume_number` | string | 册数 | -| `book_pic` | string | 图书图片（官图） | -| `book_pic_s` | string | 图书图片（实拍图） | -| `selling_price` | string | 售价 | -| `condition` | string | 品相 | -| `express_delivery_fee` | string | 快递费 | -| `editor` | string | 编辑 | -| `category` | string | 分类 | -| `buy_count` | string | 买过 | -| `sell_count` | string | 买过 | -| `content` | string | 内容 | -| `mid` | number | 商家ID | -| `item_id` | number | 商品ID | -| `shop_id` | number | 店铺ID | - -**响应示例** - -```json -{ - "success": true, - "message": "查询成功", - "goods_num": "", - "pnum": "", - "data": [ - { - "author": "", - "binding_layout": "", - "book_name": "", - "book_pic": "", - "book_pic_s": "https://www0.kfzimg.com/sw/kfz-cos/kfzimg/cddbcbda/6833c1d27437d121_s.jpg", - "buyCount": "", - "category": "", - "condition": "", - "content": "", - "edition": "", - "editor": "", - "express_delivery_fee": "", - "fix_price": "", - "format": "", - "isbn": "", - "item_id": 0, - "languages": "", - "mid": 0, - "pages": "", - "paper": "", - "print_time": "", - "publication_time": 0, - "publisher": "", - "sellCount": "", - "shop_id": 0, - "wordage": "" - } - ] -} -``` - -### 5. 初始化 - -**请求信息** - -manager.Initialize( - configJSON, -) - -**请求参数** - -| 参数名 | 类型 | 必填 | 说明 | -|--------|--------|----|------| -| configJSON | string | 是 | 配置信息 | - -**响应数据** - -| 字段名 | 类型 | 说明 | 示例值 | -|--------|------|--------|---------| -| `success` | boolean | 请求是否成功 | `true` | -| `message` | string | 响应消息 | `"查询成功"` | - -**图书信息字段说明(data数据)** - -| 字段名 | 类型 | 说明 | -|--------|------|--------| -| `book_name` | string | 书名 | -| `author` | string | 作者 | -| `publisher` | string | 出版社 | -| `isbn` | string | ISBN号 | -| `publication_time` | number | 出版时间（时间戳） | -| `edition` | string | 版次 | -| `print_time` | string | 印刷时间 | -| `fix_price` | string | 定价 | -| `binding_layout` | string | 装帧 | -| `format` | string | 开本 | -| `paper` | string | 纸张 | -| `pages` | string | 页数 | -| `wordage` | string | 字数 | -| `languages` | string | 语种 | -| `era` | string | 年代 | -| `engraving_method` | string | 刻印方式 | -| `dimensions` | string | 尺寸 | -| `volume_number` | string | 册数 | -| `book_pic` | string | 图书图片（官图） | -| `book_pic_s` | string | 图书图片（实拍图） | -| `selling_price` | string | 售价 | -| `condition` | string | 品相 | -| `express_delivery_fee` | string | 快递费 | -| `editor` | string | 编辑 | -| `category` | string | 分类 | -| `buy_count` | string | 买过 | -| `sell_count` | string | 买过 | -| `content` | string | 内容 | -| `mid` | number | 商家ID | -| `item_id` | number | 商品ID | -| `shop_id` | number | 店铺ID | - - - - -# proxyConfig.dll文件使用讲解 -由于是kongfz.dll文件去调用proxyConfig.dll文件里面的函数，无需再去调用。 -除非直接使用proxyConfig.dll文件。 -## 1.直接使用proxyConfig.dll文件，应先加载DLL -```go -func main(){ - // 加载DLL - manager, err := NewDLLManager("文件路径") - if err != nil { - log.Fatalf("初始化DLL管理器失败: %v", err) - } - // 确保字段被释放，但是需要注意，如果加这个，可能把你的dll文件释放掉了，导致程序崩溃 - defer manager.Close() -} - - -type DLLManager struct { - dll *syscall.DLL -} - -func NewDLLManager(dllPath string) (*DLLManager, error) { - dll, err := syscall.LoadDLL(dllPath) - if err != nil { - return nil, fmt.Errorf("加载DLL失败: %v", err) - } - return &DLLManager{dll: dll}, nil -} - -func (m *DLLManager) Close() { - if m.dll != nil { - m.dll.Release() - } -} - -// ProxyTypeManager 调用代理类型管理器 -func (m *ProxyConfigManager) ProxyTypeManager(proxyType, username, password, machineCode string) (string, error) { - proc, err := m.dll.FindProc("ProxyTypeManager") - if err != nil { - return "", fmt.Errorf("找不到函数 ProxyTypeManager: %v", err) - } - - // 准备参数 - proxyTypePtr, _ := syscall.BytePtrFromString(proxyType) - usernamePtr, _ := syscall.BytePtrFromString(username) - passwordPtr, _ := syscall.BytePtrFromString(password) - machineCodePtr, _ := syscall.BytePtrFromString(machineCode) - - // 调用函数 - r1, _, err := proc.Call( - uintptr(unsafe.Pointer(proxyTypePtr)), - uintptr(unsafe.Pointer(usernamePtr)), - uintptr(unsafe.Pointer(passwordPtr)), - uintptr(unsafe.Pointer(machineCodePtr)), - ) - - if err != nil && err.Error() != "The operation completed successfully." { - return "", fmt.Errorf("调用 ProxyTypeManager 失败: %v", err) - } - - // 转换结果 - result := (*byte)(unsafe.Pointer(r1)) - var resultBytes []byte - for i := 0; ; i++ { - bytePtr := (*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(result)) + uintptr(i))) - if *bytePtr == 0 { - break - } - resultBytes = append(resultBytes, *bytePtr) - } - - // 释放内存 - freeProc, _ := m.dll.FindProc("FreeCString") - if freeProc != nil { - freeProc.Call(r1) - } - - return string(resultBytes), nil -} -``` - -## 直接调用ProxyTypeManager函数方法 -```go -typeManager, err := globalProxyManager.ProxyTypeManager( - proxyType, - username, - password, - machineCode, -) -``` -**请求信息** -typeManager, err := globalProxyManager.ProxyTypeManager( - proxyType, - username, - password, - machineCode, -) - -**请求参数** - -| 参数名 | 类型 | 必填 | 说明 | -|------|--------|----|------------| -| proxyType | string | 是 | 代理类型(小象代理：CALF_ELEPHANT_PROXY,内置代理：TAIL_PROXY) | -| username | string | 是 | 小象代理账号 | -| password | string | 是 | 小象代理密码 | -| machineCode | string | 是 | 内置代理机械码 | - -**响应信息** -string字符串： http://18434270290:JWt15lWW@111.179.77.244:44751 \ No newline at end of file diff --git a/md/proxy.md b/md/proxy.md new file mode 100644 index 0000000..455d3be --- /dev/null +++ b/md/proxy.md @@ -0,0 +1,197 @@ +# proxy.dll 使用教程 +## 1.创建DLL工具实例 +### 加载DLL文件 +```gotemplate +// ProxyDLL 代理DLL结构 +type proxyDLL struct { + dll *syscall.DLL + proxyTypeManager *syscall.Proc // 获取代理服务器 + getMachineCode *syscall.Proc // 获取机器码 + rechargeCard *syscall.Proc // 充值卡密 + getProxies *syscall.Proc // 获取代理服务器 + checkTailCardSecretExpired *syscall.Proc // 检查卡密是否过期 + freeCString *syscall.Proc // 释放C字符串内存 +} + +// 初始化代理DLL +func InitProxyDLL() (*proxyDLL, error) { + dllPath := filepath.Join("dll", "proxy1.dll") + log.Printf("[DEBUG] 调用proxy.dll文件，文件路径: %s", dllPath) + if _, err := os.Stat(dllPath); os.IsNotExist(err) { + return nil, fmt.Errorf("proxy DLL 不存在: %s", dllPath) + } + if dll, err := syscall.LoadDLL(dllPath); err != nil { + return nil, fmt.Errorf("加载proxy DLL 失败: %s", err) + } else { + return &proxyDLL{ + dll: dll, + proxyTypeManager: dll.MustFindProc("ProxyTypeManager"), + getMachineCode: dll.MustFindProc("GetMachineCode"), + rechargeCard: dll.MustFindProc("RechargeCard"), + getProxies: dll.MustFindProc("GetProxies"), + checkTailCardSecretExpired: dll.MustFindProc("CheckTailCardSecretExpired"), + freeCString: dll.MustFindProc("FreeCString"), + }, nil + } +} + +// 函数调用 +dll, err := InitProxyDLL() +if err != nil { + return "", err +} +``` + +### 获取C字符串 +```gotemplate +// cStr 获取C字符串 +func (m *kongfzDLL) cStr(p uintptr) string { + if p == 0 { + return "" + } + b := []byte{} + for i := uintptr(0); ; i++ { + c := *(*byte)(unsafe.Pointer(p + i)) + if c == 0 { + break + } + b = append(b, c) + } + s := string(b) + if m.freeCString != nil { + m.freeCString.Call(p) + } + return s +} +``` + +## 2.使用dll函数示例 +```gotemplate +// ProxyTypeManager 获取代理服务器 +func (m *proxyDLL) ProxyTypeManager(proxyType, username, password, machineCode string) (string, error) { + proc, err := m.dll.FindProc("ProxyTypeManager") + if err != nil { + return "", fmt.Errorf("找不到函数 ProxyTypeManager: %v", err) + } + proxyTypePtr, _ := syscall.BytePtrFromString(proxyType) + usernamePtr, _ := syscall.BytePtrFromString(username) + passwordPtr, _ := syscall.BytePtrFromString(password) + machineCodePtr, _ := syscall.BytePtrFromString(machineCode) + info, _, err := proc.Call( + uintptr(unsafe.Pointer(proxyTypePtr)), + uintptr(unsafe.Pointer(usernamePtr)), + uintptr(unsafe.Pointer(passwordPtr)), + uintptr(unsafe.Pointer(machineCodePtr))) + if err != nil && err.Error() != "The operation completed successfully." { + return "", fmt.Errorf("调用函数 ProxyTypeManager 失败: %v", err) + } + return m.cStr(info), nil +} +``` + +# 接口详情 +## 1.获取代理服务器--ProxyTypeManager +### 请求信息 +```gotemplate +dll.ProxyTypeManager(proxyType, username, password, machineCode) +``` +### 请求参数 +| 参数名 | 类型 | 必填 | 说明 | +|--|--|--|-----------------------------------------------| +| proxyType | string | 是 | 代理类型 小象代理：CALF_ELEPHANT_PROXY 内置代理：TAIL_PROXY | +| username | string | 是 | 小象账号 | +| password | string | 是 | 小象密码 | +| machineCode | string | 是 | 内置代理机器码 | +### 响应示例 +``` +代理服务器字符串示例 +http://18434270290:JWt15lWW@183.7.131.66:36806 +``` + +## 2.查询机器码--GetMachineCode +### 请求信息 +```gotemplate +dll.GetMachineCode(tailCardSecret) +``` +### 请求参数 +| 参数名 | 类型 | 必填 | 说明 | +|--|--|--|----| +| tailCardSecret | string | 是 | 卡密 | +### 响应示例 +```json +{ + "code": 200, + "message": "success", + "data": { + "machine_code": "07f4d0fbcff99966c2b37b0c1fb7f01c", + "ip_exp_time": "2025-12-12 10:35:06", + "ip_thread": 5, + "ip_card_code": "DL_5_TK_021c06ac87434a66a857a55baac28494" + } +} +``` + +## 3.充值卡密--RechargeCard +### 请求信息 +```gotemplate +dll.RechargeCard(tailCardSecret,machineCode) +``` +### 请求参数 +| 参数名 | 类型 | 必填 | 说明 | +|--|--|--|-----| +| tailCardSecret | string | 是 | 卡密 | +| machineCode | string | 是 | 机器码 | +### 响应示例 +```json +{ + "success": true, + "message": "充值成功", + "machine_code": "e88c2c4210a2667866aab824cdfd2a9c" +} +``` + +## 4.获取代理服务器列表--GetProxies +### 请求信息 +```gotemplate +dll.GetProxies(machineCode) +``` +### 请求参数 +| 参数名 | 类型 | 必填 | 说明 | +|--|--|--|-----| +| machineCode | string | 是 | 机器码 | +### 响应示例 +```json +{ + "success": true, + "count": 4, + "proxies": ["",""] +} +``` + +## 5.检查卡密是否过期--CheckTailCardSecretExpired +### 请求信息 +```gotemplate +dll.CheckTailCardSecretExpired(tailCardSecret) +``` +### 请求参数 +| 参数名 | 类型 | 必填 | 说明 | +|--|--|--|----| +| tailCardSecret | string | 是 | 卡密 | +### 响应示例 +```json +{ + "is_valid": true, + "count": 4 +} +``` + +## 6.释放C字符串内存--FreeCString +### 请求信息 +```gotemplate +dll.FreeCString(str) +``` +### 请求参数 +| 参数名 | 类型 | 必填 | 说明 | +|--|--|--|----------| +| str | string | 是 | 需要释放的字符串 | + diff --git a/monitor/main.go b/monitor/main.go new file mode 100644 index 0000000..39c563a --- /dev/null +++ b/monitor/main.go @@ -0,0 +1,615 @@ +package main + +import ( + "fmt" + "io" + "net/http" + "os" + "strconv" + "sync" + "time" +) + +// ============================== +// 事件发射器 (Event Emitter) +// ============================== + +// 事件类型 +type EventType string + +const ( + EventProgress EventType = "progress" + EventComplete EventType = "complete" + EventError EventType = "error" + EventStart EventType = "start" + EventPause EventType = "pause" + EventResume EventType = "resume" + EventCancel EventType = "cancel" +) + +// 事件数据 +type EventData struct { + Type EventType + Downloaded int64 + Total int64 + Percentage float64 + Speed float64 // KB/s + Message string + Timestamp time.Time + Filename string + Error error +} + +// 事件监听器函数类型 +type EventListener func(data EventData) + +// 事件发射器 +type EventEmitter struct { + listeners map[EventType][]EventListener + mu sync.RWMutex +} + +// 创建新的事件发射器 +func NewEventEmitter() *EventEmitter { + return &EventEmitter{ + listeners: make(map[EventType][]EventListener), + } +} + +// 添加事件监听器 +func (ee *EventEmitter) On(eventType EventType, listener EventListener) { + ee.mu.Lock() + defer ee.mu.Unlock() + + ee.listeners[eventType] = append(ee.listeners[eventType], listener) +} + +// 移除事件监听器 +func (ee *EventEmitter) Off(eventType EventType, listener EventListener) { + ee.mu.Lock() + defer ee.mu.Unlock() + + listeners := ee.listeners[eventType] + for i, l := range listeners { + if &l == &listener { + ee.listeners[eventType] = append(listeners[:i], listeners[i+1:]...) + break + } + } +} + +// 发射事件 (类似 runtime.EventsEmit) +func (ee *EventEmitter) Emit(eventType EventType, data EventData) { + ee.mu.RLock() + listeners := ee.listeners[eventType] + ee.mu.RUnlock() + + data.Type = eventType + data.Timestamp = time.Now() + + for _, listener := range listeners { + listener(data) + } +} + +// ============================== +// CSV下载器 +// ============================== + +// CSV下载器 +type CSVDownloader struct { + emitter *EventEmitter + interval time.Duration + isPaused bool + isCanceled bool + mu sync.RWMutex +} + +// 创建新的CSV下载器 +func NewCSVDownloader() *CSVDownloader { + return &CSVDownloader{ + emitter: NewEventEmitter(), + interval: 100 * time.Millisecond, + } +} + +// 设置进度报告间隔 +func (d *CSVDownloader) SetInterval(interval time.Duration) { + d.interval = interval +} + +// 监听事件 +func (d *CSVDownloader) On(eventType EventType, listener EventListener) { + d.emitter.On(eventType, listener) +} + +// 暂停下载 +func (d *CSVDownloader) Pause() { + d.mu.Lock() + d.isPaused = true + d.mu.Unlock() + + d.emitter.Emit(EventPause, EventData{Message: "下载已暂停"}) +} + +// 恢复下载 +func (d *CSVDownloader) Resume() { + d.mu.Lock() + d.isPaused = false + d.mu.Unlock() + + d.emitter.Emit(EventResume, EventData{Message: "下载已恢复"}) +} + +// 取消下载 +func (d *CSVDownloader) Cancel() { + d.mu.Lock() + d.isCanceled = true + d.mu.Unlock() + + d.emitter.Emit(EventCancel, EventData{Message: "下载已取消"}) +} + +// 下载CSV文件 +func (d *CSVDownloader) Download(url, filename string) error { + // 检查是否已取消 + d.mu.RLock() + if d.isCanceled { + d.mu.RUnlock() + return fmt.Errorf("下载已取消") + } + d.mu.RUnlock() + + // 开始下载事件 + d.emitter.Emit(EventStart, EventData{ + Filename: filename, + Message: "开始下载文件", + }) + + // 创建HTTP请求 + resp, err := http.Get(url) + if err != nil { + errorData := EventData{ + Filename: filename, + Message: fmt.Sprintf("无法开始下载: %v", err), + Error: err, + } + d.emitter.Emit(EventError, errorData) + return err + } + defer resp.Body.Close() + + // 获取文件总大小 + totalSize, _ := strconv.ParseInt(resp.Header.Get("Content-Length"), 10, 64) + if totalSize <= 0 { + totalSize = 0 // 未知大小 + } + + // 创建本地文件 + file, err := os.Create(filename) + if err != nil { + errorData := EventData{ + Filename: filename, + Message: fmt.Sprintf("无法创建文件: %v", err), + Error: err, + } + d.emitter.Emit(EventError, errorData) + return err + } + defer file.Close() + + // 下载缓冲区 + buffer := make([]byte, 32*1024) // 32KB + var downloaded int64 = 0 + var lastReport time.Time + var lastDownloaded int64 = 0 + startTime := time.Now() + + // 开始下载循环 + for { + // 检查是否暂停 + d.mu.RLock() + if d.isPaused { + d.mu.RUnlock() + for { + time.Sleep(100 * time.Millisecond) + d.mu.RLock() + if !d.isPaused || d.isCanceled { + d.mu.RUnlock() + break + } + d.mu.RUnlock() + } + } + + // 检查是否取消 + if d.isCanceled { + d.mu.RUnlock() + file.Close() + os.Remove(filename) + return fmt.Errorf("下载已取消") + } + d.mu.RUnlock() + + // 读取数据 + n, err := resp.Body.Read(buffer) + if n > 0 { + // 写入文件 + _, writeErr := file.Write(buffer[:n]) + if writeErr != nil { + errorData := EventData{ + Filename: filename, + Message: fmt.Sprintf("写入文件失败: %v", writeErr), + Error: writeErr, + } + d.emitter.Emit(EventError, errorData) + return writeErr + } + + // 更新下载量 + downloaded += int64(n) + + // 计算下载速度 + now := time.Now() + if lastReport.IsZero() { + lastReport = now + lastDownloaded = downloaded + } + + // 定时报告进度 + if time.Since(lastReport) >= d.interval || err == io.EOF { + elapsed := time.Since(lastReport).Seconds() + speed := 0.0 + if elapsed > 0 { + speed = float64(downloaded-lastDownloaded) / elapsed / 1024 // KB/s + } + + // 计算百分比 + percentage := 0.0 + if totalSize > 0 { + percentage = float64(downloaded) / float64(totalSize) * 100 + } + + // 发射进度事件 + d.emitter.Emit(EventProgress, EventData{ + Downloaded: downloaded, + Total: totalSize, + Percentage: percentage, + Speed: speed, + Filename: filename, + Message: fmt.Sprintf("下载中: %.2f%%", percentage), + }) + + // 重置计时器 + lastReport = now + lastDownloaded = downloaded + } + } + + // 检查是否完成 + if err != nil { + if err == io.EOF { + // 下载完成 + totalTime := time.Since(startTime).Seconds() + averageSpeed := 0.0 + if totalTime > 0 { + averageSpeed = float64(downloaded) / totalTime / 1024 + } + + d.emitter.Emit(EventComplete, EventData{ + Downloaded: downloaded, + Total: totalSize, + Percentage: 100.0, + Speed: averageSpeed, + Filename: filename, + Message: fmt.Sprintf("下载完成! 总共用时: %.2f秒", totalTime), + }) + + return nil + } + + // 发生错误 + errorData := EventData{ + Filename: filename, + Message: fmt.Sprintf("下载错误: %v", err), + Error: err, + } + d.emitter.Emit(EventError, errorData) + return err + } + } +} + +// ============================== +// 模拟文件生成器（用于测试） +// ============================== + +type MockCSVGenerator struct { + emitter *EventEmitter +} + +func NewMockCSVGenerator() *MockCSVGenerator { + return &MockCSVGenerator{ + emitter: NewEventEmitter(), + } +} + +func (g *MockCSVGenerator) On(eventType EventType, listener EventListener) { + g.emitter.On(eventType, listener) +} + +func (g *MockCSVGenerator) Generate(filename string, totalRows int, columns []string) error { + // 开始事件 + g.emitter.Emit(EventStart, EventData{ + Filename: filename, + Message: "开始生成CSV文件", + }) + + file, err := os.Create(filename) + if err != nil { + g.emitter.Emit(EventError, EventData{ + Filename: filename, + Error: err, + Message: "无法创建文件", + }) + return err + } + defer file.Close() + + // 写入头部 + header := "" + for i, col := range columns { + if i > 0 { + header += "," + } + header += col + } + file.WriteString(header + "\n") + + startTime := time.Now() + + // 生成数据行 + for i := 0; i < totalRows; i++ { + // 生成一行数据 + row := "" + for j := 0; j < len(columns); j++ { + if j > 0 { + row += "," + } + row += fmt.Sprintf("data%d_%d", i, j) + } + file.WriteString(row + "\n") + + // 模拟处理时间 + time.Sleep(5 * time.Millisecond) + + // 每100行报告一次进度 + if (i+1)%100 == 0 || i == totalRows-1 { + percentage := float64(i+1) / float64(totalRows) * 100 + elapsed := time.Since(startTime).Seconds() + rowsPerSecond := 0.0 + if elapsed > 0 { + rowsPerSecond = float64(i+1) / elapsed + } + + g.emitter.Emit(EventProgress, EventData{ + Downloaded: int64(i + 1), + Total: int64(totalRows), + Percentage: percentage, + Speed: rowsPerSecond, + Filename: filename, + Message: fmt.Sprintf("已生成 %d/%d 行", i+1, totalRows), + }) + } + } + + // 完成事件 + g.emitter.Emit(EventComplete, EventData{ + Downloaded: int64(totalRows), + Total: int64(totalRows), + Percentage: 100.0, + Filename: filename, + Message: "CSV文件生成完成", + }) + + return nil +} + +// ============================== +// 主程序 +// ============================== + +func main() { + fmt.Println("=== CSV文件下载器 (事件监听模式) ===\n") + + // 创建控制台日志监听器 + consoleLogger := func(data EventData) { + timestamp := data.Timestamp.Format("15:04:05") + + switch data.Type { + case EventStart: + fmt.Printf("[%s] 🚀 %s: %s\n", timestamp, data.Filename, data.Message) + case EventProgress: + if data.Total > 0 { + fmt.Printf("[%s] 📥 %s: %s (%.2f%%) - %.2f KB/s\n", + timestamp, data.Filename, data.Message, data.Percentage, data.Speed) + } else { + fmt.Printf("[%s] 📥 %s: 已下载 %d bytes - %.2f KB/s\n", + timestamp, data.Filename, data.Downloaded, data.Speed) + } + case EventComplete: + fmt.Printf("[%s] ✅ %s: %s\n", timestamp, data.Filename, data.Message) + case EventError: + fmt.Printf("[%s] ❌ %s: %s (错误: %v)\n", + timestamp, data.Filename, data.Message, data.Error) + case EventPause: + fmt.Printf("[%s] ⏸️ %s\n", timestamp, data.Message) + case EventResume: + fmt.Printf("[%s] ▶️ %s\n", timestamp, data.Message) + case EventCancel: + fmt.Printf("[%s] ⏹️ %s\n", timestamp, data.Message) + } + } + + // 创建进度条监听器（简单的文本进度条） + progressBar := func(data EventData) { + if data.Type == EventProgress && data.Total > 0 { + barWidth := 50 + completed := int(float64(barWidth) * data.Percentage / 100) + remaining := barWidth - completed + + bar := "" + for i := 0; i < completed; i++ { + bar += "█" + } + for i := 0; i < remaining; i++ { + bar += "░" + } + + fmt.Printf("\r进度: [%s] %.2f%% | 速度: %.2f KB/s", bar, data.Percentage, data.Speed) + + if data.Percentage >= 100 { + fmt.Println() + } + } + } + + // 创建统计信息监听器 + statsTracker := func(data EventData) { + // 在实际应用中，这里可以记录统计数据到数据库或文件 + if data.Type == EventComplete { + fmt.Printf("[统计] 文件: %s, 大小: %d bytes, 平均速度: %.2f KB/s\n", + data.Filename, data.Downloaded, data.Speed) + } + } + + // 示例1：模拟CSV文件生成 + fmt.Println("示例1: 模拟生成CSV文件") + fmt.Println("======================") + + generator := NewMockCSVGenerator() + + // 注册事件监听器 + generator.On(EventStart, consoleLogger) + generator.On(EventProgress, progressBar) + generator.On(EventProgress, consoleLogger) + generator.On(EventComplete, consoleLogger) + generator.On(EventComplete, statsTracker) + generator.On(EventError, consoleLogger) + + // 生成CSV文件 + columns := []string{"ID", "Name", "Age", "Email", "City", "Salary", "Department"} + err := generator.Generate("employees.csv", 500, columns) + if err != nil { + fmt.Printf("生成失败: %v\n", err) + } + + fmt.Println("\n示例2: 模拟文件下载") + fmt.Println("======================") + + // 创建下载器 + downloader := NewCSVDownloader() + downloader.SetInterval(200 * time.Millisecond) + + // 注册事件监听器 + downloader.On(EventStart, consoleLogger) + downloader.On(EventProgress, progressBar) + downloader.On(EventProgress, consoleLogger) + downloader.On(EventComplete, consoleLogger) + downloader.On(EventComplete, statsTracker) + downloader.On(EventError, consoleLogger) + downloader.On(EventPause, consoleLogger) + downloader.On(EventResume, consoleLogger) + downloader.On(EventCancel, consoleLogger) + + // 模拟下载控制（在真实场景中，这可能是用户界面操作） + go func() { + time.Sleep(500 * time.Millisecond) + downloader.Pause() + time.Sleep(1 * time.Second) + downloader.Resume() + }() + + // 注意：这里使用了一个公开的测试CSV文件URL + // 在实际使用中，请替换为真实的CSV文件URL + testURL := "https://raw.githubusercontent.com/datasets/covid-19/main/data/time-series-19-covid-combined.csv" + + // 由于网络请求可能需要时间，这里我们使用goroutine来演示 + go func() { + err := downloader.Download(testURL, "covid-data.csv") + if err != nil { + fmt.Printf("下载失败: %v\n", err) + } + }() + + // 等待演示完成 + time.Sleep(5 * time.Second) + + // 演示文件处理进度监控 + fmt.Println("\n示例3: 文件处理进度监控") + fmt.Println("======================") + + processor := NewEventEmitter() + + // 模拟文件处理 + go func() { + processor.Emit(EventStart, EventData{ + Filename: "employees.csv", + Message: "开始处理文件", + }) + + totalRows := 500 + for i := 0; i < totalRows; i++ { + time.Sleep(10 * time.Millisecond) + + if (i+1)%50 == 0 { + percentage := float64(i+1) / float64(totalRows) * 100 + processor.Emit(EventProgress, EventData{ + Downloaded: int64(i + 1), + Total: int64(totalRows), + Percentage: percentage, + Filename: "employees.csv", + Message: fmt.Sprintf("已处理 %d/%d 行", i+1, totalRows), + }) + } + } + + processor.Emit(EventComplete, EventData{ + Downloaded: int64(totalRows), + Total: int64(totalRows), + Percentage: 100.0, + Filename: "employees.csv", + Message: "文件处理完成", + }) + }() + + // 监听处理进度 + processor.On(EventStart, consoleLogger) + processor.On(EventProgress, func(data EventData) { + barWidth := 30 + completed := int(float64(barWidth) * data.Percentage / 100) + remaining := barWidth - completed + + bar := "" + for i := 0; i < completed; i++ { + bar += "▊" + } + for i := 0; i < remaining; i++ { + bar += "░" + } + + fmt.Printf("\r处理: [%s] %.2f%%", bar, data.Percentage) + if data.Percentage >= 100 { + fmt.Println() + } + }) + processor.On(EventComplete, consoleLogger) + + // 等待所有演示完成 + time.Sleep(6 * time.Second) + + fmt.Println("\n✅ 所有演示完成!") + fmt.Println("生成的文件:") + fmt.Println(" - employees.csv (示例数据)") + fmt.Println(" - covid-data.csv (从网络下载的数据)") +} diff --git a/dll/proxyConfig.dll b/proxy/dll/proxy.dll similarity index 69% rename from dll/proxyConfig.dll rename to proxy/dll/proxy.dll index 468508c..4e745fb 100644 Binary files a/dll/proxyConfig.dll and b/proxy/dll/proxy.dll differ diff --git a/proxy/dll/proxy.h b/proxy/dll/proxy.h new file mode 100644 index 0000000..dc81637 --- /dev/null +++ b/proxy/dll/proxy.h @@ -0,0 +1,124 @@ +/* Code generated by cmd/cgo; DO NOT EDIT. */ + +/* package command-line-arguments */ + + +#line 1 "cgo-builtin-export-prolog" + +#include + +#ifndef GO_CGO_EXPORT_PROLOGUE_H +#define GO_CGO_EXPORT_PROLOGUE_H + +#ifndef GO_CGO_GOSTRING_TYPEDEF +typedef struct { const char *p; ptrdiff_t n; } _GoString_; +extern size_t _GoStringLen(_GoString_ s); +extern const char *_GoStringPtr(_GoString_ s); +#endif + +#endif + +/* Start of preamble from import "C" comments. */ + + +#line 3 "proxy.go" + #include + +#line 1 "cgo-generated-wrapper" + + +/* End of preamble from import "C" comments. */ + + +/* Start of boilerplate cgo prologue. */ +#line 1 "cgo-gcc-export-header-prolog" + +#ifndef GO_CGO_PROLOGUE_H +#define GO_CGO_PROLOGUE_H + +typedef signed char GoInt8; +typedef unsigned char GoUint8; +typedef short GoInt16; +typedef unsigned short GoUint16; +typedef int GoInt32; +typedef unsigned int GoUint32; +typedef long long GoInt64; +typedef unsigned long long GoUint64; +typedef GoInt64 GoInt; +typedef GoUint64 GoUint; +typedef size_t GoUintptr; +typedef float GoFloat32; +typedef double GoFloat64; +#ifdef _MSC_VER +#if !defined(__cplusplus) || _MSVC_LANG <= 201402L +#include +typedef _Fcomplex GoComplex64; +typedef _Dcomplex GoComplex128; +#else +#include +typedef std::complex GoComplex64; +typedef std::complex GoComplex128; +#endif +#else +typedef float _Complex GoComplex64; +typedef double _Complex GoComplex128; +#endif + +/* + static assertion to make sure the file is being used on architecture + at least with matching size of GoInt. +*/ +typedef char _check_for_64_bit_pointer_matching_GoInt[sizeof(void*)==64/8 ? 1:-1]; + +#ifndef GO_CGO_GOSTRING_TYPEDEF +typedef _GoString_ GoString; +#endif +typedef void *GoMap; +typedef void *GoChan; +typedef struct { void *t; void *v; } GoInterface; +typedef struct { void *data; GoInt len; GoInt cap; } GoSlice; + +#endif + +/* End of boilerplate cgo prologue. */ + +#ifdef __cplusplus +extern "C" { +#endif + + +// 导出函数：获取代理健康状态（用于调试） +// +extern __declspec(dllexport) char* GetProxyHealth(void); + +// 导出函数：代理类型管理器 +// +extern __declspec(dllexport) char* ProxyTypeManager(char* proxyType, char* username, char* password, char* machineCode); + +// 导出函数：查询机器码 +// +extern __declspec(dllexport) char* GetMachineCode(char* tailCardSecret); + +// 导出函数：充值卡密 +// +extern __declspec(dllexport) char* RechargeCard(char* tailCardSecret, char* machineCode); + +// 导出函数：获取代理服务器列表 +// +extern __declspec(dllexport) char* GetProxies(char* machineCode); + +// 导出函数：检查卡密是否过期 +// +extern __declspec(dllexport) char* CheckTailCardSecretExpired(char* tailCardSecret); + +// 导出函数：初始化代理管理器 +// +extern __declspec(dllexport) char* InitProxyManager(char* serversJson, char* username, char* password, char* tailCardSecret, char* proxyType); + +// 导出函数：释放C字符串内存 +// +extern __declspec(dllexport) void FreeCString(char* str); + +#ifdef __cplusplus +} +#endif diff --git a/proxy.go b/proxy/proxy.go similarity index 70% rename from proxy.go rename to proxy/proxy.go index 6fb0ff8..8c5bd47 100644 --- a/proxy.go +++ b/proxy/proxy.go @@ -1,6 +1,8 @@ package main -// #include +/* +#include +*/ import "C" import ( "crypto/md5" @@ -13,6 +15,7 @@ import ( "strings" "sync" "time" + "unsafe" ) // 代理类型常量 @@ -322,6 +325,7 @@ func checkTailCardSecretExpired(tailCardSecret string) (bool, error) { return false, fmt.Errorf("时间格式错误: %v", err) } currentTime := time.Now() + // 卡密日期在当前日期之后 if targetTime.After(currentTime) { return true, nil } else { @@ -450,6 +454,8 @@ func initProxy() { } +// =================== C 导出函数 ======================= + // 导出函数：获取代理健康状态（用于调试） // //export GetProxyHealth @@ -498,13 +504,194 @@ func ProxyTypeManager(proxyType, username, password, machineCode *C.char) *C.cha return C.CString(proxyURL) } -//// 导出函数：释放C字符串内存 -//// -////export FreeCString -//func FreeCString(str *C.char) { -// C.free(unsafe.Pointer(str)) -//} +// 导出函数：查询机器码 // -//func main() { +//export GetMachineCode +func GetMachineCode(tailCardSecret *C.char) *C.char { + goTailCardSecret := C.GoString(tailCardSecret) + log.Printf("[DEBUG] 查询机器码调用: card=%s", goTailCardSecret) + + resp, err := getMachineCode(goTailCardSecret) + if err != nil { + errorMsg := fmt.Sprintf("ERROR: %v", err) + log.Printf("[ERROR] 查询机器码错误: %v", err) + return C.CString(errorMsg) + } + + // 将响应转换为JSON + jsonData, err := json.Marshal(resp) + if err != nil { + errorMsg := fmt.Sprintf("ERROR: 序列化响应失败: %v", err) + log.Printf("[ERROR] 序列化机器码响应失败: %v", err) + return C.CString(errorMsg) + } + + log.Printf("[DEBUG] 查询机器码成功: code=%d, machine_code=%s", resp.Code, resp.Data.MachineCode) + return C.CString(string(jsonData)) +} + +// 导出函数：充值卡密 // -//} +//export RechargeCard +func RechargeCard(tailCardSecret, machineCode *C.char) *C.char { + goTailCardSecret := C.GoString(tailCardSecret) + goMachineCode := C.GoString(machineCode) + log.Printf("[DEBUG] 充值卡密调用: card=%s, machine_code=%s", goTailCardSecret, goMachineCode) + + newMachineCode, err := rechargeCard(goTailCardSecret, goMachineCode) + if err != nil { + errorMsg := fmt.Sprintf("ERROR: %v", err) + log.Printf("[ERROR] 充值卡密错误: %v", err) + return C.CString(errorMsg) + } + + // 构建成功响应 + response := map[string]interface{}{ + "success": true, + "machine_code": newMachineCode, + "message": "充值成功", + } + + jsonData, err := json.Marshal(response) + if err != nil { + errorMsg := fmt.Sprintf("ERROR: 序列化响应失败: %v", err) + log.Printf("[ERROR] 序列化充值响应失败: %v", err) + return C.CString(errorMsg) + } + + log.Printf("[DEBUG] 充值卡密成功: new_machine_code=%s", newMachineCode) + return C.CString(string(jsonData)) +} + +// 导出函数：获取代理服务器列表 +// +//export GetProxies +func GetProxies(machineCode *C.char) *C.char { + goMachineCode := C.GoString(machineCode) + log.Printf("[DEBUG] 获取代理服务器列表调用: machine_code=%s", goMachineCode) + + proxies, err := getProxies(goMachineCode) + if err != nil { + errorMsg := fmt.Sprintf("ERROR: %v", err) + log.Printf("[ERROR] 获取代理服务器列表错误: %v", err) + return C.CString(errorMsg) + } + + // 将代理列表转换为JSON + response := map[string]interface{}{ + "success": true, + "count": len(proxies), + "proxies": proxies, + } + + jsonData, err := json.Marshal(response) + if err != nil { + errorMsg := fmt.Sprintf("ERROR: 序列化响应失败: %v", err) + log.Printf("[ERROR] 序列化代理列表失败: %v", err) + return C.CString(errorMsg) + } + + log.Printf("[DEBUG] 获取代理服务器列表成功: count=%d", len(proxies)) + return C.CString(string(jsonData)) +} + +// 导出函数：检查卡密是否过期 +// +//export CheckTailCardSecretExpired +func CheckTailCardSecretExpired(tailCardSecret *C.char) *C.char { + goTailCardSecret := C.GoString(tailCardSecret) + log.Printf("[DEBUG] 检查卡密是否过期调用: card=%s", goTailCardSecret) + + isValid, err := checkTailCardSecretExpired(goTailCardSecret) + if err != nil { + // 如果是过期错误，返回特定格式 + if strings.Contains(err.Error(), "卡密已经过期") { + response := map[string]interface{}{ + "is_valid": false, + "message": err.Error(), + } + jsonData, _ := json.Marshal(response) + return C.CString(string(jsonData)) + } + + errorMsg := fmt.Sprintf("ERROR: %v", err) + log.Printf("[ERROR] 检查卡密过期错误: %v", err) + return C.CString(errorMsg) + } + + response := map[string]interface{}{ + "is_valid": isValid, + "message": "卡密有效", + } + + jsonData, err := json.Marshal(response) + if err != nil { + errorMsg := fmt.Sprintf("ERROR: 序列化响应失败: %v", err) + return C.CString(errorMsg) + } + + log.Printf("[DEBUG] 检查卡密过期结果: is_valid=%v", isValid) + return C.CString(string(jsonData)) +} + +// 导出函数：初始化代理管理器 +// +//export InitProxyManager +func InitProxyManager(serversJson, username, password, tailCardSecret, proxyType *C.char) *C.char { + goServersJson := C.GoString(serversJson) + goUsername := C.GoString(username) + goPassword := C.GoString(password) + goTailCardSecret := C.GoString(tailCardSecret) + goProxyType := C.GoString(proxyType) + + log.Printf("[DEBUG] 初始化代理管理器调用: type=%s", goProxyType) + + // 解析服务器列表 + var serverList []string + if goServersJson != "" { + if err := json.Unmarshal([]byte(goServersJson), &serverList); err != nil { + errorMsg := fmt.Sprintf("ERROR: 解析服务器列表失败: %v", err) + log.Printf("[ERROR] 解析服务器列表失败: %v", err) + return C.CString(errorMsg) + } + } + + // 更新全局服务器列表 + if len(serverList) > 0 { + randMutex.Lock() + servers = serverList + randMutex.Unlock() + log.Printf("[INFO] 更新服务器列表，共 %d 个服务器", len(servers)) + } + + // 创建代理管理器 + manager := ProxyManager{ + servers: servers, + username: goUsername, + password: goPassword, + tailCardSecret: goTailCardSecret, + proxyType: goProxyType, + } + + // 序列化管理器信息 + jsonData, err := json.Marshal(manager) + if err != nil { + errorMsg := fmt.Sprintf("ERROR: 序列化代理管理器失败: %v", err) + log.Printf("[ERROR] 序列化代理管理器失败: %v", err) + return C.CString(errorMsg) + } + + log.Printf("[DEBUG] 代理管理器初始化成功") + return C.CString(string(jsonData)) +} + +// 导出函数：释放C字符串内存 +// +//export FreeCString +func FreeCString(str *C.char) { + C.free(unsafe.Pointer(str)) +} + +// 空main函数，编译DLL时需要 +func main() { +} diff --git a/proxy/proxy_so.go b/proxy/proxy_so.go new file mode 100644 index 0000000..2688756 --- /dev/null +++ b/proxy/proxy_so.go @@ -0,0 +1,699 @@ +package main + +///* +//#cgo LDFLAGS: -ldl +// +//#include +//#include +//#include +//*/ +//import "C" +//import ( +// "crypto/md5" +// "encoding/json" +// "fmt" +// "github.com/parnurzeal/gorequest" +// "log" +// "math/rand" +// "net/url" +// "strings" +// "sync" +// "time" +// "unsafe" +//) +// +//// 代理类型常量 +//const ( +// CalfElephantProxyType = "CALF_ELEPHANT_PROXY" +// TailProxyType = "TAIL_PROXY" +//) +// +//// 代理服务器列表 +//var ( +// servers = []string{ +// "http-dynamic.xiaoxiangdaili.com", +// "http-dynamic-S02.xiaoxiangdaili.com", +// "http-dynamic-S03.xiaoxiangdaili.com", +// "http-dynamic-S04.xiaoxiangdaili.com", +// } +// randMutex sync.Mutex +// globalRand *rand.Rand +// +// // 代理健康状态管理 +// proxyHealthMaps = make(map[string]*ProxyHealth) +// proxyHealthMutex sync.RWMutex +//) +// +//// ProxyManager 代理管理器结构体 +//type ProxyManager struct { +// servers []string `json:"servers"` // 代理服务器列表 +// username string `json:"username"` // 代理账号 +// password string `json:"password"` // 代理密码 +// tailCardSecret string `json:"tail_card_secret"` // 尾巴代理卡密 +// proxyType string `json:"proxy_type"` // 代理类型 CALF_ELEPHANT_PROXY/TAIL_PROXY +//} +// +//// 代理健康状态 +//type ProxyHealth struct { +// SuccessCount int // 成功次数 +// FailCount int // 失败次数 +// LastCheck time.Time // 最后检查时间 +// ResponseTime time.Duration // 响应时间 +// IsHealthy bool // 是否健康 +//} +// +//func init() { +// // 创建全局的随机数生成器 +// globalRand = rand.New(rand.NewSource(time.Now().UnixNano())) +//} +// +//// 获取代理URL +//func proxyTypeManager(proxyType, username, password, machineCode string) (string, error) { +// switch proxyType { +// case CalfElephantProxyType: +// return buildCalfElephantProxyURL(username, password) +// case TailProxyType: +// return buildTailProxyURL(machineCode) +// default: +// return "", fmt.Errorf("不支持的代理类型: %s", proxyType) +// } +//} +// +//// 构建小象代理URL +//func buildCalfElephantProxyURL(username, password string) (string, error) { +// server := randomServer() +// proxyURL := fmt.Sprintf("http://%s:%s@%s:%d", +// url.QueryEscape(username), +// url.QueryEscape(password), +// server, +// 10030) +// +// // 检测代理可用性 +// if err := checkProxyHealth(proxyURL); err != nil { +// log.Printf("[WARN] 代理 %s 检测失败: %v", server, err) +// // 尝试下一个代理服务器 +// return tryNextCalfElephantProxy(username, password, server) +// } +// +// log.Printf("[INFO] 使用小象代理: %s", server) +// return proxyURL, nil +//} +// +//// 尝试下一个小象代理服务器 +//func tryNextCalfElephantProxy(username, password, failedServer string) (string, error) { +// // 创建服务器副本并排除失败的服务器 +// availableServers := make([]string, 0) +// for _, server := range servers { +// if server != failedServer { +// availableServers = append(availableServers, server) +// } +// } +// +// if len(availableServers) == 0 { +// return "", fmt.Errorf("所有小象代理服务器都不可用") +// } +// +// // 随机尝试可用服务器 +// for _, server := range shuffleServers(availableServers) { +// proxyURL := fmt.Sprintf("http://%s:%s@%s:%d", +// url.QueryEscape(username), +// url.QueryEscape(password), +// server, +// 10030) +// +// if err := checkProxyHealth(proxyURL); err == nil { +// log.Printf("[INFO] 切换到可用代理: %s", server) +// return proxyURL, nil +// } +// log.Printf("[WARN] 代理 %s 检测失败", server) +// } +// +// return "", fmt.Errorf("所有可用的小象代理服务器都检测失败") +//} +// +//// 构建内置代理URL +//func buildTailProxyURL(machineCode string) (string, error) { +// proxies, err := getProxies(machineCode) +// if err != nil { +// return "", err +// } +// if len(proxies) == 0 { +// return "", fmt.Errorf("未获取到有效代理") +// } +// +// // 过滤并选择健康的代理 +// healthyProxies := filterHealthyProxies(proxies) +// if len(healthyProxies) > 0 { +// proxyURL := "http://" + randomElement(healthyProxies) +// log.Printf("[INFO] 使用健康尾巴代理: %s", proxyURL) +// return proxyURL, nil +// } +// +// // 如果没有健康代理，检测所有代理 +// log.Printf("[INFO] 未找到健康代理，开始检测代理可用性...") +// return findWorkingTailProxy(proxies) +//} +// +//// 过滤健康代理 +//func filterHealthyProxies(proxies []string) []string { +// proxyHealthMutex.RLock() +// defer proxyHealthMutex.RUnlock() +// +// var healthy []string +// for _, proxy := range proxies { +// if health, exists := proxyHealthMaps[proxy]; exists && health.IsHealthy { +// // 检查是否在最近检查过（5分钟内） +// if time.Since(health.LastCheck) < 5*time.Minute { +// healthy = append(healthy, proxy) +// } +// } +// } +// return healthy +//} +// +//// 查找可用的尾巴代理 +//func findWorkingTailProxy(proxies []string) (string, error) { +// // 打乱代理顺序 +// shuffledProxies := shuffleServers(proxies) +// +// // 并发检测代理 +// type proxyResult struct { +// proxy string +// err error +// } +// +// ch := make(chan proxyResult, len(shuffledProxies)) +// var wg sync.WaitGroup +// +// // 限制并发数 +// sem := make(chan struct{}, 5) +// +// for _, proxy := range shuffledProxies { +// wg.Add(1) +// go func(p string) { +// defer wg.Done() +// sem <- struct{}{} +// defer func() { <-sem }() +// +// proxyURL := "http://" + p +// err := checkProxyHealth(proxyURL) +// ch <- proxyResult{proxy: p, err: err} +// }(proxy) +// } +// +// wg.Wait() +// close(ch) +// +// // 收集结果 +// var workingProxies []string +// for result := range ch { +// if result.err == nil { +// workingProxies = append(workingProxies, result.proxy) +// // 更新健康状态 +// updateProxyHealth(result.proxy, true, 0) +// } else { +// updateProxyHealth(result.proxy, false, 0) +// } +// } +// +// if len(workingProxies) > 0 { +// selected := randomElement(workingProxies) +// log.Printf("[INFO] 找到可用代理: %s (共 %d 个可用)", selected, len(workingProxies)) +// return "http://" + selected, nil +// } +// +// return "", fmt.Errorf("所有尾巴代理都不可用") +//} +// +//// 检测代理健康状态 +//func checkProxyHealth(proxyURL string) error { +// start := time.Now() +// +// req := gorequest.New().Proxy(proxyURL).Timeout(10 * time.Second) +// resp, _, errs := req.Get("https://shop.kongfz.com/").End() +// +// responseTime := time.Since(start) +// +// if len(errs) > 0 { +// updateProxyHealth(proxyURL, false, responseTime) +// return fmt.Errorf("代理连接失败: %v", errs) +// } +// +// if resp.StatusCode != 200 { +// updateProxyHealth(proxyURL, false, responseTime) +// return fmt.Errorf("代理响应状态码错误: %d", resp.StatusCode) +// } +// +// updateProxyHealth(proxyURL, true, responseTime) +// log.Printf("[DEBUG] 代理 %s 检测成功, 响应时间: %v", getProxyHost(proxyURL), responseTime) +// return nil +//} +// +//// 更新代理健康状态 +//func updateProxyHealth(proxyURL string, success bool, responseTime time.Duration) { +// proxyHealthMutex.Lock() +// defer proxyHealthMutex.Unlock() +// +// host := getProxyHost(proxyURL) +// if _, exists := proxyHealthMaps[host]; !exists { +// proxyHealthMaps[host] = &ProxyHealth{} +// } +// +// health := proxyHealthMaps[host] +// health.LastCheck = time.Now() +// +// if success { +// health.SuccessCount++ +// health.FailCount = 0 +// health.ResponseTime = responseTime +// health.IsHealthy = true +// } else { +// health.FailCount++ +// health.SuccessCount = 0 +// // 连续失败3次标记为不健康 +// if health.FailCount >= 3 { +// health.IsHealthy = false +// } +// } +//} +// +//// 获取代理主机名 +//func getProxyHost(proxyURL string) string { +// if strings.HasPrefix(proxyURL, "http://") { +// proxyURL = proxyURL[7:] +// } +// // 去除认证信息 +// if atIndex := strings.Index(proxyURL, "@"); atIndex != -1 { +// proxyURL = proxyURL[atIndex+1:] +// } +// // 去除端口 +// if colonIndex := strings.Index(proxyURL, ":"); colonIndex != -1 { +// proxyURL = proxyURL[:colonIndex] +// } +// return proxyURL +//} +// +//// 随机代理服务器 +//func randomServer() string { +// return randomElement(servers) +//} +// +//// 线程安全的随机元素选择 +//func randomElement(slice []string) string { +// randMutex.Lock() +// defer randMutex.Unlock() +// return slice[globalRand.Intn(len(slice))] +//} +// +//// 打乱服务器顺序 +//func shuffleServers(servers []string) []string { +// randMutex.Lock() +// defer randMutex.Unlock() +// +// shuffled := make([]string, len(servers)) +// copy(shuffled, servers) +// globalRand.Shuffle(len(shuffled), func(i, j int) { +// shuffled[i], shuffled[j] = shuffled[j], shuffled[i] +// }) +// return shuffled +//} +// +//// 检查卡密是否过期 +//func checkTailCardSecretExpired(tailCardSecret string) (bool, error) { +// code, err := getMachineCode(tailCardSecret) +// if err != nil { +// return false, fmt.Errorf("请求错误: %v", err) +// } +// targetTime, err := time.Parse("2006-01-02 15:04:05", code.Data.IpExpTime) +// if err != nil { +// return false, fmt.Errorf("时间格式错误: %v", err) +// } +// currentTime := time.Now() +// if targetTime.After(currentTime) { +// return true, nil +// } else { +// return false, fmt.Errorf("卡密已经过期！过期时间: %v", targetTime) +// } +//} +// +//// 定义响应结构体 +//type getMachineCodeResp struct { +// Code int `json:"code"` +// Message string `json:"message"` +// Data struct { +// MachineCode string `json:"machine_code"` +// IpExpTime string `json:"ip_exp_time"` +// IpThread int `json:"ip_thread"` +// IpCardCode string `json:"ip_card_code"` +// } `json:"data"` +//} +// +//// 查询机器码 +//func getMachineCode(tailCardSecret string) (*getMachineCodeResp, error) { +// url := "http://114.66.2.223:7842/api/proxies/ip_show" +// data := map[string]interface{}{ +// "ip_card_code": tailCardSecret, +// "agent_id": 9999, +// } +// _, body, errs := gorequest.New().Post(url).Send(data).End() +// if len(errs) > 0 { +// return nil, fmt.Errorf("查询机器码失败: %v", errs) +// } +// var resp getMachineCodeResp +// if err := json.Unmarshal([]byte(body), &resp); err != nil { +// return nil, fmt.Errorf("解析响应失败: %v", err) +// } +// +// if resp.Code == 201 { +// machineCode, err := rechargeCard(tailCardSecret, resp.Data.MachineCode) +// if err != nil { +// return nil, err +// } +// resp.Data.MachineCode = machineCode +// return &resp, nil +// } else if resp.Code == 200 { +// return &resp, nil +// } else { +// return nil, fmt.Errorf("查询机器码失败: %s", resp.Message) +// } +//} +// +//// 充值卡密 +//func rechargeCard(tailCardSecret, machineCode string) (string, error) { +// url := "http://114.66.2.223:7842/api/proxies/ip_recharge" +// data := map[string]interface{}{ +// "machine_code": machineCode, +// "ip_card_code": tailCardSecret, +// "agent_id": 9999, +// } +// _, body, errs := gorequest.New().Post(url).Send(data).End() +// if len(errs) > 0 { +// return "", fmt.Errorf("充值卡密失败: %v", errs) +// } +// var resp struct { +// Code int `json:"code"` // 状态码 +// Message string `json:"message"` // 返回消息 +// Data struct { +// IpExpTime string `json:"ip_exp_time"` // 过期时间 +// IpThread int `json:"ip_thread"` // 线程 +// MachineCode string `json:"machine_code"` // 机器码 +// } `json:"data"` +// } +// if err := json.Unmarshal([]byte(body), &resp); err != nil { +// return "", fmt.Errorf("解析响应失败: %v", err) +// } +// if resp.Code != 200 { +// return "", fmt.Errorf("充值卡密失败: %s", resp.Message) +// } +// return resp.Data.MachineCode, nil +//} +// +//// 获取代理服务器列表 +//func getProxies(machineCode string) ([]string, error) { +// log.Printf("[INFO] 开始获取代理列表: %s", machineCode) +// // 生成签名 +// sign := fmt.Sprintf("%x", md5.Sum([]byte(fmt.Sprintf("9999%s9999", machineCode)))) +// +// GetProxiesUrl := fmt.Sprintf("http://114.66.2.223:7842/api/proxies/get_proxy?machine_code=%s&sign=%s&agent_id=9999", +// machineCode, sign) +// +// req := gorequest.New().Get(GetProxiesUrl).Timeout(20 * time.Second) +// _, body, errs := req.End() +// if len(errs) > 0 { +// return nil, fmt.Errorf("获取代理失败: %v", errs) +// } +// +// // 检查是否为JSON错误响应 +// if strings.HasPrefix(strings.TrimSpace(body), "{") && strings.HasSuffix(strings.TrimSpace(body), "}") { +// // 尝试解析为JSON错误响应 +// var errorResp struct { +// Code int `json:"code"` +// Message string `json:"message"` +// } +// if err := json.Unmarshal([]byte(body), &errorResp); err == nil { +// return nil, fmt.Errorf("获取代理失败: %s (错误码: %d)", errorResp.Message, errorResp.Code) +// } +// } +// +// // 解析响应 +// lines := strings.Split(strings.TrimSpace(body), "\n") +// var proxies []string +// for _, line := range lines { +// line = strings.TrimSpace(line) +// if line != "" && !strings.HasPrefix(line, "{") { +// proxies = append(proxies, line) +// } +// } +// if len(proxies) == 0 { +// return nil, fmt.Errorf("未获取到有效代理") +// } +// +// log.Printf("[INFO] 获取到 %d 个代理", len(proxies)) +// return proxies, nil +//} +// +//// 初始化代理信息 +//func initProxy() { +// +//} +// +//// =================== C 导出函数 ======================= +// +//// 导出函数：获取代理健康状态（用于调试） +//// +////export GetProxyHealth +//func GetProxyHealth() *C.char { +// proxyHealthMutex.RLock() +// defer proxyHealthMutex.RUnlock() +// +// healthInfo := make(map[string]interface{}) +// for proxy, health := range proxyHealthMaps { +// healthInfo[proxy] = map[string]interface{}{ +// "success_count": health.SuccessCount, +// "fail_count": health.FailCount, +// "last_check": health.LastCheck.Format(time.RFC3339), +// "response_time": health.ResponseTime.String(), +// "is_healthy": health.IsHealthy, +// } +// } +// +// jsonData, err := json.Marshal(healthInfo) +// if err != nil { +// return C.CString(fmt.Sprintf(`{"error": "序列化健康信息失败: %v"}`, err)) +// } +// +// return C.CString(string(jsonData)) +//} +// +//// 导出函数：代理类型管理器 +//// +////export ProxyTypeManager +//func ProxyTypeManager(proxyType, username, password, machineCode *C.char) *C.char { +// goProxyType := C.GoString(proxyType) +// goUsername := C.GoString(username) +// goPassword := C.GoString(password) +// goMachineCode := C.GoString(machineCode) +// +// log.Printf("[DEBUG] 代理类型管理器调用: type=%s", goProxyType) +// +// proxyURL, err := proxyTypeManager(goProxyType, goUsername, goPassword, goMachineCode) +// if err != nil { +// errorMsg := fmt.Sprintf("ERROR: %v", err) +// log.Printf("[ERROR] 代理类型管理器错误: %v", err) +// return C.CString(errorMsg) +// } +// +// log.Printf("[DEBUG] 代理类型管理器返回: %s", proxyURL) +// return C.CString(proxyURL) +//} +// +//// 导出函数：查询机器码 +//// +////export GetMachineCode +//func GetMachineCode(tailCardSecret *C.char) *C.char { +// goTailCardSecret := C.GoString(tailCardSecret) +// log.Printf("[DEBUG] 查询机器码调用: card=%s", goTailCardSecret) +// +// resp, err := getMachineCode(goTailCardSecret) +// if err != nil { +// errorMsg := fmt.Sprintf("ERROR: %v", err) +// log.Printf("[ERROR] 查询机器码错误: %v", err) +// return C.CString(errorMsg) +// } +// +// // 将响应转换为JSON +// jsonData, err := json.Marshal(resp) +// if err != nil { +// errorMsg := fmt.Sprintf("ERROR: 序列化响应失败: %v", err) +// log.Printf("[ERROR] 序列化机器码响应失败: %v", err) +// return C.CString(errorMsg) +// } +// +// log.Printf("[DEBUG] 查询机器码成功: code=%d, machine_code=%s", resp.Code, resp.Data.MachineCode) +// return C.CString(string(jsonData)) +//} +// +//// 导出函数：充值卡密 +//// +////export RechargeCard +//func RechargeCard(tailCardSecret, machineCode *C.char) *C.char { +// goTailCardSecret := C.GoString(tailCardSecret) +// goMachineCode := C.GoString(machineCode) +// log.Printf("[DEBUG] 充值卡密调用: card=%s, machine_code=%s", goTailCardSecret, goMachineCode) +// +// newMachineCode, err := rechargeCard(goTailCardSecret, goMachineCode) +// if err != nil { +// errorMsg := fmt.Sprintf("ERROR: %v", err) +// log.Printf("[ERROR] 充值卡密错误: %v", err) +// return C.CString(errorMsg) +// } +// +// // 构建成功响应 +// response := map[string]interface{}{ +// "success": true, +// "machine_code": newMachineCode, +// "message": "充值成功", +// } +// +// jsonData, err := json.Marshal(response) +// if err != nil { +// errorMsg := fmt.Sprintf("ERROR: 序列化响应失败: %v", err) +// log.Printf("[ERROR] 序列化充值响应失败: %v", err) +// return C.CString(errorMsg) +// } +// +// log.Printf("[DEBUG] 充值卡密成功: new_machine_code=%s", newMachineCode) +// return C.CString(string(jsonData)) +//} +// +//// 导出函数：获取代理服务器列表 +//// +////export GetProxies +//func GetProxies(machineCode *C.char) *C.char { +// goMachineCode := C.GoString(machineCode) +// log.Printf("[DEBUG] 获取代理服务器列表调用: machine_code=%s", goMachineCode) +// +// proxies, err := getProxies(goMachineCode) +// if err != nil { +// errorMsg := fmt.Sprintf("ERROR: %v", err) +// log.Printf("[ERROR] 获取代理服务器列表错误: %v", err) +// return C.CString(errorMsg) +// } +// +// // 将代理列表转换为JSON +// response := map[string]interface{}{ +// "success": true, +// "count": len(proxies), +// "proxies": proxies, +// } +// +// jsonData, err := json.Marshal(response) +// if err != nil { +// errorMsg := fmt.Sprintf("ERROR: 序列化响应失败: %v", err) +// log.Printf("[ERROR] 序列化代理列表失败: %v", err) +// return C.CString(errorMsg) +// } +// +// log.Printf("[DEBUG] 获取代理服务器列表成功: count=%d", len(proxies)) +// return C.CString(string(jsonData)) +//} +// +//// 导出函数：检查卡密是否过期 +//// +////export CheckTailCardSecretExpired +//func CheckTailCardSecretExpired(tailCardSecret *C.char) *C.char { +// goTailCardSecret := C.GoString(tailCardSecret) +// log.Printf("[DEBUG] 检查卡密是否过期调用: card=%s", goTailCardSecret) +// +// isValid, err := checkTailCardSecretExpired(goTailCardSecret) +// if err != nil { +// // 如果是过期错误，返回特定格式 +// if strings.Contains(err.Error(), "卡密已经过期") { +// response := map[string]interface{}{ +// "is_valid": false, +// "message": err.Error(), +// } +// jsonData, _ := json.Marshal(response) +// return C.CString(string(jsonData)) +// } +// +// errorMsg := fmt.Sprintf("ERROR: %v", err) +// log.Printf("[ERROR] 检查卡密过期错误: %v", err) +// return C.CString(errorMsg) +// } +// +// response := map[string]interface{}{ +// "is_valid": isValid, +// "message": "卡密有效", +// } +// +// jsonData, err := json.Marshal(response) +// if err != nil { +// errorMsg := fmt.Sprintf("ERROR: 序列化响应失败: %v", err) +// return C.CString(errorMsg) +// } +// +// log.Printf("[DEBUG] 检查卡密过期结果: is_valid=%v", isValid) +// return C.CString(string(jsonData)) +//} +// +//// 导出函数：初始化代理管理器 +//// +////export InitProxyManager +//func InitProxyManager(serversJson, username, password, tailCardSecret, proxyType *C.char) *C.char { +// goServersJson := C.GoString(serversJson) +// goUsername := C.GoString(username) +// goPassword := C.GoString(password) +// goTailCardSecret := C.GoString(tailCardSecret) +// goProxyType := C.GoString(proxyType) +// +// log.Printf("[DEBUG] 初始化代理管理器调用: type=%s", goProxyType) +// +// // 解析服务器列表 +// var serverList []string +// if goServersJson != "" { +// if err := json.Unmarshal([]byte(goServersJson), &serverList); err != nil { +// errorMsg := fmt.Sprintf("ERROR: 解析服务器列表失败: %v", err) +// log.Printf("[ERROR] 解析服务器列表失败: %v", err) +// return C.CString(errorMsg) +// } +// } +// +// // 更新全局服务器列表 +// if len(serverList) > 0 { +// randMutex.Lock() +// servers = serverList +// randMutex.Unlock() +// log.Printf("[INFO] 更新服务器列表，共 %d 个服务器", len(servers)) +// } +// +// // 创建代理管理器 +// manager := ProxyManager{ +// servers: servers, +// username: goUsername, +// password: goPassword, +// tailCardSecret: goTailCardSecret, +// proxyType: goProxyType, +// } +// +// // 序列化管理器信息 +// jsonData, err := json.Marshal(manager) +// if err != nil { +// errorMsg := fmt.Sprintf("ERROR: 序列化代理管理器失败: %v", err) +// log.Printf("[ERROR] 序列化代理管理器失败: %v", err) +// return C.CString(errorMsg) +// } +// +// log.Printf("[DEBUG] 代理管理器初始化成功") +// return C.CString(string(jsonData)) +//} +// +//// 导出函数：释放C字符串内存 +//// +////export FreeCString +//func FreeCString(str *C.char) { +// C.free(unsafe.Pointer(str)) +//} +// +//func main() { +//} diff --git a/so/kongfz.so b/so/kongfz.so new file mode 100644 index 0000000..4d66ead Binary files /dev/null and b/so/kongfz.so differ diff --git a/zjdydll.go b/zjdydll.go index e6f987f..849e037 100644 --- a/zjdydll.go +++ b/zjdydll.go @@ -1,1153 +1,1237 @@ package main -//import "C" -//import ( -// "encoding/json" -// "fmt" -// "log" -// "net/http" -// "os" -// "path/filepath" -// "syscall" -// "unsafe" -//) -// -//// 配置结构 -//type Configs struct { -// App struct { -// MaxRetryTimes int `json:"max_retry_times"` -// RateLimitDelay int `json:"rate_limit_delay"` -// Size int `json:"size"` -// DefaultUserAgent string `json:"default_user_agent"` -// } `json:"app"` -// -// API struct { -// LoginURL string `json:"login_url"` -// BookSearchURL string `json:"book_search_url"` -// ProductSearchURL string `json:"product_search_url"` -// } `json:"api"` -// -// Proxy struct { -// Servers string `json:"servers"` -// Username string `json:"username"` -// Password string `json:"password"` -// TailMachineCode string `json:"tail_machine_code"` -// TailCardKey string `json:"tail_card_key"` -// ProxyFilePath string `json:"proxy_file_path"` -// } `json:"proxy"` -//} -// -//// API响应结构 -//type APIResponses struct { -// Success bool `json:"success"` -// Message string `json:"message,omitempty"` -// GoodsNum string `json:"goods_num,omitempty"` -// PNum string `json:"pnum,omitempty"` -// Data interface{} `json:"data,omitempty"` -// Error string `json:"error,omitempty"` -//} -// -//type DLLManager struct { -// dll *syscall.DLL -//} -// -//func NewDLLManager(dllPath string) (*DLLManager, error) { -// dll, err := syscall.LoadDLL(dllPath) -// if err != nil { -// return nil, fmt.Errorf("加载DLL失败: %v", err) -// } -// -// return &DLLManager{dll: dll}, nil -//} -// -//func (m *DLLManager) Close() { -// if m.dll != nil { -// m.dll.Release() -// } -//} -// -//// 单参数函数调用 -//func (m *DLLManager) callFunction(funcName string, arg string) (string, error) { -// proc, err := m.dll.FindProc(funcName) -// if err != nil { -// return "", fmt.Errorf("找不到函数 %s: %v", funcName, err) -// } -// -// argPtr, _ := syscall.BytePtrFromString(arg) -// r1, _, err := proc.Call(uintptr(unsafe.Pointer(argPtr))) -// if err != nil && err.Error() != "The operation completed successfully." { -// return "", fmt.Errorf("调用函数 %s 失败: %v", funcName, err) -// } -// -// result := (*byte)(unsafe.Pointer(r1)) -// -// // 将C字符串转换为Go字符串 -// var resultBytes []byte -// for i := 0; ; i++ { -// if *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(result)) + uintptr(i))) == 0 { -// break -// } -// resultBytes = append(resultBytes, *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(result)) + uintptr(i)))) -// } -// -// // 释放内存 -// freeProc, _ := m.dll.FindProc("FreeString") -// if freeProc != nil { -// freeProc.Call(r1) -// } -// -// return string(resultBytes), nil -//} -// -//// 二参数函数调用 -//func (m *DLLManager) callFunctionTwoArgs(funcName string, args ...string) (string, error) { -// if len(args) != 2 { -// return "", fmt.Errorf("函数 %s 需要2个参数，但提供了 %d 个", funcName, len(args)) -// } -// -// proc, err := m.dll.FindProc(funcName) -// if err != nil { -// return "", fmt.Errorf("找不到函数 %s: %v", funcName, err) -// } -// -// // 准备参数指针 -// argPtrs := make([]uintptr, 2) -// for i, arg := range args { -// argPtr, _ := syscall.BytePtrFromString(arg) -// argPtrs[i] = uintptr(unsafe.Pointer(argPtr)) -// } -// -// r1, _, err := proc.Call( -// argPtrs[0], // proxyType -// argPtrs[1], // username -// ) -// if err != nil && err.Error() != "The operation completed successfully." { -// return "", fmt.Errorf("调用函数 %s 失败: %v", funcName, err) -// } -// -// result := (*byte)(unsafe.Pointer(r1)) -// -// // 将C字符串转换为Go字符串 -// var resultBytes []byte -// for i := 0; ; i++ { -// if *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(result)) + uintptr(i))) == 0 { -// break -// } -// resultBytes = append(resultBytes, *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(result)) + uintptr(i)))) -// } -// -// // 释放内存 -// freeProc, _ := m.dll.FindProc("FreeString") -// if freeProc != nil { -// freeProc.Call(r1) -// } -// -// return string(resultBytes), nil -//} -// -//// 五参数函数调用 - 用于 GetKFZGTImageURL 和 GetKFZSPTImageURL -//func (m *DLLManager) callFunctionFiveArgs(funcName string, args ...string) (string, error) { -// if len(args) != 5 { -// return "", fmt.Errorf("函数 %s 需要5个参数，但提供了 %d 个", funcName, len(args)) -// } -// -// proc, err := m.dll.FindProc(funcName) -// if err != nil { -// return "", fmt.Errorf("找不到函数 %s: %v", funcName, err) -// } -// -// // 准备参数指针 -// argPtrs := make([]uintptr, 5) -// for i, arg := range args { -// argPtr, _ := syscall.BytePtrFromString(arg) -// argPtrs[i] = uintptr(unsafe.Pointer(argPtr)) -// } -// -// r1, _, err := proc.Call( -// argPtrs[0], // proxyType -// argPtrs[1], // username -// argPtrs[2], // password -// argPtrs[3], // machineCode -// argPtrs[4], // isbn -// ) -// if err != nil && err.Error() != "The operation completed successfully." { -// return "", fmt.Errorf("调用函数 %s 失败: %v", funcName, err) -// } -// -// result := (*byte)(unsafe.Pointer(r1)) -// -// // 将C字符串转换为Go字符串 -// var resultBytes []byte -// for i := 0; ; i++ { -// if *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(result)) + uintptr(i))) == 0 { -// break -// } -// resultBytes = append(resultBytes, *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(result)) + uintptr(i)))) -// } -// -// // 释放内存 -// freeProc, _ := m.dll.FindProc("FreeString") -// if freeProc != nil { -// freeProc.Call(r1) -// } -// -// return string(resultBytes), nil -//} -// -//// 六参数函数调用 -//func (m *DLLManager) callFunctionSixArgs(funcName string, args ...string) (string, error) { -// if len(args) != 6 { -// return "", fmt.Errorf("函数 %s 需要6个参数，但提供了 %d 个", funcName, len(args)) -// } -// -// proc, err := m.dll.FindProc(funcName) -// if err != nil { -// return "", fmt.Errorf("找不到函数 %s: %v", funcName, err) -// } -// -// // 准备参数指针 -// argPtrs := make([]uintptr, 6) -// for i, arg := range args { -// argPtr, _ := syscall.BytePtrFromString(arg) -// argPtrs[i] = uintptr(unsafe.Pointer(argPtr)) -// } -// -// r1, _, err := proc.Call( -// argPtrs[0], // fetchMode -// argPtrs[1], // proxyType -// argPtrs[2], // username -// argPtrs[3], // password -// argPtrs[4], // machineCode -// argPtrs[5], // isbn -// ) -// if err != nil && err.Error() != "The operation completed successfully." { -// return "", fmt.Errorf("调用函数 %s 失败: %v", funcName, err) -// } -// -// result := (*byte)(unsafe.Pointer(r1)) -// -// // 将C字符串转换为Go字符串 -// var resultBytes []byte -// for i := 0; ; i++ { -// if *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(result)) + uintptr(i))) == 0 { -// break -// } -// resultBytes = append(resultBytes, *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(result)) + uintptr(i)))) -// } -// -// // 释放内存 -// freeProc, _ := m.dll.FindProc("FreeString") -// if freeProc != nil { -// freeProc.Call(r1) -// } -// -// return string(resultBytes), nil -//} -// -//// 十二参数函数调用 - 专门用于 GetKFZShopBookInfo -//func (m *DLLManager) callFunctionTwelveArgs(funcName string, args ...string) (string, error) { -// if len(args) != 12 { -// return "", fmt.Errorf("函数 %s 需要12个参数，但提供了 %d 个", funcName, len(args)) -// } -// -// proc, err := m.dll.FindProc(funcName) -// if err != nil { -// return "", fmt.Errorf("找不到函数 %s: %v", funcName, err) -// } -// -// // 准备参数指针 -// argPtrs := make([]uintptr, 12) -// for i, arg := range args { -// argPtr, _ := syscall.BytePtrFromString(arg) -// argPtrs[i] = uintptr(unsafe.Pointer(argPtr)) -// } -// -// r1, _, err := proc.Call( -// argPtrs[0], // proxyType -// argPtrs[1], // username -// argPtrs[2], // password -// argPtrs[3], // machineCode -// argPtrs[4], // shopId -// argPtrs[5], // isImage -// argPtrs[6], // bookNum -// argPtrs[7], // pageNum -// argPtrs[8], // sortType -// argPtrs[9], // sort -// argPtrs[10], // priceDown -// argPtrs[11], // priceUp -// ) -// if err != nil && err.Error() != "The operation completed successfully." { -// return "", fmt.Errorf("调用函数 %s 失败: %v", funcName, err) -// } -// -// result := (*byte)(unsafe.Pointer(r1)) -// -// // 将C字符串转换为Go字符串 -// var resultBytes []byte -// for i := 0; ; i++ { -// if *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(result)) + uintptr(i))) == 0 { -// break -// } -// resultBytes = append(resultBytes, *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(result)) + uintptr(i)))) -// } -// -// // 释放内存 -// freeProc, _ := m.dll.FindProc("FreeString") -// if freeProc != nil { -// freeProc.Call(r1) -// } -// -// return string(resultBytes), nil -//} -// -//// 十三参数函数调用 - 专门用于 GetKFZShopBookInfo -//func (m *DLLManager) callFunctionThirteenArgs(funcName string, args ...string) (string, error) { -// if len(args) != 13 { -// return "", fmt.Errorf("函数 %s 需要13个参数，但提供了 %d 个", funcName, len(args)) -// } -// -// proc, err := m.dll.FindProc(funcName) -// if err != nil { -// return "", fmt.Errorf("找不到函数 %s: %v", funcName, err) -// } -// -// // 准备参数指针 -// argPtrs := make([]uintptr, 13) -// for i, arg := range args { -// argPtr, _ := syscall.BytePtrFromString(arg) -// argPtrs[i] = uintptr(unsafe.Pointer(argPtr)) -// } -// -// r1, _, err := proc.Call( -// argPtrs[0], // fetchMode -// argPtrs[1], // proxyType -// argPtrs[2], // username -// argPtrs[3], // password -// argPtrs[4], // machineCode -// argPtrs[5], // shopId -// argPtrs[6], // isImage -// argPtrs[7], // bookNum -// argPtrs[8], // pageNum -// argPtrs[9], // sortType -// argPtrs[10], // sort -// argPtrs[11], // priceDown -// argPtrs[12], // priceUp -// ) -// if err != nil && err.Error() != "The operation completed successfully." { -// return "", fmt.Errorf("调用函数 %s 失败: %v", funcName, err) -// } -// -// result := (*byte)(unsafe.Pointer(r1)) -// -// // 将C字符串转换为Go字符串 -// var resultBytes []byte -// for i := 0; ; i++ { -// if *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(result)) + uintptr(i))) == 0 { -// break -// } -// resultBytes = append(resultBytes, *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(result)) + uintptr(i)))) -// } -// -// // 释放内存 -// freeProc, _ := m.dll.FindProc("FreeString") -// if freeProc != nil { -// freeProc.Call(r1) -// } -// -// return string(resultBytes), nil -//} -// -//func (m *DLLManager) Initialize(configJSON string) (string, error) { -// return m.callFunction("Initialize", configJSON) -//} -// -//// 修改后的 GetKFZGTImageURL - 需要5个参数 -//func (m *DLLManager) GetKFZGTImageURL(proxyType, username, password, machineCode, isbn string) (string, error) { -// return m.callFunctionFiveArgs("GetKFZGTImageURL", -// proxyType, username, password, machineCode, isbn) -//} -// -//// 修改后的 GetKFZSPTImageURL - 需要5个参数 -//func (m *DLLManager) GetKFZSPTImageURL(proxyType, username, password, machineCode, isbn string) (string, error) { -// return m.callFunctionFiveArgs("GetKFZSPTImageURL", -// proxyType, username, password, machineCode, isbn) -//} -// -//// 修改后的 GetKFZShopBookInfo - 需要12个参数 -//func (m *DLLManager) GetKFZShopBookInfo(fetchMode, proxyType, username, password, machineCode, shopId, isImage, bookNum, pageNum, sortType, sort, priceDown, priceUp string) (string, error) { -// return m.callFunctionThirteenArgs("GetKFZShopBookInfo", -// fetchMode, proxyType, username, password, machineCode, shopId, isImage, bookNum, pageNum, sortType, sort, priceDown, priceUp) -//} -// -//// 获取 GetUrlBookDetails - 需要6个参数 -//func (m *DLLManager) GetUrlBookDetails(fetchMode, proxyType, username, password, machineCode, url string) (string, error) { -// return m.callFunctionSixArgs("GetUrlBookDetails", fetchMode, proxyType, username, password, machineCode, url) -//} -// -//// 获取 OutLogin -//func (m *DLLManager) OutLogin(username, password string) (string, error) { -// // 获取函数 -// proc, err := m.dll.FindProc("OutLogin") -// if err != nil { -// return "", fmt.Errorf("找不到函数 %s: %v", "OutLogin", err) -// } -// // 转换参数 -// usernamePtr := uintptr(unsafe.Pointer(syscall.StringBytePtr(username))) -// passwordPtr := uintptr(unsafe.Pointer(syscall.StringBytePtr(password))) -// // 调用函数 -// ret, _, err := proc.Call(usernamePtr, passwordPtr) -// if ret == 0 { -// return "", fmt.Errorf("DLL调用失败: %v", err) -// } -// -// // 将C字符串转换为Go字符串 -// var resultBytes []byte -// for i := 0; ; i++ { -// if *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ret)) + uintptr(i))) == 0 { -// break -// } -// resultBytes = append(resultBytes, *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ret)) + uintptr(i)))) -// } -// -// // 释放内存（假设DLL提供了FreeMemory函数） -// findProc, err := m.dll.FindProc("FreeString") -// if findProc != nil { -// findProc.Call(ret) -// } -// return string(resultBytes), nil -//} -// -//// 获取 OutGetUserMsg -//func (m *DLLManager) OutGetUserMsg(token string) (string, error) { -// // 获取函数 -// proc, err := m.dll.FindProc("OutGetUserMsg") -// if err != nil { -// return "", fmt.Errorf("找不到函数 %s: %v", "OutGetUserMsg", err) -// } -// // 转换参数 -// tokenPtr := uintptr(unsafe.Pointer(syscall.StringBytePtr(token))) -// // 调用函数 -// ret, _, err := proc.Call(tokenPtr) -// if ret == 0 { -// return "", fmt.Errorf("DLL调用失败: %v", err) -// } -// -// // 将C字符串转换为Go字符串 -// var resultBytes []byte -// for i := 0; ; i++ { -// if *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ret)) + uintptr(i))) == 0 { -// break -// } -// resultBytes = append(resultBytes, *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ret)) + uintptr(i)))) -// } -// -// // 释放内存（假设DLL提供了FreeMemory函数） -// findProc, err := m.dll.FindProc("FreeString") -// if findProc != nil { -// findProc.Call(ret) -// } -// return string(resultBytes), nil -//} -// -//// 获取 OutGetGoodsTplMsg -//func (m *DLLManager) OutGetGoodsTplMsg(token, itemId, proxy string) (string, error) { -// // 获取函数 -// proc, err := m.dll.FindProc("OutGetGoodsTplMsg") -// if err != nil { -// return "", fmt.Errorf("找不到函数 %s: %v", "OutGetGoodsTplMsg", err) -// } -// // 转换参数 -// tokenPtr := uintptr(unsafe.Pointer(syscall.StringBytePtr(token))) -// itemIdPtr := uintptr(unsafe.Pointer(syscall.StringBytePtr(itemId))) -// proxyPtr := uintptr(unsafe.Pointer(syscall.StringBytePtr(proxy))) -// // 调用函数 -// ret, _, err := proc.Call(tokenPtr, itemIdPtr, proxyPtr) -// if ret == 0 { -// return "", fmt.Errorf("DLL调用失败: %v", err) -// } -// -// // 将C字符串转换为Go字符串 -// var resultBytes []byte -// for i := 0; ; i++ { -// if *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ret)) + uintptr(i))) == 0 { -// break -// } -// resultBytes = append(resultBytes, *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ret)) + uintptr(i)))) -// } -// -// // 释放内存（假设DLL提供了FreeMemory函数） -// findProc, err := m.dll.FindProc("FreeString") -// if findProc != nil { -// findProc.Call(ret) -// } -// return string(resultBytes), nil -//} -// -//// 获取 OutGetGoodsListMsgFromSelfShop -//func (m *DLLManager) OutGetGoodsListMsgFromSelfShop(token string, proxy string, itemSn string, priceMin string, priceMax string, startCreateTime int, -// endCreateTime int, requestType string, isItemSnEqual int, page int, size int) (string, error) { -// // 获取函数 -// proc, err := m.dll.FindProc("OutGetGoodsListMsgFromSelfShop") -// if err != nil { -// return "", fmt.Errorf("找不到函数 %s: %v", "OutGetGoodsListMsgFromSelfShop", err) -// } -// // 转换参数 -// tokenPtr := uintptr(unsafe.Pointer(syscall.StringBytePtr(token))) -// proxyPtr := uintptr(unsafe.Pointer(syscall.StringBytePtr(proxy))) -// itemSnPtr := uintptr(unsafe.Pointer(syscall.StringBytePtr(itemSn))) -// priceMinPtr := uintptr(unsafe.Pointer(syscall.StringBytePtr(priceMin))) -// priceMaxPtr := uintptr(unsafe.Pointer(syscall.StringBytePtr(priceMax))) -// startCreateTimePtr := uintptr(startCreateTime) -// endCreateTimePtr := uintptr(endCreateTime) -// requestTypePtr := uintptr(unsafe.Pointer(syscall.StringBytePtr(requestType))) -// isItemSnEqualPtr := uintptr(isItemSnEqual) -// pagePtr := uintptr(page) -// sizePtr := uintptr(size) -// // 调用函数 -// ret, _, err := proc.Call(tokenPtr, proxyPtr, itemSnPtr, priceMinPtr, priceMaxPtr, startCreateTimePtr, endCreateTimePtr, requestTypePtr, isItemSnEqualPtr, pagePtr, sizePtr) -// if ret == 0 { -// return "", fmt.Errorf("DLL调用失败: %v", err) -// } -// -// // 将C字符串转换为Go字符串 -// var resultBytes []byte -// for i := 0; ; i++ { -// if *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ret)) + uintptr(i))) == 0 { -// break -// } -// resultBytes = append(resultBytes, *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ret)) + uintptr(i)))) -// } -// -// // 释放内存（假设DLL提供了FreeMemory函数） -// findProc, err := m.dll.FindProc("FreeString") -// if findProc != nil { -// findProc.Call(ret) -// } -// return string(resultBytes), nil -//} -// -//// 获取 OutGetImageByIsbn -//func (m *DLLManager) OutGetImageByIsbn(token string, isbn string, proxy string, isLiveImage bool, isReturnMsg bool) (string, error) { -// // 获取函数 -// proc, err := m.dll.FindProc("OutGetImageByIsbn") -// if err != nil { -// return "", fmt.Errorf("找不到函数 %s: %v", "OutGetImageByIsbn", err) -// } -// // 转换参数 -// tokenPtr := uintptr(unsafe.Pointer(syscall.StringBytePtr(token))) -// isbnPtr := uintptr(unsafe.Pointer(syscall.StringBytePtr(isbn))) -// var proxyPtr uintptr -// if proxy != "" { -// proxyPtr = uintptr(unsafe.Pointer(syscall.StringBytePtr(proxy))) -// } else { -// proxyPtr = 0 -// } -// var isLiveImageInt int -// if isLiveImage { -// isLiveImageInt = 0 -// } else { -// isLiveImageInt = 1 -// } -// isLiveImagePtr := uintptr(isLiveImageInt) -// var isReturnMsgInt int -// if isReturnMsg { -// isLiveImageInt = 0 -// } else { -// isLiveImageInt = 1 -// } -// isReturnMsgPtr := uintptr(isReturnMsgInt) -// // 调用函数 -// ret, _, err := proc.Call(tokenPtr, isbnPtr, proxyPtr, isLiveImagePtr, isReturnMsgPtr) -// if ret == 0 { -// return "", fmt.Errorf("DLL调用失败: %v", err) -// } -// -// // 将C字符串转换为Go字符串 -// var resultBytes []byte -// for i := 0; ; i++ { -// if *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ret)) + uintptr(i))) == 0 { -// break -// } -// resultBytes = append(resultBytes, *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ret)) + uintptr(i)))) -// } -// -// // 释放内存（假设DLL提供了FreeMemory函数） -// findProc, err := m.dll.FindProc("FreeString") -// if findProc != nil { -// findProc.Call(ret) -// } -// return string(resultBytes), nil -//} -// -//// 获取 OutGetGoodsMsgByDetailUrl -//func (m *DLLManager) OutGetGoodsMsgByDetailUrl(url, proxy string) (string, error) { -// // 获取函数 -// proc, err := m.dll.FindProc("OutGetGoodsMsgByDetailUrl") -// if err != nil { -// return "", fmt.Errorf("找不到函数 %s: %v", "OutGetGoodsMsgByDetailUrl", err) -// } -// // 转换参数 -// urlPtr := uintptr(unsafe.Pointer(syscall.StringBytePtr(url))) -// var proxyPtr uintptr -// if proxy != "" { -// proxyPtr = uintptr(unsafe.Pointer(syscall.StringBytePtr(proxy))) -// } else { -// proxyPtr = 0 -// } -// // 调用函数 -// ret, _, err := proc.Call(urlPtr, proxyPtr) -// if ret == 0 { -// return "", fmt.Errorf("DLL调用失败: %v", err) -// } -// -// // 将C字符串转换为Go字符串 -// var resultBytes []byte -// for i := 0; ; i++ { -// if *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ret)) + uintptr(i))) == 0 { -// break -// } -// resultBytes = append(resultBytes, *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ret)) + uintptr(i)))) -// } -// -// // 释放内存（假设DLL提供了FreeMemory函数） -// findProc, err := m.dll.FindProc("FreeString") -// if findProc != nil { -// findProc.Call(ret) -// } -// return string(resultBytes), nil -//} -// -//// 获取 OutGetGoodsListMsgByShopId -//func (m *DLLManager) OutGetGoodsListMsgByShopId(shopId int, proxy string, isImage bool, sortType string, sort string, priceMin float32, priceMax float32, pageNum, returnNum int) (string, error) { -// // 获取函数 -// proc, err := m.dll.FindProc("OutGetGoodsListMsgByShopId") -// if err != nil { -// return "", fmt.Errorf("找不到函数 %s: %v", "OutGetGoodsListMsgByShopId", err) -// } -// // 转换参数 -// shopIdPtr := uintptr(shopId) -// var isImageInt int -// if isImage { -// isImageInt = 0 -// } else { -// isImageInt = 1 -// } -// isImagePtr := uintptr(isImageInt) -// sortTypePtr := uintptr(unsafe.Pointer(syscall.StringBytePtr(sortType))) -// sortPtr := uintptr(unsafe.Pointer(syscall.StringBytePtr(sort))) -// priceMinPtr := uintptr(*(*uint32)(unsafe.Pointer(&priceMin))) -// priceMaxPtr := uintptr(*(*uint32)(unsafe.Pointer(&priceMax))) -// pageNumPtr := uintptr(pageNum) -// returnNumPtr := uintptr(returnNum) -// var proxyPtr uintptr -// if proxy != "" { -// proxyPtr = uintptr(unsafe.Pointer(syscall.StringBytePtr(proxy))) -// } else { -// proxyPtr = 0 -// } -// // 调用函数 -// ret, _, err := proc.Call(shopIdPtr, proxyPtr, isImagePtr, sortTypePtr, sortPtr, priceMinPtr, priceMaxPtr, pageNumPtr, returnNumPtr) -// if ret == 0 { -// return "", fmt.Errorf("DLL调用失败: %v", err) -// } -// -// // 将C字符串转换为Go字符串 -// var resultBytes []byte -// for i := 0; ; i++ { -// if *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ret)) + uintptr(i))) == 0 { -// break -// } -// resultBytes = append(resultBytes, *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ret)) + uintptr(i)))) -// } -// -// // 释放内存（假设DLL提供了FreeMemory函数） -// findProc, err := m.dll.FindProc("FreeString") -// if findProc != nil { -// findProc.Call(ret) -// } -// return string(resultBytes), nil -//} -// -//// 获取 OutGetTopGoodsListMsg -//func (m *DLLManager) OutGetTopGoodsListMsg(catId int, proxy string) (string, error) { -// // 获取函数 -// proc, err := m.dll.FindProc("OutGetTopGoodsListMsg") -// if err != nil { -// return "", fmt.Errorf("找不到函数 %s: %v", "OutGetTopGoodsListMsg", err) -// } -// // 转换参数 -// catIdPtr := uintptr(catId) -// var proxyPtr uintptr -// if proxy != "" { -// proxyPtr = uintptr(unsafe.Pointer(syscall.StringBytePtr(proxy))) -// } else { -// proxyPtr = 0 -// } -// // 调用函数 -// ret, _, err := proc.Call(catIdPtr, proxyPtr) -// if ret == 0 { -// return "", fmt.Errorf("DLL调用失败: %v", err) -// } -// -// // 将C字符串转换为Go字符串 -// var resultBytes []byte -// for i := 0; ; i++ { -// if *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ret)) + uintptr(i))) == 0 { -// break -// } -// resultBytes = append(resultBytes, *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ret)) + uintptr(i)))) -// } -// -// // 释放内存（假设DLL提供了FreeMemory函数） -// findProc, err := m.dll.FindProc("FreeString") -// if findProc != nil { -// findProc.Call(ret) -// } -// return string(resultBytes), nil -//} -// -//// 创建默认配置 -//func createDefaultConfig() Config { -// var configs Config -// -// // App配置 -// configs.App.MaxRetryTimes = 3 -// configs.App.RateLimitDelay = 1000 -// configs.App.Size = 10 -// configs.App.DefaultUserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36" -// -// // API配置 -// configs.API.LoginURL = "https://login.kongfz.com/Pc/Login/account" -// configs.API.BookSearchURL = "https://search.kongfz.com/pc-gw/search-web/client/pc/bookLib/keyword/list" -// configs.API.ProductSearchURL = "https://search.kongfz.com/pc-gw/search-web/client/pc/product/keyword/list" -// -// // 代理配置（需要根据实际情况修改） -// configs.Proxy.Servers = "http-dynamic.xiaoxiangdaili.com,http-dynamic-S02.xiaoxiangdaili.com,http-dynamic-S03.xiaoxiangdaili.com,http-dynamic-S04.xiaoxiangdaili.com" -// configs.Proxy.Username = "1297757178467602432" -// configs.Proxy.Password = "QgQBvP7f" -// configs.Proxy.TailMachineCode = "b7bf22a237ec692f13fcc2c43ee63252" -// configs.Proxy.TailCardKey = "DL_20_YK_1920acb2129844c2aabade3896560a9b" -// configs.Proxy.ProxyFilePath = "dll/proxyConfig.dll" -// -// configs.Database.Username = "newAdmin" -// configs.Database.Password = "bYPp8SbBe5F7nz2i" -// configs.Database.Host = "146.56.227.42:3306" -// configs.Database.Name = "newadmin" -// -// return configs -//} -// -//// 获取当前可执行文件所在目录 -//func getExecutableDir() string { -// exePath, err := os.Executable() -// if err != nil { -// return "." -// } -// return filepath.Dir(exePath) -//} -// -//// 格式化输出JSON响应 -//func printFormattedResponse(operation string, result string, err error) int { -// var apiResp APIResponses -// fmt.Printf("\n%s:\n", operation) -// fmt.Println("=" + string(make([]byte, 50)) + "=") -// -// if err != nil { -// fmt.Printf("❌ 错误: %v\n", err) -// } -// var count int -// if err := json.Unmarshal([]byte(result), &apiResp); err == nil { -// if apiResp.Success { -// fmt.Printf("✅ 成功: %s\n", apiResp.Message) -// if apiResp.Data != nil { -// fmt.Println("📊 数据:") -// jsonData, _ := json.MarshalIndent(apiResp.Data, "", " ") -// fmt.Println(string(jsonData)) -// // 方法1: 判断 Data 的类型并统计条数 -// switch data := apiResp.Data.(type) { -// case []interface{}: -// // 如果是切片/数组 -// count = len(data) -// fmt.Printf("📈 数据条数: %d\n", count) -// case []BookInfo: -// // 如果是 BookInfo 切片 -// count = len(data) -// fmt.Printf("📚 图书数量: %d\n", count) -// case map[string]interface{}: -// // 如果是映射 -// count = len(data) -// fmt.Printf("🗂️ 数据字段数: %d\n", count) -// case []ProductInfo: -// // 如果是 ProductInfo 切片 -// count = len(data) -// fmt.Printf("🛒 商品数量: %d\n", count) -// default: -// fmt.Printf("ℹ️ 数据类型: %T\n", apiResp.Data) -// } -// } -// if apiResp.GoodsNum != "" { -// fmt.Printf("📦 商品数量: %s\n", apiResp.GoodsNum) -// } -// if apiResp.PNum != "" { -// fmt.Printf("📄 页码: %s\n", apiResp.PNum) -// } -// } else { -// fmt.Printf("❌ 失败: %s\n", apiResp.Error) -// } -// } else { -// fmt.Printf("原始响应: %s\n", result) -// // 如果是代理地址，可以进一步处理 -// if len(result) > 0 && (result[0:4] == "http" || result[0:3] == "socks") { -// fmt.Printf("✅ 代理服务器地址获取成功\n") -// fmt.Printf("🔗 代理地址: %s\n", result) -// } -// } -// return count -//} -// -//// 专门处理代理配置响应的函数 -//func handleProxyResponse(result string, err error) { -// fmt.Printf("\n代理配置测试:\n") -// fmt.Println("=" + string(make([]byte, 50)) + "=") -// -// if err != nil { -// fmt.Printf("❌ 错误: %v\n", err) -// return -// } -// -// // 代理配置通常返回代理服务器地址，不是JSON格式 -// fmt.Printf("📡 代理服务器地址: %s\n", result) -// fmt.Printf("✅ 代理配置获取成功\n") -// -// // 如果需要，可以在这里进一步处理代理地址 -// // 例如：验证代理格式、提取IP和端口等 -// if result != "" { -// fmt.Printf("🔗 可用代理: %s\n", result) -// } -//} -// -//// // ProxyTypeManager 调用代理类型管理器 -//// -//// func (m *DLLManager) ProxyTypeManager(proxyType, username, password, machineCode string) (string, error) { -//// proc, err := m.dll.FindProc("ProxyTypeManager") -//// if err != nil { -//// return "", fmt.Errorf("找不到函数 ProxyTypeManager: %v", err) -//// } -//// -//// // 准备参数 -//// proxyTypePtr, _ := syscall.BytePtrFromString(proxyType) -//// usernamePtr, _ := syscall.BytePtrFromString(username) -//// passwordPtr, _ := syscall.BytePtrFromString(password) -//// machineCodePtr, _ := syscall.BytePtrFromString(machineCode) -//// -//// // 调用函数 -//// r1, _, err := proc.Call( -//// uintptr(unsafe.Pointer(proxyTypePtr)), -//// uintptr(unsafe.Pointer(usernamePtr)), -//// uintptr(unsafe.Pointer(passwordPtr)), -//// uintptr(unsafe.Pointer(machineCodePtr)), -//// ) -//// -//// if err != nil && err.Error() != "The operation completed successfully." { -//// return "", fmt.Errorf("调用 ProxyTypeManager 失败: %v", err) -//// } -//// -//// // 转换结果 -//// result := (*byte)(unsafe.Pointer(r1)) -//// var resultBytes []byte -//// for i := 0; ; i++ { -//// bytePtr := (*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(result)) + uintptr(i))) -//// if *bytePtr == 0 { -//// break -//// } -//// resultBytes = append(resultBytes, *bytePtr) -//// } -//// -//// // 释放内存 -//// freeProc, _ := m.dll.FindProc("FreeString") -//// if freeProc != nil { -//// freeProc.Call(r1) -//// } -//// -//// return string(resultBytes), nil -//// } -//// -//// FreeCString 释放C字符串内存 -//func (m *DLLManager) FreeCString(strPtr uintptr) error { -// proc, err := m.dll.FindProc("FreeCString") -// if err != nil { -// return fmt.Errorf("找不到函数 FreeCString: %v", err) -// } -// -// _, _, err = proc.Call(strPtr) -// if err != nil && err.Error() != "The operation completed successfully." { -// return fmt.Errorf("调用 FreeCString 失败: %v", err) -// } -// -// return nil -//} -// -//func main() { -// http.HandleFunc("/api/kfzShopBookInfo", handleGetKFZShopBookInfo) -// port := "8080" -// server := &http.Server{ -// Addr: ":" + port, -// Handler: nil, -// } -// // 启动服务器 -// if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed { -// fmt.Printf("服务器启动失败: %v\n", err) -// } -//} -// -//func handleGetKFZShopBookInfo(w http.ResponseWriter, r *http.Request) { -// // 加载DLL -// manager, err := NewDLLManager("dll/kongfz.dll") -// if err != nil { -// fmt.Printf("初始化DLL管理器失败: %v", err) -// } -// //defer manager.Close() -// -// log.Println("✅ DLL加载成功") -// -// // 使用默认配置初始化 -// config := createDefaultConfig() -// initializeConfig(config) -// configJSON, err := json.Marshal(config) -// if err != nil { -// fmt.Printf("序列化配置失败: %v", err) -// } -// -// result, err := manager.Initialize(string(configJSON)) -// if err != nil { -// fmt.Printf("初始化失败: %v", err) -// } -// -// var initResp APIResponses -// if err := json.Unmarshal([]byte(result), &initResp); err != nil { -// fmt.Printf("解析初始化响应失败: %v", err) -// } -// -// if !initResp.Success { -// fmt.Printf("初始化失败: %s", initResp.Message) -// } -// -// log.Println("✅ DLL初始化成功") -// // 设置响应头 -// w.Header().Set("Content-Type", "application/json; charset=utf-8") -// -// // 只支持GET请求 -// if r.Method != http.MethodGet { -// sendErrorResponse(w, http.StatusMethodNotAllowed, "只支持GET方法") -// return -// } -// -// // 获取代理信息 -// typeManager, err := proxyTypeManager("CALF_ELEPHANT_PROXY", "1297757178467602432", "QgQBvP7f", "") -// if err != nil { -// fmt.Printf(err.Error()) -// } -// fmt.Println(typeManager) -// -// user, err := manager.OutLogin("18904056801", "Long6166@@") -// if err != nil { -// fmt.Printf(err.Error()) -// } -// fmt.Println(user) -// -// var data APIResponse -// if err := json.Unmarshal([]byte(user), &data); err != nil { -// log.Printf("[ERROR] 解析第 %d 页失败: %v", data, err) -// } -// var token string -// // 从 Data 中提取 token -// if dataMap, ok := data.Data.(map[string]interface{}); ok { -// if tk, exists := dataMap["token"]; exists { -// fmt.Println("Token:", tk) -// token = tk.(string) -// // Token: d322c80960ab6722922912dd2ce219d4b4099d54 -// } else { -// fmt.Println("Token 不存在") -// } -// } else { -// fmt.Println("Data 格式不正确") -// } -// fmt.Println(token) -// -// //msg, err := manager.OutGetUserMsg(token) -// //if err != nil { -// // fmt.Printf(err.Error()) -// //} -// //fmt.Println(msg) -// // -// //tplMsg, err := manager.OutGetGoodsTplMsg(token, "9142583516", "") -// //if err != nil { -// // fmt.Printf(err.Error()) -// //} -// //fmt.Println("tplMsg: ", tplMsg) -// // -// //shop, err := manager.OutGetGoodsListMsgFromSelfShop(token, "", "", "", "", 0, 0, "allUnSold", 0, 1, 10) -// //if err != nil { -// // fmt.Printf(err.Error()) -// //} -// //fmt.Println(shop) -// -// //// 获取cookie -// //cookie, err := loginCookie() -// //if err != nil { -// // fmt.Printf(err.Error()) -// //} -// //fmt.Println(cookie) -// -// //account, err := getRandomAccount() -// //if err != nil { -// // fmt.Printf(err.Error()) -// //} -// //fmt.Println(account) -// -// //var isbns = []string{ -// // "9787500601593", "9787506331746", "9787020106752", "9787807089353", "9787536692930", "9787530221532", "9787544270878", "9787208061644", "9787506365437", "9787513708371", "9787513922135", "9787536693968", "9787541151736", "9787544213561", "9787544754781", "9787549204304", "9787108006639", "9787531764700", "9787544253994", "9787540456023", "9787540456429", "9787544267618", "9787544277723", "9787550008496", "9787806070680", "9787806801529", "9787807530244", "9787020008728", "9787020139590", "9787204055401", "9787500680239", "9787505724778", "9787506365680", "9787530221525", "9787536097261", -// //} -// // -// //for _, isbn := range isbns { -// // // 获取孔网图片 -// // isbnss, err := outGetImageByIsbn("", isbn, "", 0, 0) -// // if err != nil { -// // fmt.Printf(err.Error()) -// // } -// // fmt.Println(isbnss) -// //} -// -// //books, num, pNum, err := outGetGoodsListMsgByShopId(3092, -// // typeManager, true, "", -// // "", 0, 14, 1, 5) -// -// //msg, err := manager.OutGetTopGoodsListMsg(0, "") -// //if err != nil { -// // -// //} -// //fmt.Println(msg) -// //fetchMode := r.URL.Query().Get("fetchMode") -// //proxyType := r.URL.Query().Get("proxyType") -// //username := r.URL.Query().Get("username") -// //password := r.URL.Query().Get("password") -// //machineCode := r.URL.Query().Get("machineCode") -// //url := r.URL.Query().Get("url") -// //shopId := r.URL.Query().Get("shopId") //https://shop.kongfz.com/793900/all/0_100_0_0_1_sort_desc_0_0/ -// //isImage := r.URL.Query().Get("isImage") -// //bookNum := r.URL.Query().Get("bookNum") -// //pageNum := r.URL.Query().Get("pageNum") -// //sortType := r.URL.Query().Get("sortType") -// //sort := r.URL.Query().Get("sort") -// //priceDown := r.URL.Query().Get("priceDown") -// //priceUp := r.URL.Query().Get("priceUp") -// -// //details, err := manager.OutGetGoodsMsgByDetailUrl("https://book.kongfz.com/151391/6531924071/", "") -// //if err != nil { -// // -// //} -// //fmt.Println(details) -// -// //id, err := manager.OutGetGoodsListMsgByShopId(1181761, -// // "", true, "", -// // "", 0, 0, 1, 5) -// //if err != nil { -// // fmt.Println(err) -// //} -// //fmt.Println(id) -// //var pa ShopBookResult -// //if err := json.Unmarshal([]byte(id), &pa); err != nil { -// // log.Printf("[ERROR] 解析第 %d 页失败: %v", pa, err) -// //} -// //for _, urls := range pa.Data.Data { -// // ss, err := proxyTypeManager("CALF_ELEPHANT_PROXY", "1297757178467602432", "QgQBvP7f", "") -// // if err != nil { -// // fmt.Printf(err.Error()) -// // } -// // fmt.Println(ss) -// // url, err := manager.OutGetGoodsMsgByDetailUrl(urls.DetailURL, ss) -// // if err != nil { -// // fmt.Println(err) -// // } -// // fmt.Println(url) -// //} -// -// books, num, pNum, err := outGetGoodsListMsgByShopId(788247, -// typeManager, 1, 0, "", -// "", 0, 0, 1, 5) -// -// fmt.Println(books) -// fmt.Println(num) -// fmt.Println(pNum) -// fmt.Println(err) -// //for _, book := range books { -// // ss, err := proxyTypeManager("TAIL_PROXY", "", "", "07f4d0fbcff99966c2b37b0c1fb7f01c") -// // if err != nil { -// // fmt.Printf(err.Error()) -// // } -// // fmt.Println(ss) -// // url, err := outGetGoodsMsgByDetailUrl(book.DetailUrl, ss) -// // if err != nil { -// // fmt.Println(err) -// // } -// // fmt.Println(url) -// //} -// -//} -// -//func manegiyoutGetGoodsListMsgFromSelfShop() { -// -//} -// -//// 发送错误响应 -//func sendErrorResponse(w http.ResponseWriter, statusCode int, message string) { -// response := APIResp{ -// Success: false, -// Message: message, -// } -// w.WriteHeader(statusCode) -// json.NewEncoder(w).Encode(response) -//} -// -//type ShopBookResult struct { -// Success bool `json:"success"` -// Message string `json:"message"` -// Data struct { -// GoodsNum string `json:"goods_num"` -// Pnum string `json:"pnum"` -// Data []struct { -// BookName string `json:"book_name"` -// Author string `json:"author"` -// Publisher string `json:"publisher"` -// ISBN string `json:"isbn"` -// PublishTime int64 `json:"publication_time"` -// Edition string `json:"edition"` -// PrintTime string `json:"print_time"` -// FixPrice string `json:"fix_price"` -// BindingLayout string `json:"binding_layout"` -// Format string `json:"format"` -// Paper string `json:"paper"` -// Pages string `json:"pages"` -// Wordage string `json:"wordage"` -// Languages string `json:"languages"` -// Era string `json:"era"` -// EngravingMethod string `json:"engraving_method"` -// Dimensions string `json:"dimensions"` -// VolumeNumber string `json:"volume_number"` -// BookPic string `json:"book_pic"` -// BookPicS string `json:"book_pic_s"` -// SellingPrice string `json:"selling_price"` -// Condition string `json:"condition"` -// ExpressDeliveryFee string `json:"express_delivery_fee"` -// Editor string `json:"editor"` -// Category string `json:"category"` -// BuyCount string `json:"buy_count"` -// SellCount string `json:"sell_count"` -// Content string `json:"content"` -// Mid int `json:"mid"` -// ItemID int64 `json:"item_id"` -// ShopID int `json:"shop_id"` -// DetailURL string `json:"detail_url"` -// } `json:"data"` -// } `json:"data"` -//} +import "C" +import ( + "encoding/json" + "fmt" + "log" + "net/http" + "os" + "path/filepath" + "syscall" + "unsafe" +) + +// 配置结构 +type Configs struct { + App struct { + MaxRetryTimes int `json:"max_retry_times"` + RateLimitDelay int `json:"rate_limit_delay"` + Size int `json:"size"` + DefaultUserAgent string `json:"default_user_agent"` + } `json:"app"` + + API struct { + LoginURL string `json:"login_url"` + BookSearchURL string `json:"book_search_url"` + ProductSearchURL string `json:"product_search_url"` + } `json:"api"` + + Proxy struct { + Servers string `json:"servers"` + Username string `json:"username"` + Password string `json:"password"` + TailMachineCode string `json:"tail_machine_code"` + TailCardKey string `json:"tail_card_key"` + ProxyFilePath string `json:"proxy_file_path"` + } `json:"proxy"` +} + +// API响应结构 +type APIResponses struct { + Success bool `json:"success"` + Message string `json:"message,omitempty"` + GoodsNum string `json:"goods_num,omitempty"` + PNum string `json:"pnum,omitempty"` + Data interface{} `json:"data,omitempty"` + Error string `json:"error,omitempty"` +} + +// 加载DLL的函数 +type kongfzDLL struct { + dll *syscall.DLL + outLogin *syscall.Proc // 孔网登录 + outGetUserMsg *syscall.Proc // 获取孔网用户信息 + outGetGoodsTplMsg *syscall.Proc // 获取商品模版-已登的店铺 + outGetGoodsListMsgFromSelfShop *syscall.Proc // 获取商品列表-已登的店铺 + outAddGoods *syscall.Proc // 新增商品-已登的店铺 + outDelGoodsFromSelfShop *syscall.Proc // 删除商品-已登的店铺 + outGetImageFilterShopId *syscall.Proc // 获取孔网商品图片(官图和拍图)-带有店铺过滤 + outGetImageByIsbn *syscall.Proc // 获取孔网商品图片和信息(官图和拍图) + outGetGoodsListMsgByShopId *syscall.Proc // 获取商品列表通过店铺ID + outGetGoodsMsgByDetailUrl *syscall.Proc // 获取商品信息通过商品详情链接 + outGetTopGoodsListMsg *syscall.Proc // 获取销量榜商品列表 + freeCString *syscall.Proc // 释放C字符串内存 +} + +// 初始化kongfzDLL +func InitKongfzDLL() (*kongfzDLL, error) { + dllPath := filepath.Join("dll", "kongfz.dll") + if _, err := os.Stat(dllPath); os.IsNotExist(err) { + return nil, fmt.Errorf("kongfz DLL 不存在: %s", dllPath) + } + if dll, err := syscall.LoadDLL(dllPath); err != nil { + return nil, fmt.Errorf("加载 kongfz DLL 失败: %v", err) + } else { + return &kongfzDLL{ + dll: dll, + outLogin: dll.MustFindProc("OutLogin"), + outGetUserMsg: dll.MustFindProc("OutGetUserMsg"), + outGetGoodsTplMsg: dll.MustFindProc("OutGetGoodsTplMsg"), + outGetGoodsListMsgFromSelfShop: dll.MustFindProc("OutGetGoodsListMsgFromSelfShop"), + outAddGoods: dll.MustFindProc("OutAddGoods"), + outDelGoodsFromSelfShop: dll.MustFindProc("OutDelGoodsFromSelfShop"), + outGetImageFilterShopId: dll.MustFindProc("OutGetImageFilterShopId"), + outGetImageByIsbn: dll.MustFindProc("OutGetImageByIsbn"), + outGetGoodsListMsgByShopId: dll.MustFindProc("OutGetGoodsListMsgByShopId"), + outGetGoodsMsgByDetailUrl: dll.MustFindProc("OutGetGoodsMsgByDetailUrl"), + outGetTopGoodsListMsg: dll.MustFindProc("OutGetTopGoodsListMsg"), + freeCString: dll.MustFindProc("FreeCString"), + }, nil + } +} + +// cStr 获取C字符串 +func (m *kongfzDLL) cStr(p uintptr) string { + if p == 0 { + return "" + } + b := []byte{} + for i := uintptr(0); ; i++ { + c := *(*byte)(unsafe.Pointer(p + i)) + if c == 0 { + break + } + b = append(b, c) + } + s := string(b) + if m.freeCString != nil { + m.freeCString.Call(p) + } + return s +} + +type DLLManager struct { + dll *syscall.DLL +} + +func NewDLLManager(dllPath string) (*DLLManager, error) { + dll, err := syscall.LoadDLL(dllPath) + if err != nil { + return nil, fmt.Errorf("加载DLL失败: %v", err) + } + + return &DLLManager{dll: dll}, nil +} + +func (m *DLLManager) Close() { + if m.dll != nil { + m.dll.Release() + } +} + +// 单参数函数调用 +func (m *DLLManager) callFunction(funcName string, arg string) (string, error) { + proc, err := m.dll.FindProc(funcName) + if err != nil { + return "", fmt.Errorf("找不到函数 %s: %v", funcName, err) + } + + argPtr, _ := syscall.BytePtrFromString(arg) + r1, _, err := proc.Call(uintptr(unsafe.Pointer(argPtr))) + if err != nil && err.Error() != "The operation completed successfully." { + return "", fmt.Errorf("调用函数 %s 失败: %v", funcName, err) + } + + result := (*byte)(unsafe.Pointer(r1)) + + // 将C字符串转换为Go字符串 + var resultBytes []byte + for i := 0; ; i++ { + if *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(result)) + uintptr(i))) == 0 { + break + } + resultBytes = append(resultBytes, *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(result)) + uintptr(i)))) + } + + // 释放内存 + freeProc, _ := m.dll.FindProc("FreeString") + if freeProc != nil { + freeProc.Call(r1) + } + + return string(resultBytes), nil +} + +// 二参数函数调用 +func (m *DLLManager) callFunctionTwoArgs(funcName string, args ...string) (string, error) { + if len(args) != 2 { + return "", fmt.Errorf("函数 %s 需要2个参数，但提供了 %d 个", funcName, len(args)) + } + + proc, err := m.dll.FindProc(funcName) + if err != nil { + return "", fmt.Errorf("找不到函数 %s: %v", funcName, err) + } + + // 准备参数指针 + argPtrs := make([]uintptr, 2) + for i, arg := range args { + argPtr, _ := syscall.BytePtrFromString(arg) + argPtrs[i] = uintptr(unsafe.Pointer(argPtr)) + } + + r1, _, err := proc.Call( + argPtrs[0], // proxyType + argPtrs[1], // username + ) + if err != nil && err.Error() != "The operation completed successfully." { + return "", fmt.Errorf("调用函数 %s 失败: %v", funcName, err) + } + + result := (*byte)(unsafe.Pointer(r1)) + + // 将C字符串转换为Go字符串 + var resultBytes []byte + for i := 0; ; i++ { + if *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(result)) + uintptr(i))) == 0 { + break + } + resultBytes = append(resultBytes, *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(result)) + uintptr(i)))) + } + + // 释放内存 + freeProc, _ := m.dll.FindProc("FreeString") + if freeProc != nil { + freeProc.Call(r1) + } + + return string(resultBytes), nil +} + +// 五参数函数调用 - 用于 GetKFZGTImageURL 和 GetKFZSPTImageURL +func (m *DLLManager) callFunctionFiveArgs(funcName string, args ...string) (string, error) { + if len(args) != 5 { + return "", fmt.Errorf("函数 %s 需要5个参数，但提供了 %d 个", funcName, len(args)) + } + + proc, err := m.dll.FindProc(funcName) + if err != nil { + return "", fmt.Errorf("找不到函数 %s: %v", funcName, err) + } + + // 准备参数指针 + argPtrs := make([]uintptr, 5) + for i, arg := range args { + argPtr, _ := syscall.BytePtrFromString(arg) + argPtrs[i] = uintptr(unsafe.Pointer(argPtr)) + } + + r1, _, err := proc.Call( + argPtrs[0], // proxyType + argPtrs[1], // username + argPtrs[2], // password + argPtrs[3], // machineCode + argPtrs[4], // isbn + ) + if err != nil && err.Error() != "The operation completed successfully." { + return "", fmt.Errorf("调用函数 %s 失败: %v", funcName, err) + } + + result := (*byte)(unsafe.Pointer(r1)) + + // 将C字符串转换为Go字符串 + var resultBytes []byte + for i := 0; ; i++ { + if *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(result)) + uintptr(i))) == 0 { + break + } + resultBytes = append(resultBytes, *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(result)) + uintptr(i)))) + } + + // 释放内存 + freeProc, _ := m.dll.FindProc("FreeString") + if freeProc != nil { + freeProc.Call(r1) + } + + return string(resultBytes), nil +} + +// 六参数函数调用 +func (m *DLLManager) callFunctionSixArgs(funcName string, args ...string) (string, error) { + if len(args) != 6 { + return "", fmt.Errorf("函数 %s 需要6个参数，但提供了 %d 个", funcName, len(args)) + } + + proc, err := m.dll.FindProc(funcName) + if err != nil { + return "", fmt.Errorf("找不到函数 %s: %v", funcName, err) + } + + // 准备参数指针 + argPtrs := make([]uintptr, 6) + for i, arg := range args { + argPtr, _ := syscall.BytePtrFromString(arg) + argPtrs[i] = uintptr(unsafe.Pointer(argPtr)) + } + + r1, _, err := proc.Call( + argPtrs[0], // fetchMode + argPtrs[1], // proxyType + argPtrs[2], // username + argPtrs[3], // password + argPtrs[4], // machineCode + argPtrs[5], // isbn + ) + if err != nil && err.Error() != "The operation completed successfully." { + return "", fmt.Errorf("调用函数 %s 失败: %v", funcName, err) + } + + result := (*byte)(unsafe.Pointer(r1)) + + // 将C字符串转换为Go字符串 + var resultBytes []byte + for i := 0; ; i++ { + if *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(result)) + uintptr(i))) == 0 { + break + } + resultBytes = append(resultBytes, *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(result)) + uintptr(i)))) + } + + // 释放内存 + freeProc, _ := m.dll.FindProc("FreeString") + if freeProc != nil { + freeProc.Call(r1) + } + + return string(resultBytes), nil +} + +// 十二参数函数调用 - 专门用于 GetKFZShopBookInfo +func (m *DLLManager) callFunctionTwelveArgs(funcName string, args ...string) (string, error) { + if len(args) != 12 { + return "", fmt.Errorf("函数 %s 需要12个参数，但提供了 %d 个", funcName, len(args)) + } + + proc, err := m.dll.FindProc(funcName) + if err != nil { + return "", fmt.Errorf("找不到函数 %s: %v", funcName, err) + } + + // 准备参数指针 + argPtrs := make([]uintptr, 12) + for i, arg := range args { + argPtr, _ := syscall.BytePtrFromString(arg) + argPtrs[i] = uintptr(unsafe.Pointer(argPtr)) + } + + r1, _, err := proc.Call( + argPtrs[0], // proxyType + argPtrs[1], // username + argPtrs[2], // password + argPtrs[3], // machineCode + argPtrs[4], // shopId + argPtrs[5], // isImage + argPtrs[6], // bookNum + argPtrs[7], // pageNum + argPtrs[8], // sortType + argPtrs[9], // sort + argPtrs[10], // priceDown + argPtrs[11], // priceUp + ) + if err != nil && err.Error() != "The operation completed successfully." { + return "", fmt.Errorf("调用函数 %s 失败: %v", funcName, err) + } + + result := (*byte)(unsafe.Pointer(r1)) + + // 将C字符串转换为Go字符串 + var resultBytes []byte + for i := 0; ; i++ { + if *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(result)) + uintptr(i))) == 0 { + break + } + resultBytes = append(resultBytes, *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(result)) + uintptr(i)))) + } + + // 释放内存 + freeProc, _ := m.dll.FindProc("FreeString") + if freeProc != nil { + freeProc.Call(r1) + } + + return string(resultBytes), nil +} + +// 十三参数函数调用 - 专门用于 GetKFZShopBookInfo +func (m *DLLManager) callFunctionThirteenArgs(funcName string, args ...string) (string, error) { + if len(args) != 13 { + return "", fmt.Errorf("函数 %s 需要13个参数，但提供了 %d 个", funcName, len(args)) + } + + proc, err := m.dll.FindProc(funcName) + if err != nil { + return "", fmt.Errorf("找不到函数 %s: %v", funcName, err) + } + + // 准备参数指针 + argPtrs := make([]uintptr, 13) + for i, arg := range args { + argPtr, _ := syscall.BytePtrFromString(arg) + argPtrs[i] = uintptr(unsafe.Pointer(argPtr)) + } + + r1, _, err := proc.Call( + argPtrs[0], // fetchMode + argPtrs[1], // proxyType + argPtrs[2], // username + argPtrs[3], // password + argPtrs[4], // machineCode + argPtrs[5], // shopId + argPtrs[6], // isImage + argPtrs[7], // bookNum + argPtrs[8], // pageNum + argPtrs[9], // sortType + argPtrs[10], // sort + argPtrs[11], // priceDown + argPtrs[12], // priceUp + ) + if err != nil && err.Error() != "The operation completed successfully." { + return "", fmt.Errorf("调用函数 %s 失败: %v", funcName, err) + } + + result := (*byte)(unsafe.Pointer(r1)) + + // 将C字符串转换为Go字符串 + var resultBytes []byte + for i := 0; ; i++ { + if *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(result)) + uintptr(i))) == 0 { + break + } + resultBytes = append(resultBytes, *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(result)) + uintptr(i)))) + } + + // 释放内存 + freeProc, _ := m.dll.FindProc("FreeString") + if freeProc != nil { + freeProc.Call(r1) + } + + return string(resultBytes), nil +} + +func (m *DLLManager) Initialize(configJSON string) (string, error) { + return m.callFunction("Initialize", configJSON) +} + +// 修改后的 GetKFZGTImageURL - 需要5个参数 +func (m *DLLManager) GetKFZGTImageURL(proxyType, username, password, machineCode, isbn string) (string, error) { + return m.callFunctionFiveArgs("GetKFZGTImageURL", + proxyType, username, password, machineCode, isbn) +} + +// 修改后的 GetKFZSPTImageURL - 需要5个参数 +func (m *DLLManager) GetKFZSPTImageURL(proxyType, username, password, machineCode, isbn string) (string, error) { + return m.callFunctionFiveArgs("GetKFZSPTImageURL", + proxyType, username, password, machineCode, isbn) +} + +// 修改后的 GetKFZShopBookInfo - 需要12个参数 +func (m *DLLManager) GetKFZShopBookInfo(fetchMode, proxyType, username, password, machineCode, shopId, isImage, bookNum, pageNum, sortType, sort, priceDown, priceUp string) (string, error) { + return m.callFunctionThirteenArgs("GetKFZShopBookInfo", + fetchMode, proxyType, username, password, machineCode, shopId, isImage, bookNum, pageNum, sortType, sort, priceDown, priceUp) +} + +// 获取 GetUrlBookDetails - 需要6个参数 +func (m *DLLManager) GetUrlBookDetails(fetchMode, proxyType, username, password, machineCode, url string) (string, error) { + return m.callFunctionSixArgs("GetUrlBookDetails", fetchMode, proxyType, username, password, machineCode, url) +} + +// 获取 OutLogin +func (m *DLLManager) OutLogin(username, password string) (string, error) { + // 获取函数 + proc, err := m.dll.FindProc("OutLogin") + if err != nil { + return "", fmt.Errorf("找不到函数 %s: %v", "OutLogin", err) + } + // 转换参数 + usernamePtr := uintptr(unsafe.Pointer(syscall.StringBytePtr(username))) + passwordPtr := uintptr(unsafe.Pointer(syscall.StringBytePtr(password))) + // 调用函数 + ret, _, err := proc.Call(usernamePtr, passwordPtr) + if ret == 0 { + return "", fmt.Errorf("DLL调用失败: %v", err) + } + + // 将C字符串转换为Go字符串 + var resultBytes []byte + for i := 0; ; i++ { + if *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ret)) + uintptr(i))) == 0 { + break + } + resultBytes = append(resultBytes, *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ret)) + uintptr(i)))) + } + + // 释放内存（假设DLL提供了FreeMemory函数） + findProc, err := m.dll.FindProc("FreeString") + if findProc != nil { + findProc.Call(ret) + } + return string(resultBytes), nil +} + +// 获取 OutGetUserMsg +func (m *DLLManager) OutGetUserMsg(token string) (string, error) { + // 获取函数 + proc, err := m.dll.FindProc("OutGetUserMsg") + if err != nil { + return "", fmt.Errorf("找不到函数 %s: %v", "OutGetUserMsg", err) + } + // 转换参数 + tokenPtr := uintptr(unsafe.Pointer(syscall.StringBytePtr(token))) + // 调用函数 + ret, _, err := proc.Call(tokenPtr) + if ret == 0 { + return "", fmt.Errorf("DLL调用失败: %v", err) + } + + // 将C字符串转换为Go字符串 + var resultBytes []byte + for i := 0; ; i++ { + if *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ret)) + uintptr(i))) == 0 { + break + } + resultBytes = append(resultBytes, *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ret)) + uintptr(i)))) + } + + // 释放内存（假设DLL提供了FreeMemory函数） + findProc, err := m.dll.FindProc("FreeString") + if findProc != nil { + findProc.Call(ret) + } + return string(resultBytes), nil +} + +// 获取 OutGetGoodsTplMsg +func (m *DLLManager) OutGetGoodsTplMsg(token, itemId, proxy string) (string, error) { + // 获取函数 + proc, err := m.dll.FindProc("OutGetGoodsTplMsg") + if err != nil { + return "", fmt.Errorf("找不到函数 %s: %v", "OutGetGoodsTplMsg", err) + } + // 转换参数 + tokenPtr := uintptr(unsafe.Pointer(syscall.StringBytePtr(token))) + itemIdPtr := uintptr(unsafe.Pointer(syscall.StringBytePtr(itemId))) + proxyPtr := uintptr(unsafe.Pointer(syscall.StringBytePtr(proxy))) + // 调用函数 + ret, _, err := proc.Call(tokenPtr, itemIdPtr, proxyPtr) + if ret == 0 { + return "", fmt.Errorf("DLL调用失败: %v", err) + } + + // 将C字符串转换为Go字符串 + var resultBytes []byte + for i := 0; ; i++ { + if *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ret)) + uintptr(i))) == 0 { + break + } + resultBytes = append(resultBytes, *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ret)) + uintptr(i)))) + } + + // 释放内存（假设DLL提供了FreeMemory函数） + findProc, err := m.dll.FindProc("FreeString") + if findProc != nil { + findProc.Call(ret) + } + return string(resultBytes), nil +} + +// 获取 OutGetGoodsListMsgFromSelfShop +func (m *DLLManager) OutGetGoodsListMsgFromSelfShop(token string, proxy string, itemSn string, priceMin string, priceMax string, startCreateTime string, + endCreateTime string, requestType string, isItemSnEqual int, page int, size int) (string, error) { + // 获取函数 + proc, err := m.dll.FindProc("OutGetGoodsListMsgFromSelfShop") + if err != nil { + return "", fmt.Errorf("找不到函数 %s: %v", "OutGetGoodsListMsgFromSelfShop", err) + } + // 转换参数 + tokenPtr := uintptr(unsafe.Pointer(syscall.StringBytePtr(token))) + proxyPtr := uintptr(unsafe.Pointer(syscall.StringBytePtr(proxy))) + itemSnPtr := uintptr(unsafe.Pointer(syscall.StringBytePtr(itemSn))) + priceMinPtr := uintptr(unsafe.Pointer(syscall.StringBytePtr(priceMin))) + priceMaxPtr := uintptr(unsafe.Pointer(syscall.StringBytePtr(priceMax))) + startCreateTimePtr := uintptr(unsafe.Pointer(syscall.StringBytePtr(startCreateTime))) + endCreateTimePtr := uintptr(unsafe.Pointer(syscall.StringBytePtr(endCreateTime))) + requestTypePtr := uintptr(unsafe.Pointer(syscall.StringBytePtr(requestType))) + isItemSnEqualPtr := uintptr(isItemSnEqual) + pagePtr := uintptr(page) + sizePtr := uintptr(size) + // 调用函数 + ret, _, err := proc.Call(tokenPtr, proxyPtr, itemSnPtr, priceMinPtr, priceMaxPtr, startCreateTimePtr, endCreateTimePtr, requestTypePtr, isItemSnEqualPtr, pagePtr, sizePtr) + if ret == 0 { + return "", fmt.Errorf("DLL调用失败: %v", err) + } + + // 将C字符串转换为Go字符串 + var resultBytes []byte + for i := 0; ; i++ { + if *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ret)) + uintptr(i))) == 0 { + break + } + resultBytes = append(resultBytes, *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ret)) + uintptr(i)))) + } + + // 释放内存（假设DLL提供了FreeMemory函数） + findProc, err := m.dll.FindProc("FreeString") + if findProc != nil { + findProc.Call(ret) + } + return string(resultBytes), nil +} + +// 获取 OutGetImageByIsbn +func (m *DLLManager) OutGetImageByIsbn(token string, isbn string, proxy string, isLiveImage bool, isReturnMsg bool) (string, error) { + // 获取函数 + proc, err := m.dll.FindProc("OutGetImageByIsbn") + if err != nil { + return "", fmt.Errorf("找不到函数 %s: %v", "OutGetImageByIsbn", err) + } + // 转换参数 + tokenPtr := uintptr(unsafe.Pointer(syscall.StringBytePtr(token))) + isbnPtr := uintptr(unsafe.Pointer(syscall.StringBytePtr(isbn))) + var proxyPtr uintptr + if proxy != "" { + proxyPtr = uintptr(unsafe.Pointer(syscall.StringBytePtr(proxy))) + } else { + proxyPtr = 0 + } + var isLiveImageInt int + if isLiveImage { + isLiveImageInt = 0 + } else { + isLiveImageInt = 1 + } + isLiveImagePtr := uintptr(isLiveImageInt) + var isReturnMsgInt int + if isReturnMsg { + isLiveImageInt = 0 + } else { + isLiveImageInt = 1 + } + isReturnMsgPtr := uintptr(isReturnMsgInt) + // 调用函数 + ret, _, err := proc.Call(tokenPtr, isbnPtr, proxyPtr, isLiveImagePtr, isReturnMsgPtr) + if ret == 0 { + return "", fmt.Errorf("DLL调用失败: %v", err) + } + + // 将C字符串转换为Go字符串 + var resultBytes []byte + for i := 0; ; i++ { + if *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ret)) + uintptr(i))) == 0 { + break + } + resultBytes = append(resultBytes, *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ret)) + uintptr(i)))) + } + + // 释放内存（假设DLL提供了FreeMemory函数） + findProc, err := m.dll.FindProc("FreeString") + if findProc != nil { + findProc.Call(ret) + } + return string(resultBytes), nil +} + +// 获取 OutGetGoodsMsgByDetailUrl +func (m *DLLManager) OutGetGoodsMsgByDetailUrl(url, proxy string) (string, error) { + // 获取函数 + proc, err := m.dll.FindProc("OutGetGoodsMsgByDetailUrl") + if err != nil { + return "", fmt.Errorf("找不到函数 %s: %v", "OutGetGoodsMsgByDetailUrl", err) + } + // 转换参数 + urlPtr := uintptr(unsafe.Pointer(syscall.StringBytePtr(url))) + var proxyPtr uintptr + if proxy != "" { + proxyPtr = uintptr(unsafe.Pointer(syscall.StringBytePtr(proxy))) + } else { + proxyPtr = 0 + } + // 调用函数 + ret, _, err := proc.Call(urlPtr, proxyPtr) + if ret == 0 { + return "", fmt.Errorf("DLL调用失败: %v", err) + } + + // 将C字符串转换为Go字符串 + var resultBytes []byte + for i := 0; ; i++ { + if *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ret)) + uintptr(i))) == 0 { + break + } + resultBytes = append(resultBytes, *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ret)) + uintptr(i)))) + } + + // 释放内存（假设DLL提供了FreeMemory函数） + findProc, err := m.dll.FindProc("FreeString") + if findProc != nil { + findProc.Call(ret) + } + return string(resultBytes), nil +} + +// 获取 OutGetGoodsListMsgByShopId +func (m *DLLManager) OutGetGoodsListMsgByShopId(shopId int, proxy string, isImage bool, + sortType string, sort string, priceMin float32, priceMax float32, + pageNum, returnNum int) (string, error) { + // 获取函数 + proc, err := m.dll.FindProc("OutGetGoodsListMsgByShopId") + if err != nil { + return "", fmt.Errorf("找不到函数 %s: %v", "OutGetGoodsListMsgByShopId", err) + } + // 转换参数 + shopIdPtr := uintptr(shopId) + var isImageInt int + if isImage { + isImageInt = 0 + } else { + isImageInt = 1 + } + isImagePtr := uintptr(isImageInt) + sortTypePtr := uintptr(unsafe.Pointer(syscall.StringBytePtr(sortType))) + sortPtr := uintptr(unsafe.Pointer(syscall.StringBytePtr(sort))) + priceMinPtr := uintptr(*(*uint32)(unsafe.Pointer(&priceMin))) + priceMaxPtr := uintptr(*(*uint32)(unsafe.Pointer(&priceMax))) + pageNumPtr := uintptr(pageNum) + returnNumPtr := uintptr(returnNum) + var proxyPtr uintptr + if proxy != "" { + proxyPtr = uintptr(unsafe.Pointer(syscall.StringBytePtr(proxy))) + } else { + proxyPtr = 0 + } + // 调用函数 + ret, _, err := proc.Call(shopIdPtr, proxyPtr, isImagePtr, sortTypePtr, sortPtr, priceMinPtr, priceMaxPtr, pageNumPtr, returnNumPtr) + if ret == 0 { + return "", fmt.Errorf("DLL调用失败: %v", err) + } + + // 将C字符串转换为Go字符串 + var resultBytes []byte + for i := 0; ; i++ { + if *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ret)) + uintptr(i))) == 0 { + break + } + resultBytes = append(resultBytes, *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ret)) + uintptr(i)))) + } + + // 释放内存（假设DLL提供了FreeMemory函数） + findProc, err := m.dll.FindProc("FreeString") + if findProc != nil { + findProc.Call(ret) + } + return string(resultBytes), nil +} + +// 获取 OutGetTopGoodsListMsg +func (m *DLLManager) OutGetTopGoodsListMsg(catId int, proxy string) (string, error) { + // 获取函数 + proc, err := m.dll.FindProc("OutGetTopGoodsListMsg") + if err != nil { + return "", fmt.Errorf("找不到函数 %s: %v", "OutGetTopGoodsListMsg", err) + } + // 转换参数 + catIdPtr := uintptr(catId) + var proxyPtr uintptr + if proxy != "" { + proxyPtr = uintptr(unsafe.Pointer(syscall.StringBytePtr(proxy))) + } else { + proxyPtr = 0 + } + // 调用函数 + ret, _, err := proc.Call(catIdPtr, proxyPtr) + if ret == 0 { + return "", fmt.Errorf("DLL调用失败: %v", err) + } + + // 将C字符串转换为Go字符串 + var resultBytes []byte + for i := 0; ; i++ { + if *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ret)) + uintptr(i))) == 0 { + break + } + resultBytes = append(resultBytes, *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ret)) + uintptr(i)))) + } + + // 释放内存（假设DLL提供了FreeMemory函数） + findProc, err := m.dll.FindProc("FreeString") + if findProc != nil { + findProc.Call(ret) + } + return string(resultBytes), nil +} + +// 创建默认配置 +func createDefaultConfig() Config { + var configs Config + + // App配置 + configs.App.MaxRetryTimes = 3 + configs.App.RateLimitDelay = 1000 + configs.App.Size = 10 + configs.App.DefaultUserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36" + + // API配置 + configs.API.LoginURL = "https://login.kongfz.com/Pc/Login/account" + configs.API.BookSearchURL = "https://search.kongfz.com/pc-gw/search-web/client/pc/bookLib/keyword/list" + configs.API.ProductSearchURL = "https://search.kongfz.com/pc-gw/search-web/client/pc/product/keyword/list" + + // 代理配置（需要根据实际情况修改） + configs.Proxy.Servers = "http-dynamic.xiaoxiangdaili.com,http-dynamic-S02.xiaoxiangdaili.com,http-dynamic-S03.xiaoxiangdaili.com,http-dynamic-S04.xiaoxiangdaili.com" + configs.Proxy.Username = "1297757178467602432" + configs.Proxy.Password = "QgQBvP7f" + configs.Proxy.TailMachineCode = "b7bf22a237ec692f13fcc2c43ee63252" + configs.Proxy.TailCardKey = "DL_20_YK_1920acb2129844c2aabade3896560a9b" + configs.Proxy.ProxyFilePath = "dll/proxyConfig.dll" + + configs.Database.Username = "newAdmin" + configs.Database.Password = "bYPp8SbBe5F7nz2i" + configs.Database.Host = "146.56.227.42:3306" + configs.Database.Name = "newadmin" + + return configs +} + +// 获取当前可执行文件所在目录 +func getExecutableDir() string { + exePath, err := os.Executable() + if err != nil { + return "." + } + return filepath.Dir(exePath) +} + +// 格式化输出JSON响应 +func printFormattedResponse(operation string, result string, err error) int { + var apiResp APIResponses + fmt.Printf("\n%s:\n", operation) + fmt.Println("=" + string(make([]byte, 50)) + "=") + + if err != nil { + fmt.Printf("❌ 错误: %v\n", err) + } + var count int + if err := json.Unmarshal([]byte(result), &apiResp); err == nil { + if apiResp.Success { + fmt.Printf("✅ 成功: %s\n", apiResp.Message) + if apiResp.Data != nil { + fmt.Println("📊 数据:") + jsonData, _ := json.MarshalIndent(apiResp.Data, "", " ") + fmt.Println(string(jsonData)) + // 方法1: 判断 Data 的类型并统计条数 + switch data := apiResp.Data.(type) { + case []interface{}: + // 如果是切片/数组 + count = len(data) + fmt.Printf("📈 数据条数: %d\n", count) + case []BookInfo: + // 如果是 BookInfo 切片 + count = len(data) + fmt.Printf("📚 图书数量: %d\n", count) + case map[string]interface{}: + // 如果是映射 + count = len(data) + fmt.Printf("🗂️ 数据字段数: %d\n", count) + case []ProductInfo: + // 如果是 ProductInfo 切片 + count = len(data) + fmt.Printf("🛒 商品数量: %d\n", count) + default: + fmt.Printf("ℹ️ 数据类型: %T\n", apiResp.Data) + } + } + if apiResp.GoodsNum != "" { + fmt.Printf("📦 商品数量: %s\n", apiResp.GoodsNum) + } + if apiResp.PNum != "" { + fmt.Printf("📄 页码: %s\n", apiResp.PNum) + } + } else { + fmt.Printf("❌ 失败: %s\n", apiResp.Error) + } + } else { + fmt.Printf("原始响应: %s\n", result) + // 如果是代理地址，可以进一步处理 + if len(result) > 0 && (result[0:4] == "http" || result[0:3] == "socks") { + fmt.Printf("✅ 代理服务器地址获取成功\n") + fmt.Printf("🔗 代理地址: %s\n", result) + } + } + return count +} + +// 专门处理代理配置响应的函数 +func handleProxyResponse(result string, err error) { + fmt.Printf("\n代理配置测试:\n") + fmt.Println("=" + string(make([]byte, 50)) + "=") + + if err != nil { + fmt.Printf("❌ 错误: %v\n", err) + return + } + + // 代理配置通常返回代理服务器地址，不是JSON格式 + fmt.Printf("📡 代理服务器地址: %s\n", result) + fmt.Printf("✅ 代理配置获取成功\n") + + // 如果需要，可以在这里进一步处理代理地址 + // 例如：验证代理格式、提取IP和端口等 + if result != "" { + fmt.Printf("🔗 可用代理: %s\n", result) + } +} + +// ProxyTypeManager 调用代理类型管理器 +func (m *DLLManager) ProxyTypeManager(proxyType, username, password, machineCode string) (string, error) { + proc, err := m.dll.FindProc("ProxyTypeManager") + if err != nil { + return "", fmt.Errorf("找不到函数 ProxyTypeManager: %v", err) + } + + // 准备参数 + proxyTypePtr, _ := syscall.BytePtrFromString(proxyType) + usernamePtr, _ := syscall.BytePtrFromString(username) + passwordPtr, _ := syscall.BytePtrFromString(password) + machineCodePtr, _ := syscall.BytePtrFromString(machineCode) + + // 调用函数 + r1, _, err := proc.Call( + uintptr(unsafe.Pointer(proxyTypePtr)), + uintptr(unsafe.Pointer(usernamePtr)), + uintptr(unsafe.Pointer(passwordPtr)), + uintptr(unsafe.Pointer(machineCodePtr)), + ) + + if err != nil && err.Error() != "The operation completed successfully." { + return "", fmt.Errorf("调用 ProxyTypeManager 失败: %v", err) + } + + // 转换结果 + result := (*byte)(unsafe.Pointer(r1)) + var resultBytes []byte + for i := 0; ; i++ { + bytePtr := (*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(result)) + uintptr(i))) + if *bytePtr == 0 { + break + } + resultBytes = append(resultBytes, *bytePtr) + } + + // 释放内存 + freeProc, _ := m.dll.FindProc("FreeString") + if freeProc != nil { + freeProc.Call(r1) + } + + return string(resultBytes), nil +} + +// FreeCString 释放C字符串内存 +func (m *DLLManager) FreeCString(strPtr uintptr) error { + proc, err := m.dll.FindProc("FreeCString") + if err != nil { + return fmt.Errorf("找不到函数 FreeCString: %v", err) + } + + _, _, err = proc.Call(strPtr) + if err != nil && err.Error() != "The operation completed successfully." { + return fmt.Errorf("调用 FreeCString 失败: %v", err) + } + + return nil +} + +func handleGetKFZShopBookInfo(w http.ResponseWriter, r *http.Request) { + // 加载DLL + manager, err := NewDLLManager("dll/kongfz.dll") + if err != nil { + fmt.Printf("初始化DLL管理器失败: %v", err) + } + //defer manager.Close() + + log.Println("✅ DLL加载成功") + + // 使用默认配置初始化 + config := createDefaultConfig() + initializeConfig(config) + configJSON, err := json.Marshal(config) + if err != nil { + fmt.Printf("序列化配置失败: %v", err) + } + + result, err := manager.Initialize(string(configJSON)) + if err != nil { + fmt.Printf("初始化失败: %v", err) + } + + var initResp APIResponses + if err := json.Unmarshal([]byte(result), &initResp); err != nil { + fmt.Printf("解析初始化响应失败: %v", err) + } + + if !initResp.Success { + fmt.Printf("初始化失败: %s", initResp.Message) + } + + log.Println("✅ DLL初始化成功") + // 设置响应头 + w.Header().Set("Content-Type", "application/json; charset=utf-8") + + // 只支持GET请求 + if r.Method != http.MethodGet { + sendErrorResponse(w, http.StatusMethodNotAllowed, "只支持GET方法") + return + } + + //// 获取代理信息 + //typeManager, err := manager.ProxyTypeManager("CALF_ELEPHANT_PROXY", "1297757178467602432", "QgQBvP7f", "") + //if err != nil { + // fmt.Printf(err.Error()) + //} + //fmt.Println(typeManager) + + // + //user, err := manager.OutLogin("18904056801", "Long6166@@") + //if err != nil { + // fmt.Printf(err.Error()) + //} + //fmt.Println(user) + // + //var data APIResponse + //if err := json.Unmarshal([]byte(user), &data); err != nil { + // log.Printf("[ERROR] 解析第 %d 页失败: %v", data, err) + //} + //var token string + //// 从 Data 中提取 token + //if dataMap, ok := data.Data.(map[string]interface{}); ok { + // if tk, exists := dataMap["token"]; exists { + // fmt.Println("Token:", tk) + // token = tk.(string) + // // Token: d322c80960ab6722922912dd2ce219d4b4099d54 + // } else { + // fmt.Println("Token 不存在") + // } + //} else { + // fmt.Println("Data 格式不正确") + //} + //fmt.Println(token) + + //msg, err := manager.OutGetUserMsg(token) + //if err != nil { + // fmt.Printf(err.Error()) + //} + //fmt.Println(msg) + // + //tplMsg, err := manager.OutGetGoodsTplMsg(token, "9142583516", "") + //if err != nil { + // fmt.Printf(err.Error()) + //} + //fmt.Println("tplMsg: ", tplMsg) + // + //shop, err := manager.OutGetGoodsListMsgFromSelfShop("a0c75646dfefc23a9c387865d43197283192df0c", "", + // "", "", "", "", "", "allUnSold", 0, 1, 100) + //if err != nil { + // fmt.Printf(err.Error()) + //} + //fmt.Println(shop) + + // 获取孔网图片 + fmt.Println("获取孔网图片") + isbnss, err := manager.OutGetImageByIsbn("81cc0e948433343309dcf3bfe100a802803934e5", "9787020106752", "", true, false) + if err != nil { + fmt.Printf(err.Error()) + } + fmt.Println(isbnss) + + var api struct { + Success bool `json:"success"` + Data *BookInfo `json:"data"` + } + err = json.Unmarshal([]byte(isbnss), &api) + if err != nil { + fmt.Printf(err.Error()) + } + fmt.Println(api.Data.BookPic) + //// 获取cookie + //cookie, err := loginCookie() + //if err != nil { + // fmt.Printf(err.Error()) + //} + //fmt.Println(cookie) + + //account, err := getRandomAccount() + //if err != nil { + // fmt.Printf(err.Error()) + //} + //fmt.Println(account) + + //var isbns = []string{ + // "9787500601593", "9787506331746", "9787020106752", "9787807089353", "9787536692930", "9787530221532", "9787544270878", "9787208061644", "9787506365437", "9787513708371", "9787513922135", "9787536693968", "9787541151736", "9787544213561", "9787544754781", "9787549204304", "9787108006639", "9787531764700", "9787544253994", "9787540456023", "9787540456429", "9787544267618", "9787544277723", "9787550008496", "9787806070680", "9787806801529", "9787807530244", "9787020008728", "9787020139590", "9787204055401", "9787500680239", "9787505724778", "9787506365680", "9787530221525", "9787536097261", + //} + // + //for _, isbn := range isbns { + // // 获取孔网图片 + // isbnss, err := outGetImageByIsbn("", isbn, "", 0, 0) + // if err != nil { + // fmt.Printf(err.Error()) + // } + // fmt.Println(isbnss) + //} + + //books, num, pNum, err := outGetGoodsListMsgByShopId(3092, + // typeManager, true, "", + // "", 0, 14, 1, 5) + + //msg, err := manager.OutGetTopGoodsListMsg(0, "") + //if err != nil { + // + //} + //fmt.Println(msg) + //fetchMode := r.URL.Query().Get("fetchMode") + //proxyType := r.URL.Query().Get("proxyType") + //username := r.URL.Query().Get("username") + //password := r.URL.Query().Get("password") + //machineCode := r.URL.Query().Get("machineCode") + //url := r.URL.Query().Get("url") + //shopId := r.URL.Query().Get("shopId") //https://shop.kongfz.com/793900/all/0_100_0_0_1_sort_desc_0_0/ + //isImage := r.URL.Query().Get("isImage") + //bookNum := r.URL.Query().Get("bookNum") + //pageNum := r.URL.Query().Get("pageNum") + //sortType := r.URL.Query().Get("sortType") + //sort := r.URL.Query().Get("sort") + //priceDown := r.URL.Query().Get("priceDown") + //priceUp := r.URL.Query().Get("priceUp") + + //details, err := manager.OutGetGoodsMsgByDetailUrl("https://book.kongfz.com/151391/6531924071/", "") + //if err != nil { + // + //} + //fmt.Println(details) + + //id, err := manager.OutGetGoodsListMsgByShopId(1181761, + // "", true, "", + // "", 0, 0, 1, 5) + //if err != nil { + // fmt.Println(err) + //} + //fmt.Println(id) + //var pa ShopBookResult + //if err := json.Unmarshal([]byte(id), &pa); err != nil { + // log.Printf("[ERROR] 解析第 %d 页失败: %v", pa, err) + //} + //for _, urls := range pa.Data.Data { + // ss, err := proxyTypeManager("CALF_ELEPHANT_PROXY", "1297757178467602432", "QgQBvP7f", "") + // if err != nil { + // fmt.Printf(err.Error()) + // } + // fmt.Println(ss) + // url, err := manager.OutGetGoodsMsgByDetailUrl(urls.DetailURL, ss) + // if err != nil { + // fmt.Println(err) + // } + // fmt.Println(url) + //} + + //books, num, pNum, err := outGetGoodsListMsgByShopId(788247, + // typeManager, 1, 0, "", + // "", 0, 0, 1, 5) + // + //fmt.Println(books) + //fmt.Println(num) + //fmt.Println(pNum) + //fmt.Println(err) + //for _, book := range books { + // ss, err := proxyTypeManager("TAIL_PROXY", "", "", "07f4d0fbcff99966c2b37b0c1fb7f01c") + // if err != nil { + // fmt.Printf(err.Error()) + // } + // fmt.Println(ss) + // url, err := outGetGoodsMsgByDetailUrl(book.DetailUrl, ss) + // if err != nil { + // fmt.Println(err) + // } + // fmt.Println(url) + //} + +} + +func manegiyoutGetGoodsListMsgFromSelfShop() { + +} + +// 发送错误响应 +func sendErrorResponse(w http.ResponseWriter, statusCode int, message string) { + response := APIResp{ + Success: false, + Message: message, + } + w.WriteHeader(statusCode) + json.NewEncoder(w).Encode(response) +} + +type ShopBookResult struct { + Success bool `json:"success"` + Message string `json:"message"` + Data struct { + GoodsNum string `json:"goods_num"` + Pnum string `json:"pnum"` + Data []struct { + BookName string `json:"book_name"` + Author string `json:"author"` + Publisher string `json:"publisher"` + ISBN string `json:"isbn"` + PublishTime int64 `json:"publication_time"` + Edition string `json:"edition"` + PrintTime string `json:"print_time"` + FixPrice string `json:"fix_price"` + BindingLayout string `json:"binding_layout"` + Format string `json:"format"` + Paper string `json:"paper"` + Pages string `json:"pages"` + Wordage string `json:"wordage"` + Languages string `json:"languages"` + Era string `json:"era"` + EngravingMethod string `json:"engraving_method"` + Dimensions string `json:"dimensions"` + VolumeNumber string `json:"volume_number"` + BookPic string `json:"book_pic"` + BookPicS string `json:"book_pic_s"` + SellingPrice string `json:"selling_price"` + Condition string `json:"condition"` + ExpressDeliveryFee string `json:"express_delivery_fee"` + Editor string `json:"editor"` + Category string `json:"category"` + BuyCount string `json:"buy_count"` + SellCount string `json:"sell_count"` + Content string `json:"content"` + Mid int `json:"mid"` + ItemID int64 `json:"item_id"` + ShopID int `json:"shop_id"` + DetailURL string `json:"detail_url"` + } `json:"data"` + } `json:"data"` +} + +func main() { + http.HandleFunc("/api/kfzShopBookInfo", handleGetKFZShopBookInfo) + port := "8989" + server := &http.Server{ + Addr: ":" + port, + Handler: nil, + } + // 启动服务器 + if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed { + fmt.Printf("服务器启动失败: %v\n", err) + } +}