From a201193d5895f29cdf941e69403b93ccc674a4f1 Mon Sep 17 00:00:00 2001 From: Empire Date: Fri, 9 Jun 2023 01:09:59 +0200 Subject: [PATCH] include modified weatherapi, use forcast, use worst rain detection --- client/Cargo.toml | 16 +- client/bin/Cargo.toml | 16 + client/{ => bin}/src/broken_clouds.bmp | Bin client/{ => bin}/src/few_clouds.bmp | Bin client/{ => bin}/src/main.rs | 166 +- client/{ => bin}/src/mist.bmp | Bin client/{ => bin}/src/rain.bmp | Bin client/{ => bin}/src/scattered_clouds.bmp | Bin client/{ => bin}/src/shower.bmp | Bin client/{ => bin}/src/snow.bmp | Bin client/{ => bin}/src/sun.bmp | Bin client/{ => bin}/src/thunderstorm.bmp | Bin client/openweathermap/CNAME | 1 + client/openweathermap/Cargo.toml | 22 + client/openweathermap/LICENSE | 21 + client/openweathermap/README.md | 141 ++ client/openweathermap/src/api.rs | 132 ++ client/openweathermap/src/forecast.rs | 94 + client/openweathermap/src/lib.rs | 369 ++++ client/openweathermap/src/tests.rs | 2273 +++++++++++++++++++++ 20 files changed, 3175 insertions(+), 76 deletions(-) create mode 100644 client/bin/Cargo.toml rename client/{ => bin}/src/broken_clouds.bmp (100%) rename client/{ => bin}/src/few_clouds.bmp (100%) rename client/{ => bin}/src/main.rs (56%) rename client/{ => bin}/src/mist.bmp (100%) rename client/{ => bin}/src/rain.bmp (100%) rename client/{ => bin}/src/scattered_clouds.bmp (100%) rename client/{ => bin}/src/shower.bmp (100%) rename client/{ => bin}/src/snow.bmp (100%) rename client/{ => bin}/src/sun.bmp (100%) rename client/{ => bin}/src/thunderstorm.bmp (100%) create mode 100644 client/openweathermap/CNAME create mode 100644 client/openweathermap/Cargo.toml create mode 100644 client/openweathermap/LICENSE create mode 100644 client/openweathermap/README.md create mode 100644 client/openweathermap/src/api.rs create mode 100644 client/openweathermap/src/forecast.rs create mode 100755 client/openweathermap/src/lib.rs create mode 100644 client/openweathermap/src/tests.rs diff --git a/client/Cargo.toml b/client/Cargo.toml index d0377ca..2d00995 100644 --- a/client/Cargo.toml +++ b/client/Cargo.toml @@ -1,13 +1,7 @@ -[package] -name = "LEDboardClient" -version = "0.1.0" -edition = "2021" +[workspace] +members = [ + "openweathermap", + "bin" +] -# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html -[dependencies] -bit = "0.1.1" -embedded-graphics = "0.8.0" -openweathermap = "0.2.4" -substring = "1.4.5" -tinybmp = "0.5.0" diff --git a/client/bin/Cargo.toml b/client/bin/Cargo.toml new file mode 100644 index 0000000..60a2278 --- /dev/null +++ b/client/bin/Cargo.toml @@ -0,0 +1,16 @@ + +[package] +name = "LEDboardClient" +version = "0.1.0" +edition = "2021" + +[dependencies] +bit = "0.1.1" +embedded-graphics = "0.8.0" +substring = "1.4.5" +tinybmp = "0.5.0" +openweathermap = { path = "../openweathermap" } +chrono = { version = "0.4.23", default-features = false , features = ["iana-time-zone"] } +chrono-tz = "0.8.0" +colored = "2.0.0" +datetime = "0.5.2" diff --git a/client/src/broken_clouds.bmp b/client/bin/src/broken_clouds.bmp similarity index 100% rename from client/src/broken_clouds.bmp rename to client/bin/src/broken_clouds.bmp diff --git a/client/src/few_clouds.bmp b/client/bin/src/few_clouds.bmp similarity index 100% rename from client/src/few_clouds.bmp rename to client/bin/src/few_clouds.bmp diff --git a/client/src/main.rs b/client/bin/src/main.rs similarity index 56% rename from client/src/main.rs rename to client/bin/src/main.rs index 0923c62..40c1efb 100644 --- a/client/src/main.rs +++ b/client/bin/src/main.rs @@ -1,18 +1,24 @@ + use bit::BitIndex; +use chrono_tz::Europe::Berlin; +use chrono::{DateTime, NaiveDateTime, Utc, Timelike}; +use openweathermap::{forecast::{Weather, List}}; use substring::Substring; use tinybmp::Bmp; use core::time; use embedded_graphics::{ - image::{Image, ImageRaw}, + image::{Image}, mono_font::{iso_8859_1::FONT_6X10, MonoTextStyle}, - pixelcolor::{BinaryColor, Rgb565}, + pixelcolor::{BinaryColor}, prelude::*, - primitives::{Line, PrimitiveStyle}, + primitives::{PrimitiveStyle}, text::Text, }; -use openweathermap::{self, CurrentWeather, Weather}; -use std::net::UdpSocket; -use std::{env, sync::mpsc::Receiver, thread}; + +use std::{net::UdpSocket, time::{Instant, Duration}}; +use std::{env, thread}; + +use openweathermap::forecast::Forecast; const IMAGE_SIZE_BYTE: usize = (IMAGE_WIDTH_BYTE * IMAGE_HEIGHT) as usize; /* one byte contains 8 LEDs, one in each bit */ const IMAGE_WIDTH: u32 = 5 * 32; @@ -105,13 +111,8 @@ impl DrawTarget for UdpDisplay { } } -fn renderWeatherIcon(display: &mut UdpDisplay, icon: &[u8]){ - let icon_image = Bmp::from_slice(icon).unwrap(); - Image::new(&icon_image, Point::new((IMAGE_WIDTH-40) as i32, 0)).draw(display).unwrap(); -} - -fn renderWeather(display: &mut UdpDisplay ,data: &Option>){ +fn renderWeather(display: &mut UdpDisplay ,data: &Option>){ let text_style = MonoTextStyle::new(&FONT_6X10, BinaryColor::On); match data { @@ -123,47 +124,44 @@ fn renderWeather(display: &mut UdpDisplay ,data: &Option { - if(!result.weather.is_empty()){ - let condition = &result.weather[0]; - let short_icon_code = condition.icon.substring(0,2); + if !result.list.is_empty() { + let mut max:f64 = 0_f64; + let mut best = &result.list[0]; + for forecast in &result.list { + let time_s = forecast.dt; + let local_time = NaiveDateTime::from_timestamp_millis(time_s*1000).unwrap(); + let zoned_time : DateTime = DateTime::from_utc(local_time, Utc); + let europe_time = zoned_time.with_timezone(&Berlin); + + let hour = europe_time.hour(); + let minute = europe_time.minute(); + + let cur_time = DateTime::::default(); + if(zoned_time > cur_time){ + println!("Skipping old result {hour}:{minute} @{time_s}"); + } + + match &forecast.rain { + Some(x) => { + let rain_v = x.three_hours; + println!("Rain at {hour}:{minute} @{time_s} with {rain_v} prior best was {max}"); + if rain_v > max { + best = forecast; + max = rain_v; + } + }, + None => println!("No rain at {hour}:{minute}"), + } + + + } + + let condition = best.weather[0].to_owned(); + println!("Weather info: {} desc: {} icon {}", condition.main, condition.description, condition.icon); - match short_icon_code { - "01" => { - renderWeatherIcon(display, include_bytes!("sun.bmp")); - }, - "02" => { - renderWeatherIcon(display, include_bytes!("few_clouds.bmp")); - }, - "03" => { - renderWeatherIcon(display, include_bytes!("scattered_clouds.bmp")); - }, - "04" => { - renderWeatherIcon(display, include_bytes!("broken_clouds.bmp")); - }, - "09" => { - renderWeatherIcon(display, include_bytes!("shower.bmp")); - }, - "10" => { - renderWeatherIcon(display, include_bytes!("rain.bmp")); - }, - "11" => { - renderWeatherIcon(display, include_bytes!("thunderstorm.bmp")); - }, - "13" => { - renderWeatherIcon(display, include_bytes!("snow.bmp")); - }, - "50" => { - renderWeatherIcon(display, include_bytes!("mist.bmp")); - }, - _ => { - println!("Missing icon for {short_icon_code}"); - Text::new(&condition.description, Point::new(0, 0), text_style) - .draw(display) - .unwrap(); - } - } + renderWeatherIcon(&condition, display); } } }, @@ -174,12 +172,52 @@ fn renderWeather(display: &mut UdpDisplay ,data: &Option>) { + +fn renderWeatherIcon(condition: &Weather, display: &mut UdpDisplay ){ + let text_style = MonoTextStyle::new(&FONT_6X10, BinaryColor::On); + let short_icon_code = condition.icon.substring(0,2); + let icon_image: Result, tinybmp::ParseError> = match short_icon_code { + "01" => { + Bmp::from_slice(include_bytes!("sun.bmp")) + }, + "02" => { + Bmp::from_slice(include_bytes!("few_clouds.bmp")) + }, + "03" => { + Bmp::from_slice(include_bytes!("scattered_clouds.bmp")) + }, + "04" => { + Bmp::from_slice(include_bytes!("broken_clouds.bmp")) + }, + "09" => { + Bmp::from_slice(include_bytes!("shower.bmp")) + }, + "10" => { + Bmp::from_slice(include_bytes!("rain.bmp")) + }, + "11" => { + Bmp::from_slice(include_bytes!("thunderstorm.bmp")) + }, + "13" => { + Bmp::from_slice(include_bytes!("snow.bmp")) + }, + "50" => { + Bmp::from_slice(include_bytes!("mist.bmp")) + }, + _ => { + println!("Missing icon for {short_icon_code}"); + Text::new(&condition.description, Point::new(0, 0), text_style) + .draw(display) + .unwrap(); + return; + } + }; + Image::new(&icon_image.unwrap(), Point::new((IMAGE_WIDTH-40) as i32, 0)).draw(display).unwrap(); +} + +fn send_package(ipaddress: String, data: &Option>) { let mut package: [u8; PACKAGE_LENGTH] = [0; PACKAGE_LENGTH]; // Brightness @@ -228,33 +266,31 @@ fn main() { // one argument passed 2 => { let ip = &args[1]; - let receiver = openweathermap::init( - "Mannheim", - "metric", - "de", - "978882ab9dd05e7122ff2b0aef2d3e55", - 60, - ); + let receiver = openweathermap::init_forecast("Mannheim", + "metric", + "de", + "978882ab9dd05e7122ff2b0aef2d3e55", + 60,1); - let mut lastData = Option::None; + let mut last_data = Option::None; loop { let delay = time::Duration::from_millis(10000); thread::sleep(delay); - let answer = openweathermap::update(&receiver); + let answer = openweathermap::update_forecast(&receiver); match answer { Some(_) => { - lastData = answer; + last_data = answer; } None => { } } - send_package(ip.to_string(), &lastData); + send_package(ip.to_string(), &last_data); } } // all the other cases diff --git a/client/src/mist.bmp b/client/bin/src/mist.bmp similarity index 100% rename from client/src/mist.bmp rename to client/bin/src/mist.bmp diff --git a/client/src/rain.bmp b/client/bin/src/rain.bmp similarity index 100% rename from client/src/rain.bmp rename to client/bin/src/rain.bmp diff --git a/client/src/scattered_clouds.bmp b/client/bin/src/scattered_clouds.bmp similarity index 100% rename from client/src/scattered_clouds.bmp rename to client/bin/src/scattered_clouds.bmp diff --git a/client/src/shower.bmp b/client/bin/src/shower.bmp similarity index 100% rename from client/src/shower.bmp rename to client/bin/src/shower.bmp diff --git a/client/src/snow.bmp b/client/bin/src/snow.bmp similarity index 100% rename from client/src/snow.bmp rename to client/bin/src/snow.bmp diff --git a/client/src/sun.bmp b/client/bin/src/sun.bmp similarity index 100% rename from client/src/sun.bmp rename to client/bin/src/sun.bmp diff --git a/client/src/thunderstorm.bmp b/client/bin/src/thunderstorm.bmp similarity index 100% rename from client/src/thunderstorm.bmp rename to client/bin/src/thunderstorm.bmp diff --git a/client/openweathermap/CNAME b/client/openweathermap/CNAME new file mode 100644 index 0000000..f3b7959 --- /dev/null +++ b/client/openweathermap/CNAME @@ -0,0 +1 @@ +openweathermap.thats-software.com \ No newline at end of file diff --git a/client/openweathermap/Cargo.toml b/client/openweathermap/Cargo.toml new file mode 100644 index 0000000..3855d5e --- /dev/null +++ b/client/openweathermap/Cargo.toml @@ -0,0 +1,22 @@ +[package] +authors = ["Patrick Hoffmann "] +description = "easy access current weather data from OpenWeatherMap" +documentation = "https://docs.rs/openweathermap" +edition = "2018" +homepage = "https://openweathermap.thats-software.com" +keywords = ["weather", "openweathermap"] +license = "MIT OR Apache-2.0" +name = "openweathermap" +readme = "README.md" +version = "0.2.4" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +futures = {version = "0.3.1", features = ["executor"]} +http = {version = "0.2.4"} +rand = {version = "0.8.3"} +regex = {version = "1.4.6"} +reqwest = {version = "0.11.3", default-features = false, features = ["blocking"]} +serde = {version = "1.0", features = ["derive"]} +serde_json = {version = "1.0"} diff --git a/client/openweathermap/LICENSE b/client/openweathermap/LICENSE new file mode 100644 index 0000000..42476ed --- /dev/null +++ b/client/openweathermap/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2021 Patrick Hoffmann + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/client/openweathermap/README.md b/client/openweathermap/README.md new file mode 100644 index 0000000..315b3fc --- /dev/null +++ b/client/openweathermap/README.md @@ -0,0 +1,141 @@ +# openweathermap [![Rust](https://github.com/fightling/openweathermap/actions/workflows/rust.yml/badge.svg)](https://github.com/fightling/openweathermap/actions/workflows/rust.yml) + +...is a *rust crate* which lets you easily access current weather data from [OpenWeatherMap](https://openweathermap.org/). This is an *unofficial* extension I have made to learn *rust* a little but I hope you have fun with it. + +## Contents + + + +- [Contents](#contents) +- [How to use](#how-to-use) + - [Get continuous weather updates](#get-continuous-weather-updates) + - [First: Start polling](#first-start-polling) + - [Then: Get weather updates](#then-get-weather-updates) + - [Nothing New: `None`](#nothing-new-none) + - [Weather Update: `CurrentWeather`](#weather-update-currentweather) + - [Some Error: `Err`](#some-error-err) + - [Get weather just once](#get-weather-just-once) +- [Reference Documentation](#reference-documentation) +- [Links](#links) + - [Website](#website) + - [*github* repository](#github-repository) + - [on *crates.io*](#on-cratesio) +- [License](#license) + + + +## How to use + +First add this crate to your dependencies in you `Cargo.toml` file: + +```toml +[dependencies] +openweathermap = "0.2.4" +``` +### Get continuous weather updates + +Then use the crate in your rust source file by calling `openweathermap::init()` which returns a receiver object. +You can then use this receiver object to call `openweathermap::update()` to get weather updates like in the following example: + +```rust +extern crate openweathermap; + +use openweathermap::{init,update}; + +fn main() { + // start our observatory via OWM + let receiver = &init("Berlin,DE", "metric", "en", "", 10); + loop { + match update(receiver) { + Some(response) => match response { + Ok(current) => println!( + "Today's weather in {} is {}", + current.name.as_str(), + current.weather[0].main.as_str() + ), + Err(e) => println!("Could not fetch weather because: {}", e), + }, + None => (), + } + } +} +``` + +#### First: Start polling + +`init()` spawns a thread which then will periodically poll *OpenWeatherMap* for the latest current weather report. +You then can use `update()` to ask for it. + +#### Then: Get weather updates + +There are three possible kinds of result you get from `update()` which you will have to face: + +##### Nothing New: `None` + +`update()` returns `None` if there is currently no new update available. +Which means: **You wont get any update twice!** +In other words: `update()` is not caching the last weather update for you. + +##### Weather Update: `CurrentWeather` + +If a new update was downloaded by the polling thread `update()` returns some `CurrentWeather` object. +`CurrentWeather` is a nested `struct` with the already parsed json properties. +Those are well described [here](https://openweathermap.org/current#parameter). + +##### Some Error: `Err` +On error `update()` returns some `String` object which includes a brief error description. + +Errors may occur... +- initially while **there is no update yet** you will get an `Err` which includes exactly the String `"loading..."` (predefined in `openweathermap::LOADING`). +- if a **server error** response was received (e.g. `401 Unauthorized` if an **invalid API key** was used). +- on **json errors** while parsing the response from *OpenWeatherMap*. + +### Get weather just once + +If you need the weather just once you may use the method `weather()` which envelopes `init()` and `update()` into one single synchronous or asynchronous call. +After the first successful weather update the spawned thread will stop immediately and you get the result in return. + +```rust +extern crate openweathermap; +use openweathermap::blocking::weather; + +fn main() { + // start our observatory via OWM + match &weather("Berlin,DE", "metric", "en", "") { + Ok(current) => println!( + "Today's weather in {} is {}", + current.name.as_str(), + current.weather[0].main.as_str() + ), + Err(e) => println!("Could not fetch weather because: {}", e), + } +} + +``` + +There is a *blocking* and a *non-blocking* variant of `weather()`: + +- The above example uses the synchronous (*blocking*) variant `openweathermap::blocking::weather` which wont return until there is a new update. +- If you like to deal with the returned *future* by yourself just use `openweathermap::weather` and asynchronously await the result until there is any. + +## Reference Documentation + +Beside this introduction there is a reference documentation which can be found [here](https://docs.rs/openweathermap). + +## Links + +### Website + +This README tastes better at [openweathermap.thats-software.com](https://openweathermap.thats-software.com). + +### *github* repository + +For the source code see [this repository](https://github.com/fightling/openweathermap) at *github.com*. + +### on *crates.io* + +Published at [*crates.io*](https://crates.io/crates/openweathermap). + +## License + +openweathermap is licensed under the *MIT license* (LICENSE-MIT or http://opensource.org/licenses/MIT) diff --git a/client/openweathermap/src/api.rs b/client/openweathermap/src/api.rs new file mode 100644 index 0000000..6983cbc --- /dev/null +++ b/client/openweathermap/src/api.rs @@ -0,0 +1,132 @@ +use serde::Deserialize; + +/// Location coordinates +#[derive(Deserialize, Debug)] +pub struct Coord { + /// geo location, longitude + pub lon: f64, + /// geo location, latitude + pub lat: f64, +} + +/// Weather condition description +#[derive(Deserialize, Debug)] +pub struct Weather { + /// Weather condition id + pub id: u64, + /// Group of weather parameters (Rain, Snow, Extreme etc.) + pub main: String, + /// Weather condition + pub description: String, + /// Weather icon id + pub icon: String, +} + +/// Detailed weather report +#[derive(Deserialize, Debug)] +pub struct Main { + /// Temperature. Unit Default: Kelvin, Metric: Celsius, Imperial: Fahrenheit. + pub temp: f64, + /// Temperature. This temperature parameter accounts for the human perception of weather. + /// Unit Default: Kelvin, Metric: Celsius, Imperial: Fahrenheit. + pub feels_like: f64, + /// Atmospheric pressure (on the sea level, if there is no sea_level or grnd_level data), hPa + pub pressure: f64, + /// Humidity, % + pub humidity: f64, + /// Minimum temperature at the moment. + /// This is minimal currently observed temperature (within large megalopolises and urban areas). + /// Unit Default: Kelvin, Metric: Celsius, Imperial: Fahrenheit. + pub temp_min: f64, + /// Maximum temperature at the moment. + /// This is maximal currently observed temperature (within large megalopolises and urban areas). + /// Unit Default: Kelvin, Metric: Celsius, Imperial: Fahrenheit. + pub temp_max: f64, + /// Atmospheric pressure on the sea level, hPa + pub sea_level: Option, + /// Atmospheric pressure on the ground level, hPa + pub grnd_level: Option, +} + +/// Detailed wind report +#[derive(Deserialize, Debug)] +pub struct Wind { + /// Wind speed. Unit Default: meter/sec, Metric: meter/sec, Imperial: miles/hour. + pub speed: f64, + /// Wind direction, degrees (meteorological) + pub deg: f64, + /// Wind gust. Unit Default: meter/sec, Metric: meter/sec, Imperial: miles/hour + pub gust: Option, +} + +/// Detailed clouds report +#[derive(Deserialize, Debug)] +pub struct Clouds { + /// Cloudiness, % + pub all: f64, +} + +/// Rain or snow volume report +#[derive(Deserialize, Debug)] +pub struct Volume { + /// Volume for the last 1 hour, mm + #[serde(rename = "1h")] + pub h1: Option, + /// Volume for the last 3 hours, mm + #[serde(rename = "3h")] + pub h3: Option, +} + +/// Additional information +#[derive(Deserialize, Debug)] +pub struct Sys { + /// Internal parameter + #[serde(rename = "type")] + pub type_: Option, + /// Internal parameter + pub id: Option, + /// Internal parameter + pub message: Option, + /// Country code (GB, JP etc.) + pub country: String, + /// Sunrise time, unix, UTC + pub sunrise: i64, + /// Sunset time, unix, UTC + pub sunset: i64, +} + +#[derive(Deserialize, Debug)] +/// current weather report in a nested struct +pub struct CurrentWeather { + /// report origin coordinates + pub coord: Coord, + /// vector with one item of weather condition descriptions + pub weather: Vec, + /// Internal parameter + pub base: String, + /// detailed weather report + pub main: Main, + /// Visibility, meter + pub visibility: u64, + /// detailed wind report + pub wind: Wind, + /// detailed clouds report + pub clouds: Clouds, + /// detailed rain report + pub rain: Option, + /// detailed snow report + pub snow: Option, + /// Time of data calculation, unix, UTC + pub dt: i64, + /// additional information + pub sys: Sys, + /// Shift in seconds from UTC + pub timezone: i64, + /// City ID + pub id: u64, + /// City name + pub name: String, + /// Internal parameter + pub cod: u64, +} + diff --git a/client/openweathermap/src/forecast.rs b/client/openweathermap/src/forecast.rs new file mode 100644 index 0000000..2096157 --- /dev/null +++ b/client/openweathermap/src/forecast.rs @@ -0,0 +1,94 @@ +use serde::{Deserialize, __private::de}; + +#[derive(Default, Debug, Clone, PartialEq, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct Forecast { + pub city: City, + pub cod: String, + pub message: f64, + pub cnt: f64, + pub list: Vec, +} + +#[derive(Default, Debug, Clone, PartialEq, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct City { + pub id: f64, + pub name: String, + pub coord: Coord, + pub country: String, + pub population: f64, + pub timezone: f64, + pub sunrise: i64, + pub sunset: i64, +} + +#[derive(Default, Debug, Clone, PartialEq, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct Coord { + pub lon: f64, + pub lat: f64, +} + +#[derive(Default, Debug, Clone, PartialEq, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct List { + pub dt: i64, + pub main: Main, + pub weather: Vec, + pub wind: Wind, + pub clouds: Clouds, + pub pop: f64, + pub rain: Option, +} + +#[derive(Default, Debug, Clone, PartialEq, Deserialize)] +pub struct Wind{ + pub speed:f64, + pub deg:f64, + pub gust:f64 +} + +#[derive(Default, Debug, Clone, PartialEq, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct Rain{ + #[serde(rename = "3h")] + pub three_hours:f64 +} + +#[derive(Default, Debug, Clone, PartialEq, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct Clouds{ + all:f64 +} + +#[derive(Default, Debug, Clone, PartialEq, Deserialize)] +pub struct Main { + pub temp: f64, + pub feels_like: f64, + pub temp_min: f64, + pub temp_max: f64, + pub pressure: f64, + pub sea_level: f64, + pub grnd_level: f64, + pub humidity: f64, + pub temp_kf: f64, +} + +#[derive(Default, Debug, Clone, PartialEq, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct FeelsLike { + pub day: f64, + pub night: f64, + pub eve: f64, + pub morn: f64, +} + +#[derive(Default, Debug, Clone, PartialEq, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct Weather { + pub id: f64, + pub main: String, + pub description: String, + pub icon: String, +} diff --git a/client/openweathermap/src/lib.rs b/client/openweathermap/src/lib.rs new file mode 100755 index 0000000..6485ad0 --- /dev/null +++ b/client/openweathermap/src/lib.rs @@ -0,0 +1,369 @@ +extern crate reqwest; +extern crate serde_json; + +use forecast::Forecast; +use futures::executor; +use http::StatusCode; +use regex::Regex; +use std::sync::mpsc; +use std::thread; +use std::time::Duration; + +mod api; +pub mod forecast; +pub use api::*; + +#[cfg(test)] +mod tests; + +/// Receiver object you get from `init()` and have top handle to `update()`. +pub type Receiver = mpsc::Receiver>; + +/// Receiver object you get from `init_forecast()` and have top handle to `update()`. +pub type ForecastReceiver = mpsc::Receiver>; + +/// Loading error messaage you get at the first call of `update()`. +pub const LOADING: &str = "loading..."; + +/// Spawns a thread which fetches the current weather from +/// [openweathermap.org](https://openweathermap.org) periodically. +/// #### Parameters +/// - `location`: Can be a city name, a city ID or a geographical coordinate: +/// - city name: may be followed by comma separated state code and/or country code (e.g. `"Berlin,DE"`). +/// - city ID: which can be found at [this](https://openweathermap.org/find) where you will get link that includes the ID +/// - e.g. `"2950159"` for Berlin, Germany +/// - coordinates: given by comma separated latitude and longitude (e.g. `"52.5244,13.4105"`). | +/// - `units`: One of the following: +/// - `"metric"`: meters, m/s, °C, etc. +/// - `"imperial"`: miles, mi/s, °F, etc. +/// - `"standard"`: meters, m/s, K, etc. +/// - `lang`: Language code: +/// - `"en"`: for English +/// - `"de"`: for German +/// - see [this list](https://openweathermap.org/current#multi) for all available language codes +/// - `api_key`: Your API key which you can get [here](https://openweathermap.org/price) +/// - `poll_mins`: Update interval: +/// - `> 0`: duration of poll period in minutes (`10` is recommended) +/// - `= 0`: thread will terminate after the first successful update. +/// #### Return value +/// - `openweathermap::Receiver`: Handle this to `openweathermap::update()` to get the latest weather update. +/// +/// The return value is a `mpsc` *channel receiver*: +/// ```rust +/// pub type Receiver = std::sync::mpsc::Receiver>; +/// ``` + +pub fn init(location: &str, units: &str, lang: &str, api_key: &str, poll_mins: u64) -> Receiver { + // generate correct request URL depending on city is id or name + let url = match location.parse::().is_ok() { + true => format!( + "http://api.openweathermap.org/data/2.5/weather?id={}&units={}&lang={}&appid={}", + location, units, lang, api_key + ), + false => { + let re = Regex::new(r"(-?\d+\.\d+)\s*,\s*(-?\d+\.\d+)").unwrap(); + match re.captures(&location) { + Some(caps) => format!("http://api.openweathermap.org/data/2.5/weather?lat={}&lon={}&units={}&lang={}&appid={}", + caps.get(1).unwrap().as_str(), caps.get(2).unwrap().as_str(), units, lang, api_key ), + None => format!( + "http://api.openweathermap.org/data/2.5/weather?q={}&units={}&lang={}&appid={}", + location, units, lang, api_key ), + } + } + }; + // fork thread that continuously fetches weather updates every minutes + let period = Duration::from_secs(60 * poll_mins); + let (tx, rx) = mpsc::channel(); + thread::spawn(move || { + tx.send(Err(LOADING.to_string())).unwrap_or(()); + loop { + match reqwest::blocking::get(&url) { + Ok(response) => match response.status() { + StatusCode::OK => match serde_json::from_str(&response.text().unwrap()) { + Ok(w) => { + tx.send(Ok(w)).unwrap_or(()); + if period == Duration::new(0, 0) { + break; + } + thread::sleep(period); + } + Err(e) => tx.send(Err(e.to_string())).unwrap_or(()), + }, + _ => tx.send(Err(response.status().to_string())).unwrap_or(()), + }, + Err(_e) => (), + } + } + }); + // return receiver that provides the updated weather as json string + return rx; +} + +/// Spawns a thread which fetches the forecast from +/// [openweathermap.org](https://openweathermap.org) periodically. +/// #### Parameters +/// - `location`: Can be a city name, a city ID or a geographical coordinate: +/// - city name: may be followed by comma separated state code and/or country code (e.g. `"Berlin,DE"`). +/// - city ID: which can be found at [this](https://openweathermap.org/find) where you will get link that includes the ID +/// - e.g. `"2950159"` for Berlin, Germany +/// - coordinates: given by comma separated latitude and longitude (e.g. `"52.5244,13.4105"`). | +/// - `units`: One of the following: +/// - `"metric"`: meters, m/s, °C, etc. +/// - `"imperial"`: miles, mi/s, °F, etc. +/// - `"standard"`: meters, m/s, K, etc. +/// - `lang`: Language code: +/// - `"en"`: for English +/// - `"de"`: for German +/// - see [this list](https://openweathermap.org/current#multi) for all available language codes +/// - `api_key`: Your API key which you can get [here](https://openweathermap.org/price) +/// - `poll_mins`: Update interval: +/// - `> 0`: duration of poll period in minutes (`10` is recommended) +/// - `= 0`: thread will terminate after the first successful update. +/// #### Return value +/// - `openweathermap::Receiver`: Handle this to `openweathermap::update()` to get the latest weather update. +/// +/// The return value is a `mpsc` *channel receiver*: +/// ```rust +/// pub type Receiver = std::sync::mpsc::Receiver>; +/// ``` + +pub fn init_forecast( + location: &str, + units: &str, + lang: &str, + api_key: &str, + poll_mins: u64, + days: u32, +) -> ForecastReceiver { + // generate correct request URL depending on city is id or name + let url = match location.parse::().is_ok() { + true => format!( + "http://api.openweathermap.org/data/2.5/forecast?id={}&units={}&lang={}&appid={}&cnt={}", + location, units, lang, api_key, days + ), + false => { + let re = Regex::new(r"(-?\d+\.\d+)\s*,\s*(-?\d+\.\d+)").unwrap(); + match re.captures(&location) { + Some(caps) => format!("http://api.openweathermap.org/data/2.5/forecast?lat={}&lon={}&units={}&lang={}&appid={}&cnt={}", + caps.get(1).unwrap().as_str(), caps.get(2).unwrap().as_str(), units, lang, api_key, days ), + None => format!( + "http://api.openweathermap.org/data/2.5/forecast?q={}&units={}&lang={}&appid={}&cnt={}", + location, units, lang, api_key, days ), + } + } + }; + // fork thread that continuously fetches weather updates every minutes + let period = Duration::from_secs(60 * poll_mins); + let (tx, rx) = mpsc::channel(); + thread::spawn(move || { + tx.send(Err(LOADING.to_string())).unwrap_or(()); + loop { + //let fake: Result = serde_json::from_str(include_str!("example.json")); + //tx.send(Result::Ok(fake.unwrap())).unwrap(); + + match reqwest::blocking::get(&url) { + Ok(response) => match response.status() { + StatusCode::OK => match serde_json::from_str(&response.text().unwrap()) { + Ok(w) => { + tx.send(Ok(w)).unwrap_or(()); + if period == Duration::new(0, 0) { + break; + } + thread::sleep(period); + } + Err(e) => tx.send(Err(e.to_string())).unwrap_or(()), + }, + _ => tx.send(Err(response.status().to_string())).unwrap_or(()), + }, + Err(_e) => (), + } + } + }); + // return receiver that provides the updated weather as json string + return rx; +} + +/// Get current weather update that the spawned thread could fetched. +/// #### Parameters +/// - `receiver`: the *channel receiver* from preceded call to `openweathermap::init()` +/// #### Returng value +/// - ⇒ `None`: No update available +/// - ⇒ `Some(Result)`: Update available +/// - ⇒ `Ok(CurrentWeather)`: Weather information in a nested struct called `CurrentWeather` +/// (see also [*OpenWeatherMap* documentation](https://openweathermap.org/current#parameter) for details) +/// - ⇒ `Err(String)`: Error message about any occured http or json issue +/// - e.g. `401 Unauthorized`: if your API key is invalid +/// - some json parser error message if response from OpenWeatherMap could not be parsed +pub fn update(receiver: &Receiver) -> Option> { + match receiver.try_recv() { + Ok(response) => Some(response), + Err(_e) => None, + } +} + +pub fn update_forecast(receiver: &ForecastReceiver) -> Option> { + match receiver.try_recv() { + Ok(response) => Some(response), + Err(_e) => None, + } +} + +/// Fetch current weather update once and stop thread immediately after success. +/// Returns the result in a *future*. +/// #### Parameters +/// - `location`: Can be a city name, a city ID or a geographical coordinate: +/// - city name: may be followed by comma separated state code and/or country code (e.g. `"Berlin,DE"`). +/// - city ID: which can be found at [this](https://openweathermap.org/find) where you will get link that includes the ID +/// - e.g. `"2950159"` for Berlin, Germany +/// - coordinates: given by comma separated latitude and longitude (e.g. `"52.5244,13.4105"`). | +/// - `units`: One of the following: +/// - `"metric"`: meters, m/s, °C, etc. +/// - `"imperial"`: miles, mi/s, °F, etc. +/// - `"standard"`: meters, m/s, K, etc. +/// - `lang`: Language code: +/// - `"en"`: for English +/// - `"de"`: for German +/// - see [this list](https://openweathermap.org/current#multi) for all available language codes +/// - `api_key`: Your API key which you can get [here](https://openweathermap.org/price) +/// #### Return value +/// - ⇒ `Ok(CurrentWeather)`: weather information in a nested struct called `CurrentWeather` +/// (see also [*OpenWeatherMap* documentation](https://openweathermap.org/current#parameter) for details) +/// - ⇒ `Err(String)`: Error message about any occured http or json issue +/// - e.g. `401 Unauthorized` if your API key is invalid +/// - some json parser error message if response from OpenWeatherMap could not be parsed +pub async fn weather( + location: &str, + units: &str, + lang: &str, + api_key: &str, +) -> Result { + let r = init(location, units, lang, api_key, 0); + loop { + match update(&r) { + Some(response) => match response { + Ok(current) => return Ok(current), + Err(e) => { + if e != LOADING { + return Err(e); + } + } + }, + None => (), + } + } +} + +/// Fetch forecast weather update once and stop thread immediately after success. +/// Returns the result in a *future*. +/// #### Parameters +/// - `location`: Can be a city name, a city ID or a geographical coordinate: +/// - city name: may be followed by comma separated state code and/or country code (e.g. `"Berlin,DE"`). +/// - city ID: which can be found at [this](https://openweathermap.org/find) where you will get link that includes the ID +/// - e.g. `"2950159"` for Berlin, Germany +/// - coordinates: given by comma separated latitude and longitude (e.g. `"52.5244,13.4105"`). | +/// - `units`: One of the following: +/// - `"metric"`: meters, m/s, °C, etc. +/// - `"imperial"`: miles, mi/s, °F, etc. +/// - `"standard"`: meters, m/s, K, etc. +/// - `lang`: Language code: +/// - `"en"`: for English +/// - `"de"`: for German +/// - see [this list](https://openweathermap.org/current#multi) for all available language codes +/// - `api_key`: Your API key which you can get [here](https://openweathermap.org/price) +/// #### Return value +/// - ⇒ `Ok(Forecast)`: weather information in a nested struct called `CurrentWeather` +/// (see also [*OpenWeatherMap* documentation](https://openweathermap.org/current#parameter) for details) +/// - ⇒ `Err(String)`: Error message about any occured http or json issue +/// - e.g. `401 Unauthorized` if your API key is invalid +/// - some json parser error message if response from OpenWeatherMap could not be parsed +pub async fn forecast( + location: &str, + units: &str, + lang: &str, + api_key: &str, + days: u32, +) -> Result { + let r = init_forecast(location, units, lang, api_key, 0, days); + loop { + match update_forecast(&r) { + Some(response) => match response { + Ok(forecast) => return Ok(forecast), + Err(e) => { + if e != LOADING { + return Err(e); + } + } + }, + None => (), + } + } +} + +/// synchronous functions +pub mod blocking { + use super::*; + /// Fetches a weather update once and stops the thread immediately after success then returns the update. + /// #### Parameters + /// - `location`: Can be a city name, a city ID or a geographical coordinate: + /// - city name may be followed by comma separated state code and/or country code (e.g. `"Berlin,DE"`). + /// - city ID which can be found at [this](https://openweathermap.org/find) where you will get link that includes the ID + /// - e.g. `"2950159"` for Berlin, Germany + /// - coordinates given by comma separated latitude and longitude (e.g. `"52.5244,13.4105"`). | + /// - `units`: One of the following: + /// - `"metric"`: meters, m/s, °C, etc. + /// - `"imperial"`: miles, mi/s, °F, etc. + /// - `"standard"`: meters, m/s, K, etc. + /// - `lang`: Language code: + /// - `"en"`: for English + /// - `"de"`: for German + /// - see [this list](https://openweathermap.org/current#multi) for all available language codes + /// - `api_key`: Your API key which you can get [here](https://openweathermap.org/price) + /// #### Return value + /// - ⇒ `Ok(CurrentWeather)`: weather information in a nested struct called `CurrentWeather` + /// (see also [*OpenWeatherMap* documentation](https://openweathermap.org/current#parameter) for details) + /// - ⇒ `Err(String)`: Error message about any occured http or json issue + /// - e.g. `401 Unauthorized` if your API key is invalid + /// - some json parser error message if response from OpenWeatherMap could not be parsed + pub fn weather( + location: &str, + units: &str, + lang: &str, + api_key: &str, + ) -> Result { + // wait for result + executor::block_on(super::weather(location, units, lang, api_key)) + } + + /// Fetches a weather update once and stops the thread immediately after success then returns the update. + /// #### Parameters + /// - `location`: Can be a city name, a city ID or a geographical coordinate: + /// - city name may be followed by comma separated state code and/or country code (e.g. `"Berlin,DE"`). + /// - city ID which can be found at [this](https://openweathermap.org/find) where you will get link that includes the ID + /// - e.g. `"2950159"` for Berlin, Germany + /// - coordinates given by comma separated latitude and longitude (e.g. `"52.5244,13.4105"`). | + /// - `units`: One of the following: + /// - `"metric"`: meters, m/s, °C, etc. + /// - `"imperial"`: miles, mi/s, °F, etc. + /// - `"standard"`: meters, m/s, K, etc. + /// - `lang`: Language code: + /// - `"en"`: for English + /// - `"de"`: for German + /// - see [this list](https://openweathermap.org/current#multi) for all available language codes + /// - `api_key`: Your API key which you can get [here](https://openweathermap.org/price) + /// #### Return value + /// - ⇒ `Ok(CurrentWeather)`: weather information in a nested struct called `CurrentWeather` + /// (see also [*OpenWeatherMap* documentation](https://openweathermap.org/current#parameter) for details) + /// - ⇒ `Err(String)`: Error message about any occured http or json issue + /// - e.g. `401 Unauthorized` if your API key is invalid + /// - some json parser error message if response from OpenWeatherMap could not be parsed + pub fn forecast( + location: &str, + units: &str, + lang: &str, + api_key: &str, + days: u32, + ) -> Result { + // wait for result + executor::block_on(super::forecast(location, units, lang, api_key, days)) + } +} diff --git a/client/openweathermap/src/tests.rs b/client/openweathermap/src/tests.rs new file mode 100644 index 0000000..0d3f5ad --- /dev/null +++ b/client/openweathermap/src/tests.rs @@ -0,0 +1,2273 @@ +// Note this useful idiom: importing names from outer (for mod tests) scope. +use super::*; +use rand::{thread_rng, Rng}; + +fn apikey() -> String { + match std::env::var("OWM_APIKEY") { + Ok(key) => key, + Err(_r) => { + eprintln!("error: set API-key with environment valiable OWM_APIKEY"); + "".to_string() + } + } +} + +#[test] +fn test_city() { + let w = blocking::weather("Munich,DE", "metric", "en", &apikey()).unwrap(); + assert_eq!(w.name, "Munich"); +} + +#[test] +fn test_cityid() { + let w = blocking::weather("2950159", "metric", "en", &apikey()).unwrap(); + assert_eq!(w.name, "Berlin"); +} + +#[test] +fn test_coordinate() { + let w = blocking::weather("52.5244,13.4105", "metric", "en", &apikey()).unwrap(); + assert_eq!(w.coord.lat, 52.5244); + assert_eq!(w.coord.lon, 13.4105); +} + +#[test] +fn test_language() { + let w = blocking::weather("München,DE", "metric", "de", &apikey()).unwrap(); + assert_eq!(w.name, "München"); +} + +#[test] +fn test_units() { + let w1 = blocking::weather("Berlin,DE", "metric", "en", &apikey()).unwrap(); + let w2 = blocking::weather("Berlin,DE", "imperial", "en", &apikey()).unwrap(); + let w3 = blocking::weather("Berlin,DE", "standard", "en", &apikey()).unwrap(); + assert_ne!(w1.main.temp, w2.main.temp); + assert_ne!(w1.main.temp, w3.main.temp); + assert_ne!(w2.main.temp, w3.main.temp); +} + +#[test] +fn test_apikey() { + let w = blocking::weather("Berlin,DE", "metric", "de", ""); + assert!(w.is_err()); +} + +#[test] +fn test_cities() { + let mut rng = thread_rng(); + let max = 10; + for _i in 0..=max { + let city = CITIES[rng.gen_range(0..CITIES.len() - 1)]; + let w = blocking::weather(&city.to_string(), "metric", "en", &apikey()).unwrap(); + assert_eq!(w.id, city); + } +} + +// this is a list of city IDs +// (generated from https://bulk.openweathermap.org/sample/current.city.list.min.json.gz) +const CITIES: &[u64] = &[ + 14256, 18918, 23814, 24851, 32723, 32767, 41210, 50672, 52867, 53157, 53654, 54715, 55671, + 56166, 56335, 56399, 57289, 59611, 60019, 62691, 62788, 63571, 63689, 63795, 64013, 64435, + 64460, 64536, 65170, 65785, 69500, 69559, 70225, 70979, 71137, 71273, 73560, 74477, 75337, + 76154, 76991, 77408, 78754, 79415, 79836, 81302, 81604, 87205, 88319, 88380, 88562, 88834, + 88835, 88903, 89055, 89087, 89113, 89570, 89824, 90026, 90150, 90353, 90708, 91597, 91812, + 92002, 92004, 92430, 93709, 94220, 94298, 94787, 94824, 95446, 95788, 96205, 96309, 97417, + 97783, 97990, 98012, 98112, 98182, 98245, 98459, 98463, 98530, 98589, 98622, 98629, 98677, + 98685, 98717, 98854, 98860, 98885, 99010, 99039, 99060, 99062, 99071, 99072, 99097, 99131, + 99169, 99306, 99344, 99347, 99350, 99369, 99434, 99439, 99446, 99454, 99532, 99548, 99608, + 99738, 99759, 99762, 100077, 100425, 100926, 101312, 101322, 101554, 101628, 101631, 101760, + 102318, 102451, 102527, 102585, 102651, 102985, 103035, 103369, 103630, 104515, 105072, 105299, + 105343, 106281, 106909, 107304, 107312, 107744, 107781, 107797, 107959, 107968, 108048, 108410, + 108435, 108512, 108617, 108648, 108773, 108918, 108927, 109059, 109101, 109223, 109323, 109380, + 109417, 109435, 109571, 109878, 109915, 109953, 110250, 110314, 110325, 110336, 110619, 110690, + 110831, 111421, 111453, 111822, 112214, 112646, 112656, 112931, 113343, 113491, 113508, 113632, + 113646, 113659, 114049, 114259, 114584, 114593, 115019, 115770, 115781, 116102, 116402, 116406, + 116667, 116996, 117392, 117574, 117656, 117793, 118063, 118191, 118367, 118704, 118743, 118805, + 118826, 118994, 119115, 119161, 119208, 119374, 119505, 119730, 120678, 120694, 120931, 120972, + 121110, 121240, 121380, 121795, 121801, 121861, 121925, 121959, 122285, 122289, 122397, 122438, + 122698, 122915, 123941, 124085, 124193, 124274, 124620, 124647, 124665, 124862, 125185, 125188, + 125446, 125897, 126409, 126914, 126972, 127033, 127319, 127349, 127403, 128008, 128226, 128234, + 128321, 128447, 128477, 128747, 128831, 128905, 129512, 129933, 130245, 130802, 131962, 132144, + 132892, 132938, 132961, 133037, 133595, 134217, 134518, 134602, 134721, 134762, 135298, 135423, + 136014, 136399, 136702, 136987, 137268, 137956, 138025, 138042, 138742, 139223, 139817, 139889, + 140044, 140046, 140097, 140380, 140463, 140521, 140889, 140918, 140951, 141584, 141665, 141668, + 141679, 141681, 141736, 142000, 142255, 142358, 142363, 142496, 142554, 142676, 142679, 142872, + 143052, 143073, 143083, 143127, 143534, 143748, 143860, 143921, 144269, 144410, 144443, 144448, + 144616, 144696, 144794, 145034, 145233, 145449, 145459, 145531, 145724, 146214, 146268, 146384, + 146400, 146412, 146617, 146970, 147059, 147105, 147271, 147425, 147429, 147622, 147982, 148290, + 148340, 148445, 148565, 148619, 148730, 148842, 148942, 148987, 149027, 149050, 149129, 149132, + 149151, 149155, 149172, 149402, 149418, 149437, 149512, 149581, 149606, 149658, 149703, 149775, + 149792, 149812, 149854, 149879, 149929, 150006, 150037, 150099, 150276, 150436, 150453, 150634, + 150885, 150930, 151108, 151211, 151266, 151363, 151373, 151479, 151567, 151599, 151678, 151711, + 151929, 151986, 152224, 152376, 152403, 152451, 152497, 152546, 152632, 152663, 152718, 152743, + 152781, 152933, 153094, 153176, 153209, 153220, 153352, 153384, 153408, 153412, 153423, 153482, + 153709, 153759, 153871, 154002, 154097, 154321, 154380, 154470, 154566, 154638, 154648, 154654, + 154780, 155016, 155056, 155076, 155101, 155285, 155307, 155310, 155321, 155334, 155405, 155515, + 155569, 155743, 155921, 156025, 156080, 156098, 156111, 156510, 156627, 156963, 156974, 157107, + 157198, 157268, 157403, 157738, 157826, 157863, 157960, 157977, 158016, 158024, 158027, 158151, + 158160, 158179, 158214, 158289, 158324, 158492, 158563, 158597, 158684, 158825, 158904, 159045, + 159071, 159107, 159179, 159186, 159218, 159267, 159380, 159386, 159398, 159492, 159647, 159909, + 159951, 160172, 160196, 160263, 160266, 160464, 160552, 160592, 160660, 160670, 160677, 160798, + 160833, 160877, 160892, 160961, 161023, 161154, 161197, 161204, 161218, 161290, 161312, 161325, + 161616, 161901, 161943, 161974, 162099, 162158, 162183, 162199, 162627, 163270, 163345, 163476, + 163533, 163779, 163806, 163808, 163811, 163915, 164025, 164328, 164816, 164898, 164947, 165060, + 165929, 165997, 166111, 166331, 167046, 167357, 167605, 168325, 168620, 168629, 168661, 168668, + 169023, 169113, 169179, 169304, 169372, 169375, 169389, 169577, 169897, 170017, 170044, 170063, + 170592, 170654, 170785, 170794, 170887, 170892, 171451, 171830, 172059, 172082, 172349, 172374, + 172408, 172469, 172503, 172946, 172955, 173193, 173312, 173322, 173334, 173361, 173480, 173576, + 173598, 173811, 173819, 174018, 174186, 174259, 174448, 174506, 174875, 174895, 174972, 174979, + 174991, 175499, 176146, 176555, 178202, 178443, 178522, 179330, 181135, 182701, 183027, 184379, + 184433, 184622, 184707, 184745, 185702, 185939, 186180, 186301, 186315, 186731, 186827, 187585, + 187725, 187896, 187968, 188080, 188492, 188657, 189280, 189741, 191038, 191220, 191245, 191299, + 192067, 192710, 192859, 192900, 193627, 195272, 196231, 196742, 197745, 198476, 198629, 200067, + 200787, 201463, 201521, 201865, 202061, 202065, 202068, 202217, 202326, 202905, 203104, 203112, + 203717, 204283, 204318, 204405, 204953, 205970, 207570, 207596, 209228, 210379, 210939, 211098, + 211647, 211734, 212360, 212730, 212902, 213940, 214389, 214481, 214575, 214614, 214974, 215527, + 215605, 215668, 215771, 215976, 216281, 216404, 216449, 217389, 217562, 217570, 217637, 217695, + 217745, 217831, 217834, 218253, 218680, 219057, 219414, 220448, 220782, 221527, 223817, 225284, + 225835, 225858, 225964, 226110, 226234, 226823, 226853, 227592, 227593, 227812, 227904, 228227, + 228853, 228971, 229059, 229139, 229268, 229278, 229362, 229380, 229746, 229911, 230166, 230299, + 230617, 230893, 231139, 231696, 232066, 232371, 232422, 233070, 233114, 233275, 233312, 233346, + 233476, 233508, 233730, 233886, 234077, 234092, 234178, 234565, 235039, 235489, 235715, 237478, + 238566, 239899, 240498, 240604, 241131, 245338, 245785, 246013, 246314, 247105, 248370, 248414, + 248875, 248923, 248946, 250090, 250152, 250198, 250258, 250336, 250420, 250441, 250461, 250582, + 250624, 250637, 250774, 250799, 251780, 251833, 251948, 252601, 252664, 252910, 253394, 254144, + 254352, 254698, 255229, 255274, 255377, 255524, 255588, 255683, 256075, 256429, 256575, 256601, + 256614, 256621, 256622, 256639, 256750, 256866, 257302, 257365, 258463, 258576, 258620, 259245, + 259251, 259289, 259824, 259949, 259973, 260114, 260133, 260172, 260204, 260989, 261414, 261604, + 261614, 261678, 261743, 261745, 261779, 262135, 262719, 262752, 264194, 264371, 264445, 264559, + 264670, 264888, 265243, 265252, 265488, 265500, 265533, 265560, 266045, 266826, 267008, 268064, + 268743, 273140, 273203, 274874, 276359, 276781, 277130, 278913, 281102, 281109, 281124, 281129, + 281133, 281141, 281145, 281146, 281148, 281161, 281165, 281184, 281292, 281577, 281581, 281793, + 282239, 282457, 282476, 282615, 283506, 283621, 283806, 284011, 284315, 284324, 284431, 284446, + 284486, 284583, 284890, 284899, 284999, 285066, 285108, 285111, 285603, 285663, 285704, 285728, + 285778, 285782, 285787, 285799, 285811, 285812, 285815, 285856, 286245, 286282, 286293, 286402, + 286621, 286647, 286987, 287286, 287614, 287814, 287830, 287832, 288721, 288764, 288789, 288899, + 288902, 288955, 288967, 289011, 289174, 289199, 289317, 289433, 289523, 289888, 289915, 289962, + 290030, 290104, 290187, 290215, 290247, 290269, 290332, 290340, 290594, 291074, 291696, 292223, + 292239, 292672, 292688, 292878, 292913, 292932, 292953, 292968, 293100, 293222, 293253, 293286, + 293308, 293322, 293397, 293420, 293426, 293619, 293655, 293690, 293703, 293768, 293783, 293788, + 293822, 293825, 293831, 293842, 293844, 293845, 293896, 293962, 293992, 294068, 294071, 294074, + 294078, 294098, 294117, 294210, 294244, 294387, 294421, 294514, 294577, 294604, 294608, 294610, + 294622, 294751, 294760, 294778, 294801, 294946, 294981, 294999, 295127, 295130, 295174, 295277, + 295328, 295365, 295432, 295435, 295514, 295530, 295548, 295620, 295629, 295721, 295739, 296173, + 296562, 296832, 296852, 296895, 297090, 297564, 297789, 297917, 298033, 298088, 298117, 298230, + 298299, 298316, 298326, 298333, 298806, 298846, 298935, 299137, 299445, 299545, 299582, 299817, + 299900, 300058, 300075, 300352, 300371, 300377, 300399, 300614, 300619, 300640, 300791, 300796, + 300797, 300808, 300822, 301010, 301101, 301116, 301172, 301209, 301256, 301350, 301537, 301539, + 301827, 301911, 302043, 302355, 302525, 302800, 302819, 302824, 303195, 303290, 303354, 303700, + 303750, 303798, 303827, 303831, 303873, 304013, 304081, 304184, 304196, 304355, 304382, 304531, + 304612, 304782, 304797, 304827, 304854, 304916, 304922, 305089, 305268, 305359, 305532, 305680, + 305742, 305750, 305810, 306041, 306112, 306207, 306474, 306571, 307084, 307211, 307515, 307623, + 307654, 307657, 307864, 308024, 308220, 308224, 308464, 309415, 309527, 309647, 309663, 310004, + 310641, 310855, 310859, 310892, 310907, 311046, 311073, 311111, 311314, 311453, 311553, 311665, + 311704, 312024, 312114, 312134, 312899, 313013, 313331, 314136, 314188, 314648, 314665, 314716, + 314812, 314830, 314903, 314967, 315061, 315202, 315368, 315373, 315401, 315468, 315498, 315515, + 315530, 315621, 315639, 315697, 315720, 315758, 315795, 315808, 315905, 315985, 316102, 316284, + 316411, 316541, 316542, 316634, 316795, 317109, 317241, 317587, 317588, 317844, 317851, 318137, + 318253, 318372, 318668, 318675, 318755, 318766, 319104, 320004, 320369, 320392, 320448, 320533, + 320552, 320557, 320581, 320871, 320879, 320995, 321031, 321062, 321082, 321136, 321191, 321337, + 321426, 321572, 321580, 321786, 321836, 321929, 322051, 322165, 322391, 322673, 322830, 323094, + 323777, 323779, 323786, 323828, 324106, 324172, 324190, 324490, 324496, 324698, 324768, 324944, + 325103, 325303, 325304, 325330, 325336, 325363, 325579, 325780, 326036, 326206, 326308, 327694, + 328689, 328709, 328716, 329114, 329586, 330120, 330186, 330491, 330546, 330764, 330811, 331038, + 331180, 331416, 332746, 332880, 333103, 333287, 333356, 333373, 333750, 333772, 333795, 334227, + 335035, 335288, 336014, 336350, 336372, 336454, 336496, 336931, 337010, 337152, 337405, 337712, + 337771, 337853, 338554, 338726, 338832, 338998, 339219, 339448, 339666, 339686, 339708, 339734, + 339823, 341297, 341397, 341742, 341877, 342190, 342559, 342567, 342641, 342711, 342856, 342884, + 343137, 343292, 343300, 343386, 343402, 343409, 343413, 343593, 343663, 344420, 344620, 344661, + 344901, 344923, 344979, 345149, 345353, 345704, 346030, 347236, 347497, 347542, 347591, 347612, + 347634, 347749, 347796, 348112, 349114, 349156, 349715, 349717, 350203, 350370, 350376, 350422, + 350550, 350789, 351434, 352344, 352354, 352628, 352679, 352733, 352913, 352951, 353219, 353802, + 353828, 354105, 354365, 354502, 354775, 354981, 355026, 355392, 355420, 355449, 355628, 355648, + 355795, 355939, 356000, 356806, 356933, 356945, 356989, 358048, 358095, 358108, 358115, 358172, + 358269, 358274, 358448, 358600, 358619, 358620, 358821, 358840, 358970, 359173, 359212, 359280, + 359493, 359576, 359710, 359783, 359792, 359796, 359900, 359953, 360048, 360464, 360502, 360526, + 360531, 360542, 360612, 360615, 360630, 360686, 360716, 360754, 360761, 360773, 360829, 360928, + 360995, 361029, 361055, 361058, 361103, 361179, 361213, 361291, 361320, 361329, 361394, 361435, + 361457, 361478, 361495, 361546, 361661, 361702, 361827, 362004, 362277, 362485, 362882, 362973, + 363243, 363533, 363619, 363656, 363885, 364103, 364367, 364706, 365137, 365742, 365763, 366323, + 366426, 366847, 367308, 367544, 367644, 367927, 368277, 370737, 370838, 371760, 371870, 372386, + 372753, 373141, 373303, 374739, 375495, 376332, 376450, 377039, 377241, 377690, 377724, 378231, + 378271, 378459, 378493, 378699, 379003, 379014, 379102, 379149, 379252, 379303, 379406, 379416, + 379427, 379555, 379630, 380129, 380151, 380173, 380174, 380348, 380757, 383388, 385038, 387958, + 388065, 388349, 400666, 400769, 406993, 411165, 411849, 412800, 415189, 417594, 418521, 418571, + 418606, 418710, 418723, 418851, 418863, 418868, 418896, 419435, 422232, 423328, 425378, 425551, + 426272, 426700, 430569, 430952, 431748, 433635, 438400, 442301, 447273, 448149, 452949, 453754, + 454310, 454432, 454768, 455898, 456172, 456202, 457065, 457954, 459201, 459279, 459283, 460413, + 460570, 461699, 461910, 461920, 462444, 462522, 462755, 462822, 462984, 463082, 463217, 463340, + 463343, 463355, 463637, 463824, 463829, 463835, 463885, 464101, 464625, 464687, 464790, 465543, + 466215, 466806, 466885, 466989, 466990, 467120, 467525, 467854, 467978, 468063, 468082, 468250, + 468307, 468390, 468657, 468671, 468866, 468902, 469005, 469178, 469844, 470252, 470338, 470444, + 470546, 470666, 470676, 470734, 471101, 471430, 471457, 471656, 472045, 472231, 472234, 472278, + 472433, 472459, 472722, 472750, 472757, 472761, 473021, 473247, 473249, 473778, 473788, 475777, + 475881, 475938, 476062, 476077, 477192, 477301, 477494, 477626, 477656, 478044, 478071, 478130, + 478317, 478544, 478581, 479028, 479123, 479411, 479532, 479561, 479687, 479704, 479933, 480060, + 480089, 480122, 480562, 480685, 480716, 480876, 481350, 481605, 481608, 481964, 481985, 482260, + 482283, 482965, 483019, 483029, 483137, 483495, 483661, 483883, 484646, 484856, 484907, 484972, + 485239, 485432, 485639, 485660, 485698, 485871, 485888, 486071, 486110, 486665, 486968, 487095, + 487147, 487495, 487846, 487928, 488635, 488742, 488852, 489088, 489162, 490067, 490068, 490172, + 490391, 490466, 490554, 490996, 491019, 491023, 491281, 491351, 491422, 491480, 491687, 491882, + 492094, 492162, 492376, 492448, 492944, 493160, 493231, 493316, 493463, 493702, 494427, 495062, + 495112, 495206, 495260, 495344, 495394, 495518, 495619, 496012, 496015, 496267, 496269, 496275, + 496278, 496285, 496478, 496519, 496527, 496638, 496802, 496934, 497206, 497218, 497450, 497610, + 497927, 498418, 498525, 498677, 498687, 498698, 498708, 498817, 499099, 499161, 499292, 499452, + 499717, 499975, 500004, 500047, 500096, 500299, 500843, 500886, 501175, 501183, 501215, 501231, + 501283, 501320, 501730, 502011, 502018, 502400, 502540, 502793, 503550, 503977, 504003, 504042, + 504341, 504576, 504831, 504935, 505014, 505057, 505060, 505230, 505259, 505421, 505806, 506762, + 506763, 507599, 507624, 508034, 508101, 508656, 509052, 509598, 509697, 509820, 509987, 510225, + 510364, 510808, 511196, 511359, 511565, 511794, 512023, 512051, 512053, 512382, 513042, 513378, + 513883, 513898, 513911, 514171, 514198, 514259, 514706, 514734, 514796, 515003, 515012, 515024, + 515083, 515246, 515267, 515698, 515804, 515879, 516215, 516256, 516436, 516576, 516647, 516716, + 516931, 517269, 517716, 517739, 517766, 517836, 517842, 517963, 518255, 518325, 518383, 518557, + 518602, 518659, 518682, 518909, 518970, 518976, 519062, 519106, 519336, 519447, 520068, 520204, + 520494, 520555, 520574, 521118, 521776, 521874, 522260, 522301, 522377, 522410, 522470, 522594, + 522775, 522941, 522942, 522945, 523064, 523198, 523392, 523405, 523426, 523523, 523553, 523750, + 523812, 524294, 524305, 524640, 524699, 524712, 524736, 524809, 524901, 525138, 525162, 525396, + 525404, 526346, 526480, 526558, 527012, 527191, 527361, 527529, 527579, 527717, 527740, 527888, + 527968, 528056, 528109, 528293, 529073, 529505, 530849, 531129, 531820, 532096, 532288, 532459, + 532615, 532657, 532675, 532715, 533543, 533690, 534015, 534341, 534560, 534595, 534701, 534838, + 535121, 535243, 535334, 535886, 536156, 536162, 536200, 536206, 536518, 536625, 537107, 537281, + 537345, 537737, 538138, 538340, 538416, 538442, 538560, 538601, 538836, 538908, 538913, 539147, + 539283, 539555, 539689, 539817, 540030, 540103, 540251, 540761, 540771, 541404, 542000, 542184, + 542199, 542327, 542334, 542374, 542420, 542461, 542463, 542464, 543018, 543348, 543436, 543460, + 543508, 543605, 543633, 543704, 543728, 543731, 543737, 543878, 543899, 544293, 544370, 544896, + 545277, 545575, 545626, 545673, 545788, 546105, 546230, 546521, 546672, 547475, 547523, 547560, + 547840, 547849, 547875, 548114, 548278, 548330, 548391, 548392, 548395, 548408, 548410, 548442, + 548506, 548602, 548605, 548622, 548625, 548652, 548658, 549373, 549424, 549741, 550280, 550478, + 550671, 550846, 551487, 551794, 551847, 551891, 551964, 551986, 552920, 552924, 552951, 552977, + 553092, 553152, 553190, 553216, 553248, 553287, 553399, 553915, 554199, 554233, 554234, 554397, + 554410, 554599, 554840, 554894, 555111, 555312, 555746, 555980, 556230, 556283, 556320, 556951, + 557469, 557775, 557882, 558066, 558082, 558118, 558146, 558209, 558236, 558312, 558418, 558799, + 559317, 559320, 559654, 559678, 560756, 561347, 561515, 561627, 561667, 561731, 561762, 561887, + 562161, 562237, 562309, 562319, 562321, 562389, 563379, 563464, 563472, 563514, 563522, 563523, + 563524, 563551, 563705, 563708, 563719, 563822, 564654, 564719, 565289, 565290, 565348, 565381, + 565614, 565778, 565955, 566155, 566181, 566199, 566384, 566532, 566854, 567006, 567109, 567183, + 567290, 567434, 567774, 567990, 568012, 568587, 568595, 568608, 568808, 569154, 569223, 569591, + 569639, 569696, 569742, 569955, 570427, 570479, 570508, 570563, 571155, 571159, 571170, 571306, + 571420, 571476, 571557, 572154, 572525, 572665, 575349, 575410, 575457, 575560, 575591, 575948, + 576116, 576172, 576317, 576566, 576590, 576697, 577206, 577881, 577893, 577901, 578072, 578091, + 578120, 578155, 578169, 578534, 578638, 578740, 578931, 579432, 579460, 579464, 579492, 579514, + 579529, 579574, 579738, 579771, 580054, 580218, 580420, 580497, 580660, 580716, 580724, 580850, + 580922, 581049, 581126, 581179, 581313, 581321, 581357, 581671, 582182, 582432, 582750, 582956, + 582993, 583041, 583350, 583437, 583673, 583785, 583798, 583983, 584126, 584243, 584298, 584441, + 584471, 584596, 584614, 584649, 584716, 584717, 584791, 584871, 584923, 585103, 585152, 585156, + 585170, 585184, 585187, 585220, 585221, 585225, 585226, 585379, 585514, 585557, 585568, 585630, + 586427, 586429, 586523, 586925, 586968, 587057, 587078, 587084, 587261, 587361, 587378, 587384, + 587577, 588335, 588409, 588686, 589165, 589580, 590031, 590447, 591260, 593063, 593116, 593672, + 593733, 593926, 593959, 594656, 594739, 595213, 595449, 595689, 596128, 596238, 597188, 597231, + 597989, 598098, 598272, 598316, 598818, 599506, 599757, 601084, 601294, 601339, 601417, 601475, + 601594, 601608, 601661, 601734, 602150, 602913, 603570, 604490, 605155, 606531, 608668, 608679, + 609123, 609404, 609655, 609924, 610445, 610529, 610611, 610612, 610613, 610824, 610864, 611182, + 611403, 611583, 611694, 611717, 611847, 612053, 612126, 612287, 612366, 612652, 613074, 613273, + 613607, 613762, 613988, 614455, 615532, 615860, 615912, 616052, 616062, 616199, 616250, 616435, + 616530, 616599, 616629, 616631, 616635, 616743, 616877, 617026, 617076, 617180, 617239, 617302, + 617345, 617367, 617381, 617486, 617638, 618120, 618329, 618365, 618370, 618405, 618426, 618450, + 618456, 618577, 618605, 618800, 618806, 620127, 620181, 620391, 621074, 621266, 621713, 621741, + 621754, 622113, 622428, 622739, 622794, 622997, 623317, 623549, 623760, 624034, 624079, 624400, + 624784, 624785, 625144, 625324, 625367, 625409, 625625, 625665, 625743, 625818, 626081, 626450, + 627083, 627145, 627751, 627800, 627904, 627905, 627907, 627908, 628634, 629018, 629447, 629454, + 629634, 630376, 630429, 630468, 630752, 631707, 632370, 632453, 632672, 632978, 633221, 633591, + 633679, 634093, 634963, 636947, 637067, 637219, 637292, 637948, 638936, 639406, 639734, 640124, + 640276, 640999, 641489, 643492, 644171, 644450, 646005, 646723, 647751, 648056, 648366, 648738, + 648900, 649360, 649630, 649919, 649924, 650224, 650859, 650946, 651299, 651943, 653185, 653281, + 654137, 654440, 654899, 655130, 655194, 655808, 655958, 656073, 656083, 656130, 656688, 656820, + 656913, 657530, 658225, 658288, 658629, 659169, 659180, 659935, 660158, 660561, 661164, 662187, + 662334, 662432, 662476, 662699, 663100, 663118, 664074, 664437, 664460, 664518, 665000, 665003, + 665004, 665010, 665024, 665087, 665355, 665850, 666767, 667101, 667227, 667268, 667303, 667526, + 667873, 668129, 668314, 668605, 668732, 668828, 668872, 668873, 668954, 668995, 669289, 669870, + 670474, 670609, 670889, 670938, 670969, 671382, 671757, 671768, 671832, 671964, 672024, 672486, + 672757, 672862, 672926, 673033, 673441, 673634, 673636, 673816, 673921, 674295, 674531, 674541, + 675810, 675892, 675918, 676527, 677106, 677429, 677458, 677697, 677742, 678015, 678261, 678306, + 678459, 678499, 678817, 678978, 679065, 679452, 679550, 679907, 679995, 680332, 680897, 680963, + 681017, 681179, 681290, 681502, 681845, 681865, 682321, 682685, 682729, 682747, 683034, 683123, + 683365, 683394, 683506, 683760, 683844, 683902, 683974, 684039, 684156, 684490, 684612, 684657, + 684802, 685586, 685785, 685811, 685823, 685826, 685948, 686254, 686502, 686578, 686590, 686669, + 686729, 686803, 686818, 686875, 686896, 686919, 686928, 686967, 687116, 687196, 687245, 687432, + 687700, 687997, 688105, 688148, 688373, 688533, 688587, 688723, 688746, 688860, 689198, 689304, + 689378, 689487, 689558, 690312, 690412, 690548, 690688, 691016, 691037, 691179, 691374, 691469, + 691650, 691999, 692087, 692105, 692118, 692129, 692194, 692372, 692632, 692818, 692832, 692975, + 693301, 693381, 693457, 693468, 693581, 693615, 693709, 693796, 693805, 693920, 693942, 694216, + 694382, 694423, 694792, 694864, 694910, 695019, 695274, 695344, 695379, 695464, 695594, 695670, + 695912, 695965, 696008, 696108, 696566, 696643, 696660, 696677, 696943, 697183, 697592, 697593, + 697637, 697650, 697889, 698131, 698428, 698625, 698740, 698770, 698782, 698953, 699035, 699078, + 699445, 699553, 699839, 699917, 699942, 700019, 700051, 700261, 700507, 700569, 700646, 700829, + 700918, 700997, 701075, 701347, 701404, 701822, 701855, 702116, 702320, 702417, 702550, 702563, + 702569, 702658, 702723, 702760, 702972, 703428, 703448, 703464, 703646, 703845, 704000, 704138, + 704143, 704147, 704202, 704204, 704362, 704388, 704403, 704422, 704492, 704508, 704608, 704617, + 704679, 704858, 704885, 704901, 705104, 705135, 705183, 705392, 705730, 705809, 705812, 705883, + 706165, 706369, 706380, 706448, 706466, 706483, 706524, 706571, 706749, 706900, 706950, 707099, + 707155, 707244, 707292, 707296, 707308, 707471, 707565, 707679, 707688, 707752, 707753, 707758, + 707898, 708313, 708366, 708632, 708878, 708898, 708901, 709054, 709161, 709248, 709276, 709334, + 709354, 709429, 709540, 709611, 709717, 709755, 709782, 709835, 709900, 709930, 709932, 709960, + 710098, 710229, 710374, 710400, 710548, 710554, 710719, 710735, 710791, 711350, 711369, 711390, + 711416, 711515, 711660, 711669, 711841, 711867, 711894, 712160, 712165, 712374, 712423, 712441, + 712451, 712559, 712587, 712861, 712886, 712926, 712930, 712967, 712969, 713122, 713163, 713174, + 713203, 713245, 713259, 713504, 713513, 713716, 713749, 714581, 714697, 715126, 715338, 715429, + 715466, 715839, 716301, 716671, 716736, 716935, 717582, 717635, 717652, 717771, 717902, 718739, + 719311, 719404, 719965, 720276, 720284, 720292, 720334, 720364, 721239, 721472, 721592, 722324, + 722437, 722439, 722636, 723030, 723195, 723358, 723505, 723526, 723559, 723713, 723736, 723819, + 723846, 724144, 724443, 724503, 724627, 725168, 725578, 725712, 725905, 725988, 725993, 726050, + 726174, 726320, 726409, 726418, 726534, 726546, 726848, 726872, 727011, 727030, 727079, 727221, + 727233, 727337, 727447, 727462, 727523, 727696, 727791, 728075, 728193, 728203, 728288, 728317, + 728330, 728378, 728448, 728742, 729114, 729559, 729581, 729730, 729794, 730435, 730442, 730496, + 730559, 730565, 731108, 731233, 731549, 732263, 732452, 732491, 732770, 733014, 733191, 733264, + 733579, 733618, 733776, 733840, 733905, 734077, 734301, 734330, 734426, 734538, 734643, 734712, + 734771, 734880, 734883, 735030, 735215, 735563, 735640, 735736, 735861, 735914, 736083, 736229, + 736357, 736364, 736928, 737022, 737054, 737071, 737421, 737611, 737961, 738025, 738064, 738167, + 738228, 738251, 738349, 738377, 738618, 738648, 738662, 738743, 738753, 738803, 738858, 738907, + 738927, 739015, 739061, 739209, 739215, 739236, 739251, 739549, 739600, 739634, 739914, 740088, + 740230, 740264, 740430, 740483, 740881, 740883, 741045, 741100, 741160, 741240, 741304, 741347, + 741487, 741529, 741609, 741763, 741771, 741855, 742238, 742658, 742902, 743051, 743166, 743404, + 743439, 743537, 743615, 743818, 743882, 743952, 744093, 744168, 744537, 744562, 744873, 745026, + 745028, 745042, 745044, 745076, 745169, 745527, 745530, 745664, 745697, 745714, 746232, 746234, + 746252, 746425, 746565, 746574, 746666, 746881, 746898, 746940, 746958, 746983, 747014, 747135, + 747155, 747323, 747340, 747471, 747482, 747489, 747712, 747764, 748167, 748870, 748879, 748893, + 749274, 749279, 749502, 749508, 749644, 749704, 749748, 749780, 749795, 750269, 750317, 750468, + 750516, 750598, 750605, 750637, 750735, 750938, 751057, 751077, 751324, 751335, 751371, 751817, + 751838, 751931, 751949, 751952, 751971, 752015, 752184, 752278, 752288, 752584, 752627, 752850, + 752967, 753276, 753866, 753895, 754351, 754454, 754800, 755889, 756135, 756867, 756868, 757026, + 757033, 757357, 757692, 757718, 757809, 758252, 758390, 758445, 758626, 758651, 758682, 759123, + 759141, 759320, 759412, 759591, 759603, 759734, 760343, 760584, 760680, 760778, 760917, 760924, + 761131, 761168, 761218, 761228, 762021, 762120, 762199, 762381, 762423, 762788, 762850, 762863, + 762909, 763111, 763166, 763291, 763523, 763534, 763556, 763829, 764312, 764634, 764679, 764749, + 764849, 764862, 765191, 765749, 765876, 765927, 766027, 766042, 766307, 766555, 766583, 766783, + 766810, 767470, 767605, 767623, 767814, 768216, 768218, 768905, 769250, 769274, 769893, 769981, + 770157, 770293, 770380, 770966, 771158, 771401, 771506, 771804, 772195, 772227, 772339, 772621, + 772748, 773357, 773380, 774208, 774558, 774747, 775183, 775758, 775922, 775986, 776069, 776175, + 776337, 776597, 782661, 782756, 783148, 783263, 783493, 783814, 783920, 783926, 784024, 784097, + 784136, 784227, 784424, 784759, 784873, 785058, 785082, 785113, 785238, 785345, 785380, 785387, + 785482, 785485, 785559, 785615, 785753, 785756, 785842, 785965, 786093, 786341, 786565, 786690, + 786712, 786714, 786735, 786827, 786950, 787050, 787157, 787237, 787456, 787487, 787516, 787595, + 787615, 787657, 787715, 787716, 787718, 788470, 788654, 788709, 788731, 788771, 788886, 788975, + 789045, 789107, 789128, 789225, 789228, 789403, 789518, 789527, 789541, 789611, 789923, 789996, + 790015, 790295, 790367, 790674, 790698, 790744, 791122, 791559, 791580, 791606, 791678, 792078, + 792227, 792456, 792501, 792578, 792680, 792814, 793111, 802078, 802714, 823674, 824003, 824288, + 824987, 827329, 828055, 829005, 830844, 831129, 831130, 831165, 831432, 833357, 841006, 857689, + 857690, 863061, 874045, 876177, 877178, 877384, 877391, 877401, 877471, 877532, 877581, 877597, + 877605, 877702, 877747, 877998, 878041, 878058, 878073, 878195, 878223, 878281, 878367, 878400, + 878549, 879431, 881164, 882100, 882599, 884141, 884979, 886763, 886990, 888710, 889191, 889215, + 889453, 889942, 890299, 890422, 890983, 893485, 893549, 893697, 894239, 894701, 895061, 895269, + 898188, 898905, 899274, 899825, 901344, 904422, 905395, 905846, 906044, 906054, 907111, 907770, + 909137, 909863, 910111, 911148, 912764, 913029, 913613, 914959, 915883, 916095, 917748, 918702, + 919009, 919544, 921753, 921772, 921815, 922704, 922741, 922773, 922806, 923058, 923295, 924055, + 924102, 924572, 924705, 925498, 925789, 926747, 927246, 927834, 927967, 928534, 930025, 931755, + 931865, 932183, 932218, 932438, 932505, 932521, 932614, 932698, 932886, 933000, 933018, 933088, + 933099, 933141, 933182, 933271, 933305, 933331, 933340, 933366, 933471, 933521, 933535, 933685, + 933719, 933773, 933778, 933945, 933959, 934032, 934131, 934154, 934322, 934488, 934570, 934631, + 934750, 934985, 934995, 935048, 935214, 935221, 935223, 935225, 935227, 935248, 935255, 935264, + 935267, 935268, 935582, 935616, 935691, 936374, 937136, 938457, 938694, 939270, 940316, 940424, + 940909, 941931, 941966, 942470, 942511, 943032, 943882, 943960, 944385, 944986, 945945, 946058, + 946128, 946257, 946877, 946973, 949224, 949282, 949703, 949880, 951650, 952192, 952734, 952747, + 952865, 953781, 954161, 955313, 956507, 956767, 956878, 956907, 957487, 958724, 962330, 962367, + 962847, 963230, 963516, 963525, 964137, 964315, 964349, 964406, 964420, 964432, 964712, 965241, + 965289, 965301, 965401, 965528, 966166, 966380, 967106, 967476, 968665, 970341, 970566, 971421, + 971534, 973111, 973139, 974670, 975436, 976358, 976361, 976885, 978895, 980921, 981158, 981827, + 982899, 984087, 985011, 985015, 986083, 986717, 986822, 986846, 987202, 988290, 988356, 988698, + 989921, 990930, 993800, 995202, 996918, 996930, 997140, 997151, 997751, 1000501, 1000543, + 1001860, 1002145, 1002851, 1003764, 1003953, 1004109, 1005029, 1005125, 1005544, 1005646, + 1005768, 1006984, 1007311, 1007400, 1007514, 1008261, 1011031, 1011632, 1012413, 1012600, + 1013550, 1014073, 1014489, 1015504, 1015621, 1016181, 1016670, 1016698, 1017780, 1018673, + 1018725, 1019330, 1019704, 1019760, 1020098, 1020641, 1021086, 1021360, 1021396, 1023287, + 1023309, 1024552, 1024696, 1024701, 1026014, 1028434, 1028918, 1033356, 1035025, 1037125, + 1037370, 1037390, 1039536, 1039854, 1040652, 1040938, 1043893, 1045114, 1047660, 1048364, + 1049261, 1049861, 1052373, 1052944, 1053384, 1053507, 1054035, 1054192, 1054329, 1054463, + 1054500, 1055059, 1055429, 1055433, 1056151, 1056386, 1056899, 1057095, 1058080, 1058381, + 1058532, 1059051, 1059507, 1060007, 1060283, 1060673, 1061335, 1061412, 1061605, 1062553, + 1062663, 1064234, 1064258, 1064275, 1064366, 1064890, 1064978, 1064980, 1065140, 1065158, + 1065222, 1066310, 1066514, 1066831, 1067531, 1067565, 1068670, 1068865, 1068971, 1069129, + 1070661, 1070940, 1071296, 1072849, 1072879, 1073482, 1076105, 1076194, 1076454, 1078446, + 1078553, 1079048, 1079088, 1081790, 1082639, 1082992, 1083239, 1083257, 1083724, 1083968, + 1085510, 1088155, 1090225, 1105726, 1105776, 1105777, 1106542, 1106809, 1108161, 1113217, + 1117652, 1117823, 1123004, 1125155, 1125444, 1125896, 1127110, 1127628, 1127768, 1128265, + 1129516, 1129648, 1130490, 1131316, 1132495, 1133453, 1133574, 1133616, 1134720, 1135158, + 1135689, 1136469, 1136575, 1136863, 1137168, 1137807, 1138336, 1138958, 1139715, 1139807, + 1140026, 1141089, 1141269, 1141540, 1141857, 1142170, 1142264, 1142404, 1145352, 1147066, + 1147290, 1147540, 1148106, 1148205, 1148311, 1148658, 1149698, 1150007, 1150085, 1150154, + 1150210, 1150246, 1150275, 1150490, 1150515, 1150533, 1150624, 1150681, 1150728, 1150732, + 1150921, 1150954, 1150965, 1151063, 1151074, 1151211, 1151254, 1151340, 1151426, 1151528, + 1151933, 1152188, 1152194, 1152202, 1152227, 1152377, 1152432, 1152468, 1152473, 1152562, + 1152633, 1152919, 1152953, 1153035, 1153081, 1153090, 1153241, 1153269, 1153386, 1153464, + 1153513, 1153557, 1153646, 1153669, 1153671, 1153807, 1153850, 1154677, 1155139, 1156046, + 1156257, 1157662, 1157683, 1159301, 1159362, 1159384, 1159716, 1160571, 1160939, 1161724, + 1161983, 1161991, 1162004, 1162105, 1162261, 1162275, 1162285, 1162316, 1162456, 1162572, + 1162589, 1162813, 1162855, 1162862, 1162868, 1162959, 1163021, 1163054, 1163224, 1163272, + 1163414, 1163582, 1163595, 1163724, 1163905, 1163927, 1163952, 1163958, 1163965, 1163967, + 1163968, 1164045, 1164064, 1164069, 1164076, 1164216, 1164408, 1164419, 1164679, 1164716, + 1164776, 1164825, 1164896, 1164909, 1164970, 1164987, 1165108, 1165221, 1165260, 1165388, + 1165486, 1165507, 1165635, 1165638, 1165744, 1165789, 1166000, 1166062, 1166066, 1166073, + 1166146, 1166164, 1166265, 1166381, 1166547, 1166548, 1166652, 1166827, 1166933, 1166993, + 1167031, 1167142, 1167380, 1167386, 1167398, 1167501, 1167528, 1167622, 1167648, 1167718, + 1167821, 1167873, 1168015, 1168021, 1168036, 1168166, 1168197, 1168226, 1168307, 1168312, + 1168412, 1168555, 1168633, 1168652, 1168680, 1168718, 1168749, 1169116, 1169143, 1169145, + 1169187, 1169254, 1169278, 1169334, 1169367, 1169372, 1169605, 1169607, 1169620, 1169684, + 1169692, 1169825, 1170013, 1170219, 1170222, 1170294, 1170295, 1170395, 1170398, 1170425, + 1170486, 1170564, 1170584, 1170667, 1170677, 1170706, 1170880, 1170951, 1171050, 1171123, + 1171165, 1171198, 1171502, 1171757, 1171868, 1171965, 1172035, 1172128, 1172295, 1172318, + 1172339, 1172451, 1172488, 1172513, 1172657, 1172663, 1172682, 1172779, 1172888, 1172904, + 1172915, 1172964, 1172993, 1173025, 1173055, 1173272, 1173302, 1173378, 1173491, 1173687, + 1173692, 1173889, 1173920, 1174042, 1174062, 1174167, 1174171, 1174211, 1174217, 1174301, + 1174344, 1174355, 1174357, 1174625, 1174653, 1174720, 1174872, 1174984, 1175010, 1175021, + 1175082, 1175088, 1175098, 1175125, 1175156, 1175180, 1175232, 1175283, 1175296, 1175365, + 1175436, 1175446, 1175453, 1175560, 1175678, 1175712, 1175748, 1175762, 1175864, 1175870, + 1175892, 1176022, 1176035, 1176106, 1176218, 1176241, 1176358, 1176368, 1176444, 1176515, + 1176615, 1176734, 1176800, 1176889, 1176948, 1176995, 1176997, 1177042, 1177064, 1177073, + 1177089, 1177107, 1177203, 1177278, 1177384, 1177397, 1177446, 1177654, 1177662, 1177682, + 1178231, 1178456, 1178560, 1178587, 1178841, 1179061, 1179223, 1179255, 1179305, 1179346, + 1179377, 1179400, 1179406, 1179450, 1179463, 1179496, 1179757, 1179760, 1179790, 1179834, + 1179837, 1179902, 1180133, 1180281, 1180289, 1180295, 1180374, 1180419, 1180436, 1180454, + 1180752, 1180809, 1180825, 1180942, 1180983, 1181022, 1181053, 1181073, 1181096, 1181163, + 1181352, 1181439, 1181611, 1181636, 1181887, 1182092, 1182577, 1182607, 1182637, 1182665, + 1182682, 1182775, 1182787, 1182815, 1182829, 1182998, 1183090, 1183224, 1183460, 1183880, + 1183883, 1184055, 1184075, 1184249, 1184370, 1184569, 1184655, 1184752, 1184845, 1185056, + 1185092, 1185095, 1185098, 1185099, 1185100, 1185106, 1185108, 1185111, 1185115, 1185116, + 1185117, 1185120, 1185121, 1185127, 1185128, 1185138, 1185141, 1185148, 1185149, 1185155, + 1185156, 1185160, 1185162, 1185164, 1185165, 1185166, 1185167, 1185171, 1185173, 1185181, + 1185183, 1185186, 1185188, 1185191, 1185199, 1185204, 1185206, 1185207, 1185209, 1185210, + 1185218, 1185224, 1185236, 1185239, 1185241, 1185247, 1185249, 1185251, 1185252, 1185254, + 1185260, 1185262, 1185263, 1185270, 1185272, 1185274, 1185276, 1185283, 1185293, 1185920, + 1188569, 1189056, 1189638, 1191139, 1191368, 1192366, 1193823, 1196292, 1197895, 1201753, + 1203344, 1203891, 1205481, 1205733, 1207047, 1209562, 1210565, 1213493, 1213500, 1213530, + 1213547, 1213614, 1213655, 1213821, 1213855, 1214026, 1214055, 1214073, 1214189, 1214191, + 1214204, 1214302, 1214369, 1214488, 1214520, 1214658, 1214724, 1214800, 1214882, 1214965, + 1215199, 1215350, 1215355, 1215412, 1215498, 1215502, 1215694, 1215839, 1215957, 1216115, + 1216187, 1216265, 1216311, 1216475, 1216787, 1216982, 1217007, 1217084, 1217180, 1217262, + 1217340, 1217362, 1217474, 1217540, 1217569, 1217658, 1217662, 1217703, 1217734, 1217926, + 1218021, 1218239, 1218420, 1218436, 1218667, 1219002, 1219392, 1219649, 1219762, 1220112, + 1220163, 1220219, 1220253, 1220301, 1220747, 1220798, 1220826, 1220855, 1220905, 1221194, + 1221259, 1221328, 1221614, 1221714, 1221874, 1221965, 1221997, 1222107, 1222396, 1222562, + 1222662, 1223648, 1223738, 1224085, 1225018, 1225142, 1226260, 1228730, 1229293, 1229989, + 1230089, 1230613, 1231410, 1232783, 1233369, 1234378, 1234633, 1235846, 1236854, 1237980, + 1238992, 1239047, 1239593, 1240622, 1240935, 1241622, 1241750, 1241964, 1242110, 1242833, + 1242835, 1243936, 1244397, 1244596, 1244773, 1246000, 1246294, 1246321, 1246924, 1248749, + 1248991, 1249145, 1249931, 1249978, 1250161, 1250615, 1251081, 1251459, 1251574, 1252416, + 1252646, 1252653, 1252692, 1252698, 1252699, 1252738, 1252744, 1252745, 1252758, 1252770, + 1252773, 1252795, 1252797, 1252822, 1252840, 1252885, 1252887, 1252892, 1252908, 1252919, + 1252925, 1252930, 1252942, 1252946, 1252948, 1252956, 1252958, 1252960, 1252997, 1253013, + 1253041, 1253074, 1253077, 1253079, 1253080, 1253084, 1253091, 1253095, 1253102, 1253105, + 1253113, 1253127, 1253132, 1253133, 1253150, 1253166, 1253182, 1253184, 1253193, 1253200, + 1253219, 1253220, 1253237, 1253242, 1253251, 1253275, 1253278, 1253286, 1253315, 1253330, + 1253352, 1253357, 1253363, 1253367, 1253372, 1253374, 1253392, 1253403, 1253405, 1253437, + 1253452, 1253468, 1253472, 1253482, 1253512, 1253544, 1253545, 1253573, 1253577, 1253578, + 1253579, 1253595, 1253605, 1253610, 1253623, 1253628, 1253635, 1253638, 1253671, 1253673, + 1253698, 1253702, 1253736, 1253744, 1253747, 1253750, 1253754, 1253782, 1253783, 1253785, + 1253786, 1253805, 1253807, 1253860, 1253861, 1253863, 1253870, 1253888, 1253894, 1253914, + 1253918, 1253944, 1253952, 1253956, 1253958, 1253972, 1253977, 1253984, 1253985, 1253986, + 1253987, 1253993, 1254000, 1254043, 1254046, 1254054, 1254069, 1254080, 1254089, 1254102, + 1254111, 1254131, 1254133, 1254163, 1254187, 1254241, 1254249, 1254274, 1254282, 1254283, + 1254304, 1254309, 1254317, 1254322, 1254327, 1254331, 1254335, 1254342, 1254343, 1254346, + 1254347, 1254348, 1254356, 1254360, 1254361, 1254373, 1254377, 1254385, 1254388, 1254390, + 1254396, 1254420, 1254432, 1254436, 1254444, 1254481, 1254534, 1254538, 1254570, 1254589, + 1254624, 1254638, 1254649, 1254657, 1254661, 1254673, 1254675, 1254694, 1254695, 1254710, + 1254727, 1254732, 1254744, 1254745, 1254780, 1254787, 1254794, 1254795, 1254797, 1254808, + 1254813, 1254858, 1254868, 1254880, 1254904, 1254908, 1254909, 1254910, 1254912, 1254948, + 1254953, 1255004, 1255023, 1255024, 1255027, 1255046, 1255076, 1255082, 1255104, 1255121, + 1255122, 1255131, 1255134, 1255143, 1255175, 1255211, 1255212, 1255213, 1255224, 1255254, + 1255264, 1255265, 1255344, 1255346, 1255349, 1255361, 1255364, 1255372, 1255383, 1255396, + 1255425, 1255434, 1255437, 1255449, 1255482, 1255483, 1255484, 1255488, 1255491, 1255551, + 1255597, 1255616, 1255619, 1255620, 1255621, 1255625, 1255630, 1255631, 1255634, 1255635, + 1255643, 1255646, 1255647, 1255654, 1255667, 1255704, 1255705, 1255712, 1255714, 1255744, + 1255762, 1255763, 1255788, 1255792, 1255816, 1255823, 1255850, 1255858, 1255860, 1255870, + 1255884, 1255925, 1255927, 1255947, 1255950, 1255951, 1255953, 1255955, 1255963, 1255969, + 1255983, 1255995, 1256003, 1256025, 1256027, 1256029, 1256039, 1256040, 1256047, 1256050, + 1256052, 1256064, 1256067, 1256075, 1256087, 1256104, 1256119, 1256124, 1256176, 1256184, + 1256207, 1256214, 1256237, 1256246, 1256259, 1256269, 1256287, 1256295, 1256320, 1256322, + 1256328, 1256329, 1256333, 1256335, 1256340, 1256343, 1256363, 1256369, 1256372, 1256377, + 1256382, 1256388, 1256418, 1256421, 1256422, 1256426, 1256431, 1256432, 1256435, 1256436, + 1256451, 1256468, 1256475, 1256483, 1256489, 1256515, 1256523, 1256525, 1256529, 1256532, + 1256537, 1256539, 1256558, 1256569, 1256572, 1256593, 1256597, 1256598, 1256620, 1256639, + 1256659, 1256660, 1256671, 1256673, 1256693, 1256698, 1256705, 1256706, 1256713, 1256715, + 1256720, 1256722, 1256728, 1256731, 1256735, 1256739, 1256750, 1256752, 1256753, 1256755, + 1256759, 1256812, 1256814, 1256823, 1256826, 1256828, 1256832, 1256854, 1256913, 1256922, + 1256929, 1256949, 1256959, 1256967, 1256968, 1256974, 1256983, 1256989, 1256995, 1257001, + 1257022, 1257055, 1257060, 1257066, 1257093, 1257149, 1257191, 1257196, 1257198, 1257219, + 1257237, 1257259, 1257260, 1257268, 1257307, 1257354, 1257369, 1257402, 1257409, 1257410, + 1257416, 1257429, 1257431, 1257436, 1257456, 1257459, 1257461, 1257476, 1257477, 1257481, + 1257482, 1257486, 1257498, 1257503, 1257528, 1257539, 1257540, 1257542, 1257545, 1257551, + 1257565, 1257566, 1257587, 1257588, 1257629, 1257638, 1257673, 1257698, 1257751, 1257762, + 1257771, 1257776, 1257794, 1257799, 1257800, 1257802, 1257804, 1257806, 1257830, 1257845, + 1257851, 1257854, 1257855, 1257865, 1257890, 1257895, 1257896, 1257928, 1257936, 1257940, + 1257951, 1258012, 1258044, 1258061, 1258076, 1258099, 1258109, 1258111, 1258124, 1258126, + 1258128, 1258140, 1258164, 1258178, 1258182, 1258186, 1258201, 1258203, 1258207, 1258213, + 1258229, 1258247, 1258270, 1258278, 1258290, 1258291, 1258292, 1258294, 1258295, 1258297, + 1258307, 1258338, 1258342, 1258347, 1258352, 1258362, 1258366, 1258380, 1258386, 1258406, + 1258449, 1258455, 1258470, 1258474, 1258477, 1258492, 1258501, 1258526, 1258534, 1258546, + 1258553, 1258581, 1258584, 1258592, 1258598, 1258599, 1258637, 1258639, 1258642, 1258658, + 1258677, 1258686, 1258692, 1258698, 1258726, 1258740, 1258744, 1258756, 1258786, 1258795, + 1258797, 1258803, 1258815, 1258816, 1258819, 1258831, 1258843, 1258847, 1258859, 1258864, + 1258868, 1258869, 1258875, 1258876, 1258891, 1258916, 1258922, 1258928, 1258930, 1258932, + 1258950, 1258952, 1258967, 1258972, 1258980, 1258993, 1259004, 1259005, 1259009, 1259012, + 1259019, 1259026, 1259034, 1259049, 1259056, 1259060, 1259064, 1259069, 1259083, 1259091, + 1259108, 1259110, 1259123, 1259124, 1259148, 1259154, 1259157, 1259163, 1259166, 1259177, + 1259184, 1259190, 1259210, 1259222, 1259228, 1259229, 1259231, 1259239, 1259243, 1259244, + 1259251, 1259263, 1259264, 1259272, 1259283, 1259297, 1259312, 1259338, 1259385, 1259388, + 1259395, 1259400, 1259408, 1259409, 1259411, 1259425, 1259429, 1259434, 1259440, 1259446, + 1259460, 1259503, 1259508, 1259530, 1259535, 1259541, 1259552, 1259554, 1259592, 1259608, + 1259630, 1259638, 1259647, 1259652, 1259680, 1259686, 1259688, 1259693, 1259701, 1259735, + 1259744, 1259756, 1259773, 1259775, 1259784, 1259801, 1259811, 1259813, 1259818, 1259827, + 1259841, 1259855, 1259857, 1259878, 1259879, 1259890, 1259892, 1259896, 1259905, 1259907, + 1259916, 1259917, 1259931, 1259939, 1259954, 1259961, 1259986, 1259994, 1260003, 1260014, + 1260016, 1260022, 1260035, 1260040, 1260045, 1260082, 1260086, 1260107, 1260120, 1260129, + 1260134, 1260135, 1260137, 1260138, 1260141, 1260156, 1260168, 1260173, 1260178, 1260206, + 1260210, 1260221, 1260222, 1260228, 1260274, 1260290, 1260296, 1260313, 1260335, 1260341, + 1260354, 1260368, 1260387, 1260393, 1260406, 1260417, 1260421, 1260434, 1260448, 1260454, + 1260476, 1260482, 1260527, 1260543, 1260546, 1260553, 1260607, 1260612, 1260637, 1260667, + 1260671, 1260674, 1260681, 1260685, 1260692, 1260694, 1260697, 1260702, 1260707, 1260713, + 1260716, 1260718, 1260728, 1260730, 1260734, 1260771, 1260777, 1260792, 1260793, 1260824, + 1260830, 1260833, 1260868, 1260909, 1260911, 1260918, 1260938, 1260940, 1260954, 1260959, + 1261008, 1261012, 1261039, 1261045, 1261066, 1261068, 1261086, 1261110, 1261122, 1261181, + 1261186, 1261205, 1261227, 1261234, 1261242, 1261258, 1261285, 1261288, 1261309, 1261342, + 1261369, 1261375, 1261378, 1261382, 1261394, 1261396, 1261401, 1261402, 1261415, 1261446, + 1261451, 1261470, 1261481, 1261512, 1261517, 1261529, 1261532, 1261539, 1261553, 1261567, + 1261580, 1261598, 1261613, 1261614, 1261631, 1261639, 1261641, 1261642, 1261647, 1261667, + 1261669, 1261672, 1261696, 1261705, 1261711, 1261721, 1261722, 1261726, 1261727, 1261731, + 1261736, 1261739, 1261748, 1261752, 1261754, 1261771, 1261772, 1261800, 1261810, 1261823, + 1261828, 1261835, 1261837, 1261839, 1261848, 1261852, 1261853, 1261871, 1261872, 1261882, + 1261901, 1261910, 1261913, 1261922, 1261927, 1261931, 1261932, 1261957, 1261960, 1261971, + 1261998, 1262013, 1262034, 1262039, 1262040, 1262065, 1262067, 1262073, 1262089, 1262092, + 1262097, 1262109, 1262115, 1262116, 1262117, 1262131, 1262140, 1262151, 1262180, 1262187, + 1262200, 1262204, 1262209, 1262216, 1262230, 1262240, 1262253, 1262260, 1262266, 1262292, + 1262296, 1262302, 1262318, 1262319, 1262321, 1262330, 1262332, 1262338, 1262346, 1262374, + 1262380, 1262382, 1262395, 1262410, 1262412, 1262419, 1262426, 1262444, 1262453, 1262463, + 1262482, 1262484, 1262485, 1262491, 1262497, 1262510, 1262516, 1262534, 1262546, 1262553, + 1262562, 1262566, 1262574, 1262578, 1262591, 1262596, 1262624, 1262625, 1262626, 1262634, + 1262651, 1262663, 1262664, 1262669, 1262672, 1262678, 1262710, 1262734, 1262740, 1262771, + 1262775, 1262783, 1262794, 1262801, 1262824, 1262843, 1262852, 1262863, 1262951, 1262958, + 1262988, 1262995, 1263012, 1263015, 1263021, 1263022, 1263034, 1263051, 1263057, 1263083, + 1263101, 1263103, 1263120, 1263142, 1263148, 1263151, 1263185, 1263195, 1263214, 1263220, + 1263230, 1263247, 1263255, 1263275, 1263280, 1263285, 1263293, 1263300, 1263303, 1263306, + 1263309, 1263311, 1263331, 1263364, 1263395, 1263427, 1263494, 1263504, 1263522, 1263523, + 1263528, 1263532, 1263564, 1263567, 1263580, 1263591, 1263594, 1263610, 1263622, 1263623, + 1263649, 1263659, 1263661, 1263664, 1263678, 1263684, 1263691, 1263694, 1263723, 1263730, + 1263744, 1263751, 1263752, 1263761, 1263780, 1263787, 1263797, 1263807, 1263814, 1263824, + 1263826, 1263834, 1263852, 1263862, 1263879, 1263898, 1263900, 1263911, 1263917, 1263936, + 1263940, 1263943, 1263949, 1263952, 1263965, 1263968, 1264007, 1264010, 1264032, 1264037, + 1264047, 1264071, 1264075, 1264085, 1264111, 1264115, 1264136, 1264138, 1264154, 1264196, + 1264198, 1264206, 1264282, 1264292, 1264301, 1264317, 1264323, 1264344, 1264356, 1264359, + 1264363, 1264368, 1264383, 1264385, 1264395, 1264398, 1264403, 1264407, 1264409, 1264414, + 1264433, 1264436, 1264455, 1264457, 1264489, 1264504, 1264514, 1264520, 1264521, 1264523, + 1264524, 1264527, 1264540, 1264543, 1264551, 1264553, 1264555, 1264570, 1264588, 1264592, + 1264621, 1264637, 1264643, 1264644, 1264647, 1264688, 1264700, 1264728, 1264733, 1264735, + 1264756, 1264773, 1264793, 1264794, 1264839, 1264890, 1264912, 1264949, 1264976, 1264989, + 1265007, 1265014, 1265022, 1265025, 1265053, 1265143, 1265150, 1265157, 1265163, 1265166, + 1265169, 1265170, 1265201, 1265208, 1265220, 1265233, 1265242, 1265246, 1265310, 1265311, + 1265323, 1265331, 1265354, 1265387, 1265400, 1265415, 1265446, 1265504, 1265521, 1265539, + 1265555, 1265579, 1265580, 1265591, 1265605, 1265607, 1265613, 1265632, 1265645, 1265655, + 1265660, 1265670, 1265683, 1265709, 1265711, 1265716, 1265723, 1265734, 1265752, 1265767, + 1265773, 1265795, 1265811, 1265821, 1265828, 1265830, 1265852, 1265859, 1265863, 1265873, + 1265886, 1265888, 1265891, 1265905, 1265911, 1265938, 1265961, 1265964, 1266014, 1266029, + 1266031, 1266038, 1266049, 1266051, 1266070, 1266073, 1266087, 1266092, 1266116, 1266122, + 1266124, 1266128, 1266154, 1266162, 1266164, 1266178, 1266179, 1266209, 1266216, 1266217, + 1266220, 1266258, 1266267, 1266285, 1266302, 1266305, 1266322, 1266330, 1266366, 1266372, + 1266385, 1266390, 1266397, 1266414, 1266416, 1266425, 1266436, 1266448, 1266452, 1266461, + 1266475, 1266486, 1266489, 1266509, 1266510, 1266518, 1266575, 1266596, 1266607, 1266616, + 1266620, 1266622, 1266649, 1266666, 1266710, 1266731, 1266744, 1266746, 1266762, 1266774, + 1266794, 1266806, 1266809, 1266838, 1266843, 1266847, 1266849, 1266862, 1266872, 1266891, + 1266928, 1266945, 1266960, 1266966, 1266975, 1266976, 1267006, 1267016, 1267031, 1267044, + 1267065, 1267076, 1267084, 1267090, 1267091, 1267097, 1267115, 1267154, 1267173, 1267174, + 1267175, 1267182, 1267187, 1267189, 1267195, 1267202, 1267203, 1267222, 1267226, 1267227, + 1267239, 1267283, 1267290, 1267297, 1267336, 1267360, 1267361, 1267369, 1267394, 1267433, + 1267439, 1267456, 1267457, 1267461, 1267480, 1267486, 1267492, 1267517, 1267537, 1267538, + 1267558, 1267579, 1267588, 1267616, 1267635, 1267648, 1267669, 1267675, 1267708, 1267716, + 1267739, 1267742, 1267755, 1267758, 1267772, 1267786, 1267794, 1267819, 1267853, 1267862, + 1267869, 1267885, 1267887, 1267904, 1267911, 1267923, 1267939, 1267972, 1267978, 1267979, + 1267995, 1268007, 1268008, 1268011, 1268015, 1268020, 1268031, 1268032, 1268035, 1268059, + 1268095, 1268111, 1268124, 1268135, 1268138, 1268159, 1268189, 1268205, 1268214, 1268246, + 1268257, 1268259, 1268266, 1268276, 1268279, 1268293, 1268295, 1268310, 1268325, 1268327, + 1268339, 1268341, 1268344, 1268360, 1268376, 1268381, 1268383, 1268403, 1268434, 1268450, + 1268469, 1268476, 1268480, 1268484, 1268495, 1268540, 1268545, 1268561, 1268567, 1268593, + 1268601, 1268615, 1268616, 1268622, 1268624, 1268627, 1268651, 1268662, 1268667, 1268673, + 1268680, 1268707, 1268715, 1268722, 1268739, 1268761, 1268772, 1268773, 1268775, 1268782, + 1268799, 1268820, 1268823, 1268834, 1268855, 1268863, 1268865, 1268866, 1268896, 1268907, + 1268929, 1268936, 1268961, 1268962, 1268977, 1268988, 1268990, 1269006, 1269012, 1269019, + 1269020, 1269026, 1269027, 1269042, 1269046, 1269053, 1269056, 1269057, 1269065, 1269092, + 1269093, 1269094, 1269102, 1269126, 1269135, 1269153, 1269154, 1269158, 1269168, 1269175, + 1269177, 1269179, 1269183, 1269217, 1269227, 1269247, 1269256, 1269269, 1269280, 1269291, + 1269298, 1269300, 1269317, 1269321, 1269323, 1269328, 1269350, 1269374, 1269377, 1269379, + 1269388, 1269392, 1269395, 1269406, 1269407, 1269413, 1269415, 1269422, 1269435, 1269439, + 1269441, 1269445, 1269446, 1269447, 1269477, 1269488, 1269498, 1269502, 1269507, 1269509, + 1269515, 1269545, 1269551, 1269557, 1269562, 1269564, 1269570, 1269573, 1269578, 1269581, + 1269602, 1269605, 1269633, 1269646, 1269653, 1269655, 1269665, 1269666, 1269670, 1269690, + 1269693, 1269723, 1269731, 1269743, 1269751, 1269752, 1269761, 1269771, 1269784, 1269810, + 1269819, 1269827, 1269834, 1269843, 1269849, 1269862, 1269873, 1269876, 1269908, 1269910, + 1269920, 1269927, 1269934, 1269935, 1269936, 1269937, 1269939, 1269943, 1269970, 1269976, + 1269979, 1269985, 1269990, 1269993, 1270000, 1270021, 1270022, 1270032, 1270036, 1270059, + 1270066, 1270072, 1270077, 1270079, 1270082, 1270090, 1270099, 1270102, 1270164, 1270171, + 1270185, 1270216, 1270237, 1270239, 1270245, 1270251, 1270265, 1270271, 1270287, 1270291, + 1270343, 1270349, 1270351, 1270370, 1270375, 1270393, 1270396, 1270407, 1270417, 1270435, + 1270437, 1270454, 1270455, 1270466, 1270474, 1270482, 1270484, 1270498, 1270509, 1270522, + 1270525, 1270530, 1270543, 1270554, 1270568, 1270583, 1270598, 1270603, 1270612, 1270618, + 1270619, 1270627, 1270642, 1270667, 1270668, 1270670, 1270674, 1270686, 1270711, 1270718, + 1270722, 1270723, 1270750, 1270752, 1270759, 1270763, 1270787, 1270791, 1270800, 1270801, + 1270820, 1270824, 1270845, 1270863, 1270926, 1270927, 1270947, 1270965, 1270990, 1270994, + 1270996, 1271005, 1271049, 1271050, 1271064, 1271067, 1271079, 1271083, 1271107, 1271113, + 1271131, 1271142, 1271151, 1271175, 1271199, 1271212, 1271213, 1271244, 1271250, 1271259, + 1271306, 1271308, 1271319, 1271343, 1271345, 1271346, 1271363, 1271413, 1271439, 1271453, + 1271459, 1271476, 1271493, 1271495, 1271533, 1271538, 1271543, 1271563, 1271613, 1271631, + 1271642, 1271644, 1271662, 1271670, 1271675, 1271676, 1271680, 1271685, 1271688, 1271715, + 1271722, 1271729, 1271780, 1271789, 1271819, 1271834, 1271839, 1271847, 1271850, 1271871, + 1271874, 1271881, 1271883, 1271885, 1271888, 1271891, 1271892, 1271900, 1271910, 1271911, + 1271912, 1271923, 1271929, 1271934, 1271936, 1271940, 1271942, 1271947, 1271949, 1271951, + 1271954, 1271965, 1271975, 1271976, 1271987, 1272008, 1272013, 1272022, 1272025, 1272045, + 1272051, 1272052, 1272061, 1272084, 1272101, 1272140, 1272175, 1272177, 1272181, 1272201, + 1272207, 1272225, 1272229, 1272237, 1272242, 1272243, 1272259, 1272277, 1272320, 1272367, + 1272375, 1272396, 1272411, 1272423, 1272473, 1272476, 1272502, 1272513, 1272525, 1272532, + 1272540, 1272543, 1272546, 1272552, 1272596, 1272606, 1272610, 1272629, 1272639, 1272640, + 1272646, 1272648, 1272653, 1272657, 1272670, 1272674, 1272689, 1272691, 1272694, 1272699, + 1272701, 1272720, 1272722, 1272733, 1272768, 1272780, 1272790, 1272802, 1272805, 1272819, + 1272822, 1272832, 1272842, 1272847, 1272852, 1272856, 1272857, 1272860, 1272861, 1272873, + 1272874, 1272881, 1272892, 1272962, 1272970, 1272979, 1272983, 1272985, 1272997, 1273002, + 1273006, 1273043, 1273066, 1273083, 1273098, 1273104, 1273109, 1273123, 1273128, 1273136, + 1273153, 1273181, 1273191, 1273193, 1273206, 1273228, 1273232, 1273246, 1273265, 1273272, + 1273294, 1273309, 1273313, 1273369, 1273374, 1273390, 1273397, 1273403, 1273409, 1273410, + 1273416, 1273434, 1273440, 1273467, 1273491, 1273574, 1273581, 1273587, 1273593, 1273618, + 1273626, 1273628, 1273642, 1273665, 1273687, 1273704, 1273708, 1273724, 1273745, 1273751, + 1273756, 1273766, 1273780, 1273788, 1273793, 1273795, 1273800, 1273802, 1273834, 1273850, + 1273856, 1273858, 1273865, 1273874, 1273880, 1273892, 1273909, 1273923, 1273960, 1273992, + 1274020, 1274021, 1274032, 1274040, 1274043, 1274056, 1274077, 1274102, 1274106, 1274116, + 1274119, 1274129, 1274146, 1274151, 1274169, 1274195, 1274213, 1274218, 1274219, 1274220, + 1274237, 1274243, 1274256, 1274265, 1274284, 1274285, 1274304, 1274315, 1274337, 1274342, + 1274343, 1274346, 1274351, 1274359, 1274369, 1274381, 1274389, 1274394, 1274422, 1274428, + 1274429, 1274430, 1274468, 1274532, 1274533, 1274536, 1274553, 1274560, 1274571, 1274574, + 1274618, 1274640, 1274641, 1274642, 1274664, 1274673, 1274674, 1274675, 1274676, 1274693, + 1274699, 1274714, 1274746, 1274755, 1274767, 1274770, 1274784, 1274807, 1274821, 1274837, + 1274848, 1274861, 1274862, 1274868, 1274874, 1274890, 1274896, 1274899, 1274914, 1274928, + 1274984, 1274987, 1275004, 1275016, 1275019, 1275050, 1275066, 1275068, 1275097, 1275103, + 1275117, 1275120, 1275147, 1275152, 1275163, 1275194, 1275198, 1275218, 1275230, 1275248, + 1275321, 1275339, 1275346, 1275362, 1275364, 1275368, 1275388, 1275389, 1275391, 1275406, + 1275435, 1275441, 1275462, 1275476, 1275481, 1275488, 1275499, 1275506, 1275558, 1275572, + 1275582, 1275589, 1275590, 1275593, 1275614, 1275618, 1275619, 1275634, 1275637, 1275641, + 1275646, 1275647, 1275655, 1275665, 1275679, 1275692, 1275694, 1275701, 1275716, 1275719, + 1275732, 1275738, 1275762, 1275768, 1275778, 1275804, 1275812, 1275814, 1275817, 1275818, + 1275836, 1275841, 1275848, 1275849, 1275882, 1275899, 1275901, 1275905, 1275920, 1275921, + 1275925, 1275926, 1275930, 1275947, 1275960, 1275971, 1275977, 1275978, 1276013, 1276023, + 1276026, 1276027, 1276032, 1276037, 1276054, 1276058, 1276067, 1276070, 1276084, 1276092, + 1276095, 1276100, 1276103, 1276128, 1276147, 1276151, 1276152, 1276159, 1276178, 1276191, + 1276219, 1276249, 1276265, 1276300, 1276320, 1276321, 1276325, 1276328, 1276330, 1276335, + 1276353, 1276355, 1276370, 1276371, 1276378, 1276381, 1276389, 1276393, 1276416, 1276437, + 1276449, 1276455, 1276478, 1276486, 1276495, 1276502, 1276509, 1276533, 1276548, 1276574, + 1276589, 1276600, 1276609, 1276615, 1276621, 1276627, 1276634, 1276642, 1276652, 1276663, + 1276686, 1276720, 1276724, 1276731, 1276736, 1276752, 1276754, 1276757, 1276764, 1276765, + 1276767, 1276782, 1276783, 1276810, 1276815, 1276829, 1276832, 1276856, 1276867, 1276870, + 1276895, 1276901, 1276919, 1276927, 1276938, 1276939, 1276948, 1276954, 1276977, 1276982, + 1276988, 1277013, 1277022, 1277029, 1277038, 1277044, 1277053, 1277065, 1277082, 1277084, + 1277085, 1277091, 1277100, 1277183, 1277200, 1277201, 1277202, 1277214, 1277216, 1277232, + 1277238, 1277240, 1277255, 1277263, 1277264, 1277273, 1277289, 1277318, 1277320, 1277324, + 1277330, 1277333, 1277338, 1277358, 1277362, 1277397, 1277398, 1277409, 1277426, 1277442, + 1277508, 1277514, 1277525, 1277527, 1277530, 1277535, 1277539, 1277557, 1277590, 1277599, + 1277634, 1277636, 1277643, 1277661, 1277666, 1277684, 1277723, 1277748, 1277759, 1277765, + 1277776, 1277780, 1277799, 1277808, 1277814, 1277820, 1277835, 1277836, 1277841, 1277844, + 1277882, 1277897, 1277902, 1277909, 1277924, 1277930, 1277936, 1277939, 1277949, 1277950, + 1277970, 1277976, 1278017, 1278023, 1278026, 1278036, 1278052, 1278054, 1278058, 1278064, + 1278073, 1278083, 1278094, 1278100, 1278122, 1278124, 1278130, 1278139, 1278148, 1278149, + 1278152, 1278156, 1278173, 1278176, 1278190, 1278201, 1278204, 1278208, 1278216, 1278228, + 1278278, 1278279, 1278282, 1278294, 1278296, 1278297, 1278314, 1278320, 1278335, 1278340, + 1278343, 1278345, 1278354, 1278365, 1278393, 1278405, 1278432, 1278446, 1278448, 1278454, + 1278455, 1278458, 1278466, 1278471, 1278483, 1278498, 1278507, 1278508, 1278510, 1278532, + 1278534, 1278539, 1278540, 1278553, 1278573, 1278580, 1278588, 1278593, 1278602, 1278609, + 1278621, 1278622, 1278625, 1278667, 1278672, 1278676, 1278685, 1278688, 1278692, 1278698, + 1278703, 1278707, 1278708, 1278710, 1278715, 1278718, 1278742, 1278768, 1278774, 1278775, + 1278808, 1278815, 1278827, 1278840, 1278841, 1278860, 1278862, 1278868, 1278871, 1278895, + 1278899, 1278903, 1278931, 1278935, 1278946, 1278964, 1278969, 1278973, 1278974, 1278985, + 1278994, 1279005, 1279017, 1279023, 1279027, 1279058, 1279061, 1279064, 1279066, 1279068, + 1279094, 1279105, 1279115, 1279123, 1279134, 1279135, 1279144, 1279147, 1279154, 1279158, + 1279159, 1279186, 1279219, 1279227, 1279228, 1279233, 1279259, 1279290, 1279299, 1279306, + 1279307, 1279323, 1279334, 1279335, 1279344, 1279356, 1279382, 1279390, 1279394, 1279396, + 1279403, 1279407, 1279715, 1279945, 1280037, 1280281, 1280517, 1280737, 1280757, 1280849, + 1280957, 1281019, 1281368, 1282027, 1282616, 1282635, 1282666, 1282714, 1282770, 1282884, + 1282898, 1282931, 1282950, 1283082, 1283095, 1283161, 1283190, 1283217, 1283240, 1283318, + 1283323, 1283329, 1283333, 1283339, 1283368, 1283401, 1283460, 1283465, 1283467, 1283484, + 1283496, 1283499, 1283562, 1283581, 1283582, 1283613, 1283621, 1283628, 1283679, 1283711, + 1285173, 1285871, 1285899, 1289828, 1290374, 1290596, 1291193, 1292037, 1292288, 1292313, + 1292579, 1292580, 1293625, 1293960, 1294041, 1295395, 1295765, 1296736, 1298482, 1298824, + 1298911, 1298987, 1299154, 1299237, 1300466, 1300969, 1302439, 1303406, 1307741, 1307835, + 1308204, 1308415, 1308464, 1308465, 1308522, 1308937, 1309289, 1309611, 1309793, 1309937, + 1310120, 1310362, 1310460, 1311874, 1312609, 1313479, 1314042, 1314759, 1316703, 1317375, + 1317397, 1317402, 1319533, 1320944, 1325211, 1327659, 1328121, 1328218, 1328421, 1329239, + 1332083, 1336133, 1336134, 1336135, 1336136, 1336137, 1336140, 1336143, 1336144, 1337233, + 1337239, 1337240, 1337245, 1337248, 1337249, 1341204, 1344069, 1344377, 1348562, 1348739, + 1348747, 1348753, 1348775, 1348780, 1348785, 1348818, 1348820, 1349041, 1349357, 1356491, + 1357699, 1360491, 1412008, 1430991, 1445156, 1445378, 1448637, 1462681, 1462711, 1462733, + 1465622, 1465825, 1465828, 1465910, 1469706, 1477498, 1485357, 1485439, 1485445, 1485627, + 1485634, 1485724, 1485997, 1486039, 1486209, 1486298, 1486340, 1486468, 1486910, 1486913, + 1487277, 1487281, 1487394, 1487882, 1488253, 1488429, 1488754, 1488933, 1489246, 1489394, + 1489425, 1489508, 1489530, 1489870, 1489907, 1489962, 1490003, 1490042, 1490085, 1490140, + 1490256, 1490266, 1490277, 1490281, 1490402, 1490551, 1490624, 1490686, 1490796, 1491159, + 1491230, 1491291, 1491706, 1491953, 1491999, 1492401, 1492517, 1492663, 1492893, 1493197, + 1493467, 1493648, 1493687, 1494091, 1494114, 1494276, 1494456, 1494573, 1494907, 1495974, + 1496153, 1496421, 1496476, 1496503, 1496511, 1496739, 1496747, 1496990, 1497173, 1497337, + 1497393, 1497543, 1497549, 1497795, 1497917, 1497951, 1498087, 1498129, 1498693, 1498894, + 1498920, 1499053, 1499163, 1499350, 1500532, 1500607, 1500665, 1500933, 1500973, 1500997, + 1501141, 1501255, 1501321, 1501365, 1501460, 1502026, 1502060, 1502061, 1502091, 1502536, + 1502603, 1502725, 1502862, 1503037, 1503082, 1503277, 1503335, 1503772, 1503901, 1503940, + 1504139, 1504212, 1504251, 1504317, 1504343, 1504489, 1504636, 1504682, 1504769, 1504826, + 1504871, 1504972, 1505074, 1505260, 1505429, 1505453, 1505526, 1505933, 1506073, 1506260, + 1506271, 1507116, 1507379, 1507488, 1507636, 1508054, 1508161, 1508291, 1508350, 1508879, + 1508943, 1509819, 1509852, 1509888, 1510018, 1510203, 1510205, 1510350, 1510450, 1510469, + 1510853, 1510916, 1511309, 1511330, 1511368, 1511466, 1511494, 1511783, 1511954, 1512086, + 1512165, 1512205, 1512236, 1512287, 1512320, 1512339, 1512342, 1512348, 1512350, 1512372, + 1512423, 1512449, 1512473, 1512480, 1512501, 1512524, 1512549, 1512568, 1512569, 1512658, + 1512770, 1512790, 1512838, 1512934, 1512978, 1512979, 1512986, 1513011, 1513017, 1513023, + 1513038, 1513064, 1513072, 1513087, 1513092, 1513131, 1513157, 1513243, 1513245, 1513271, + 1513331, 1513364, 1513555, 1513567, 1513600, 1513604, 1513655, 1513714, 1513886, 1513900, + 1513957, 1513962, 1513966, 1513983, 1513996, 1514011, 1514019, 1514125, 1514192, 1514210, + 1514215, 1514258, 1514330, 1514382, 1514387, 1514396, 1514402, 1514581, 1514588, 1514615, + 1514792, 1514839, 1514879, 1514891, 1514896, 1515029, 1515436, 1516048, 1516438, 1516519, + 1516589, 1516601, 1516788, 1516789, 1516905, 1517060, 1517323, 1517501, 1517637, 1517945, + 1518262, 1518296, 1518431, 1518518, 1518542, 1518543, 1518980, 1519030, 1519226, 1519244, + 1519422, 1519673, 1519691, 1519725, 1519843, 1519922, 1519928, 1519938, 1519948, 1520172, + 1520240, 1520253, 1520316, 1520947, 1520969, 1521230, 1521315, 1521368, 1521370, 1521379, + 1522203, 1522751, 1523741, 1524245, 1524298, 1524308, 1524325, 1524801, 1524889, 1524958, + 1525462, 1525798, 1525988, 1526038, 1526168, 1526193, 1526265, 1526273, 1526384, 1526797, + 1526970, 1526979, 1527004, 1527199, 1527260, 1527299, 1527497, 1527513, 1527534, 1527592, + 1527719, 1528091, 1528121, 1528182, 1528193, 1528249, 1528512, 1528675, 1528717, 1528796, + 1529102, 1529114, 1529195, 1529363, 1529376, 1529484, 1529569, 1529626, 1529641, 1529651, + 1529660, 1536289, 1537939, 1538311, 1538634, 1538635, 1538636, 1538637, 1538648, 1539209, + 1540356, 1540711, 1541359, 1546102, 1560349, 1562414, 1562548, 1562693, 1562798, 1562820, + 1563241, 1563281, 1563287, 1563926, 1565022, 1566083, 1566166, 1566319, 1566346, 1566559, + 1567069, 1567148, 1567621, 1567681, 1567723, 1567788, 1568043, 1568212, 1568510, 1568574, + 1568770, 1569684, 1570449, 1570549, 1571058, 1571067, 1571968, 1572151, 1573517, 1574023, + 1575627, 1576303, 1576633, 1577995, 1578500, 1580142, 1580240, 1580410, 1580541, 1580830, + 1581047, 1581052, 1581130, 1581298, 1581326, 1581349, 1581364, 1582436, 1582886, 1582926, + 1583477, 1583992, 1584071, 1584661, 1585660, 1586151, 1586185, 1586203, 1586288, 1586296, + 1586350, 1586357, 1586443, 1586896, 1587919, 1587923, 1587976, 1591449, 1591474, 1591527, + 1591538, 1595679, 1599640, 1601579, 1603235, 1604452, 1604654, 1604769, 1604771, 1604870, + 1605018, 1605024, 1605069, 1605102, 1605118, 1605119, 1605215, 1605221, 1605239, 1605245, + 1605279, 1605467, 1605509, 1605538, 1605601, 1605677, 1605754, 1605957, 1606030, 1606033, + 1606050, 1606147, 1606239, 1606250, 1606270, 1606343, 1606350, 1606376, 1606386, 1606418, + 1606586, 1606588, 1606590, 1606638, 1606790, 1606807, 1606939, 1607001, 1607017, 1607068, + 1607083, 1607257, 1607280, 1607435, 1607439, 1607508, 1607512, 1607532, 1607552, 1607615, + 1607708, 1607725, 1607730, 1607737, 1607779, 1607793, 1607801, 1607838, 1607865, 1607978, + 1607983, 1608033, 1608048, 1608057, 1608133, 1608136, 1608191, 1608232, 1608239, 1608269, + 1608409, 1608424, 1608452, 1608462, 1608527, 1608529, 1608531, 1608534, 1608539, 1608541, + 1608597, 1608900, 1609032, 1609043, 1609071, 1609278, 1609324, 1609345, 1609350, 1609395, + 1609610, 1609776, 1609795, 1609899, 1609990, 1610185, 1610187, 1610227, 1610459, 1610469, + 1610503, 1610505, 1610538, 1610780, 1610940, 1610943, 1610963, 1611026, 1611106, 1611110, + 1611135, 1611269, 1611407, 1611416, 1611424, 1611439, 1611492, 1611635, 1613284, 1613769, + 1614295, 1614336, 1614455, 1614465, 1616658, 1617111, 1619276, 1619281, 1619363, 1619369, + 1619400, 1619415, 1619423, 1619434, 1619437, 1619602, 1619616, 1619650, 1620254, 1620442, + 1620875, 1620919, 1621020, 1621060, 1621177, 1621395, 1621416, 1621439, 1621520, 1621613, + 1621655, 1621659, 1621678, 1621884, 1622090, 1622138, 1622318, 1622636, 1622786, 1622846, + 1623080, 1623096, 1623180, 1623197, 1623223, 1623251, 1623424, 1623446, 1624041, 1624058, + 1624494, 1624545, 1624647, 1624668, 1624725, 1624863, 1624877, 1624917, 1624987, 1625067, + 1625084, 1625708, 1625812, 1625822, 1625908, 1625929, 1625958, 1626099, 1626100, 1626134, + 1626183, 1626185, 1626312, 1626381, 1626486, 1626493, 1626498, 1626542, 1626560, 1626649, + 1626703, 1626754, 1626758, 1626801, 1626895, 1626899, 1626903, 1626916, 1626921, 1626932, + 1626936, 1627035, 1627185, 1627253, 1627267, 1627357, 1627459, 1627549, 1627610, 1627896, + 1627969, 1628453, 1628884, 1628899, 1629001, 1629131, 1629380, 1629710, 1629749, 1629974, + 1630058, 1630088, 1630200, 1630328, 1630333, 1630341, 1630366, 1630416, 1630634, 1630649, + 1630662, 1630681, 1630723, 1630789, 1630798, 1630935, 1630997, 1631271, 1631393, 1631637, + 1631648, 1631733, 1631761, 1631766, 1631851, 1631905, 1631992, 1632033, 1632197, 1632228, + 1632276, 1632334, 1632358, 1632566, 1632654, 1632694, 1632823, 1632859, 1632861, 1632903, + 1632937, 1632974, 1632978, 1632998, 1633034, 1633056, 1633070, 1633118, 1633182, 1633308, + 1633419, 1633442, 1633986, 1634010, 1634098, 1634131, 1634266, 1634614, 1634678, 1634680, + 1634718, 1634954, 1635111, 1635116, 1635164, 1635283, 1635342, 1635660, 1635815, 1635882, + 1636022, 1636121, 1636125, 1636308, 1636322, 1636426, 1636507, 1636544, 1636556, 1636722, + 1636806, 1636808, 1636816, 1636884, 1636930, 1637001, 1637090, 1637158, 1637510, 1638063, + 1638217, 1638284, 1638352, 1638562, 1638775, 1638868, 1638870, 1638981, 1639002, 1639094, + 1639215, 1639286, 1639304, 1639337, 1639356, 1639362, 1639431, 1639524, 1639850, 1639900, + 1639925, 1640044, 1640138, 1640185, 1640296, 1640344, 1640354, 1640576, 1640581, 1640585, + 1640660, 1640755, 1640765, 1640902, 1640972, 1641184, 1641301, 1641333, 1641342, 1641792, + 1641977, 1642317, 1642414, 1642437, 1642588, 1642628, 1642684, 1642692, 1642726, 1642754, + 1642858, 1642911, 1643078, 1643761, 1643776, 1643837, 1643898, 1643920, 1643981, 1644178, + 1644349, 1644360, 1644522, 1644557, 1644605, 1644932, 1645133, 1645154, 1645220, 1645428, + 1645457, 1645518, 1645524, 1645528, 1645559, 1645565, 1645749, 1645875, 1645895, 1645976, + 1645978, 1646034, 1646170, 1646194, 1646448, 1646492, 1646494, 1646678, 1646698, 1646893, + 1647003, 1647149, 1647179, 1647187, 1647298, 1647383, 1647834, 1647866, 1647936, 1647991, + 1648082, 1648084, 1648186, 1648266, 1648451, 1648473, 1648568, 1648580, 1648636, 1648759, + 1648918, 1649150, 1649378, 1649593, 1649595, 1649824, 1649881, 1650064, 1650077, 1650095, + 1650119, 1650213, 1650227, 1650232, 1650234, 1650298, 1650319, 1650357, 1650434, 1650460, + 1650527, 1650572, 1650600, 1650670, 1650815, 1650888, 1651103, 1651112, 1651226, 1651461, + 1651531, 1651555, 1651591, 1651887, 1651944, 1652203, 1653316, 1654379, 1655078, 1655087, + 1655140, 1655199, 1655559, 1665196, 1665357, 1668341, 1668355, 1668399, 1668467, 1670029, + 1670310, 1671566, 1672228, 1672551, 1673820, 1674199, 1674504, 1675151, 1676242, 1678228, + 1679432, 1679678, 1679802, 1679980, 1680007, 1680018, 1680040, 1680116, 1680197, 1680505, + 1680613, 1680932, 1681333, 1681602, 1681676, 1682472, 1682478, 1682537, 1682598, 1682659, + 1682812, 1683013, 1683088, 1683116, 1683302, 1683319, 1683340, 1683342, 1683800, 1683860, + 1683877, 1683881, 1684016, 1684137, 1684269, 1684320, 1684379, 1684497, 1684577, 1684681, + 1684803, 1685117, 1685146, 1685218, 1685230, 1685577, 1685622, 1685755, 1685875, 1685880, + 1686004, 1686102, 1686547, 1686728, 1686933, 1687029, 1687164, 1687409, 1687529, 1687534, + 1687687, 1687801, 1687894, 1687937, 1688017, 1688058, 1688232, 1688248, 1688253, 1688363, + 1688372, 1688398, 1688425, 1688749, 1688795, 1688830, 1688859, 1688912, 1688949, 1688954, + 1689052, 1689056, 1689087, 1689099, 1689129, 1689171, 1689395, 1689498, 1689510, 1689832, + 1689973, 1689994, 1690019, 1690033, 1690039, 1690060, 1690313, 1690315, 1690324, 1690570, + 1690664, 1690666, 1691150, 1691280, 1691441, 1691444, 1691446, 1691538, 1691606, 1691804, + 1691904, 1691911, 1692199, 1692214, 1692489, 1692520, 1692565, 1692685, 1692872, 1692914, + 1693077, 1693136, 1693239, 1693401, 1693574, 1693618, 1693778, 1693795, 1693839, 1693870, + 1694075, 1694290, 1694498, 1694775, 1694791, 1694826, 1694861, 1694909, 1694914, 1695097, + 1695283, 1695462, 1695583, 1695743, 1695804, 1696041, 1696165, 1696614, 1696683, 1696718, + 1696814, 1696899, 1697006, 1697018, 1697023, 1697046, 1697175, 1697376, 1697486, 1697497, + 1697773, 1698030, 1698103, 1698548, 1698740, 1698829, 1698839, 1698887, 1698921, 1699054, + 1699060, 1699088, 1699204, 1699205, 1699296, 1699323, 1699388, 1699572, 1699755, 1699802, + 1699805, 1699833, 1699858, 1700179, 1700360, 1700665, 1700712, 1700753, 1700868, 1700917, + 1700980, 1701053, 1701124, 1701149, 1701472, 1701500, 1701516, 1701537, 1701668, 1701692, + 1701872, 1701947, 1701966, 1702002, 1702032, 1702077, 1702096, 1702263, 1702372, 1702413, + 1702425, 1702442, 1702540, 1702649, 1702763, 1702934, 1703051, 1703116, 1703355, 1703598, + 1703773, 1704002, 1704021, 1704067, 1704703, 1704758, 1704781, 1704968, 1705190, 1705357, + 1705367, 1705440, 1705536, 1705572, 1705771, 1706090, 1706188, 1706361, 1706393, 1706402, + 1706609, 1706684, 1706889, 1707049, 1707123, 1707267, 1707324, 1707398, 1707404, 1707944, + 1708056, 1708217, 1708226, 1708291, 1708522, 1708824, 1709003, 1709632, 1709968, 1710011, + 1710103, 1710141, 1710258, 1710357, 1710389, 1710441, 1710470, 1710518, 1710519, 1710531, + 1710544, 1710612, 1710770, 1710914, 1711005, 1711082, 1711146, 1711437, 1711621, 1711718, + 1711829, 1711982, 1712051, 1712162, 1712232, 1712488, 1712520, 1712531, 1712808, 1712819, + 1713004, 1713014, 1713018, 1713022, 1713027, 1713226, 1713818, 1713857, 1714201, 1714441, + 1714482, 1714519, 1714674, 1714766, 1714956, 1715348, 1715430, 1715542, 1715804, 1715812, + 1716287, 1716618, 1716771, 1716858, 1716924, 1716995, 1717008, 1717051, 1717053, 1717512, + 1717641, 1717911, 1717926, 1717960, 1718078, 1718306, 1718328, 1718393, 1718426, 1718436, + 1718722, 1719053, 1719274, 1719329, 1719683, 1720034, 1720052, 1720402, 1720464, 1720472, + 1720499, 1720508, 1720561, 1720681, 1720751, 1720793, 1720840, 1721080, 1721168, 1721695, + 1721906, 1722005, 1722032, 1722267, 1722356, 1722433, 1722731, 1722818, 1722930, 1722985, + 1723066, 1723166, 1723257, 1723481, 1723510, 1723822, 1723893, 1724088, 1724106, 1724435, + 1724489, 1724767, 1724933, 1724956, 1725094, 1725157, 1725359, 1725684, 1725729, 1725799, + 1725804, 1725863, 1725919, 1725983, 1725991, 1726156, 1726280, 1726339, 1726765, 1727043, + 1727080, 1727400, 1727522, 1727663, 1727995, 1728336, 1728523, 1728546, 1728584, 1728772, + 1728825, 1728930, 1729085, 1729324, 1729524, 1729564, 1729734, 1729814, 1729987, 1730097, + 1730171, 1730225, 1730398, 1730413, 1730501, 1730713, 1730737, 1730749, 1731212, 1731486, + 1731528, 1731686, 1731744, 1731959, 1732312, 1732354, 1732602, 1732663, 1732687, 1732698, + 1732706, 1732711, 1732721, 1732738, 1732741, 1732742, 1732745, 1732752, 1732811, 1732814, + 1732826, 1732846, 1732857, 1732869, 1732871, 1732877, 1732891, 1732892, 1732893, 1732903, + 1732905, 1732945, 1733023, 1733353, 1733432, 1733438, 1733440, 1733449, 1733502, 1733697, + 1733782, 1733874, 1733953, 1734052, 1734098, 1734199, 1734313, 1734316, 1734393, 1734409, + 1734439, 1734576, 1734586, 1734599, 1734634, 1734651, 1734705, 1734715, 1734738, 1734745, + 1734753, 1734757, 1734759, 1734781, 1734793, 1734798, 1734810, 1734815, 1734839, 1734841, + 1734971, 1735018, 1735022, 1735076, 1735077, 1735079, 1735086, 1735089, 1735093, 1735106, + 1735148, 1735150, 1735158, 1735161, 1735195, 1735199, 1735227, 1735268, 1735274, 1735282, + 1735287, 1735450, 1735459, 1735485, 1735498, 1735506, 1735553, 1735634, 1735799, 1735837, + 1735902, 1736278, 1736302, 1736305, 1736309, 1736372, 1736376, 1736458, 1737185, 1737486, + 1737714, 1738050, 1738294, 1741550, 1741562, 1750500, 1750582, 1750974, 1752256, 1759486, + 1761242, 1763412, 1764160, 1764318, 1766249, 1767021, 1768664, 1769612, 1770351, 1771023, + 1771287, 1771304, 1771485, 1778290, 1779790, 1780890, 1783621, 1783633, 1783683, 1783745, + 1783763, 1783873, 1783934, 1783940, 1783988, 1784055, 1784074, 1784130, 1784178, 1784185, + 1784253, 1784310, 1784553, 1784554, 1784580, 1784642, 1784647, 1784658, 1784820, 1784841, + 1784853, 1784929, 1784953, 1784990, 1785018, 1785036, 1785286, 1785294, 1785453, 1785462, + 1785545, 1785566, 1785572, 1785623, 1785655, 1785698, 1785710, 1785716, 1785725, 1785738, + 1785777, 1785781, 1785964, 1785974, 1785980, 1786060, 1786067, 1786112, 1786357, 1786378, + 1786455, 1786546, 1786587, 1786640, 1786657, 1786676, 1786720, 1786731, 1786746, 1786759, + 1786760, 1786764, 1786770, 1786855, 1786867, 1787031, 1787093, 1787144, 1787227, 1787323, + 1787331, 1787351, 1787437, 1787601, 1787646, 1787746, 1787824, 1787837, 1787858, 1787901, + 1788046, 1788081, 1788206, 1788268, 1788402, 1788406, 1788450, 1788452, 1788462, 1788508, + 1788522, 1788534, 1788572, 1788618, 1788638, 1788694, 1788816, 1788852, 1788869, 1788927, + 1789065, 1789118, 1789137, 1789176, 1789273, 1789289, 1789427, 1789462, 1789647, 1789693, + 1789703, 1789799, 1789897, 1789945, 1789998, 1790100, 1790254, 1790353, 1790371, 1790379, + 1790392, 1790396, 1790413, 1790437, 1790451, 1790471, 1790492, 1790587, 1790601, 1790630, + 1790645, 1790840, 1790885, 1790894, 1790923, 1791056, 1791121, 1791236, 1791247, 1791249, + 1791325, 1791347, 1791388, 1791428, 1791464, 1791536, 1791636, 1791673, 1791681, 1791748, + 1791779, 1792087, 1792260, 1792359, 1792516, 1792520, 1792585, 1792592, 1792621, 1792692, + 1792916, 1792947, 1793036, 1793089, 1793230, 1793286, 1793346, 1793364, 1793385, 1793419, + 1793424, 1793505, 1793511, 1793533, 1793700, 1793724, 1793743, 1793774, 1793879, 1793889, + 1793899, 1793900, 1794035, 1794140, 1794479, 1794794, 1794806, 1794825, 1794903, 1794904, + 1794947, 1794971, 1795055, 1795060, 1795166, 1795184, 1795196, 1795270, 1795565, 1795579, + 1795632, 1795816, 1795842, 1795855, 1795857, 1795874, 1795919, 1795928, 1795940, 1795941, + 1796236, 1796421, 1796556, 1796663, 1797038, 1797120, 1797121, 1797132, 1797181, 1797264, + 1797318, 1797333, 1797353, 1797417, 1797438, 1797535, 1797543, 1797551, 1797575, 1797595, + 1797658, 1797793, 1797873, 1797929, 1797945, 1798082, 1798422, 1798425, 1798449, 1798473, + 1798480, 1798490, 1798548, 1798632, 1798634, 1798636, 1798654, 1798713, 1798733, 1798760, + 1798821, 1798827, 1798946, 1798998, 1799348, 1799352, 1799383, 1799384, 1799397, 1799491, + 1799552, 1799574, 1799629, 1799722, 1799832, 1799846, 1799869, 1799897, 1799908, 1799962, + 1800065, 1800088, 1800101, 1800107, 1800146, 1800163, 1800430, 1800498, 1800519, 1800521, + 1800627, 1800657, 1800675, 1800764, 1800779, 1800829, 1801401, 1801455, 1801582, 1801615, + 1801722, 1801757, 1801792, 1801797, 1801799, 1801850, 1801934, 1801983, 1802068, 1802171, + 1802177, 1802204, 1802238, 1802476, 1802550, 1802788, 1802875, 1802940, 1803245, 1803266, + 1803318, 1803331, 1803334, 1803352, 1803364, 1803365, 1803367, 1803374, 1803422, 1803551, + 1803560, 1803567, 1803616, 1803782, 1803791, 1803834, 1803841, 1803842, 1803886, 1803948, + 1804120, 1804153, 1804162, 1804169, 1804208, 1804252, 1804386, 1804430, 1804442, 1804451, + 1804540, 1804578, 1804586, 1804591, 1804609, 1804645, 1804651, 1804850, 1804874, 1804879, + 1804892, 1804979, 1805179, 1805267, 1805270, 1805298, 1805334, 1805379, 1805408, 1805505, + 1805515, 1805518, 1805528, 1805540, 1805563, 1805611, 1805618, 1805680, 1805733, 1805741, + 1805753, 1805757, 1805798, 1805833, 1805844, 1805857, 1805884, 1805935, 1805953, 1805987, + 1806096, 1806097, 1806167, 1806218, 1806248, 1806299, 1806327, 1806408, 1806445, 1806466, + 1806535, 1806591, 1806651, 1806696, 1806776, 1806840, 1806881, 1806882, 1806960, 1807112, + 1807143, 1807234, 1807301, 1807308, 1807339, 1807508, 1807544, 1807553, 1807645, 1807681, + 1807687, 1807689, 1807695, 1807700, 1808106, 1808198, 1808212, 1808316, 1808336, 1808370, + 1808392, 1808722, 1808744, 1808747, 1808770, 1808857, 1808872, 1808879, 1808926, 1808931, + 1808963, 1808977, 1808981, 1809003, 1809061, 1809062, 1809077, 1809078, 1809159, 1809263, + 1809412, 1809461, 1809483, 1809486, 1809498, 1809532, 1809610, 1809858, 1809879, 1810240, + 1810295, 1810309, 1810437, 1810458, 1810553, 1810821, 1810845, 1810846, 1810920, 1810979, + 1811103, 1811114, 1811200, 1811260, 1811305, 1811440, 1811542, 1811619, 1811720, 1811729, + 1811764, 1811829, 1811929, 1812057, 1812101, 1812228, 1812256, 1812427, 1812521, 1812545, + 1812597, 1812621, 1812728, 1812754, 1812955, 1812961, 1812981, 1812988, 1812990, 1813016, + 1813088, 1813171, 1813206, 1813253, 1813325, 1813344, 1813451, 1813658, 1813775, 1813812, + 1813828, 1813851, 1813892, 1814082, 1814087, 1814093, 1814757, 1814786, 1814870, 1814906, + 1814919, 1814934, 1815059, 1815184, 1815251, 1815286, 1815302, 1815395, 1815427, 1815456, + 1815463, 1815577, 1815585, 1815656, 1815667, 1816026, 1816028, 1816080, 1816176, 1816221, + 1816234, 1816256, 1816265, 1816269, 1816336, 1816338, 1816373, 1816406, 1816440, 1816670, + 1816705, 1816751, 1816753, 1816790, 1816890, 1816924, 1816971, 1817240, 1817701, 1817720, + 1817858, 1817952, 1817968, 1817990, 1817993, 1818004, 1818016, 1818051, 1818116, 1818209, + 1819609, 1819729, 1820071, 1820187, 1820491, 1820906, 1821274, 1821306, 1821935, 1822029, + 1822207, 1822214, 1822768, 1822906, 1830098, 1830194, 1830205, 1830377, 1830468, 1830564, + 1831112, 1831125, 1831133, 1831142, 1831167, 1831173, 1831797, 1832015, 1832157, 1832215, + 1832257, 1832384, 1832501, 1832566, 1832617, 1832697, 1832743, 1832771, 1832828, 1832830, + 1832847, 1832909, 1833105, 1833466, 1833514, 1833747, 1833788, 1834885, 1835096, 1835235, + 1835329, 1835447, 1835515, 1835553, 1835648, 1835848, 1835895, 1835967, 1836208, 1836553, + 1837706, 1838069, 1838508, 1838524, 1838716, 1838722, 1839011, 1839071, 1839652, 1839726, + 1839873, 1840179, 1840211, 1840379, 1840536, 1840862, 1840886, 1841066, 1841149, 1841245, + 1841598, 1841603, 1841775, 1841810, 1841811, 1841976, 1841988, 1842016, 1842025, 1842153, + 1842225, 1842485, 1842518, 1842616, 1842754, 1842800, 1842859, 1842939, 1842943, 1842944, + 1842966, 1843082, 1843137, 1843163, 1843491, 1843564, 1843585, 1843702, 1843841, 1843847, + 1844045, 1844174, 1844191, 1844308, 1844751, 1845136, 1845457, 1845519, 1845604, 1845759, + 1846052, 1846069, 1846095, 1846114, 1846266, 1846326, 1846355, 1846898, 1846912, 1846918, + 1846986, 1847050, 1847947, 1847963, 1847966, 1847968, 1848004, 1848016, 1848087, 1848096, + 1848113, 1848188, 1848194, 1848210, 1848243, 1848254, 1848277, 1848313, 1848354, 1848373, + 1848382, 1848439, 1848445, 1848447, 1848482, 1848489, 1848498, 1848499, 1848522, 1848550, + 1848573, 1848633, 1848689, 1848705, 1848774, 1848776, 1848903, 1848933, 1849053, 1849069, + 1849094, 1849154, 1849183, 1849186, 1849237, 1849299, 1849367, 1849372, 1849407, 1849414, + 1849424, 1849429, 1849498, 1849519, 1849539, 1849561, 1849563, 1849584, 1849592, 1849647, + 1849661, 1849706, 1849782, 1849788, 1849796, 1849814, 1849817, 1849831, 1849837, 1849845, + 1849846, 1849850, 1849876, 1849892, 1849904, 1850004, 1850034, 1850091, 1850108, 1850144, + 1850147, 1850152, 1850158, 1850181, 1850185, 1850207, 1850217, 1850269, 1850307, 1850311, + 1850345, 1850396, 1850405, 1850472, 1850498, 1850499, 1850523, 1850559, 1850589, 1850600, + 1850627, 1850630, 1850692, 1850693, 1850707, 1850708, 1850742, 1850745, 1850746, 1850818, + 1850834, 1850860, 1850872, 1850878, 1850892, 1850910, 1851002, 1851012, 1851032, 1851068, + 1851100, 1851125, 1851137, 1851155, 1851170, 1851193, 1851259, 1851273, 1851282, 1851307, + 1851348, 1851357, 1851368, 1851390, 1851426, 1851462, 1851483, 1851494, 1851504, 1851542, + 1851604, 1851606, 1851622, 1851711, 1851713, 1851717, 1851813, 1851883, 1851935, 1851952, + 1852003, 1852046, 1852102, 1852109, 1852140, 1852225, 1852347, 1852357, 1852383, 1852385, + 1852472, 1852479, 1852502, 1852561, 1852588, 1852595, 1852607, 1852663, 1852673, 1852736, + 1852849, 1852899, 1852901, 1852915, 1852964, 1852984, 1853008, 1853066, 1853081, 1853140, + 1853174, 1853190, 1853192, 1853193, 1853195, 1853209, 1853237, 1853280, 1853295, 1853303, + 1853338, 1853354, 1853371, 1853433, 1853483, 1853486, 1853514, 1853564, 1853574, 1853662, + 1853677, 1853909, 1853992, 1854018, 1854022, 1854026, 1854028, 1854083, 1854093, 1854162, + 1854177, 1854186, 1854246, 1854371, 1854376, 1854383, 1854384, 1854405, 1854444, 1854487, + 1854492, 1854530, 1854629, 1854665, 1854703, 1854747, 1854774, 1854803, 1854807, 1854849, + 1854868, 1854902, 1854905, 1854979, 1855066, 1855078, 1855095, 1855134, 1855189, 1855203, + 1855207, 1855363, 1855380, 1855395, 1855410, 1855416, 1855425, 1855431, 1855476, 1855503, + 1855540, 1855580, 1855612, 1855670, 1855694, 1855753, 1855757, 1855852, 1855863, 1855891, + 1855907, 1856035, 1856057, 1856068, 1856177, 1856184, 1856199, 1856215, 1856243, 1856293, + 1856367, 1856392, 1856426, 1856434, 1856456, 1856476, 1856560, 1856569, 1856584, 1856586, + 1856667, 1856697, 1856698, 1856703, 1856717, 1856775, 1856828, 1856878, 1856881, 1856938, + 1856942, 1856977, 1857046, 1857062, 1857144, 1857208, 1857209, 1857260, 1857276, 1857334, + 1857379, 1857403, 1857470, 1857496, 1857519, 1857550, 1857553, 1857560, 1857568, 1857594, + 1857651, 1857659, 1857665, 1857712, 1857751, 1857766, 1857843, 1857844, 1857871, 1857910, + 1857968, 1858041, 1858067, 1858088, 1858249, 1858283, 1858296, 1858301, 1858311, 1858421, + 1858428, 1858445, 1858498, 1858591, 1858695, 1858729, 1858756, 1858794, 1858836, 1858858, + 1858866, 1858902, 1858910, 1858926, 1858964, 1858972, 1859088, 1859093, 1859094, 1859100, + 1859113, 1859116, 1859146, 1859171, 1859175, 1859234, 1859307, 1859319, 1859335, 1859383, + 1859393, 1859400, 1859405, 1859492, 1859586, 1859642, 1859647, 1859675, 1859730, 1859740, + 1859765, 1859884, 1859891, 1859908, 1859924, 1859941, 1859951, 1859952, 1859964, 1859990, + 1859998, 1860034, 1860063, 1860095, 1860098, 1860112, 1860122, 1860176, 1860191, 1860211, + 1860234, 1860243, 1860256, 1860321, 1860335, 1860341, 1860458, 1860563, 1860626, 1860635, + 1860648, 1860672, 1860704, 1860728, 1860735, 1860748, 1860750, 1860765, 1860785, 1860827, + 1861084, 1861095, 1861107, 1861108, 1861164, 1861171, 1861207, 1861212, 1861223, 1861244, + 1861261, 1861280, 1861285, 1861290, 1861310, 1861383, 1861393, 1861400, 1861406, 1861416, + 1861436, 1861449, 1861450, 1861454, 1861464, 1861528, 1861584, 1861586, 1861602, 1861641, + 1861677, 1861699, 1861749, 1861799, 1861825, 1861835, 1861838, 1861864, 1861901, 1861949, + 1861968, 1862010, 1862033, 1862034, 1862098, 1862198, 1862230, 1862302, 1862352, 1862373, + 1862389, 1862415, 1862462, 1862471, 1862505, 1862540, 1862555, 1862599, 1862601, 1862612, + 1862627, 1862636, 1862689, 1862912, 1862992, 1863018, 1863023, 1863082, 1863173, 1863183, + 1863209, 1863279, 1863289, 1863293, 1863310, 1863341, 1863398, 1863418, 1863426, 1863431, + 1863440, 1863451, 1863482, 1863495, 1863521, 1863528, 1863540, 1863541, 1863592, 1863611, + 1863614, 1863627, 1863641, 1863693, 1863713, 1863905, 1863917, 1863945, 1863953, 1863967, + 1863973, 1863978, 1863985, 1863997, 1864009, 1864025, 1864031, 1864092, 1864098, 1864099, + 1864105, 1864132, 1864134, 1864154, 1864155, 1864180, 1864416, 1864518, 1864549, 1864557, + 1864572, 1864624, 1864637, 1864652, 1864750, 1864873, 1864945, 1864985, 1865005, 1865207, + 1865290, 1865294, 1865309, 1865375, 1865387, 1865401, 1865412, 1865449, 1865661, 1865714, + 1866569, 1866923, 1867927, 1868998, 1869021, 1869446, 1870413, 1870434, 1870742, 1870883, + 1871484, 1871859, 1873172, 1873757, 1875107, 1875506, 1875588, 1875632, 1876153, 1876373, + 1876873, 1877030, 1877046, 1877148, 1877449, 1877615, 1877872, 1878389, 1879029, 1879487, + 1879544, 1879613, 1879672, 1879682, 1880252, 1882056, 1885823, 1886598, 1886760, 1886762, + 1892823, 1894616, 1895695, 1896348, 1896953, 1897000, 1897007, 1897118, 1897122, 1897590, + 1898359, 1898494, 1899102, 1904391, 1907123, 1907125, 1907146, 1907148, 1907165, 1907299, + 1907300, 1907301, 1907306, 1907307, 1907309, 1912205, 1912209, 1915223, 1919014, 1920772, + 1921372, 1925936, 1925943, 1926004, 1926006, 1926020, 1926054, 1926055, 1926099, 1926101, + 1926116, 1926142, 1927639, 1929434, 1948005, 1948015, 1952156, 1963770, 1964032, 1966336, + 1978681, 1985663, 1990589, 2002872, 2005057, 2005237, 2010971, 2010985, 2011457, 2012484, + 2012557, 2012593, 2013159, 2013229, 2013258, 2013348, 2013399, 2013923, 2013952, 2014006, + 2014022, 2014407, 2014624, 2014718, 2014927, 2015051, 2015310, 2015833, 2016187, 2016422, + 2016701, 2016764, 2016910, 2017487, 2017945, 2018116, 2019309, 2019326, 2019528, 2019951, + 2020689, 2020812, 2020838, 2021066, 2021618, 2021851, 2022890, 2023058, 2023469, 2023782, + 2025159, 2025339, 2025527, 2026126, 2026303, 2026583, 2026609, 2026643, 2026696, 2026895, + 2026979, 2027296, 2027456, 2027468, 2027667, 2027749, 2027968, 2028462, 2029156, 2029945, + 2030065, 2030474, 2031405, 2031533, 2031964, 2032007, 2032081, 2032201, 2032532, 2032614, + 2033128, 2033135, 2033147, 2033149, 2033168, 2033196, 2033225, 2033242, 2033301, 2033370, + 2033403, 2033413, 2033423, 2033449, 2033467, 2033536, 2033574, 2033602, 2033667, 2033675, + 2033739, 2033766, 2033824, 2033866, 2033934, 2034141, 2034221, 2034226, 2034228, 2034312, + 2034340, 2034400, 2034439, 2034440, 2034497, 2034599, 2034600, 2034615, 2034638, 2034651, + 2034655, 2034657, 2034691, 2034714, 2034754, 2034761, 2034786, 2034791, 2034834, 2034918, + 2034937, 2034995, 2035002, 2035182, 2035196, 2035225, 2035261, 2035265, 2035325, 2035399, + 2035453, 2035511, 2035513, 2035593, 2035601, 2035610, 2035635, 2035644, 2035669, 2035707, + 2035715, 2035746, 2035754, 2035758, 2035801, 2035836, 2035966, 2035970, 2035980, 2036033, + 2036055, 2036066, 2036069, 2036075, 2036081, 2036106, 2036109, 2036113, 2036226, 2036237, + 2036241, 2036283, 2036337, 2036338, 2036389, 2036401, 2036403, 2036418, 2036427, 2036434, + 2036458, 2036502, 2036519, 2036536, 2036581, 2036595, 2036597, 2036619, 2036653, 2036670, + 2036671, 2036685, 2036713, 2036734, 2036753, 2036776, 2036876, 2036892, 2036920, 2036933, + 2036959, 2036973, 2036986, 2037013, 2037069, 2037075, 2037078, 2037086, 2037222, 2037240, + 2037252, 2037311, 2037330, 2037331, 2037334, 2037335, 2037345, 2037346, 2037355, 2037370, + 2037375, 2037391, 2037393, 2037411, 2037485, 2037494, 2037534, 2037611, 2037620, 2037658, + 2037685, 2037712, 2037799, 2037820, 2037823, 2037860, 2037886, 2037913, 2037930, 2038067, + 2038080, 2038087, 2038118, 2038120, 2038139, 2038154, 2038158, 2038180, 2038198, 2038274, + 2038283, 2038300, 2038342, 2038421, 2038432, 2038438, 2038446, 2038482, 2038529, 2038541, + 2038569, 2038584, 2038632, 2038650, 2038665, 2038679, 2038854, 2039623, 2040674, 2040893, + 2041533, 2042249, 2042267, 2042498, 2042503, 2042645, 2042738, 2042987, 2043484, 2043531, + 2043572, 2043677, 2043835, 2044050, 2044091, 2044757, 2045311, 2051471, 2051523, 2055166, + 2056752, 2057087, 2058430, 2062276, 2063523, 2065176, 2065594, 2065740, 2067119, 2068079, + 2068823, 2070571, 2070998, 2071059, 2073124, 2075432, 2077895, 2077963, 2078025, 2078127, + 2081986, 2082600, 2082727, 2083537, 2088122, 2088163, 2090409, 2090990, 2091996, 2092740, + 2093685, 2093967, 2096742, 2098329, 2098869, 2100633, 2108502, 2110257, 2110394, 2110460, + 2110480, 2110498, 2110506, 2110518, 2110538, 2110541, 2110556, 2110560, 2110579, 2110586, + 2110596, 2110629, 2110683, 2110729, 2110735, 2110743, 2110744, 2110774, 2110793, 2110891, + 2110893, 2110959, 2110994, 2111008, 2111016, 2111018, 2111049, 2111065, 2111149, 2111173, + 2111220, 2111248, 2111258, 2111277, 2111310, 2111325, 2111425, 2111429, 2111435, 2111441, + 2111461, 2111495, 2111530, 2111559, 2111567, 2111568, 2111656, 2111677, 2111684, 2111687, + 2111704, 2111749, 2111781, 2111824, 2111827, 2111831, 2111834, 2111836, 2111855, 2111859, + 2111884, 2111901, 2111943, 2111964, 2111999, 2112008, 2112019, 2112077, 2112141, 2112182, + 2112227, 2112232, 2112297, 2112309, 2112312, 2112319, 2112343, 2112354, 2112409, 2112444, + 2112455, 2112521, 2112527, 2112539, 2112555, 2112571, 2112576, 2112583, 2112615, 2112656, + 2112664, 2112692, 2112708, 2112758, 2112802, 2112823, 2112899, 2112903, 2112913, 2112923, + 2112940, 2112963, 2112989, 2113015, 2113077, 2113115, 2113126, 2113164, 2113719, 2113779, + 2118647, 2119441, 2119538, 2119932, 2121052, 2121909, 2122104, 2122614, 2122850, 2122894, + 2123628, 2124286, 2124615, 2127383, 2127515, 2127733, 2127802, 2127878, 2127896, 2127910, + 2127955, 2128025, 2128072, 2128147, 2128206, 2128295, 2128382, 2128558, 2128574, 2128787, + 2128815, 2128867, 2128975, 2128983, 2129003, 2129005, 2129101, 2129163, 2129211, 2129218, + 2129324, 2129376, 2129395, 2129513, 2129537, 2129766, 2129868, 2129870, 2129909, 2129961, + 2130054, 2130057, 2130146, 2130188, 2130203, 2130332, 2130404, 2130421, 2130452, 2130534, + 2130612, 2130629, 2130658, 2130741, 2131612, 2135171, 2139521, 2140066, 2141394, 2143285, + 2144528, 2145110, 2146108, 2146142, 2146219, 2146268, 2147381, 2147497, 2147714, 2147892, + 2147914, 2148398, 2148928, 2148997, 2149645, 2150660, 2151437, 2152286, 2152329, 2152659, + 2154219, 2154787, 2154796, 2155472, 2155542, 2156340, 2156643, 2156813, 2156878, 2157109, + 2157698, 2158151, 2158177, 2158562, 2158626, 2158651, 2159220, 2159851, 2160063, 2160517, + 2161314, 2161776, 2163137, 2163355, 2164422, 2164515, 2164691, 2164837, 2165087, 2165478, + 2165796, 2165798, 2166143, 2166309, 2167280, 2167312, 2167817, 2167949, 2168305, 2168943, + 2169220, 2169956, 2170078, 2170089, 2171085, 2171507, 2171845, 2172111, 2172303, 2172311, + 2172517, 2172686, 2172710, 2172797, 2172832, 2173125, 2173323, 2173605, 2173741, 2173911, + 2174003, 2175411, 2176187, 2176632, 2176934, 2177091, 2177671, 2178174, 2179537, 2179670, + 2181133, 2181742, 2184155, 2184397, 2184904, 2185018, 2185964, 2186239, 2186280, 2186313, + 2187404, 2187454, 2188164, 2189529, 2190224, 2190324, 2191562, 2192362, 2193733, 2198148, + 2202064, 2204582, 2206371, 2206854, 2206890, 2207259, 2208032, 2208285, 2208305, 2208329, + 2208330, 2208425, 2208485, 2208655, 2208791, 2209055, 2210221, 2210247, 2210394, 2210554, + 2210560, 2212771, 2212775, 2214433, 2214603, 2214827, 2214846, 2215163, 2216645, 2216885, + 2217351, 2217362, 2218478, 2218840, 2218963, 2219235, 2219905, 2219960, 2220957, 2221030, + 2221053, 2221394, 2221504, 2221530, 2221607, 2222230, 2222623, 2223293, 2223734, 2223763, + 2224827, 2225457, 2225726, 2225728, 2225991, 2226275, 2227230, 2227402, 2227613, 2228005, + 2228028, 2228079, 2228373, 2228499, 2228675, 2229152, 2229267, 2229411, 2229681, 2229748, + 2229752, 2229761, 2229798, 2230599, 2230876, 2231319, 2231320, 2231482, 2231504, 2231506, + 2231564, 2231881, 2232239, 2232283, 2232444, 2232593, 2232997, 2233410, 2233805, 2234359, + 2234536, 2234663, 2234794, 2234865, 2234941, 2234974, 2235029, 2235189, 2235194, 2235196, + 2235776, 2236568, 2236967, 2239001, 2239520, 2239862, 2240449, 2242001, 2243271, 2243940, + 2244177, 2244616, 2244799, 2244991, 2245704, 2246452, 2246544, 2246606, 2246608, 2246678, + 2247157, 2247381, 2247813, 2248409, 2248698, 2249782, 2250645, 2250677, 2250805, 2251084, + 2251230, 2251339, 2253277, 2253354, 2253901, 2255285, 2255414, 2255542, 2255564, 2256895, + 2257990, 2258261, 2258378, 2259383, 2259655, 2259947, 2260535, 2261639, 2261697, 2262581, + 2262644, 2262912, 2262957, 2262963, 2263326, 2263352, 2263480, 2263523, 2263667, 2263827, + 2264087, 2264268, 2264299, 2264359, 2264456, 2264508, 2264526, 2264575, 2264718, 2264736, + 2264923, 2265169, 2265223, 2265326, 2265447, 2265467, 2265788, 2266249, 2266319, 2266703, + 2266977, 2266988, 2267057, 2267067, 2267095, 2267131, 2267226, 2267827, 2268339, 2268406, + 2268436, 2268575, 2269041, 2269282, 2269514, 2269594, 2270157, 2270184, 2270229, 2270377, + 2270380, 2270437, 2270503, 2270981, 2271071, 2271473, 2271680, 2271772, 2271961, 2271985, + 2272215, 2272222, 2272491, 2272790, 2273312, 2274895, 2276086, 2276492, 2276600, 2277060, + 2278158, 2278682, 2279172, 2279755, 2280045, 2280316, 2280376, 2280589, 2280761, 2280995, + 2281120, 2281606, 2281951, 2282006, 2282178, 2282827, 2283016, 2284589, 2284647, 2285449, + 2286304, 2287298, 2287790, 2287958, 2288115, 2288118, 2288829, 2289049, 2289549, 2289887, + 2289983, 2290412, 2290462, 2290486, 2290582, 2290836, 2290849, 2290956, 2290964, 2291087, + 2291113, 2291136, 2291580, 2291666, 2291779, 2292179, 2292755, 2292852, 2293107, 2293260, + 2293268, 2293342, 2293428, 2293507, 2293521, 2293538, 2293549, 2293801, 2294034, 2294086, + 2294206, 2294665, 2294700, 2294727, 2294768, 2294877, 2294915, 2294938, 2294962, 2295021, + 2295065, 2295385, 2295458, 2295517, 2295672, 2295684, 2295840, 2296458, 2296564, 2296606, + 2296969, 2297141, 2297313, 2297505, 2298264, 2298330, 2298890, 2299233, 2299349, 2299522, + 2299625, 2299645, 2300372, 2300379, 2300721, 2300883, 2301190, 2301217, 2301400, 2301639, + 2302357, 2302821, 2303060, 2303125, 2303236, 2303287, 2303611, 2304220, 2304389, 2304548, + 2304931, 2305537, 2306079, 2306104, 2306119, 2309332, 2309527, 2310046, 2311127, 2311968, + 2312249, 2312888, 2312895, 2313002, 2313084, 2313762, 2314302, 2314705, 2315026, 2315057, + 2315417, 2315728, 2316259, 2316748, 2317397, 2317548, 2317569, 2317765, 2318044, 2318123, + 2318921, 2318933, 2319133, 2319257, 2319668, 2320576, 2320829, 2320831, 2320920, 2321031, + 2322263, 2322495, 2322529, 2322552, 2322794, 2322911, 2322957, 2323390, 2323411, 2323675, + 2324504, 2324575, 2324767, 2324774, 2324857, 2324960, 2325060, 2325161, 2325200, 2325249, + 2325314, 2325330, 2325437, 2325733, 2326016, 2326171, 2326302, 2326811, 2326899, 2327143, + 2327223, 2327494, 2327513, 2327521, 2327650, 2327827, 2327879, 2328090, 2328151, 2328185, + 2328617, 2328684, 2328765, 2328790, 2328811, 2328952, 2329451, 2329562, 2329821, 2329920, + 2329946, 2329981, 2330028, 2330100, 2330719, 2331005, 2331140, 2331447, 2331528, 2331939, + 2332079, 2332249, 2332357, 2332459, 2332504, 2332515, 2332871, 2333451, 2333490, 2333563, + 2334008, 2334327, 2334652, 2334756, 2334801, 2334802, 2335015, 2335204, 2335333, 2335596, + 2335614, 2335713, 2335727, 2335798, 2335843, 2335953, 2336056, 2336237, 2336251, 2336589, + 2336905, 2336985, 2337148, 2337207, 2337235, 2337352, 2337379, 2337490, 2337639, 2337659, + 2337680, 2337704, 2337759, 2337765, 2338106, 2338242, 2338269, 2338273, 2338287, 2338385, + 2338400, 2338401, 2338403, 2338497, 2338630, 2338640, 2338660, 2338669, 2338711, 2338772, + 2338810, 2338876, 2339150, 2339156, 2339287, 2339293, 2339354, 2339631, 2339665, 2339756, + 2339786, 2339892, 2339937, 2340086, 2340091, 2340446, 2340451, 2341275, 2341294, 2341355, + 2341580, 2341656, 2341758, 2341955, 2342192, 2342490, 2342628, 2342883, 2343093, 2343252, + 2343270, 2343273, 2343279, 2343299, 2343512, 2343641, 2343720, 2343784, 2343822, 2343943, + 2343983, 2343985, 2344082, 2344229, 2344245, 2344418, 2344600, 2344854, 2345029, 2345094, + 2345096, 2345152, 2345498, 2345521, 2346229, 2346317, 2346561, 2346615, 2346812, 2346951, + 2346995, 2347057, 2347059, 2347061, 2347155, 2347209, 2347283, 2347303, 2347330, 2347470, + 2347592, 2347954, 2348395, 2348507, 2348595, 2348773, 2348783, 2348892, 2349276, 2349431, + 2349529, 2349558, 2349951, 2350249, 2350806, 2350841, 2350886, 2351470, 2351740, 2351979, + 2352250, 2352356, 2352778, 2352947, 2353099, 2353151, 2353197, 2353688, 2354176, 2354349, + 2354675, 2356228, 2356454, 2357043, 2357048, 2357163, 2358100, 2358382, 2358738, 2358946, + 2359142, 2359227, 2359317, 2359608, 2360073, 2360238, 2360615, 2360886, 2361082, 2361177, + 2361373, 2361477, 2361845, 2361946, 2362344, 2362909, 2363490, 2363534, 2363908, 2364079, + 2364104, 2364752, 2364812, 2365190, 2365267, 2365560, 2366152, 2367164, 2367568, 2367656, + 2367660, 2367886, 2367990, 2374775, 2375254, 2377450, 2377457, 2383119, 2383523, 2383827, + 2384770, 2386012, 2387435, 2387495, 2387546, 2387926, 2388036, 2388614, 2388873, 2389086, + 2389691, 2389853, 2391377, 2391455, 2391893, 2391895, 2392009, 2392087, 2392108, 2392204, + 2392308, 2392505, 2392601, 2392837, 2392897, 2393551, 2393693, 2394545, 2394560, 2394711, + 2394814, 2394819, 2394824, 2395049, 2395182, 2395261, 2395317, 2395568, 2395635, 2395914, + 2395915, 2396253, 2396518, 2396646, 2398073, 2398269, 2399697, 2399888, 2399959, 2400555, + 2403094, 2404433, 2406407, 2406916, 2407660, 2407790, 2408329, 2409306, 2410048, 2410763, + 2411585, 2411880, 2412749, 2413515, 2413753, 2413876, 2413920, 2414545, 2414926, 2415703, + 2416443, 2416969, 2417833, 2417988, 2418362, 2419472, 2419533, 2419992, 2420056, 2420562, + 2420884, 2422457, 2422465, 2422488, 2422924, 2425791, 2426240, 2426370, 2427123, 2427336, + 2427455, 2427637, 2428042, 2428228, 2428231, 2428394, 2429296, 2429344, 2429605, 2430506, + 2433055, 2433437, 2434910, 2435124, 2435508, 2436400, 2437732, 2437798, 2438678, 2438774, + 2438823, 2438855, 2439155, 2439376, 2440485, 2440495, 2440921, 2441194, 2441217, 2441291, + 2441482, 2441530, 2443304, 2444489, 2445488, 2445553, 2445704, 2446267, 2447416, 2447938, + 2448442, 2449067, 2451185, 2451478, 2451778, 2453348, 2453662, 2454268, 2454530, 2454955, + 2455516, 2455518, 2455558, 2455735, 2457163, 2458589, 2459775, 2460546, 2460596, 2460755, + 2461874, 2462881, 2463447, 2463679, 2464041, 2464168, 2464470, 2464648, 2464701, 2464795, + 2464804, 2464809, 2464915, 2465030, 2465840, 2467246, 2467454, 2467521, 2467815, 2467856, + 2467920, 2467959, 2468018, 2468106, 2468245, 2468285, 2468329, 2468353, 2468369, 2468561, + 2468579, 2468925, 2469088, 2469140, 2469256, 2469262, 2469264, 2469268, 2469274, 2469386, + 2470088, 2470173, 2470191, 2470384, 2470579, 2470588, 2470656, 2471287, 2471475, 2471637, + 2472706, 2472722, 2472774, 2473229, 2473257, 2473420, 2473449, 2473457, 2473470, 2473493, + 2473499, 2473517, 2473540, 2473572, 2473634, 2473654, 2473744, 2473747, 2473826, 2473876, + 2473913, 2474141, 2474506, 2474583, 2474638, 2475475, 2475612, 2475687, 2475740, 2475752, + 2475764, 2475921, 2476396, 2476403, 2476412, 2476915, 2476917, 2477255, 2477462, 2477528, + 2478216, 2478226, 2478831, 2479161, 2479183, 2479247, 2479536, 2479609, 2479916, 2479966, + 2480198, 2480368, 2480618, 2481007, 2481058, 2481207, 2481246, 2481389, 2481639, 2482090, + 2482159, 2482211, 2482390, 2482447, 2482572, 2482886, 2482908, 2482939, 2483000, 2483649, + 2483746, 2483757, 2483761, 2483936, 2483968, 2484620, 2484846, 2485572, 2485582, 2485618, + 2485633, 2485636, 2485801, 2485926, 2486284, 2486505, 2486825, 2487134, 2487452, 2487620, + 2487772, 2487805, 2487852, 2487882, 2488202, 2488500, 2488616, 2488716, 2488722, 2488835, + 2489987, 2490180, 2490183, 2490297, 2491042, 2491050, 2491134, 2491191, 2491323, 2491335, + 2491578, 2491911, 2491913, 2492345, 2492920, 2492991, 2493222, 2493605, 2493918, 2493956, + 2494029, 2494548, 2494554, 2494610, 2494962, 2495662, 2496232, 2496241, 2496573, 2497060, + 2497714, 2497796, 2497849, 2497988, 2498000, 2498172, 2498183, 2498392, 2498590, 2498667, + 2498704, 2498752, 2498766, 2498775, 2498782, 2498954, 2499055, 2499104, 2499116, 2499193, + 2500282, 2500401, 2500583, 2500737, 2500889, 2500904, 2501152, 2501289, 2501323, 2501362, + 2501404, 2501465, 2501508, 2501541, 2501680, 2501767, 2501873, 2502034, 2502239, 2502686, + 2502924, 2502939, 2502962, 2503033, 2503147, 2503156, 2503181, 2503229, 2503237, 2503468, + 2503620, 2503654, 2503661, 2503755, 2503847, 2503852, 2503874, 2503878, 2504072, 2504099, + 2504110, 2504136, 2504385, 2504486, 2504581, 2504616, 2504622, 2504703, 2504739, 2505329, + 2505530, 2505572, 2505629, 2505651, 2505653, 2505854, 2505915, 2506043, 2506404, 2506519, + 2506623, 2506795, 2506999, 2507155, 2507169, 2507480, 2507646, 2507877, 2507901, 2507912, + 2507926, 2507943, 2507972, 2508010, 2508059, 2508102, 2508119, 2508130, 2508152, 2508157, + 2508174, 2508180, 2508184, 2508225, 2508268, 2508275, 2508287, 2508297, 2508309, 2508737, + 2509031, 2509305, 2509377, 2509402, 2509463, 2509491, 2509509, 2509553, 2509588, 2509650, + 2509769, 2509954, 2509982, 2510073, 2510112, 2510116, 2510224, 2510245, 2510253, 2510271, + 2510279, 2510281, 2510392, 2510394, 2510409, 2510485, 2510542, 2510573, 2510599, 2510693, + 2510725, 2510743, 2510764, 2510880, 2510911, 2511032, 2511050, 2511102, 2511150, 2511162, + 2511174, 2511180, 2511202, 2511239, 2511247, 2511287, 2511306, 2511329, 2511330, 2511352, + 2511366, 2511388, 2511401, 2511440, 2511447, 2511448, 2511619, 2511700, 2511716, 2511730, + 2511752, 2511852, 2511880, 2511930, 2511994, 2512127, 2512169, 2512177, 2512186, 2512196, + 2512232, 2512251, 2512282, 2512340, 2512432, 2512581, 2512620, 2512862, 2512989, 2512990, + 2513026, 2513029, 2513052, 2513076, 2513106, 2513115, 2513145, 2513195, 2513222, 2513240, + 2513324, 2513416, 2513436, 2513465, 2513477, 2513509, 2513601, 2513604, 2513703, 2513759, + 2513791, 2513798, 2513811, 2513882, 2513917, 2513947, 2513983, 2514066, 2514073, 2514097, + 2514158, 2514169, 2514176, 2514190, 2514197, 2514216, 2514256, 2514287, 2514288, 2514301, + 2514392, 2514553, 2514651, 2514824, 2514868, 2514891, 2514893, 2514946, 2514984, 2515036, + 2515045, 2515072, 2515096, 2515151, 2515219, 2515270, 2515284, 2515493, 2515555, 2515562, + 2515692, 2515698, 2515701, 2515812, 2516004, 2516088, 2516255, 2516326, 2516336, 2516345, + 2516395, 2516431, 2516443, 2516452, 2516474, 2516479, 2516480, 2516542, 2516548, 2516797, + 2516852, 2516860, 2516902, 2516925, 2517111, 2517117, 2517367, 2517436, 2517595, 2517750, + 2517816, 2518040, 2518207, 2518494, 2518505, 2518559, 2518729, 2518770, 2518794, 2518820, + 2518878, 2518924, 2518949, 2519068, 2519110, 2519233, 2519240, 2519289, 2519367, 2519402, + 2519425, 2519466, 2519477, 2519513, 2519651, 2519690, 2519738, 2519752, 2520052, 2520055, + 2520058, 2520118, 2520121, 2520150, 2520171, 2520283, 2520413, 2520447, 2520477, 2520493, + 2520496, 2520502, 2520600, 2520611, 2520645, 2520709, 2520712, 2520833, 2520968, 2521016, + 2521088, 2521105, 2521139, 2521215, 2521335, 2521410, 2521413, 2521415, 2521420, 2521456, + 2521485, 2521510, 2521519, 2521570, 2521582, 2521590, 2521665, 2521676, 2521710, 2521738, + 2521804, 2521847, 2521855, 2521857, 2521886, 2521893, 2521909, 2521923, 2521964, 2521978, + 2521985, 2521986, 2521992, 2522012, 2522013, 2522057, 2522077, 2522091, 2522098, 2522129, + 2522131, 2522152, 2522160, 2522165, 2522203, 2522208, 2522250, 2522258, 2522297, 2522325, + 2522333, 2522430, 2522437, 2522713, 2522767, 2522776, 2522857, 2522876, 2522960, 2522971, + 2523083, 2523087, 2523112, 2523113, 2523136, 2523166, 2523180, 2523192, 2523194, 2523460, + 2523461, 2523513, 2523578, 2523581, 2523585, 2523619, 2523623, 2523630, 2523650, 2523665, + 2523693, 2523705, 2523796, 2523866, 2523871, 2523888, 2523902, 2523908, 2523920, 2523927, + 2523938, 2523964, 2523998, 2524006, 2524013, 2524076, 2524084, 2524085, 2524119, 2524123, + 2524126, 2524155, 2524170, 2524205, 2524236, 2524245, 2524393, 2524410, 2524533, 2524606, + 2524618, 2524653, 2524734, 2524786, 2524815, 2524819, 2524881, 2524907, 2524929, 2524955, + 2525059, 2525068, 2525070, 2525083, 2525110, 2525207, 2525349, 2525350, 2525362, 2525379, + 2525405, 2525448, 2525450, 2525473, 2525498, 2525560, 2525571, 2525597, 2525628, 2525643, + 2525646, 2525655, 2525725, 2525755, 2525764, 2525769, 2525772, 2525789, 2525790, 2525791, + 2525792, 2526435, 2526452, 2526488, 2527089, 2527645, 2527915, 2528659, 2528910, 2529317, + 2529649, 2530048, 2530155, 2530241, 2530335, 2531480, 2532394, 2532822, 2532945, 2533191, + 2534515, 2536074, 2537406, 2537545, 2537763, 2537881, 2538475, 2539134, 2540483, 2540689, + 2540810, 2540850, 2541479, 2542051, 2542227, 2542715, 2542866, 2542987, 2542997, 2543549, + 2544001, 2544248, 2544333, 2544571, 2544720, 2545017, 2545985, 2548489, 2548526, 2548830, + 2548885, 2549263, 2550078, 2550252, 2550806, 2553455, 2553604, 2553751, 2555467, 2555745, + 2556272, 2556464, 2556657, 2557055, 2558470, 2561124, 2561668, 2562055, 2562266, 2562305, + 2562629, 2562704, 2563191, 2567529, 2577162, 2577164, 2581754, 2591159, 2593460, 2594800, + 2596934, 2598243, 2609906, 2610319, 2610613, 2611396, 2611828, 2612045, 2612629, 2613102, + 2613460, 2613731, 2614030, 2614481, 2614600, 2614764, 2615006, 2615876, 2615961, 2616015, + 2616038, 2617658, 2618361, 2618415, 2618425, 2618528, 2619154, 2619377, 2619528, 2619771, + 2619856, 2620046, 2620147, 2620214, 2620320, 2620425, 2620473, 2620964, 2621215, 2621356, + 2621927, 2621942, 2621951, 2622306, 2622447, 2623188, 2624112, 2624341, 2624652, 2624886, + 2624906, 2625070, 2633274, 2633352, 2633373, 2633397, 2633406, 2633485, 2633521, 2633551, + 2633553, 2633563, 2633681, 2633691, 2633708, 2633709, 2633729, 2633749, 2633765, 2633771, + 2633810, 2633842, 2633858, 2633883, 2633912, 2633936, 2633948, 2633954, 2633976, 2634021, + 2634032, 2634096, 2634103, 2634155, 2634202, 2634204, 2634308, 2634340, 2634387, 2634491, + 2634493, 2634552, 2634573, 2634578, 2634616, 2634617, 2634672, 2634677, 2634686, 2634715, + 2634725, 2634739, 2634755, 2634777, 2634825, 2634843, 2634853, 2634864, 2634873, 2634887, + 2634910, 2635062, 2635243, 2635269, 2635281, 2635412, 2635427, 2635603, 2635650, 2635703, + 2635762, 2635785, 2636005, 2636032, 2636049, 2636132, 2636177, 2636276, 2636333, 2636373, + 2636389, 2636432, 2636433, 2636439, 2636465, 2636484, 2636486, 2636503, 2636531, 2636534, + 2636616, 2636619, 2636663, 2636713, 2636749, 2636767, 2636769, 2636841, 2636876, 2636882, + 2636910, 2636940, 2636995, 2637104, 2637106, 2637126, 2637142, 2637235, 2637265, 2637329, + 2637330, 2637343, 2637355, 2637433, 2637435, 2637476, 2637487, 2637546, 2637627, 2637659, + 2637752, 2637762, 2637802, 2637891, 2637916, 2637917, 2637958, 2638077, 2638187, 2638235, + 2638302, 2638311, 2638324, 2638419, 2638568, 2638600, 2638664, 2638671, 2638678, 2638717, + 2638785, 2638853, 2638864, 2638867, 2638894, 2638911, 2638926, 2638946, 2638960, 2638977, + 2638978, 2639015, 2639022, 2639069, 2639093, 2639189, 2639265, 2639268, 2639272, 2639317, + 2639323, 2639325, 2639409, 2639447, 2639495, 2639506, 2639545, 2639557, 2639563, 2639577, + 2639583, 2639586, 2639588, 2639660, 2639668, 2639728, 2639866, 2639896, 2639897, 2639912, + 2639926, 2639928, 2639958, 2639970, 2639996, 2639998, 2640037, 2640054, 2640060, 2640101, + 2640104, 2640106, 2640132, 2640155, 2640190, 2640194, 2640246, 2640349, 2640351, 2640354, + 2640358, 2640377, 2640465, 2640496, 2640677, 2640681, 2640729, 2640861, 2640869, 2640894, + 2640908, 2640967, 2641022, 2641134, 2641157, 2641170, 2641181, 2641224, 2641267, 2641319, + 2641430, 2641435, 2641519, 2641520, 2641544, 2641546, 2641555, 2641557, 2641581, 2641589, + 2641591, 2641598, 2641599, 2641609, 2641616, 2641673, 2641674, 2641689, 2641690, 2641731, + 2641810, 2641843, 2641913, 2641942, 2642135, 2642189, 2642204, 2642214, 2642423, 2642465, + 2642593, 2642607, 2642683, 2642705, 2642763, 2642999, 2643003, 2643027, 2643044, 2643071, + 2643096, 2643097, 2643116, 2643123, 2643144, 2643160, 2643179, 2643186, 2643198, 2643218, + 2643266, 2643339, 2643490, 2643553, 2643567, 2643696, 2643697, 2643734, 2643741, 2643743, + 2643776, 2644100, 2644120, 2644204, 2644210, 2644319, 2644386, 2644411, 2644487, 2644531, + 2644547, 2644559, 2644597, 2644652, 2644660, 2644668, 2644684, 2644688, 2644726, 2644737, + 2644849, 2644853, 2644972, 2645261, 2645298, 2645309, 2645313, 2645418, 2645420, 2645425, + 2645456, 2645541, 2645605, 2645721, 2645722, 2645724, 2645733, 2645753, 2645822, 2645826, + 2645831, 2645889, 2645951, 2645972, 2646003, 2646032, 2646042, 2646057, 2646088, 2646274, + 2646317, 2646327, 2646329, 2646393, 2646458, 2646460, 2646471, 2646504, 2646525, 2646542, + 2646557, 2646558, 2646606, 2646807, 2646826, 2646862, 2646867, 2646914, 2646979, 2647026, + 2647044, 2647057, 2647074, 2647138, 2647209, 2647227, 2647246, 2647248, 2647261, 2647265, + 2647303, 2647310, 2647317, 2647349, 2647356, 2647363, 2647383, 2647400, 2647428, 2647451, + 2647461, 2647570, 2647632, 2647639, 2647644, 2647655, 2647679, 2647784, 2647785, 2647793, + 2647837, 2647948, 2647984, 2647985, 2648026, 2648063, 2648182, 2648187, 2648208, 2648215, + 2648272, 2648273, 2648290, 2648319, 2648356, 2648372, 2648404, 2648405, 2648438, 2648579, + 2648657, 2648683, 2648728, 2648773, 2648875, 2648945, 2648970, 2649024, 2649049, 2649198, + 2649258, 2649312, 2649322, 2649578, 2649579, 2649622, 2649650, 2649660, 2649672, 2649692, + 2649715, 2649723, 2649750, 2649800, 2649808, 2649833, 2649911, 2649957, 2650004, 2650096, + 2650122, 2650188, 2650225, 2650278, 2650285, 2650309, 2650346, 2650376, 2650396, 2650405, + 2650435, 2650470, 2650497, 2650628, 2650657, 2650732, 2650752, 2650802, 2650815, 2650839, + 2650962, 2650967, 2650983, 2651048, 2651095, 2651101, 2651123, 2651269, 2651286, 2651347, + 2651357, 2651468, 2651485, 2651495, 2651497, 2651500, 2651513, 2651621, 2651654, 2651715, + 2651831, 2651852, 2652002, 2652053, 2652095, 2652191, 2652204, 2652221, 2652381, 2652437, + 2652458, 2652464, 2652513, 2652544, 2652586, 2652618, 2652622, 2652689, 2652696, 2652698, + 2652730, 2652734, 2652819, 2652861, 2652885, 2652890, 2652974, 2652995, 2653075, 2653086, + 2653137, 2653144, 2653192, 2653224, 2653225, 2653228, 2653232, 2653235, 2653261, 2653265, + 2653266, 2653290, 2653305, 2653353, 2653393, 2653520, 2653558, 2653584, 2653680, 2653755, + 2653775, 2653822, 2653877, 2653883, 2653941, 2653945, 2653947, 2654089, 2654141, 2654179, + 2654186, 2654187, 2654200, 2654252, 2654264, 2654269, 2654308, 2654394, 2654415, 2654450, + 2654490, 2654579, 2654635, 2654663, 2654668, 2654675, 2654710, 2654715, 2654724, 2654728, + 2654730, 2654755, 2654782, 2654927, 2654938, 2654993, 2655009, 2655095, 2655138, 2655186, + 2655198, 2655237, 2655262, 2655315, 2655329, 2655351, 2655459, 2655524, 2655557, 2655562, + 2655582, 2655583, 2655603, 2655613, 2655642, 2655664, 2655672, 2655689, 2655707, 2655708, + 2655729, 2655777, 2655785, 2655819, 2655858, 2655882, 2655942, 2655952, 2655984, 2656031, + 2656039, 2656046, 2656070, 2656086, 2656168, 2656169, 2656173, 2656192, 2656194, 2656235, + 2656241, 2656258, 2656281, 2656284, 2656379, 2656396, 2656397, 2656406, 2656407, 2656490, + 2656627, 2656708, 2656719, 2656847, 2656915, 2656918, 2656955, 2656992, 2657030, 2657215, + 2657255, 2657324, 2657356, 2657402, 2657408, 2657471, 2657508, 2657528, 2657540, 2657613, + 2657697, 2657770, 2657780, 2657782, 2657812, 2657832, 2657835, 2657896, 2657908, 2657941, + 2657970, 2657996, 2658011, 2658145, 2658154, 2658216, 2658377, 2658494, 2658576, 2658656, + 2658822, 2659070, 2659099, 2659127, 2659296, 2659297, 2659310, 2659422, 2659496, 2659522, + 2659601, 2659613, 2659667, 2659811, 2659836, 2659873, 2659977, 2659994, 2660076, 2660104, + 2660108, 2660119, 2660127, 2660221, 2660305, 2660306, 2660365, 2660512, 2660549, 2660646, + 2660718, 2660727, 2660911, 2660971, 2661015, 2661169, 2661265, 2661513, 2661552, 2661567, + 2661604, 2661653, 2661666, 2661810, 2661861, 2661881, 2662149, 2662689, 2663536, 2664203, + 2664454, 2664855, 2664996, 2665171, 2665452, 2666199, 2666238, 2666670, 2667094, 2667109, + 2667303, 2667402, 2669772, 2670781, 2670879, 2673730, 2675397, 2675408, 2676176, 2677234, + 2680075, 2684395, 2685750, 2685828, 2686162, 2686469, 2686657, 2687700, 2688250, 2688368, + 2690170, 2690580, 2690960, 2691459, 2692475, 2692969, 2693678, 2694762, 2696329, 2696334, + 2696503, 2697720, 2698729, 2698739, 2699282, 2699310, 2699791, 2700791, 2701223, 2701680, + 2701713, 2701715, 2701727, 2702261, 2702979, 2703396, 2704136, 2704620, 2706767, 2707399, + 2707684, 2707953, 2708365, 2711537, 2712414, 2715459, 2715568, 2715573, 2715946, 2715953, + 2716166, 2719111, 2720383, 2720501, 2721259, 2725201, 2725901, 2726756, 2727234, 2729907, + 2732265, 2732438, 2732475, 2732544, 2732649, 2732773, 2732978, 2734106, 2734140, 2734363, + 2734434, 2734484, 2735083, 2735787, 2735943, 2736041, 2736521, 2736930, 2737039, 2737523, + 2737824, 2738014, 2738347, 2738348, 2738707, 2738752, 2738925, 2739723, 2739756, 2739788, + 2739848, 2739849, 2739997, 2740174, 2740313, 2740637, 2741551, 2742027, 2742032, 2742051, + 2742416, 2742506, 2742611, 2743304, 2743477, 2743493, 2743608, 2743619, 2743856, 2743949, + 2743977, 2743997, 2744042, 2744102, 2744114, 2744118, 2744194, 2744248, 2744257, 2744324, + 2744332, 2744344, 2744483, 2744514, 2744549, 2744675, 2744827, 2744904, 2744911, 2744991, + 2745088, 2745096, 2745123, 2745127, 2745154, 2745297, 2745301, 2745311, 2745321, 2745340, + 2745392, 2745461, 2745467, 2745580, 2745634, 2745641, 2745673, 2745677, 2745706, 2745726, + 2745739, 2745774, 2745783, 2745860, 2745912, 2745932, 2745973, 2746005, 2746133, 2746215, + 2746301, 2746331, 2746420, 2746504, 2746766, 2746804, 2746839, 2746860, 2746932, 2747021, + 2747034, 2747063, 2747169, 2747203, 2747227, 2747351, 2747364, 2747373, 2747584, 2747596, + 2747599, 2747720, 2747858, 2747891, 2747930, 2748000, 2748076, 2748172, 2748178, 2748185, + 2748371, 2748392, 2748413, 2748591, 2748729, 2749182, 2749234, 2749450, 2749644, 2749668, + 2749680, 2749723, 2749753, 2749756, 2749780, 2749811, 2749812, 2750053, 2750065, 2750325, + 2750467, 2750521, 2750523, 2750815, 2750884, 2750896, 2750947, 2751037, 2751283, 2751285, + 2751316, 2751424, 2751456, 2751547, 2751582, 2751651, 2751687, 2751738, 2751771, 2751773, + 2751792, 2751808, 2751834, 2752264, 2752420, 2752923, 2753010, 2753106, 2753355, 2753468, + 2753557, 2753587, 2753638, 2753706, 2753719, 2753801, 2753996, 2754064, 2754066, 2754073, + 2754394, 2754408, 2754447, 2754454, 2754516, 2754635, 2754652, 2754659, 2754669, 2754681, + 2754692, 2754697, 2754817, 2754837, 2754841, 2754848, 2754861, 2755003, 2755030, 2755251, + 2755272, 2755420, 2755434, 2755464, 2755476, 2755584, 2755599, 2755619, 2755633, 2755669, + 2756039, 2756059, 2756071, 2756077, 2756136, 2756139, 2756161, 2756232, 2756253, 2756295, + 2756342, 2756429, 2756507, 2756539, 2756559, 2756569, 2756619, 2756644, 2756669, 2756723, + 2756767, 2756888, 2756987, 2757220, 2757340, 2757345, 2757347, 2757783, 2757850, 2757872, + 2757874, 2757890, 2757991, 2758007, 2758012, 2758064, 2758104, 2758174, 2758177, 2758245, + 2758258, 2758401, 2758460, 2758547, 2758587, 2758598, 2758602, 2758621, 2758765, 2758804, + 2758878, 2758998, 2759016, 2759040, 2759113, 2759132, 2759145, 2759178, 2759350, 2759407, + 2759426, 2759544, 2759621, 2759633, 2759661, 2759706, 2759746, 2759794, 2759798, 2759821, + 2759875, 2759879, 2759887, 2759899, 2759915, 2760123, 2760134, 2760910, 2761353, 2761369, + 2761524, 2761669, 2762372, 2763423, 2763460, 2763795, 2764359, 2764786, 2765388, 2766429, + 2766824, 2766922, 2771335, 2772173, 2772400, 2772635, 2772649, 2773300, 2773549, 2773913, + 2774326, 2774773, 2775220, 2776951, 2778067, 2779674, 2780741, 2781503, 2781520, 2782067, + 2782555, 2783081, 2783089, 2783175, 2783188, 2783204, 2783274, 2783293, 2783308, 2783310, + 2783416, 2783632, 2783759, 2783763, 2783801, 2783820, 2783941, 2783985, 2784068, 2784189, + 2784548, 2784604, 2784821, 2785141, 2785169, 2785341, 2785364, 2785389, 2785470, 2785476, + 2785612, 2785622, 2785778, 2786087, 2786229, 2786344, 2786420, 2786545, 2786559, 2786578, + 2786641, 2786694, 2786700, 2786824, 2786963, 2787048, 2787356, 2787416, 2787662, 2787769, + 2787889, 2787989, 2788088, 2788348, 2788499, 2788506, 2788521, 2788726, 2788765, 2789162, + 2789232, 2789413, 2789471, 2789529, 2789751, 2789786, 2790101, 2790114, 2790135, 2790357, + 2790471, 2790595, 2790676, 2790697, 2790869, 2791067, 2791194, 2791315, 2791343, 2791424, + 2791537, 2791744, 2791814, 2791857, 2791961, 2791964, 2792073, 2792165, 2792179, 2792196, + 2792235, 2792360, 2792397, 2792413, 2792482, 2792567, 2793077, 2793144, 2793446, 2793508, + 2794055, 2794070, 2794117, 2794166, 2794210, 2794663, 2794730, 2794788, 2795009, 2795100, + 2795113, 2795261, 2795398, 2795730, 2795800, 2795908, 2795912, 2795930, 2796009, 2796012, + 2796132, 2796153, 2796491, 2796542, 2796637, 2796696, 2796833, 2797114, 2797638, 2797656, + 2797670, 2797713, 2797779, 2798023, 2798297, 2798301, 2798307, 2798551, 2798573, 2798615, + 2798987, 2799007, 2799090, 2799226, 2799365, 2799369, 2799397, 2799412, 2799496, 2799645, + 2799647, 2799746, 2800063, 2800220, 2800438, 2800448, 2800461, 2800481, 2800866, 2800931, + 2801106, 2801117, 2801150, 2801154, 2801226, 2801447, 2801494, 2801858, 2801922, 2801924, + 2802031, 2802170, 2802433, 2802435, 2802743, 2803010, 2803033, 2803073, 2803138, 2803160, + 2803204, 2803429, 2803443, 2803448, 2803560, 2803620, 2803723, 2803870, 2804008, 2804034, + 2804748, 2804922, 2805385, 2805597, 2805615, 2805644, 2805753, 2805761, 2805910, 2806081, + 2806142, 2806654, 2806768, 2806914, 2806919, 2807184, 2807201, 2807218, 2807240, 2807344, + 2807363, 2807465, 2807594, 2807748, 2807845, 2807872, 2808461, 2808559, 2808720, 2808893, + 2809138, 2809346, 2809517, 2809889, 2809984, 2810188, 2810612, 2810678, 2810716, 2810808, + 2810833, 2810855, 2810878, 2810919, 2810945, 2810969, 2811204, 2811278, 2811292, 2811644, + 2811698, 2811899, 2811909, 2812145, 2812174, 2812204, 2812482, 2812515, 2812522, 2812625, + 2812636, 2813040, 2813390, 2813433, 2813464, 2813786, 2814005, 2814127, 2814131, 2814146, + 2814153, 2814270, 2814305, 2814362, 2814462, 2814632, 2814791, 2814874, 2814883, 2815137, + 2815330, 2815487, 2815559, 2815565, 2815678, 2815824, 2816630, 2817065, 2817105, 2817202, + 2817220, 2817311, 2817324, 2817537, 2817576, 2817599, 2817724, 2817812, 2817813, 2817818, + 2817873, 2817927, 2818067, 2818094, 2818766, 2819465, 2819974, 2820087, 2820256, 2820456, + 2820577, 2820621, 2820693, 2820860, 2820973, 2821029, 2821164, 2821515, 2821517, 2821807, + 2821899, 2823368, 2823533, 2823567, 2823590, 2823799, 2823812, 2824461, 2824655, 2824801, + 2824841, 2824948, 2825297, 2825422, 2826082, 2826099, 2826287, 2826304, 2826595, 2826861, + 2826909, 2827479, 2827552, 2828050, 2828105, 2828994, 2829422, 2829457, 2829758, 2829777, + 2829804, 2829901, 2829998, 2830035, 2830582, 2830637, 2831088, 2831250, 2831276, 2831403, + 2831486, 2831580, 2831708, 2831852, 2831872, 2831924, 2831948, 2832023, 2832232, 2832495, + 2832521, 2833073, 2833079, 2833080, 2833170, 2833242, 2833296, 2833475, 2833564, 2833592, + 2833641, 2834240, 2834265, 2834282, 2834372, 2834498, 2834629, 2834978, 2835260, 2835297, + 2835342, 2835345, 2835382, 2835481, 2835482, 2835537, 2836084, 2836203, 2836282, 2836320, + 2836413, 2836809, 2837291, 2837470, 2837954, 2838053, 2838059, 2838201, 2838634, 2839050, + 2839316, 2839335, 2839764, 2841125, 2841374, 2841386, 2841463, 2841590, 2841648, 2841693, + 2842112, 2842131, 2842632, 2842647, 2842688, 2842884, 2843355, 2843636, 2843729, 2844265, + 2844437, 2844588, 2844862, 2844988, 2845222, 2846032, 2846523, 2846843, 2846939, 2847033, + 2847524, 2847639, 2847645, 2847662, 2847666, 2847689, 2847690, 2847736, 2848175, 2848245, + 2848273, 2848335, 2848756, 2848762, 2848845, 2849156, 2849483, 2849548, 2849647, 2849802, + 2850174, 2850213, 2850235, 2850253, 2850257, 2850887, 2850954, 2850995, 2851077, 2851079, + 2851343, 2851465, 2851584, 2851746, 2851782, 2852218, 2852280, 2852458, 2852577, 2852673, + 2853209, 2853292, 2853572, 2853574, 2853658, 2853924, 2853928, 2853969, 2854386, 2854655, + 2854923, 2855047, 2855328, 2855441, 2855525, 2855598, 2855745, 2855794, 2855859, 2855917, + 2855935, 2856500, 2856883, 2856930, 2856944, 2857129, 2857185, 2857291, 2857306, 2857458, + 2857472, 2857565, 2857798, 2857807, 2857900, 2857904, 2857943, 2858103, 2858245, 2858738, + 2858763, 2859380, 2860080, 2860410, 2861402, 2861632, 2861650, 2861677, 2861733, 2861814, + 2861914, 2861934, 2861982, 2862026, 2862104, 2862118, 2862620, 2863199, 2863223, 2863240, + 2863712, 2863716, 2863795, 2863840, 2863941, 2864005, 2864034, 2864053, 2864054, 2864058, + 2864072, 2864118, 2864276, 2864435, 2864475, 2864549, 2864820, 2865376, 2865716, 2866070, + 2866135, 2866280, 2866333, 2866375, 2866758, 2866906, 2866930, 2867164, 2867542, 2867543, + 2867613, 2867714, 2867770, 2867838, 2867985, 2867993, 2867996, 2868506, 2868788, 2868936, + 2869019, 2869120, 2869449, 2869791, 2869894, 2869994, 2870221, 2870318, 2871039, 2871284, + 2871486, 2871535, 2871668, 2871675, 2871736, 2871845, 2871983, 2871992, 2872079, 2872155, + 2872225, 2872237, 2872504, 2872519, 2872582, 2872611, 2872649, 2873211, 2873263, 2873289, + 2873291, 2873351, 2873759, 2873776, 2873891, 2874225, 2874230, 2874545, 2875107, 2875115, + 2875376, 2875379, 2875392, 2875417, 2875457, 2875484, 2875601, 2875623, 2875626, 2875645, + 2875831, 2875881, 2876147, 2876185, 2876218, 2876755, 2876865, 2877088, 2877142, 2877550, + 2877648, 2877673, 2877709, 2878074, 2878234, 2878270, 2878673, 2878695, 2878784, 2878840, + 2878943, 2879139, 2879185, 2879241, 2879315, 2879367, 2879697, 2879832, 2880077, 2880144, + 2880221, 2881018, 2881062, 2881085, 2881276, 2881279, 2881485, 2881509, 2881646, 2881695, + 2881885, 2881889, 2881956, 2882087, 2882091, 2882318, 2882439, 2882440, 2882588, 2883754, + 2883784, 2884050, 2884245, 2884509, 2885237, 2885397, 2885408, 2885412, 2885536, 2885657, + 2885672, 2885679, 2885732, 2885734, 2885760, 2885800, 2885908, 2886242, 2886446, 2886946, + 2887835, 2888523, 2890158, 2890425, 2890473, 2890504, 2891014, 2891122, 2891258, 2891524, + 2891621, 2891643, 2891832, 2891834, 2891951, 2892080, 2892518, 2892786, 2892794, 2892874, + 2892980, 2893264, 2893437, 2893438, 2893544, 2894003, 2894375, 2894553, 2894637, 2895044, + 2895569, 2895664, 2895669, 2895992, 2896514, 2896538, 2896546, 2896736, 2896753, 2896817, + 2897132, 2897216, 2897436, 2897674, 2898079, 2898098, 2898111, 2898304, 2898321, 2898364, + 2898603, 2899101, 2899449, 2899538, 2899601, 2899676, 2901420, 2901588, 2902533, 2902559, + 2902768, 2902852, 2903175, 2904725, 2904789, 2904795, 2904808, 2904886, 2904985, 2904992, + 2905206, 2905290, 2905455, 2905457, 2905560, 2905826, 2905891, 2906121, 2906152, 2906199, + 2906268, 2906331, 2906376, 2906530, 2906595, 2906676, 2907201, 2907545, 2907585, 2907669, + 2907851, 2907887, 2907911, 2908032, 2908495, 2909230, 2909240, 2909313, 2910278, 2910514, + 2910685, 2910831, 2911007, 2911051, 2911240, 2911271, 2911285, 2911287, 2911293, 2911296, + 2911298, 2911384, 2911395, 2911408, 2911520, 2911522, 2911584, 2911665, 2911964, 2912621, + 2913192, 2913195, 2913366, 2913433, 2913537, 2913555, 2913761, 2913922, 2914929, 2915196, + 2915613, 2916630, 2917138, 2917221, 2917325, 2917412, 2917540, 2917544, 2917737, 2917788, + 2917816, 2918632, 2918752, 2918840, 2918987, 2919054, 2919625, 2919880, 2920020, 2920236, + 2920329, 2920433, 2920478, 2920512, 2920620, 2920757, 2920834, 2920842, 2920891, 2921034, + 2921039, 2921061, 2921139, 2921232, 2921242, 2921466, 2921473, 2921528, 2921653, 2921837, + 2922102, 2922230, 2922530, 2922582, 2922586, 2922731, 2923362, 2923544, 2923588, 2923625, + 2923822, 2924206, 2924360, 2924585, 2924625, 2924802, 2924803, 2924894, 2924915, 2925017, + 2925034, 2925080, 2925177, 2925189, 2925192, 2925259, 2925533, 2925535, 2925550, 2925629, + 2925630, 2925832, 2925910, 2926120, 2926271, 2926670, 2926716, 2927043, 2927268, 2927930, + 2928381, 2928396, 2928615, 2928751, 2928810, 2928874, 2928963, 2928967, 2929134, 2929247, + 2929567, 2929600, 2929622, 2929670, 2929671, 2929715, 2929831, 2929865, 2930030, 2930043, + 2930182, 2930216, 2930449, 2930509, 2930523, 2930596, 2930646, 2930778, 2930821, 2930889, + 2931361, 2931414, 2931481, 2931574, 2931804, 2931871, 2932924, 2933101, 2933364, 2933627, + 2933882, 2933959, 2934020, 2934246, 2934486, 2934662, 2934691, 2934728, 2935022, 2935042, + 2935220, 2935517, 2935530, 2935825, 2936253, 2936267, 2936658, 2936705, 2936871, 2936909, + 2936974, 2936977, 2936985, 2937040, 2937317, 2937591, 2937936, 2937959, 2938323, 2938376, + 2938389, 2938540, 2938784, 2938913, 2939167, 2939623, 2939658, 2939747, 2939797, 2939811, + 2939820, 2939945, 2939951, 2939969, 2939995, 2940132, 2940204, 2940213, 2940231, 2940383, + 2940451, 2940512, 2940938, 2940942, 2941279, 2941405, 2941501, 2941570, 2941694, 2941976, + 2942073, 2942159, 2942323, 2942634, 2943320, 2943336, 2943408, 2943560, 2943573, 2944079, + 2944200, 2944354, 2944368, 2944388, 2945024, 2945358, 2945474, 2945542, 2945545, 2945591, + 2945756, 2946111, 2946172, 2946228, 2946366, 2946447, 2946478, 2947416, 2947421, 2947444, + 2947449, 2947641, 2947739, 2948071, 2948164, 2948825, 2949012, 2949186, 2949423, 2949470, + 2949475, 2950073, 2950096, 2950159, 2950294, 2950344, 2950349, 2950438, 2950978, 2951111, + 2951648, 2951654, 2951679, 2951825, 2951881, 2951923, 2952252, 2952984, 2953089, 2953197, + 2953269, 2953302, 2953310, 2953317, 2953320, 2953321, 2953324, 2953339, 2953341, 2953347, + 2953357, 2953358, 2953363, 2953371, 2953374, 2953379, 2953385, 2953386, 2953389, 2953391, + 2953395, 2953398, 2953400, 2953402, 2953405, 2953413, 2953416, 2953424, 2953435, 2953436, + 2953439, 2953449, 2953464, 2953504, 2953522, 2953525, 2953545, 2953552, 2953558, 2953568, + 2953770, 2954006, 2954172, 2954602, 2954695, 2954932, 2955168, 2955224, 2955272, 2955421, + 2955439, 2955471, 2955770, 2955936, 2956005, 2956093, 2956206, 2956656, 2956710, 2956715, + 2957773, 2957886, 2958024, 2958128, 2958141, 2958516, 2958533, 2958595, 2958975, 2959083, + 2959223, 2959279, 2959681, 2959686, 2959927, 2960316, 2960596, 2960634, 2960964, 2960992, + 2961123, 2961284, 2961297, 2961423, 2962290, 2962308, 2962334, 2962361, 2962943, 2962961, + 2962974, 2963398, 2964180, 2964405, 2964506, 2964540, 2964574, 2964661, 2965140, 2965353, + 2965529, 2965768, 2966022, 2966131, 2966839, 2967245, 2967318, 2967421, 2967438, 2967758, + 2967849, 2967856, 2967870, 2967879, 2967917, 2967934, 2968054, 2968142, 2968176, 2968254, + 2968368, 2968482, 2968496, 2968515, 2968529, 2968546, 2968555, 2968620, 2968653, 2968705, + 2968748, 2968771, 2969109, 2969257, 2969284, 2969392, 2969562, 2969612, 2969679, 2969692, + 2969766, 2969796, 2969958, 2970072, 2970110, 2970148, 2970203, 2970432, 2970456, 2970777, + 2970797, 2970962, 2971041, 2971053, 2971482, 2971549, 2971874, 2972049, 2972191, 2972237, + 2972270, 2972284, 2972315, 2972328, 2972350, 2972444, 2972742, 2972811, 2972893, 2973146, + 2973258, 2973317, 2973385, 2973495, 2973675, 2973745, 2973783, 2973841, 2974153, 2974188, + 2974385, 2974389, 2974427, 2974494, 2974655, 2974678, 2974681, 2974733, 2975050, 2975088, + 2975233, 2975349, 2975446, 2975469, 2975525, 2975536, 2975758, 2975921, 2975964, 2976043, + 2976050, 2976179, 2976258, 2976341, 2976406, 2976984, 2977246, 2977295, 2977356, 2977388, + 2977491, 2977800, 2977824, 2977845, 2977921, 2977952, 2978072, 2978100, 2978179, 2978317, + 2978621, 2978640, 2978742, 2978758, 2978768, 2978771, 2978891, 2979316, 2979341, 2979590, + 2979627, 2979783, 2979985, 2980097, 2980236, 2980291, 2980340, 2980558, 2980586, 2980636, + 2980816, 2980827, 2980916, 2980935, 2980942, 2981041, 2981206, 2981280, 2981492, 2981512, + 2981839, 2982235, 2982343, 2982652, 2982681, 2982757, 2982944, 2982967, 2983011, 2983026, + 2983074, 2983154, 2983276, 2983362, 2983440, 2983489, 2983536, 2983770, 2983990, 2984114, + 2984513, 2984701, 2985034, 2986025, 2986140, 2986160, 2986302, 2986306, 2986495, 2986501, + 2986732, 2986930, 2986933, 2987271, 2987805, 2987825, 2987914, 2987967, 2988358, 2988507, + 2988621, 2988670, 2988758, 2988867, 2988888, 2988936, 2988998, 2989130, 2989170, 2989204, + 2989297, 2989317, 2989460, 2989611, 2989755, 2989877, 2990187, 2990189, 2990192, 2990264, + 2990265, 2990355, 2990363, 2990440, 2990474, 2990611, 2990612, 2990616, 2990919, 2990969, + 2990970, 2990999, 2991153, 2991214, 2991481, 2991551, 2991719, 2991772, 2992003, 2992017, + 2992090, 2992166, 2992229, 2992292, 2992367, 2992402, 2992404, 2992415, 2992536, 2992616, + 2992650, 2992671, 2992703, 2992741, 2992771, 2992863, 2992890, 2992938, 2993002, 2993024, + 2993207, 2993458, 2993572, 2993679, 2993760, 2993875, 2994048, 2994087, 2994144, 2994160, + 2994393, 2994497, 2994651, 2994798, 2994935, 2995041, 2995121, 2995150, 2995206, 2995387, + 2995469, 2995642, 2995652, 2995750, 2995908, 2996146, 2996148, 2996180, 2996255, 2996514, + 2996564, 2996568, 2996882, 2996944, 2997110, 2997116, 2997246, 2997336, 2997395, 2997556, + 2997577, 2997620, 2997626, 2997712, 2997803, 2997904, 2998056, 2998127, 2998150, 2998224, + 2998286, 2998305, 2998311, 2998324, 2998431, 2998517, 2998632, 2998854, 2998975, 2999683, + 3000047, 3000060, 3000192, 3000491, 3000648, 3001402, 3002465, 3002570, 3002647, 3002650, + 3002880, 3002965, 3002984, 3003093, 3003481, 3003603, 3003737, 3003796, 3003952, 3004427, + 3004630, 3004871, 3005066, 3005269, 3005417, 3005825, 3005866, 3006121, 3006283, 3006414, + 3006767, 3006787, 3007477, 3007609, 3007794, 3007874, 3008218, 3008379, 3009071, 3009223, + 3009443, 3009791, 3009824, 3010025, 3010237, 3010529, 3012162, 3012219, 3012313, 3012621, + 3012647, 3012649, 3012664, 3012829, 3012834, 3012937, 3013097, 3013403, 3013477, 3013525, + 3013549, 3013619, 3013627, 3013681, 3013701, 3013862, 3014034, 3014078, 3014143, 3014175, + 3014383, 3014392, 3014646, 3014728, 3014856, 3015160, 3015419, 3015490, 3015689, 3015902, + 3016078, 3016097, 3016292, 3016321, 3016621, 3016667, 3016675, 3016702, 3016830, 3016956, + 3017178, 3017253, 3017341, 3017609, 3017651, 3017805, 3017910, 3017921, 3017924, 3018074, + 3018095, 3018246, 3018280, 3018339, 3018455, 3018794, 3019153, 3019193, 3019256, 3019265, + 3019459, 3019766, 3019897, 3019952, 3019960, 3020020, 3020035, 3020062, 3020307, 3020310, + 3020392, 3020495, 3020601, 3020686, 3020810, 3020832, 3020839, 3020850, 3020996, 3021000, + 3021150, 3021263, 3021372, 3021382, 3021411, 3021516, 3021605, 3021662, 3021670, 3021852, + 3022151, 3022376, 3022530, 3022569, 3022610, 3022700, 3022988, 3023141, 3023240, 3023324, + 3023356, 3023645, 3023763, 3023924, 3024035, 3024066, 3024107, 3024195, 3024223, 3024266, + 3024297, 3024440, 3024532, 3024596, 3024597, 3024635, 3024783, 3025053, 3025055, 3025144, + 3025314, 3025466, 3025496, 3025509, 3025622, 3025715, 3025892, 3026033, 3026083, 3026108, + 3026141, 3026194, 3026204, 3026285, 3026467, 3026613, 3026637, 3027014, 3027105, 3027422, + 3027453, 3027484, 3027487, 3027513, 3027763, 3027767, 3027883, 3027950, 3028097, 3028133, + 3028134, 3028263, 3028337, 3028486, 3028521, 3028535, 3028542, 3028641, 3028779, 3028808, + 3029030, 3029096, 3029162, 3029213, 3029227, 3029241, 3029276, 3029706, 3029748, 3029825, + 3029931, 3029974, 3030057, 3030101, 3030257, 3030300, 3030303, 3030960, 3030985, 3031005, + 3031009, 3031133, 3031137, 3031268, 3031582, 3031709, 3031815, 3031898, 3032179, 3032213, + 3032340, 3032469, 3032551, 3032797, 3032824, 3032833, 3033002, 3033123, 3033391, 3033415, + 3033416, 3033791, 3033881, 3034006, 3034126, 3034475, 3034483, 3034640, 3034911, 3035204, + 3035396, 3035403, 3035409, 3035654, 3035667, 3035681, 3035843, 3035883, 3036016, 3036145, + 3036240, 3036281, 3036386, 3036433, 3036460, 3036572, 3036784, 3036903, 3036938, 3037044, + 3037051, 3037423, 3037456, 3037514, 3037538, 3037540, 3037543, 3037598, 3037612, 3037656, + 3037854, 3038159, 3038213, 3038224, 3038230, 3038261, 3038266, 3038334, 3038350, 3038354, + 3038634, 3038638, 3038712, 3038789, 3041563, 3041732, 3042030, 3042091, 3042237, 3042287, + 3042638, 3042929, 3043019, 3043095, 3043293, 3044082, 3044083, 3044141, 3044310, 3044475, + 3044681, 3044760, 3044774, 3044821, 3045190, 3045332, 3045487, 3045643, 3046526, 3046619, + 3046686, 3046768, 3046888, 3047651, 3047679, 3047896, 3047942, 3047967, 3049512, 3049519, + 3049880, 3049885, 3049896, 3050212, 3050434, 3050616, 3050719, 3050907, 3051621, 3052009, + 3052040, 3052101, 3052236, 3052241, 3052542, 3053163, 3053281, 3053438, 3053476, 3053485, + 3053590, 3053836, 3054543, 3054643, 3054646, 3055601, 3055685, 3056357, 3056459, 3056495, + 3056508, 3056523, 3057124, 3057140, 3057630, 3057691, 3057769, 3057789, 3057963, 3058000, + 3058060, 3058202, 3058210, 3058268, 3058472, 3058477, 3058531, 3058780, 3058897, 3058986, + 3059050, 3059101, 3059179, 3059436, 3060095, 3060139, 3060219, 3060308, 3060346, 3060405, + 3060589, 3060835, 3060950, 3060972, 3061186, 3061188, 3061284, 3061344, 3061369, 3061370, + 3061692, 3061695, 3061822, 3062283, 3062339, 3063375, 3063447, 3063546, 3063548, 3063736, + 3063739, 3063907, 3064000, 3064104, 3064288, 3064379, 3064454, 3064673, 3065067, 3065281, + 3065617, 3065903, 3066651, 3067051, 3067421, 3067433, 3067542, 3067580, 3067696, 3068160, + 3068293, 3068445, 3068582, 3068689, 3068690, 3068766, 3068799, 3068873, 3068927, 3069011, + 3069305, 3069844, 3070122, 3070291, 3070420, 3070544, 3070862, 3071507, 3071665, 3071677, + 3071961, 3071966, 3072137, 3072463, 3072649, 3072656, 3072929, 3073254, 3073371, 3073660, + 3073668, 3073699, 3073789, 3073803, 3074020, 3074110, 3074149, 3074199, 3074204, 3074603, + 3074893, 3074967, 3075654, 3075919, 3075921, 3076127, 3077244, 3077539, 3077685, 3077835, + 3077916, 3077920, 3077929, 3078545, 3078610, 3078773, 3078833, 3078837, 3079129, 3079273, + 3079348, 3079467, 3079508, 3079855, 3080004, 3080071, 3080074, 3080165, 3080231, 3080251, + 3080414, 3080526, 3080644, 3080866, 3080944, 3080985, 3081046, 3081324, 3081368, 3081677, + 3081741, 3082197, 3082473, 3082704, 3082707, 3082712, 3082722, 3082751, 3082756, 3082914, + 3082998, 3083111, 3083185, 3083271, 3083426, 3083440, 3083826, 3083829, 3083878, 3083955, + 3083988, 3084062, 3084074, 3084084, 3084085, 3084093, 3084130, 3084241, 3084415, 3084440, + 3084826, 3084840, 3085045, 3085056, 3085128, 3085151, 3085172, 3085450, 3085807, 3085941, + 3085978, 3086024, 3086511, 3086531, 3086586, 3086706, 3086800, 3087281, 3087307, 3087418, + 3087497, 3087529, 3087584, 3087628, 3087705, 3088034, 3088065, 3088171, 3088435, 3088461, + 3088825, 3088848, 3088972, 3089033, 3089125, 3089578, 3089582, 3089658, 3089684, 3089779, + 3089965, 3090048, 3090146, 3090170, 3090205, 3090403, 3090433, 3090436, 3090452, 3090558, + 3090764, 3090768, 3091141, 3091150, 3091217, 3091232, 3091256, 3091831, 3091969, 3092472, + 3092856, 3092906, 3092931, 3093040, 3093066, 3093133, 3093457, 3093524, 3093692, 3093708, + 3093726, 3093739, 3093785, 3093902, 3094086, 3094170, 3094625, 3094788, 3094802, 3095049, + 3095057, 3095126, 3095151, 3095277, 3095321, 3095795, 3095797, 3095971, 3096003, 3096053, + 3096328, 3096372, 3096472, 3096525, 3096779, 3096880, 3097257, 3097333, 3097367, 3097391, + 3097528, 3097872, 3097902, 3098130, 3098200, 3098201, 3098218, 3098619, 3098625, 3098722, + 3098966, 3099112, 3099169, 3099180, 3099213, 3099230, 3099424, 3099434, 3099654, 3099759, + 3099828, 3100796, 3100946, 3100974, 3101057, 3101076, 3101321, 3101547, 3101613, 3101619, + 3101672, 3101680, 3101787, 3101795, 3101943, 3101950, 3102014, 3102459, 3102627, 3102677, + 3102987, 3103034, 3103096, 3103365, 3103402, 3103476, 3103556, 3103709, 3103719, 3104115, + 3104132, 3104316, 3104324, 3104342, 3104475, 3104499, 3104584, 3104703, 3105148, 3105184, + 3105214, 3105247, 3105522, 3105575, 3105600, 3105803, 3105805, 3105935, 3105976, 3106050, + 3106180, 3106492, 3106672, 3106868, 3107112, 3107139, 3107364, 3107418, 3107677, 3107765, + 3107775, 3107784, 3107807, 3107955, 3108008, 3108126, 3108165, 3108285, 3108286, 3108288, + 3108317, 3108681, 3108877, 3109041, 3109050, 3109256, 3109402, 3109442, 3109453, 3109481, + 3109546, 3109642, 3109689, 3109718, 3109804, 3109981, 3110040, 3110044, 3110101, 3110143, + 3110360, 3110458, 3110516, 3110519, 3110610, 3110627, 3110642, 3110643, 3110718, 3110813, + 3110821, 3110834, 3110880, 3110885, 3110921, 3110962, 3110983, 3110986, 3111108, 3111199, + 3111294, 3111348, 3111605, 3111807, 3111933, 3112011, 3112154, 3112761, 3112866, 3112989, + 3113035, 3113082, 3113157, 3113209, 3113236, 3113268, 3113331, 3113415, 3113526, 3114256, + 3114267, 3114472, 3114531, 3114566, 3114567, 3114711, 3114957, 3114965, 3115093, 3115171, + 3115177, 3115463, 3115659, 3115739, 3115907, 3116025, 3116224, 3116262, 3116478, 3116503, + 3116527, 3116553, 3116562, 3116653, 3116689, 3116789, 3116963, 3117010, 3117164, 3117232, + 3117331, 3117409, 3117533, 3117539, 3117636, 3117667, 3117735, 3117814, 3118150, 3118212, + 3118228, 3118514, 3118532, 3118554, 3118594, 3118848, 3119027, 3119231, 3119536, 3119631, + 3119746, 3119841, 3120304, 3120410, 3120431, 3120501, 3120514, 3120619, 3120811, 3120989, + 3121007, 3121070, 3121145, 3121424, 3121437, 3121456, 3121751, 3121766, 3121881, 3121960, + 3122452, 3122453, 3122826, 3122912, 3123063, 3123104, 3123329, 3123493, 3123667, 3123688, + 3123709, 3123773, 3124041, 3124132, 3124408, 3124432, 3124569, 3124765, 3124794, 3124967, + 3125082, 3125621, 3125723, 3125897, 3125915, 3126317, 3126369, 3126534, 3126577, 3126888, + 3126890, 3126917, 3127007, 3127035, 3127047, 3127065, 3127066, 3127451, 3127461, 3127889, + 3127958, 3127978, 3128026, 3128174, 3128201, 3128272, 3128273, 3128291, 3128382, 3128760, + 3128795, 3128824, 3128885, 3128978, 3129028, 3129046, 3129135, 3129136, 3129329, 3129636, + 3129857, 3129877, 3130131, 3130137, 3130155, 3130380, 3130383, 3130564, 3130583, 3130606, + 3130616, 3133880, 3133895, 3134331, 3136947, 3137115, 3139075, 3140084, 3140321, 3140390, + 3142657, 3143244, 3145375, 3145580, 3145614, 3147474, 3148129, 3149312, 3149318, 3149563, + 3151770, 3153623, 3153823, 3154084, 3154209, 3155573, 3156529, 3159016, 3160881, 3161732, + 3162955, 3163392, 3163853, 3163995, 3164028, 3164039, 3164083, 3164090, 3164153, 3164241, + 3164318, 3164342, 3164376, 3164407, 3164419, 3164433, 3164440, 3164527, 3164528, 3164565, + 3164582, 3164603, 3164617, 3164630, 3164672, 3164699, 3164919, 3164920, 3164954, 3165035, + 3165052, 3165072, 3165178, 3165185, 3165198, 3165201, 3165207, 3165243, 3165275, 3165322, + 3165340, 3165370, 3165435, 3165456, 3165475, 3165524, 3165595, 3165612, 3165624, 3165698, + 3165737, 3165762, 3165771, 3165773, 3165788, 3165803, 3165919, 3165926, 3166006, 3166034, + 3166224, 3166235, 3166236, 3166350, 3166387, 3166397, 3166404, 3166409, 3166540, 3166548, + 3166571, 3166576, 3166595, 3166598, 3166601, 3166614, 3166706, 3166711, 3166740, 3166753, + 3166766, 3166808, 3166866, 3166917, 3166988, 3166989, 3167010, 3167022, 3167034, 3167044, + 3167053, 3167096, 3167104, 3167113, 3167116, 3167184, 3167327, 3167333, 3167373, 3167393, + 3167419, 3167509, 3167561, 3167731, 3167736, 3167751, 3167777, 3167811, 3167940, 3167954, + 3167978, 3168070, 3168075, 3168175, 3168209, 3168221, 3168222, 3168231, 3168234, 3168236, + 3168239, 3168295, 3168309, 3168414, 3168429, 3168498, 3168514, 3168550, 3168599, 3168609, + 3168627, 3168673, 3168730, 3168764, 3168770, 3168775, 3168837, 3168843, 3168854, 3168931, + 3168936, 3169056, 3169070, 3169231, 3169262, 3169361, 3169412, 3169424, 3169447, 3169522, + 3169540, 3169561, 3169602, 3169713, 3169724, 3169742, 3169921, 3169984, 3170027, 3170069, + 3170072, 3170073, 3170086, 3170102, 3170116, 3170147, 3170272, 3170317, 3170335, 3170341, + 3170342, 3170382, 3170384, 3170457, 3170504, 3170621, 3170622, 3170647, 3170657, 3170659, + 3170674, 3170676, 3170694, 3170778, 3170937, 3171058, 3171148, 3171155, 3171168, 3171173, + 3171180, 3171214, 3171355, 3171366, 3171457, 3171484, 3171562, 3171586, 3171606, 3171664, + 3171703, 3171710, 3171728, 3171737, 3171778, 3171786, 3171848, 3171874, 3171886, 3171900, + 3171961, 3171986, 3172023, 3172087, 3172116, 3172154, 3172170, 3172184, 3172189, 3172191, + 3172227, 3172228, 3172240, 3172243, 3172244, 3172269, 3172287, 3172297, 3172338, 3172377, + 3172379, 3172394, 3172472, 3172479, 3172499, 3172629, 3172681, 3172718, 3172730, 3172768, + 3172828, 3172979, 3172996, 3173029, 3173122, 3173124, 3173131, 3173153, 3173160, 3173162, + 3173180, 3173287, 3173302, 3173314, 3173326, 3173331, 3173369, 3173370, 3173385, 3173391, + 3173435, 3173529, 3173537, 3173560, 3173577, 3173582, 3173599, 3173614, 3173615, 3173631, + 3173671, 3173721, 3173754, 3173762, 3173775, 3173841, 3173852, 3173870, 3173914, 3173935, + 3173945, 3173949, 3173995, 3174021, 3174032, 3174051, 3174092, 3174096, 3174141, 3174254, + 3174295, 3174358, 3174380, 3174494, 3174526, 3174530, 3174638, 3174659, 3174679, 3174719, + 3174741, 3174921, 3174922, 3174945, 3174953, 3175058, 3175061, 3175074, 3175081, 3175121, + 3175173, 3175235, 3175238, 3175298, 3175384, 3175445, 3175453, 3175458, 3175532, 3175537, + 3175627, 3175628, 3175678, 3175687, 3175722, 3175755, 3175773, 3175775, 3175786, 3175860, + 3175952, 3175986, 3175990, 3176041, 3176053, 3176059, 3176072, 3176090, 3176097, 3176177, + 3176203, 3176219, 3176322, 3176366, 3176391, 3176406, 3176407, 3176438, 3176504, 3176515, + 3176560, 3176561, 3176589, 3176603, 3176605, 3176639, 3176733, 3176738, 3176746, 3176843, + 3176849, 3176854, 3176885, 3176923, 3176959, 3176970, 3176983, 3177009, 3177029, 3177090, + 3177099, 3177102, 3177120, 3177171, 3177219, 3177250, 3177300, 3177315, 3177337, 3177363, + 3177372, 3177400, 3177438, 3177532, 3177608, 3177610, 3177650, 3177664, 3177700, 3177838, + 3177841, 3177924, 3177948, 3178004, 3178019, 3178074, 3178087, 3178112, 3178117, 3178131, + 3178137, 3178141, 3178147, 3178197, 3178229, 3178245, 3178283, 3178349, 3178388, 3178398, + 3178402, 3178587, 3178595, 3178619, 3178622, 3178631, 3178650, 3178671, 3178738, 3178745, + 3178784, 3178796, 3178818, 3178832, 3178850, 3178956, 3178957, 3178972, 3178998, 3178999, + 3179024, 3179066, 3179075, 3179106, 3179109, 3179162, 3179218, 3179235, 3179243, 3179294, + 3179337, 3179347, 3179415, 3179443, 3179479, 3179560, 3179655, 3179656, 3179661, 3179684, + 3179686, 3179696, 3179697, 3179781, 3179795, 3179806, 3179866, 3179911, 3179977, 3180133, + 3180172, 3180208, 3180224, 3180240, 3180423, 3180445, 3180496, 3180541, 3180581, 3180601, + 3180733, 3180746, 3180758, 3180792, 3180991, 3181018, 3181066, 3181125, 3181199, 3181258, + 3181355, 3181359, 3181443, 3181471, 3181495, 3181528, 3181548, 3181550, 3181554, 3181628, + 3181631, 3181683, 3181754, 3181790, 3181891, 3181913, 3181928, 3181931, 3181995, 3182007, + 3182043, 3182164, 3182179, 3182210, 3182245, 3182272, 3182289, 3182297, 3182337, 3182340, + 3182351, 3182361, 3182518, 3182522, 3182552, 3182599, 3182636, 3182640, 3182650, 3182714, + 3182722, 3182749, 3182757, 3182765, 3182851, 3182854, 3182878, 3182884, 3182886, 3182897, + 3182904, 3182957, 3182997, 3183005, 3183063, 3183072, 3183089, 3183098, 3183178, 3183187, + 3183284, 3183299, 3183316, 3183319, 3183343, 3183356, 3183364, 3183365, 3183412, 3183455, + 3183466, 3183472, 3183490, 3183494, 3183541, 3183573, 3183587, 3183719, 3183875, 3184081, + 3184517, 3184862, 3184935, 3185012, 3185060, 3185082, 3185211, 3185670, 3185728, 3186084, + 3186573, 3186781, 3186952, 3187047, 3187297, 3187609, 3187694, 3187719, 3188225, 3188244, + 3188383, 3188402, 3188434, 3188582, 3188893, 3188915, 3188924, 3189075, 3189595, 3190103, + 3190261, 3190342, 3190359, 3190586, 3190589, 3190813, 3190941, 3190966, 3191281, 3191316, + 3191376, 3191429, 3191648, 3192224, 3192241, 3192409, 3193044, 3193935, 3194351, 3194360, + 3194494, 3194828, 3195506, 3196359, 3197378, 3197728, 3197753, 3198259, 3199744, 3199779, + 3200396, 3201047, 3201984, 3202641, 3202781, 3202822, 3202888, 3203099, 3203521, 3203653, + 3203982, 3204186, 3204222, 3204541, 3204672, 3204674, 3204793, 3206590, 3207197, 3207384, + 3207567, 3209083, 3209584, 3219114, 3247449, 3272460, 3272941, 3274966, 3323063, 3336587, + 3336891, 3336892, 3336893, 3337476, 3337504, 3345317, 3345432, 3345437, 3345439, 3345440, + 3346015, 3347019, 3347353, 3347719, 3347762, 3347853, 3347939, 3348078, 3348313, 3350246, + 3350372, 3351014, 3351024, 3351500, 3351663, 3352136, 3352844, 3353383, 3353540, 3353811, + 3354021, 3354898, 3355672, 3356264, 3357114, 3357247, 3359041, 3359638, 3361025, 3361934, + 3363613, 3364346, 3366880, 3367513, 3369129, 3369157, 3370352, 3370903, 3372783, 3374036, + 3374218, 3374333, 3374462, 3376762, 3377408, 3378644, 3380387, 3380892, 3380965, 3381303, + 3382160, 3383330, 3383714, 3384986, 3384987, 3385022, 3385077, 3385088, 3385106, 3385109, + 3385122, 3385467, 3385504, 3385538, 3385592, 3385742, 3385745, 3385922, 3385935, 3385980, + 3386042, 3386177, 3386264, 3386279, 3386361, 3386372, 3386396, 3386449, 3386496, 3386567, + 3386931, 3387082, 3387115, 3387202, 3387204, 3387266, 3387296, 3387604, 3387663, 3387786, + 3387926, 3387987, 3388145, 3388269, 3388270, 3388318, 3388341, 3388368, 3388376, 3388435, + 3388441, 3388443, 3388615, 3388714, 3388847, 3388868, 3388991, 3389006, 3389321, 3389353, + 3389358, 3389361, 3389384, 3389557, 3389609, 3389622, 3389652, 3389673, 3389822, 3389860, + 3390160, 3390288, 3390295, 3390326, 3390760, 3390901, 3390907, 3391220, 3391360, 3391397, + 3391412, 3391556, 3391571, 3391908, 3391991, 3392054, 3392088, 3392126, 3392167, 3392242, + 3392243, 3392251, 3392345, 3392368, 3392431, 3392629, 3392734, 3392740, 3392887, 3392998, + 3393001, 3393008, 3393017, 3393091, 3393106, 3393115, 3393264, 3393400, 3393409, 3393452, + 3393465, 3393471, 3393536, 3393764, 3393768, 3393832, 3393876, 3393972, 3394023, 3394116, + 3394453, 3394500, 3394549, 3394605, 3394649, 3394661, 3394682, 3394745, 3395062, 3395077, + 3395380, 3395395, 3395458, 3395473, 3395503, 3395717, 3395981, 3395998, 3396016, 3396048, + 3396266, 3396277, 3396364, 3396496, 3396601, 3396769, 3397147, 3397230, 3397277, 3397315, + 3397665, 3397675, 3397838, 3397851, 3397893, 3397898, 3397904, 3397909, 3397936, 3397941, + 3397967, 3397969, 3398003, 3398076, 3398105, 3398112, 3398115, 3398269, 3398331, 3398343, + 3398350, 3398352, 3398379, 3398450, 3398569, 3398570, 3398614, 3398691, 3398706, 3398856, + 3398904, 3398920, 3399058, 3399132, 3399415, 3399506, 3399518, 3400558, 3400567, 3400617, + 3400740, 3400752, 3400804, 3400969, 3401106, 3401109, 3401138, 3401148, 3401283, 3401340, + 3401545, 3401548, 3401703, 3401830, 3401845, 3401963, 3401992, 3402000, 3402229, 3402271, + 3402360, 3402429, 3402465, 3402528, 3402591, 3402613, 3402655, 3402721, 3402724, 3403127, + 3403208, 3403353, 3403362, 3403534, 3403566, 3403611, 3403642, 3403687, 3403697, 3403941, + 3404020, 3404117, 3404513, 3404545, 3404558, 3404722, 3404766, 3404817, 3404833, 3404862, + 3405006, 3405380, 3405616, 3405738, 3405792, 3405812, 3405863, 3405870, 3405924, 3405940, + 3405954, 3406160, 3406196, 3406263, 3406318, 3406429, 3406442, 3406545, 3406910, 3406961, + 3406996, 3407194, 3407216, 3407243, 3407258, 3407327, 3407357, 3407378, 3407407, 3407440, + 3407669, 3407758, 3407797, 3407882, 3407903, 3407980, 3408100, 3408166, 3408175, 3408274, + 3408337, 3408343, 3408368, 3408404, 3408424, 3413829, 3415212, 3416706, 3421319, 3424934, + 3426466, 3426691, 3427213, 3427388, 3427428, 3427431, 3427761, 3427833, 3428068, 3428071, + 3428359, 3428577, 3428708, 3428759, 3428975, 3429403, 3429576, 3429577, 3429594, 3429652, + 3429732, 3429777, 3429786, 3429790, 3429886, 3429902, 3429949, 3430104, 3430340, 3430443, + 3430545, 3430598, 3430601, 3430708, 3430709, 3430863, 3430988, 3432043, 3432079, 3433349, + 3433658, 3433663, 3433715, 3433753, 3433803, 3433836, 3433899, 3433901, 3433956, 3434095, + 3434291, 3435038, 3435103, 3435217, 3435261, 3435264, 3435356, 3435486, 3435810, 3435910, + 3436124, 3436199, 3436230, 3436287, 3436714, 3436728, 3437056, 3437127, 3437444, 3437526, + 3437665, 3437842, 3437863, 3437918, 3437954, 3438115, 3438735, 3438819, 3438834, 3438995, + 3439214, 3439317, 3439320, 3439389, 3439525, 3439749, 3439781, 3440034, 3440571, 3440639, + 3440696, 3440714, 3440777, 3440781, 3440963, 3441243, 3441292, 3441354, 3441575, 3441665, + 3441684, 3441702, 3441894, 3442057, 3442098, 3442568, 3442585, 3442727, 3442750, 3442778, + 3443013, 3443341, 3443413, 3443758, 3444823, 3444848, 3444864, 3444866, 3444876, 3444914, + 3444924, 3444969, 3444997, 3445014, 3445026, 3445126, 3445133, 3445153, 3445156, 3445162, + 3445299, 3445307, 3445348, 3445350, 3445418, 3445433, 3445446, 3445451, 3445459, 3445487, + 3445500, 3445575, 3445578, 3445596, 3445597, 3445630, 3445679, 3445690, 3445713, 3445746, + 3445764, 3445781, 3445782, 3445831, 3445839, 3445847, 3445849, 3445853, 3445859, 3445939, + 3445941, 3445942, 3445983, 3445993, 3446038, 3446065, 3446077, 3446087, 3446098, 3446130, + 3446137, 3446138, 3446194, 3446232, 3446295, 3446370, 3446400, 3446445, 3446465, 3446500, + 3446539, 3446556, 3446606, 3446621, 3446625, 3446652, 3446682, 3446692, 3446752, 3446753, + 3446783, 3446847, 3446866, 3446880, 3446974, 3446979, 3447005, 3447059, 3447186, 3447212, + 3447259, 3447399, 3447423, 3447437, 3447473, 3447562, 3447591, 3447597, 3447624, 3447651, + 3447690, 3447718, 3447720, 3447779, 3447785, 3447839, 3447854, 3447928, 3447929, 3447961, + 3447969, 3447997, 3447998, 3448011, 3448031, 3448063, 3448136, 3448207, 3448219, 3448221, + 3448227, 3448257, 3448300, 3448351, 3448403, 3448439, 3448453, 3448455, 3448502, 3448519, + 3448533, 3448545, 3448552, 3448558, 3448596, 3448616, 3448622, 3448632, 3448636, 3448639, + 3448640, 3448742, 3448825, 3448828, 3448846, 3448877, 3448879, 3448902, 3448903, 3449045, + 3449053, 3449056, 3449099, 3449112, 3449116, 3449176, 3449195, 3449310, 3449319, 3449324, + 3449340, 3449344, 3449350, 3449427, 3449433, 3449467, 3449500, 3449516, 3449518, 3449519, + 3449521, 3449529, 3449696, 3449701, 3449707, 3449711, 3449720, 3449741, 3449747, 3449793, + 3449822, 3449847, 3449851, 3449933, 3449936, 3449948, 3450063, 3450083, 3450144, 3450157, + 3450188, 3450206, 3450225, 3450232, 3450269, 3450272, 3450283, 3450288, 3450376, 3450404, + 3450554, 3450563, 3450594, 3450671, 3450759, 3450832, 3450843, 3450873, 3450909, 3450963, + 3450964, 3451051, 3451071, 3451102, 3451124, 3451134, 3451138, 3451152, 3451190, 3451202, + 3451205, 3451234, 3451241, 3451242, 3451261, 3451328, 3451329, 3451353, 3451357, 3451383, + 3451474, 3451650, 3451668, 3451704, 3451709, 3451856, 3451931, 3452073, 3452141, 3452179, + 3452216, 3452233, 3452237, 3452320, 3452324, 3452331, 3452440, 3452465, 3452483, 3452525, + 3452599, 3452623, 3452640, 3452775, 3452779, 3452925, 3452982, 3453014, 3453060, 3453078, + 3453150, 3453171, 3453186, 3453240, 3453242, 3453245, 3453303, 3453315, 3453337, 3453406, + 3453420, 3453435, 3453439, 3453457, 3453467, 3453478, 3453494, 3453503, 3453535, 3453542, + 3453546, 3453605, 3453610, 3453622, 3453635, 3453639, 3453643, 3453659, 3453661, 3453767, + 3453777, 3453807, 3453827, 3453837, 3453896, 3453926, 3454031, 3454061, 3454131, 3454139, + 3454213, 3454231, 3454235, 3454244, 3454358, 3454407, 3454578, 3454620, 3454690, 3454763, + 3454783, 3454818, 3454827, 3454847, 3454857, 3454954, 3455036, 3455051, 3455061, 3455065, + 3455070, 3455141, 3455152, 3455155, 3455161, 3455168, 3455170, 3455281, 3455298, 3455342, + 3455416, 3455425, 3455459, 3455478, 3455553, 3455580, 3455671, 3455689, 3455729, 3455756, + 3455769, 3455775, 3455784, 3455785, 3455908, 3455923, 3456060, 3456068, 3456102, 3456110, + 3456125, 3456127, 3456137, 3456138, 3456147, 3456160, 3456164, 3456166, 3456176, 3456223, + 3456240, 3456283, 3456285, 3456290, 3456322, 3456324, 3456366, 3456368, 3456370, 3456398, + 3456412, 3456483, 3456500, 3456593, 3456696, 3456724, 3456735, 3456814, 3456816, 3456827, + 3456848, 3456863, 3456866, 3456873, 3456944, 3456998, 3457000, 3457001, 3457025, 3457107, + 3457133, 3457147, 3457191, 3457192, 3457247, 3457359, 3457360, 3457381, 3457393, 3457484, + 3457509, 3457528, 3457566, 3457595, 3457671, 3457692, 3457708, 3457736, 3457741, 3457772, + 3457817, 3457819, 3457850, 3457854, 3457859, 3457950, 3457952, 3457991, 3458049, 3458131, + 3458132, 3458147, 3458211, 3458245, 3458266, 3458329, 3458397, 3458406, 3458425, 3458449, + 3458479, 3458481, 3458494, 3458498, 3458575, 3458632, 3458645, 3458662, 3458696, 3458746, + 3458778, 3458786, 3458826, 3458902, 3458930, 3459035, 3459094, 3459126, 3459138, 3459251, + 3459342, 3459352, 3459462, 3459495, 3459505, 3459550, 3459667, 3459712, 3459785, 3459796, + 3459869, 3459922, 3459925, 3459943, 3460005, 3460064, 3460068, 3460071, 3460087, 3460102, + 3460107, 3460132, 3460148, 3460170, 3460172, 3460174, 3460186, 3460200, 3460214, 3460225, + 3460232, 3460242, 3460267, 3460344, 3460355, 3460362, 3460370, 3460441, 3460484, 3460511, + 3460513, 3460516, 3460522, 3460523, 3460530, 3460535, 3460542, 3460584, 3460594, 3460598, + 3460620, 3460629, 3460644, 3460648, 3460671, 3460699, 3460718, 3460723, 3460728, 3460730, + 3460733, 3460734, 3460738, 3460740, 3460748, 3460752, 3460764, 3460773, 3460774, 3460791, + 3460813, 3460825, 3460826, 3460831, 3460834, 3460845, 3460887, 3460899, 3460949, 3460950, + 3460954, 3460960, 3460963, 3460966, 3460971, 3460974, 3461013, 3461017, 3461055, 3461090, + 3461124, 3461129, 3461134, 3461144, 3461151, 3461153, 3461194, 3461311, 3461316, 3461368, + 3461370, 3461408, 3461411, 3461425, 3461444, 3461465, 3461481, 3461498, 3461499, 3461501, + 3461519, 3461525, 3461528, 3461550, 3461563, 3461565, 3461576, 3461588, 3461606, 3461620, + 3461625, 3461628, 3461638, 3461655, 3461680, 3461724, 3461763, 3461786, 3461789, 3461824, + 3461857, 3461859, 3461871, 3461874, 3461879, 3461888, 3461910, 3461914, 3461935, 3461941, + 3461949, 3461958, 3461973, 3461995, 3462022, 3462089, 3462315, 3462371, 3462374, 3462376, + 3462377, 3462378, 3462535, 3462557, 3462580, 3462601, 3462916, 3462956, 3462964, 3462980, + 3462996, 3463011, 3463030, 3463066, 3463140, 3463174, 3463237, 3463271, 3463422, 3463432, + 3463478, 3463605, 3463698, 3463762, 3463859, 3463865, 3463900, 3463920, 3463939, 3464008, + 3464073, 3464100, 3464255, 3464274, 3464304, 3464305, 3464329, 3464374, 3464460, 3464547, + 3464579, 3464618, 3464688, 3464724, 3464728, 3464739, 3464809, 3464891, 3464974, 3464975, + 3465038, 3465059, 3465083, 3465090, 3465105, 3465108, 3465164, 3465196, 3465209, 3465228, + 3465284, 3465320, 3465329, 3465342, 3465459, 3465476, 3465487, 3465512, 3465524, 3465527, + 3465624, 3465644, 3465671, 3465713, 3465721, 3465731, 3465748, 3465758, 3465764, 3465767, + 3465769, 3465881, 3465927, 3465944, 3466041, 3466062, 3466171, 3466174, 3466261, 3466296, + 3466429, 3466436, 3466481, 3466537, 3466547, 3466641, 3466692, 3466696, 3466698, 3466704, + 3466723, 3466750, 3466763, 3466779, 3466824, 3466902, 3466903, 3466933, 3466978, 3466988, + 3466998, 3467012, 3467026, 3467081, 3467197, 3467261, 3467272, 3467305, 3467319, 3467362, + 3467371, 3467452, 3467467, 3467512, 3467530, 3467542, 3467550, 3467577, 3467673, 3467677, + 3467680, 3467684, 3467687, 3467693, 3467717, 3467736, 3467747, 3467760, 3467796, 3467865, + 3467877, 3467956, 3467978, 3467985, 3468014, 3468023, 3468031, 3468100, 3468121, 3468157, + 3468158, 3468215, 3468317, 3468327, 3468376, 3468403, 3468425, 3468436, 3468535, 3468560, + 3468562, 3468570, 3468592, 3468615, 3468704, 3468720, 3468732, 3468802, 3468858, 3468879, + 3468893, 3468894, 3468899, 3468902, 3469058, 3469092, 3469115, 3469136, 3469425, 3469437, + 3469516, 3469540, 3469601, 3469932, 3469968, 3469984, 3469989, 3470003, 3470044, 3470052, + 3470073, 3470117, 3470127, 3470142, 3470177, 3470264, 3470279, 3470324, 3470341, 3470353, + 3470369, 3470428, 3470451, 3470470, 3470583, 3470597, 3470636, 3470674, 3470691, 3470709, + 3470718, 3470730, 3470776, 3470821, 3470825, 3470858, 3470878, 3470912, 3471005, 3471039, + 3471061, 3471196, 3471291, 3471335, 3471368, 3471374, 3471393, 3471395, 3471422, 3471428, + 3471451, 3471487, 3471683, 3471691, 3471697, 3471715, 3471758, 3471766, 3471772, 3471798, + 3471830, 3471840, 3471846, 3471848, 3471849, 3471854, 3471859, 3471872, 3471896, 3471910, + 3471927, 3471940, 3471949, 3472048, 3472138, 3472177, 3472248, 3472254, 3472284, 3472287, + 3472311, 3472338, 3472343, 3472370, 3472417, 3472518, 3472520, 3472603, 3472609, 3472638, + 3472666, 3472766, 3472808, 3472825, 3472848, 3472869, 3472969, 3473157, 3473267, 3473964, + 3474574, 3480908, 3483197, 3486270, 3487903, 3488465, 3488981, 3489227, 3489297, 3489460, + 3489523, 3489577, 3489760, 3489854, 3490165, 3491948, 3491952, 3492517, 3492908, 3492914, + 3492984, 3492985, 3493032, 3493081, 3493100, 3493146, 3493174, 3493175, 3493240, 3493383, + 3493482, 3494121, 3494242, 3495857, 3496021, 3496134, 3496331, 3496831, 3500370, 3500957, + 3504158, 3504765, 3505855, 3508952, 3509207, 3509363, 3509382, 3511233, 3511540, 3511626, + 3512067, 3512128, 3512208, 3513090, 3513392, 3513966, 3513967, 3514134, 3514148, 3514163, + 3514321, 3514398, 3514409, 3514437, 3514450, 3514510, 3514518, 3514519, 3514663, 3514670, + 3514674, 3514683, 3514783, 3514785, 3514868, 3514876, 3514929, 3515001, 3515011, 3515042, + 3515044, 3515062, 3515064, 3515302, 3515358, 3515373, 3515384, 3515386, 3515428, 3515431, + 3515463, 3515504, 3515505, 3515510, 3515665, 3515679, 3515690, 3515696, 3515715, 3515794, + 3515796, 3515807, 3515811, 3515827, 3515887, 3515904, 3515906, 3515942, 3515956, 3515993, + 3516006, 3516035, 3516053, 3516060, 3516076, 3516109, 3516188, 3516210, 3516225, 3516266, + 3516271, 3516355, 3516385, 3516843, 3516912, 3516926, 3516982, 3517231, 3517293, 3517517, + 3517524, 3517742, 3517831, 3517832, 3518135, 3518138, 3518221, 3518277, 3518387, 3518407, + 3518475, 3518618, 3518692, 3518723, 3519290, 3519531, 3519537, 3519907, 3520064, 3520235, + 3520271, 3520274, 3520339, 3520994, 3521051, 3521081, 3521103, 3521108, 3521168, 3521342, + 3521476, 3521596, 3521628, 3521912, 3521922, 3521941, 3522118, 3522164, 3522210, 3522232, + 3522251, 3522307, 3522343, 3522444, 3522445, 3522484, 3522507, 3522551, 3522696, 3522732, + 3522790, 3522804, 3522845, 3522924, 3522926, 3523011, 3523061, 3523127, 3523141, 3523149, + 3523183, 3523202, 3523240, 3523303, 3523349, 3523450, 3523466, 3523513, 3523590, 3523760, + 3523791, 3523900, 3523908, 3524348, 3524389, 3524391, 3524744, 3524903, 3525158, 3525596, + 3526323, 3526357, 3526467, 3526485, 3526603, 3526617, 3526657, 3526674, 3526681, 3526682, + 3526683, 3526696, 3526700, 3526708, 3526798, 3526838, 3526855, 3526864, 3526908, 3526952, + 3526953, 3526992, 3526993, 3527023, 3527545, 3527596, 3527639, 3527795, 3527879, 3527880, + 3528756, 3529612, 3529886, 3529947, 3529981, 3529982, 3529986, 3529989, 3530049, 3530103, + 3530123, 3530139, 3530167, 3530177, 3530240, 3530276, 3530367, 3530385, 3530513, 3530517, + 3530531, 3530569, 3530580, 3530582, 3530584, 3530587, 3530589, 3530590, 3530592, 3530594, + 3530596, 3530597, 3530599, 3530617, 3530757, 3530870, 3530886, 3530908, 3530932, 3530937, + 3530978, 3531013, 3531023, 3531177, 3531200, 3531321, 3531416, 3531556, 3531574, 3531576, + 3531598, 3531673, 3531732, 3531784, 3531865, 3532254, 3532414, 3532497, 3532545, 3532592, + 3532617, 3532624, 3532792, 3532815, 3532881, 3532899, 3532964, 3532969, 3532989, 3533005, + 3533056, 3533107, 3533126, 3533269, 3533389, 3533426, 3533433, 3533440, 3533462, 3533486, + 3533753, 3533826, 3534094, 3534363, 3534432, 3534632, 3534761, 3534915, 3536259, 3536640, + 3536724, 3536729, 3537840, 3537845, 3537906, 3539093, 3539560, 3540667, 3540680, 3540885, + 3541440, 3541446, 3541999, 3542137, 3542167, 3542455, 3542744, 3543299, 3543498, 3543961, + 3544091, 3544393, 3544607, 3545040, 3545064, 3545841, 3545867, 3545981, 3546434, 3546791, + 3546894, 3547260, 3547398, 3547600, 3547867, 3547976, 3548529, 3548993, 3550598, 3551608, + 3553478, 3555907, 3556077, 3556168, 3556334, 3556351, 3556437, 3556969, 3557332, 3557347, + 3557378, 3557689, 3557758, 3557801, 3557923, 3558315, 3558744, 3558771, 3559318, 3559416, + 3562827, 3562895, 3563145, 3563317, 3563504, 3563559, 3563609, 3563843, 3563856, 3564114, + 3564124, 3564178, 3564394, 3565432, 3565951, 3566054, 3566067, 3566134, 3566356, 3566603, + 3567546, 3567597, 3567612, 3567823, 3567834, 3567869, 3567995, 3568312, 3569136, 3569370, + 3569546, 3569741, 3569915, 3569926, 3570166, 3570412, 3570428, 3570429, 3570446, 3570675, + 3570785, 3571824, 3571971, 3572375, 3573197, 3573374, 3573576, 3573703, 3573732, 3573738, + 3573890, 3573899, 3574116, 3574194, 3574810, 3575051, 3575551, 3575635, 3576022, 3576812, + 3576994, 3577154, 3577277, 3577284, 3577430, 3577887, 3578069, 3578447, 3578466, 3578599, + 3578682, 3578851, 3578959, 3578967, 3578978, 3579132, 3579585, 3579732, 3579767, 3579925, + 3580661, 3581194, 3581514, 3582672, 3582677, 3582805, 3582883, 3583096, 3583098, 3583102, + 3583158, 3583178, 3583199, 3583334, 3583361, 3583379, 3583446, 3583471, 3583480, 3583747, + 3583981, 3584003, 3584257, 3584384, 3584399, 3584772, 3585157, 3585473, 3585484, 3586814, + 3586833, 3586977, 3587086, 3587091, 3587345, 3587362, 3587426, 3587428, 3587498, 3587587, + 3587902, 3587923, 3588258, 3588476, 3588653, 3588698, 3589101, 3589105, 3589253, 3589289, + 3589404, 3589452, 3589626, 3589646, 3589671, 3589805, 3589852, 3589885, 3589977, 3590219, + 3590316, 3590389, 3590406, 3590529, 3590858, 3590979, 3591060, 3591062, 3591093, 3591181, + 3591415, 3591512, 3591523, 3591676, 3591833, 3591851, 3591997, 3592105, 3592237, 3592286, + 3592362, 3592483, 3592519, 3592609, 3594575, 3594703, 3595069, 3595171, 3595237, 3595248, + 3595416, 3595560, 3595714, 3595725, 3595783, 3595803, 3596041, 3596644, 3597078, 3597804, + 3598025, 3598034, 3598073, 3598119, 3598122, 3598128, 3598132, 3598415, 3598465, 3598529, + 3598572, 3598655, 3598678, 3599069, 3599582, 3599639, 3599699, 3599735, 3599788, 3600026, + 3600195, 3600327, 3600704, 3600931, 3600949, 3601311, 3601494, 3601691, 3601782, 3601977, + 3603330, 3604251, 3607254, 3607511, 3608248, 3608503, 3610613, 3610965, 3612907, 3613321, + 3613394, 3613528, 3613533, 3616035, 3616232, 3616234, 3616253, 3616594, 3616682, 3617052, + 3617069, 3617095, 3617154, 3617448, 3617459, 3617513, 3617522, 3617708, 3617723, 3617725, + 3617763, 3618030, 3618411, 3618908, 3618926, 3618929, 3618954, 3619136, 3619194, 3619267, + 3619853, 3620170, 3620269, 3620381, 3620390, 3620544, 3620674, 3620680, 3621184, 3621335, + 3621440, 3621505, 3621659, 3621687, 3621689, 3621717, 3621729, 3621753, 3621804, 3621819, + 3621841, 3621849, 3621889, 3621911, 3621922, 3621926, 3622190, 3622217, 3622228, 3622247, + 3622507, 3622547, 3622716, 3622881, 3623076, 3623394, 3623486, 3623580, 3623781, 3623977, + 3624174, 3624288, 3624370, 3624468, 3624509, 3624848, 3624955, 3625066, 3625207, 3625341, + 3625346, 3625515, 3625542, 3625549, 3625710, 3625829, 3625929, 3625979, 3626219, 3626402, + 3627047, 3627186, 3627968, 3628053, 3628060, 3628142, 3628267, 3628423, 3628473, 3628489, + 3628503, 3628549, 3628550, 3628952, 3628966, 3629419, 3629576, 3629614, 3629672, 3629706, + 3629710, 3629965, 3630297, 3630932, 3631412, 3631507, 3631741, 3631878, 3632308, 3632929, + 3632998, 3633009, 3633341, 3633444, 3633677, 3634184, 3634922, 3635325, 3637623, 3637721, + 3639107, 3639725, 3639747, 3639898, 3640049, 3640226, 3640465, 3641099, 3641275, 3641351, + 3642833, 3643031, 3644417, 3644768, 3644918, 3645213, 3645528, 3645532, 3645671, 3645854, + 3645981, 3646062, 3646169, 3646190, 3646382, 3646451, 3646487, 3646738, 3646767, 3646869, + 3647444, 3647549, 3647651, 3648439, 3648522, 3648540, 3648559, 3649017, 3649408, 3649833, + 3649959, 3650121, 3650186, 3650267, 3650273, 3650721, 3650960, 3651297, 3651356, 3651438, + 3651694, 3651868, 3652065, 3652100, 3652257, 3652350, 3652462, 3652567, 3652584, 3652684, + 3652881, 3652941, 3653015, 3653130, 3653287, 3653295, 3653403, 3653693, 3653873, 3653882, + 3654055, 3654064, 3654410, 3654533, 3654536, 3654541, 3654667, 3654853, 3654870, 3655117, + 3655131, 3655185, 3655446, 3655673, 3655720, 3657509, 3657571, 3657670, 3658053, 3658192, + 3658666, 3659139, 3659578, 3659599, 3659711, 3659926, 3660152, 3660361, 3660401, 3660418, + 3660434, 3660478, 3660689, 3661944, 3661980, 3662075, 3662155, 3662342, 3662574, 3662762, + 3663517, 3663529, 3664078, 3664207, 3664321, 3664539, 3664659, 3664980, 3665199, 3665202, + 3665542, 3665559, 3665566, 3665657, 3665688, 3665741, 3665851, 3665895, 3665900, 3665913, + 3665934, 3665951, 3665973, 3666304, 3666395, 3666519, 3666570, 3666577, 3666582, 3666608, + 3666640, 3666645, 3666939, 3667158, 3667478, 3667728, 3667820, 3667849, 3667873, 3667887, + 3667905, 3667983, 3667991, 3668087, 3668132, 3668175, 3668323, 3668332, 3668454, 3668572, + 3668605, 3668655, 3669218, 3669332, 3669346, 3669454, 3669469, 3669736, 3669808, 3669997, + 3669998, 3670038, 3670218, 3670280, 3670370, 3670419, 3670475, 3670502, 3670513, 3670644, + 3670719, 3670730, 3670745, 3670874, 3671098, 3671116, 3671315, 3671325, 3671418, 3671497, + 3671531, 3671540, 3671549, 3671772, 3671916, 3672068, 3672093, 3672110, 3672328, 3672486, + 3672761, 3672778, 3673045, 3673164, 3673220, 3673398, 3673424, 3673662, 3673899, 3674292, + 3674412, 3674453, 3674463, 3674470, 3674597, 3674654, 3674885, 3674962, 3675252, 3675263, + 3675287, 3675409, 3675443, 3675595, 3675605, 3675657, 3675692, 3675707, 3675975, 3676397, + 3676604, 3676623, 3676626, 3676720, 3676928, 3676934, 3677010, 3678097, 3678405, 3678674, + 3679065, 3679277, 3679554, 3680387, 3680450, 3680539, 3680656, 3680840, 3681797, 3681957, + 3682018, 3682028, 3682108, 3682238, 3682274, 3682281, 3682292, 3682330, 3682374, 3682385, + 3682393, 3682426, 3682458, 3682516, 3682573, 3682631, 3683233, 3684452, 3684579, 3684615, + 3684666, 3684917, 3684945, 3685084, 3685095, 3685335, 3685533, 3685823, 3685871, 3685949, + 3686233, 3686272, 3686279, 3686479, 3686513, 3686540, 3686561, 3686585, 3686636, 3686675, + 3686793, 3686922, 3687025, 3687230, 3687238, 3687318, 3687644, 3687758, 3687806, 3687925, + 3687952, 3687964, 3688006, 3688071, 3688256, 3688451, 3688452, 3688465, 3688689, 3688928, + 3688989, 3689147, 3689162, 3689169, 3689205, 3689206, 3689235, 3689381, 3689560, 3689570, + 3689589, 3689718, 3689759, 3689798, 3689833, 3689899, 3689905, 3690316, 3690431, 3690465, + 3690577, 3690654, 3690875, 3691094, 3691148, 3691175, 3691324, 3691348, 3691530, 3691582, + 3691674, 3691954, 3692073, 3692310, 3692667, 3692863, 3693057, 3693345, 3693528, 3693584, + 3693645, 3694112, 3694119, 3694178, 3694564, 3694666, 3694725, 3694939, 3695466, 3695617, + 3695675, 3695754, 3696057, 3696150, 3696183, 3696378, 3696417, 3696509, 3696847, 3697033, + 3697990, 3698105, 3698176, 3698194, 3698304, 3698350, 3698390, 3698540, 3698658, 3699088, + 3699364, 3699484, 3700038, 3700164, 3700563, 3701117, 3701329, 3702431, 3703229, 3703443, + 3703647, 3703833, 3706567, 3707899, 3707961, 3708066, 3711668, 3712076, 3712384, 3712455, + 3712505, 3712560, 3712884, 3714637, 3714932, 3715042, 3716044, 3716667, 3717546, 3717588, + 3718426, 3718962, 3719028, 3720824, 3722124, 3722286, 3723440, 3723593, 3723779, 3723841, + 3724233, 3724337, 3724696, 3725276, 3726674, 3726786, 3727135, 3728097, 3728338, 3728474, + 3740016, 3746938, 3748726, 3762770, 3770718, 3778045, 3792044, 3792375, 3792376, 3792383, + 3792392, 3795152, 3802739, 3803449, 3803515, 3803651, 3804949, 3805673, 3814568, 3815324, + 3815392, 3815415, 3815447, 3815453, 3816721, 3816739, 3818398, 3827254, 3827256, 3827406, + 3827407, 3827408, 3827409, 3827414, 3827586, 3827588, 3827596, 3828262, 3828545, 3832132, + 3832260, 3832647, 3832653, 3832662, 3832694, 3832756, 3832778, 3832791, 3832811, 3832815, + 3832899, 3832934, 3833027, 3833062, 3833112, 3833367, 3833412, 3833794, 3833859, 3833883, + 3834502, 3834601, 3834813, 3834971, 3835793, 3835869, 3835994, 3836194, 3836277, 3836564, + 3836620, 3836669, 3836772, 3836846, 3836873, 3836951, 3836992, 3837056, 3837124, 3837213, + 3837240, 3837441, 3837675, 3837702, 3837980, 3838233, 3838506, 3838583, 3838793, 3838797, + 3838859, 3838874, 3838902, 3839307, 3839479, 3839490, 3839982, 3840092, 3840300, 3840860, + 3840885, 3841490, 3841500, 3841956, 3842190, 3842670, 3842881, 3843123, 3843619, 3843803, + 3844421, 3844899, 3845330, 3846864, 3846915, 3848687, 3848950, 3851331, 3852374, 3852468, + 3853354, 3853491, 3853510, 3854895, 3854985, 3855065, 3855074, 3855075, 3855116, 3855244, + 3855554, 3855666, 3855974, 3856022, 3856231, 3856235, 3858765, 3859384, 3859512, 3859552, + 3859828, 3859904, 3859965, 3860164, 3860217, 3860259, 3860443, 3861056, 3861061, 3861344, + 3861416, 3861445, 3861678, 3861953, 3862144, 3862240, 3862254, 3862320, 3862351, 3862655, + 3862738, 3862981, 3863379, 3864331, 3864375, 3865086, 3865385, 3865424, 3865840, 3866163, + 3866242, 3866367, 3866425, 3866496, 3868121, 3868158, 3868192, 3868326, 3868626, 3868633, + 3868707, 3869657, 3869716, 3870011, 3870282, 3870294, 3870306, 3871286, 3871336, 3871616, + 3872154, 3872255, 3872326, 3872348, 3872395, 3873145, 3873441, 3873775, 3874096, 3874119, + 3874787, 3874930, 3874943, 3874958, 3874960, 3874997, 3875024, 3875070, 3876664, 3876685, + 3877146, 3877348, 3877739, 3877918, 3877949, 3878456, 3879123, 3879200, 3879627, 3880107, + 3881102, 3881276, 3882428, 3882434, 3882582, 3883035, 3883167, 3883214, 3883457, 3883615, + 3883629, 3884373, 3885273, 3885456, 3885509, 3887127, 3887344, 3888214, 3888749, 3889263, + 3890949, 3892454, 3892870, 3892892, 3893532, 3893629, 3893656, 3893726, 3893894, 3894177, + 3894426, 3895061, 3895088, 3895138, 3896105, 3896218, 3896433, 3896924, 3897347, 3897557, + 3897774, 3899361, 3899462, 3899539, 3899629, 3899695, 3901178, 3901301, 3901501, 3901504, + 3901547, 3902202, 3902377, 3903320, 3903987, 3904666, 3904906, 3905658, 3905792, 3906466, + 3907080, 3907584, 3909234, 3910027, 3910291, 3911409, 3911925, 3914839, 3915350, 3918937, + 3919968, 3919998, 3922414, 3924679, 3924877, 3924908, 3924948, 3925040, 3925075, 3925212, + 3925476, 3925863, 3927758, 3927942, 3928128, 3928679, 3928924, 3928993, 3929295, 3929631, + 3929768, 3931276, 3931470, 3932145, 3933024, 3934239, 3934356, 3934608, 3934707, 3935288, + 3935572, 3936456, 3936952, 3937486, 3937513, 3937733, 3938396, 3938415, 3938451, 3938527, + 3939023, 3939168, 3939285, 3939386, 3939459, 3939470, 3940002, 3941584, 3943423, 3943789, + 3944179, 3944399, 3944797, 3945985, 3946083, 3946820, 3946985, 3947019, 3947322, 3947740, + 3948642, 3976775, 3976999, 3979505, 3979673, 3979717, 3979727, 3979770, 3979802, 3979822, + 3979844, 3979846, 3979855, 3979856, 3980174, 3980180, 3980190, 3980194, 3980605, 3980621, + 3980760, 3980777, 3980844, 3981254, 3981369, 3981461, 3981467, 3981609, 3981791, 3981885, + 3981941, 3981984, 3982007, 3982034, 3982121, 3982213, 3982266, 3982545, 3982567, 3982616, + 3982693, 3982887, 3982912, 3983058, 3983216, 3983636, 3983671, 3983820, 3984237, 3984583, + 3984791, 3985129, 3985241, 3985323, 3985327, 3985344, 3985604, 3985606, 3985620, 3985710, + 3985865, 3986088, 3986172, 3986984, 3987224, 3987246, 3987500, 3988025, 3988050, 3988086, + 3988214, 3988258, 3988327, 3988333, 3988392, 3988462, 3988594, 3988651, 3991043, 3991164, + 3991219, 3991328, 3991347, 3992619, 3992842, 3992986, 3993179, 3993335, 3993457, 3993893, + 3994469, 3994489, 3994604, 3994616, 3994667, 3994674, 3994912, 3995017, 3995050, 3995343, + 3995402, 3995465, 3995523, 3996069, 3996234, 3996271, 3996322, 3996387, 3996426, 3996595, + 3996626, 3996663, 3996737, 3996893, 3996956, 3997220, 3997479, 3998291, 3998655, 3999325, + 4000821, 4000900, 4001056, 4002224, 4003526, 4003662, 4003908, 4003923, 4003938, 4004024, + 4004092, 4004126, 4004153, 4004267, 4004293, 4004330, 4004555, 4004647, 4004867, 4004885, + 4004886, 4004887, 4004898, 4005143, 4005219, 4005270, 4005297, 4005492, 4005509, 4005539, + 4005775, 4005864, 4005867, 4005937, 4006163, 4006622, 4006702, 4006783, 4006806, 4007676, + 4007684, 4008303, 4009697, 4011743, 4012176, 4012406, 4012693, 4012721, 4013085, 4013094, + 4013516, 4013704, 4013706, 4013708, 4013712, 4013714, 4013720, 4013723, 4013724, 4013726, + 4013727, 4013728, 4014338, 4014553, 4014875, 4015022, 4015700, 4015938, 4016086, 4016132, + 4017957, 4017984, 4017992, 4018227, 4018320, 4018348, 4018390, 4018400, 4018403, 4018404, + 4018582, 4018761, 4018762, 4019233, 4019260, 4019819, 4019827, 4019869, 4023117, 4026075, + 4026082, 4030723, 4032402, 4033779, 4033936, 4034561, 4034821, 4035413, 4035715, 4036284, + 4038659, 4038794, 4043909, 4044012, 4046704, 4048023, 4048662, 4049979, 4054378, 4058219, + 4058553, 4059102, 4059870, 4060791, 4061234, 4062577, 4063619, 4066811, 4067927, 4067994, + 4068446, 4068590, 4074267, 4076598, 4076784, 4078646, 4080555, 4081644, 4081914, 4082569, + 4082866, 4084796, 4084888, 4089114, 4092788, 4093753, 4094163, 4094212, 4094455, 4095415, + 4101114, 4101115, 4101241, 4101260, 4102412, 4103448, 4103957, 4106458, 4109785, 4110486, + 4111382, 4111410, 4115412, 4116315, 4116834, 4119403, 4120792, 4124112, 4125388, 4126226, + 4128894, 4129397, 4130430, 4131116, 4132093, 4133367, 4134716, 4135865, 4140963, 4141363, + 4142290, 4143637, 4143861, 4145381, 4145941, 4146166, 4146429, 4146723, 4146901, 4146934, + 4147241, 4147290, 4148207, 4148399, 4148411, 4148533, 4148677, 4148708, 4148757, 4148803, + 4149077, 4149269, 4149962, 4150115, 4150118, 4150190, 4151157, 4151316, 4151352, 4151440, + 4151455, 4151824, 4151871, 4151909, 4151921, 4152064, 4152093, 4152311, 4152772, 4152820, + 4152872, 4152890, 4152926, 4153071, 4153132, 4153146, 4153471, 4153759, 4154008, 4154047, + 4154205, 4154280, 4154489, 4154568, 4154606, 4155017, 4155726, 4155966, 4155995, 4156018, + 4156042, 4156091, 4156331, 4156404, 4156857, 4156920, 4156931, 4157467, 4157827, 4157898, + 4158476, 4158482, 4158865, 4158928, 4159050, 4159553, 4159805, 4159896, 4160021, 4160023, + 4160100, 4160610, 4160705, 4160711, 4160812, 4160822, 4160983, 4161178, 4161313, 4161422, + 4161424, 4161438, 4161461, 4161534, 4161580, 4161616, 4161625, 4161771, 4161785, 4161797, + 4163033, 4163049, 4163220, 4163407, 4163918, 4163971, 4164092, 4164138, 4164143, 4164167, + 4164186, 4164601, 4165519, 4165565, 4165637, 4165913, 4166066, 4166195, 4166222, 4166232, + 4166233, 4166274, 4166583, 4166638, 4166673, 4166776, 4166805, 4167003, 4167147, 4167178, + 4167348, 4167424, 4167499, 4167519, 4167536, 4167538, 4167545, 4167583, 4167601, 4167634, + 4167694, 4167829, 4168139, 4168228, 4168459, 4168590, 4168630, 4168659, 4168773, 4168782, + 4168930, 4169014, 4169060, 4169130, 4169156, 4169171, 4169345, 4169452, 4169455, 4170005, + 4170156, 4170174, 4170358, 4170617, 4170688, 4170797, 4170965, 4171563, 4171782, 4171972, + 4172086, 4172131, 4172372, 4172434, 4173392, 4173497, 4173838, 4174201, 4174317, 4174383, + 4174402, 4174425, 4174715, 4174738, 4174744, 4174757, 4174855, 4174969, 4175091, 4175117, + 4175179, 4175296, 4175437, 4175538, 4176217, 4176318, 4176380, 4176409, 4177679, 4177703, + 4177727, 4177779, 4177865, 4177872, 4177887, 4177908, 4177960, 4177965, 4178003, 4178550, + 4178552, 4178560, 4178573, 4178775, 4179074, 4179320, 4179574, 4179667, 4180386, 4180439, + 4180531, 4181936, 4184845, 4185657, 4186213, 4186416, 4186531, 4188985, 4189213, 4190581, + 4191124, 4191955, 4192205, 4192289, 4192375, 4192674, 4193699, 4194474, 4195701, 4196586, + 4198322, 4200671, 4203696, 4204007, 4204230, 4205196, 4205885, 4207226, 4207400, 4207783, + 4207981, 4208442, 4209448, 4212684, 4212937, 4212992, 4212995, 4215110, 4216948, 4218165, + 4219001, 4219762, 4219934, 4220629, 4221333, 4221552, 4223379, 4223413, 4224413, 4224681, + 4225039, 4225309, 4226348, 4226552, 4227213, 4227777, 4228147, 4229476, 4231354, 4231874, + 4232679, 4233813, 4234969, 4235193, 4235668, 4236191, 4236895, 4237579, 4237717, 4238132, + 4239509, 4239714, 4241704, 4243899, 4244099, 4245152, 4245926, 4247703, 4250542, 4251841, + 4254679, 4255056, 4255466, 4255836, 4256038, 4257227, 4257494, 4258285, 4258313, 4259418, + 4259640, 4259671, 4260210, 4262045, 4262072, 4263108, 4263681, 4264617, 4264688, 4265737, + 4266307, 4270356, 4271086, 4271935, 4272340, 4272782, 4273299, 4273680, 4273837, 4274277, + 4274305, 4274317, 4274356, 4274994, 4276248, 4276614, 4276873, 4277241, 4277718, 4278890, + 4279247, 4280539, 4281730, 4282757, 4285268, 4286281, 4288809, 4289445, 4290988, 4291255, + 4291620, 4291945, 4292071, 4292188, 4292686, 4294494, 4294799, 4295251, 4295776, 4296218, + 4297983, 4297999, 4299276, 4299670, 4302035, 4302504, 4302529, 4302561, 4303012, 4303436, + 4304713, 4305504, 4305974, 4307238, 4308225, 4311963, 4313697, 4314550, 4315588, 4315768, + 4317639, 4319435, 4319518, 4323873, 4326575, 4326868, 4327047, 4328010, 4329753, 4330145, + 4330236, 4330525, 4332628, 4333190, 4333669, 4334720, 4334971, 4335045, 4336153, 4338012, + 4339348, 4341378, 4341513, 4341727, 4342816, 4343327, 4346991, 4347242, 4347371, 4347426, + 4347553, 4347778, 4347839, 4348353, 4348599, 4349159, 4350160, 4350288, 4350413, 4350635, + 4351383, 4351851, 4351871, 4351887, 4351977, 4352053, 4352539, 4352681, 4352728, 4353765, + 4353925, 4353962, 4354087, 4354163, 4354234, 4354256, 4354265, 4354428, 4354573, 4354821, + 4355355, 4355585, 4355843, 4356050, 4356165, 4356188, 4356783, 4356847, 4357141, 4358082, + 4358701, 4358821, 4358864, 4360201, 4360287, 4360314, 4360369, 4360954, 4361831, 4362344, + 4362438, 4362743, 4363836, 4363843, 4363990, 4364362, 4364537, 4364727, 4364759, 4364946, + 4364964, 4364990, 4365227, 4365387, 4366001, 4366476, 4366593, 4366647, 4367175, 4367372, + 4367419, 4367734, 4368711, 4369076, 4369190, 4369224, 4369596, 4369928, 4369964, 4369978, + 4370616, 4370890, 4371582, 4372599, 4373104, 4373238, 4373349, 4373449, 4374054, 4374513, + 4375087, 4375663, 4376482, 4377664, 4379966, 4381072, 4381478, 4381982, 4382072, 4382837, + 4385018, 4386289, 4386387, 4386802, 4387990, 4388460, 4389418, 4389967, 4391812, 4392388, + 4392768, 4393217, 4393739, 4394870, 4394905, 4395052, 4396915, 4397340, 4397962, 4400648, + 4401242, 4401618, 4402178, 4402245, 4404233, 4405180, 4405188, 4406282, 4406831, 4407010, + 4407066, 4407237, 4408000, 4408672, 4409591, 4409896, 4412697, 4413595, 4413872, 4414001, + 4414749, 4418478, 4419290, 4421935, 4422133, 4422442, 4427569, 4428475, 4428495, 4428667, + 4429295, 4430400, 4431410, 4433039, 4434663, 4435764, 4437982, 4439506, 4439869, 4440076, + 4440397, 4440559, 4443296, 4446675, 4447161, 4448903, 4449620, 4450687, 4452303, 4452808, + 4453035, 4453066, 4456703, 4458228, 4459343, 4459467, 4460162, 4460243, 4460943, 4461015, + 4461574, 4461941, 4464368, 4464873, 4465088, 4466033, 4467485, 4467657, 4467732, 4468261, + 4469146, 4469160, 4470244, 4470566, 4470778, 4471025, 4471641, 4471851, 4472370, 4472687, + 4473083, 4474040, 4474221, 4474436, 4475347, 4475640, 4475773, 4477525, 4478334, 4479759, + 4479946, 4480125, 4480219, 4480285, 4481682, 4487042, 4488232, 4488762, 4489985, 4490329, + 4491180, 4493316, 4494942, 4497290, 4498303, 4499379, 4499389, 4499612, 4500546, 4500942, + 4501018, 4501198, 4501931, 4502434, 4502687, 4502901, 4503078, 4503136, 4503346, 4503548, + 4503646, 4504225, 4504476, 4504621, 4504871, 4505542, 4506008, 4508204, 4508722, 4509177, + 4509884, 4511263, 4511283, 4512060, 4513409, 4513575, 4514746, 4515843, 4516233, 4516412, + 4517698, 4518188, 4518264, 4520760, 4521209, 4521816, 4522411, 4522586, 4525304, 4525353, + 4526576, 4526993, 4527124, 4528259, 4528291, 4528810, 4528923, 4529096, 4529292, 4529469, + 4529987, 4530372, 4530801, 4531405, 4533029, 4533580, 4534934, 4535389, 4535414, 4535740, + 4535783, 4535961, 4539615, 4540737, 4542367, 4542765, 4542975, 4543338, 4543352, 4543762, + 4544349, 4547407, 4548267, 4550659, 4550881, 4551177, 4552215, 4552707, 4553433, 4556165, + 4557109, 4557137, 4557606, 4558475, 4560349, 4561407, 4562144, 4562407, 4562506, 4562635, + 4562768, 4562831, 4563008, 4563122, 4563243, 4563298, 4563308, 4564946, 4565105, 4565119, + 4565564, 4566002, 4566137, 4566385, 4566880, 4568127, 4568451, 4568533, 4568917, 4569067, + 4569298, 4574324, 4575352, 4575461, 4577263, 4578737, 4580098, 4580543, 4580569, 4580599, + 4581023, 4581833, 4585000, 4586523, 4588165, 4588718, 4589368, 4589387, 4593142, 4593724, + 4595374, 4595864, 4596208, 4597200, 4597499, 4597919, 4597948, 4598353, 4599937, 4604183, + 4608408, 4608657, 4612862, 4613868, 4614088, 4614748, 4614867, 4615145, 4619800, 4619943, + 4619947, 4620131, 4621846, 4623560, 4624180, 4624601, 4625282, 4626334, 4628735, 4632595, + 4633419, 4634662, 4634946, 4635031, 4636045, 4639848, 4641239, 4642938, 4643336, 4644312, + 4644585, 4645421, 4646571, 4657077, 4658590, 4659446, 4659557, 4663494, 4669635, 4670074, + 4670146, 4670234, 4670300, 4670592, 4670866, 4671240, 4671524, 4671654, 4672059, 4672731, + 4672989, 4673094, 4673353, 4673425, 4673482, 4676206, 4676740, 4676798, 4676920, 4677008, + 4677551, 4678901, 4679195, 4679803, 4679867, 4680388, 4681462, 4681485, 4681976, 4682127, + 4682464, 4682478, 4682991, 4683021, 4683217, 4683244, 4683317, 4683416, 4683462, 4684724, + 4684888, 4685524, 4685737, 4685892, 4685907, 4686163, 4686593, 4687331, 4688275, 4689311, + 4689550, 4690198, 4691585, 4691930, 4692400, 4692521, 4692559, 4692746, 4692883, 4693003, + 4693150, 4693342, 4694482, 4694568, 4695066, 4695317, 4695912, 4696202, 4696233, 4697645, + 4699066, 4699442, 4699540, 4699575, 4700168, 4701458, 4702828, 4703078, 4703223, 4703384, + 4703811, 4704108, 4704628, 4705191, 4705349, 4705692, 4705708, 4706057, 4706736, 4707814, + 4708308, 4709013, 4709272, 4709796, 4710178, 4710749, 4710826, 4711156, 4711647, 4711725, + 4711729, 4711801, 4712933, 4713507, 4713735, 4713932, 4714131, 4714582, 4715292, 4716805, + 4717232, 4717560, 4717782, 4718097, 4718209, 4718711, 4718721, 4719457, 4720039, 4720131, + 4722625, 4723406, 4723914, 4724129, 4724194, 4724564, 4724642, 4726206, 4726290, 4726440, + 4726491, 4727326, 4727756, 4728328, 4733042, 4733313, 4733624, 4734005, 4734350, 4734825, + 4734909, 4735702, 4735966, 4736028, 4736096, 4736134, 4736388, 4736476, 4738214, 4738574, + 4738606, 4738721, 4739157, 4739526, 4740214, 4740328, 4740364, 4740629, 4741616, 4741752, + 4743275, 4744091, 4744468, 4744709, 4744870, 4745272, 4747845, 4748305, 4749627, 4749950, + 4751421, 4751839, 4751935, 4752031, 4752136, 4752186, 4752229, 4752665, 4753671, 4754966, + 4755158, 4755280, 4756955, 4758023, 4759968, 4760059, 4761951, 4762894, 4763231, 4763793, + 4764127, 4764826, 4765520, 4765553, 4766586, 4768351, 4768678, 4769125, 4769608, 4769667, + 4770714, 4771075, 4771401, 4772354, 4772566, 4772735, 4773677, 4776024, 4776222, 4776970, + 4778626, 4779999, 4780011, 4780837, 4781530, 4781708, 4782167, 4782864, 4784112, 4785576, + 4786667, 4786714, 4787117, 4787440, 4787534, 4788145, 4788158, 4790207, 4790534, 4791160, + 4791259, 4792522, 4792867, 4792901, 4794120, 4794350, 4794531, 4795467, 4798308, 4801859, + 4802316, 4805404, 4809537, 4813878, 4815352, 4817641, 4828193, 4828382, 4828890, 4829307, + 4829762, 4829791, 4830198, 4830668, 4830796, 4832038, 4832272, 4832294, 4832353, 4832425, + 4832554, 4833320, 4833403, 4833425, 4833505, 4834157, 4834272, 4835003, 4835512, 4835654, + 4835797, 4837278, 4837648, 4838116, 4838174, 4838204, 4838524, 4838633, 4838652, 4838887, + 4839222, 4839292, 4839366, 4839416, 4839497, 4839704, 4839745, 4839822, 4839843, 4840755, + 4840767, 4842818, 4842898, 4843353, 4843362, 4843564, 4843786, 4843811, 4844309, 4844459, + 4845056, 4845193, 4845411, 4845419, 4845519, 4845585, 4845612, 4845823, 4845898, 4845984, + 4846834, 4846960, 4848489, 4849826, 4850699, 4850751, 4852022, 4852052, 4852065, 4852640, + 4852832, 4853423, 4853828, 4854529, 4857486, 4862034, 4862760, 4866263, 4866371, 4866445, + 4868404, 4868907, 4870380, 4876523, 4879890, 4880889, 4881346, 4882920, 4883078, 4883207, + 4883555, 4883817, 4884141, 4884192, 4884434, 4884453, 4884509, 4884597, 4885156, 4885164, + 4885186, 4885265, 4885342, 4885418, 4885573, 4885689, 4885955, 4885983, 4886255, 4886662, + 4886676, 4886738, 4887158, 4887398, 4887442, 4888015, 4888892, 4889107, 4889229, 4889426, + 4889447, 4889553, 4889668, 4889772, 4889959, 4890009, 4890119, 4890536, 4890549, 4890864, + 4890925, 4891010, 4891051, 4891382, 4891431, 4893037, 4893070, 4893171, 4893392, 4893591, + 4893811, 4893886, 4894061, 4894465, 4894861, 4895066, 4895298, 4895876, 4896012, 4896075, + 4896336, 4896353, 4896691, 4898015, 4898182, 4898846, 4899012, 4899170, 4899184, 4899340, + 4899581, 4899739, 4900080, 4900292, 4900373, 4900579, 4900801, 4900817, 4901445, 4901514, + 4901663, 4901868, 4902475, 4902476, 4902559, 4902754, 4902763, 4903024, 4903184, 4903279, + 4903535, 4903730, 4903780, 4903818, 4903862, 4903976, 4904056, 4904286, 4904365, 4904381, + 4904937, 4904996, 4905006, 4905211, 4905263, 4905337, 4905367, 4905599, 4905687, 4906125, + 4906882, 4907907, 4907959, 4908052, 4908068, 4908173, 4908236, 4908237, 4908737, 4910713, + 4911418, 4911600, 4911893, 4911934, 4912499, 4912691, 4913110, 4913723, 4914570, 4914738, + 4914830, 4915545, 4915734, 4915963, 4916140, 4916207, 4916288, 4916311, 4916732, 4917089, + 4917123, 4917298, 4917358, 4917592, 4919381, 4919451, 4919820, 4919857, 4919987, 4920423, + 4920473, 4920607, 4920808, 4920869, 4920986, 4921100, 4921402, 4921476, 4921725, 4922388, + 4922459, 4922462, 4922673, 4922968, 4923210, 4923482, 4923531, 4923670, 4924006, 4924014, + 4924198, 4925006, 4926170, 4926563, 4927537, 4928096, 4928118, 4928662, 4928703, 4928788, + 4929004, 4929023, 4929180, 4929283, 4929399, 4929417, 4929771, 4930282, 4930505, 4930511, + 4930577, 4930956, 4931181, 4931429, 4931482, 4931737, 4931972, 4932214, 4932869, 4932879, + 4933002, 4933743, 4934500, 4934664, 4935038, 4935434, 4935582, 4935623, 4936008, 4936087, + 4936159, 4936812, 4937230, 4937232, 4937276, 4937557, 4937829, 4938048, 4938378, 4938836, + 4939085, 4939647, 4939783, 4940764, 4941720, 4941873, 4941935, 4942508, 4942618, 4942744, + 4942807, 4942939, 4943021, 4943097, 4943170, 4943629, 4943677, 4943828, 4943958, 4944193, + 4944994, 4945055, 4945121, 4945256, 4945283, 4945588, 4945819, 4945911, 4945952, 4946620, + 4946863, 4947459, 4948247, 4948403, 4948462, 4948924, 4950065, 4950267, 4950898, 4951248, + 4951257, 4951305, 4951397, 4951473, 4951594, 4951788, 4952121, 4952206, 4952320, 4952487, + 4952629, 4952762, 4954265, 4954380, 4954611, 4954738, 4955089, 4955190, 4955219, 4955336, + 4955840, 4955884, 4955993, 4956032, 4956184, 4956335, 4956976, 4957003, 4957280, 4958141, + 4959473, 4969398, 4975802, 4977222, 4979244, 4979245, 4982236, 4982720, 4982753, 4983811, + 4984016, 4984029, 4984247, 4984565, 4985153, 4985180, 4986172, 4987482, 4987990, 4989133, + 4990510, 4990512, 4990729, 4991640, 4991735, 4992523, 4992635, 4992982, 4993125, 4993659, + 4994358, 4994391, 4994871, 4995197, 4995514, 4995664, 4996248, 4996306, 4997384, 4997500, + 4997787, 4998018, 4998830, 4999311, 4999837, 5000500, 5000947, 5001929, 5002344, 5002656, + 5002714, 5003132, 5004005, 5004062, 5004188, 5004359, 5004792, 5006166, 5006233, 5006250, + 5006917, 5007402, 5007531, 5007655, 5007804, 5007989, 5009586, 5010636, 5010646, 5010978, + 5011148, 5011908, 5012521, 5012639, 5013924, 5014051, 5014130, 5014208, 5014224, 5014681, + 5015599, 5015618, 5015688, 5016024, 5016374, 5016450, 5016494, 5016884, 5018651, 5019330, + 5019335, 5019588, 5019767, 5020859, 5020881, 5020938, 5021828, 5022025, 5022134, 5023571, + 5024719, 5024825, 5025219, 5025264, 5025471, 5026291, 5026321, 5027117, 5027482, 5028163, + 5029181, 5029500, 5030005, 5030670, 5031412, 5034059, 5034767, 5036420, 5036493, 5036588, + 5037649, 5037784, 5037790, 5038108, 5039080, 5039094, 5039675, 5039978, 5040647, 5041926, + 5042373, 5042561, 5042773, 5043193, 5043473, 5043779, 5043799, 5044407, 5045021, 5045258, + 5045360, 5046001, 5046063, 5046997, 5047234, 5048033, 5048814, 5052361, 5052467, 5052658, + 5052916, 5053156, 5053358, 5055787, 5059163, 5059429, 5059836, 5062458, 5063805, 5066001, + 5068725, 5069297, 5069802, 5071348, 5071665, 5072006, 5073965, 5074472, 5074792, 5083221, + 5084868, 5085374, 5085382, 5085520, 5085688, 5088262, 5088438, 5089178, 5089478, 5090046, + 5091383, 5091872, 5092268, 5095281, 5095325, 5095445, 5095549, 5095611, 5095779, 5096316, + 5096686, 5096699, 5096798, 5097017, 5097315, 5097357, 5097402, 5097441, 5097529, 5097598, + 5097627, 5097672, 5097751, 5097773, 5098109, 5098135, 5098343, 5098706, 5098909, 5099093, + 5099133, 5099289, 5099292, 5099724, 5099738, 5099836, 5099967, 5100280, 5100506, 5100572, + 5100604, 5100619, 5100706, 5100748, 5100854, 5101334, 5101427, 5101717, 5101766, 5101798, + 5101873, 5101879, 5101938, 5102076, 5102162, 5102213, 5102369, 5102387, 5102427, 5102443, + 5102466, 5102578, 5102713, 5102720, 5102796, 5103055, 5103269, 5103500, 5103580, 5104404, + 5104405, 5104473, 5104504, 5104755, 5104835, 5104836, 5104844, 5104853, 5105127, 5105262, + 5105433, 5105496, 5105608, 5105634, 5106160, 5106279, 5106292, 5106298, 5106331, 5106453, + 5106529, 5106615, 5106834, 5107152, 5107505, 5107760, 5108093, 5108169, 5108219, 5108707, + 5108815, 5108955, 5109177, 5110077, 5110159, 5110302, 5110629, 5112035, 5112078, 5112375, + 5113142, 5113412, 5113481, 5113683, 5113694, 5113790, 5114731, 5114900, 5115107, 5115960, + 5115962, 5115985, 5115989, 5116004, 5116060, 5116119, 5116303, 5116497, 5116508, 5116937, + 5117438, 5117891, 5117949, 5118226, 5118626, 5118743, 5119347, 5120095, 5120228, 5120478, + 5120656, 5120987, 5121163, 5121636, 5121650, 5122331, 5122413, 5122432, 5122534, 5122794, + 5123247, 5123456, 5123477, 5123533, 5123718, 5123840, 5124276, 5124497, 5125011, 5125086, + 5125125, 5125523, 5125738, 5125771, 5126183, 5126208, 5126518, 5126555, 5126630, 5126842, + 5127134, 5127315, 5127835, 5128266, 5128481, 5128549, 5128581, 5128638, 5128654, 5128723, + 5128884, 5128886, 5128898, 5128904, 5129134, 5129245, 5129248, 5129603, 5130045, 5130081, + 5130780, 5130831, 5131638, 5131692, 5132002, 5132029, 5132143, 5134086, 5134203, 5134295, + 5134316, 5134323, 5134453, 5134693, 5136334, 5136421, 5136433, 5136454, 5137507, 5137600, + 5138022, 5138539, 5139301, 5140402, 5140405, 5141175, 5141502, 5141927, 5142056, 5142109, + 5143198, 5143396, 5143620, 5143630, 5143832, 5143866, 5143992, 5144040, 5144336, 5145028, + 5145215, 5145476, 5145607, 5146055, 5146089, 5146233, 5146256, 5146277, 5146282, 5146286, + 5146491, 5146675, 5147097, 5147784, 5147968, 5148273, 5148326, 5148480, 5149222, 5150529, + 5151613, 5151861, 5151891, 5152333, 5152599, 5152833, 5153207, 5153420, 5153680, 5153924, + 5155207, 5155393, 5155499, 5156371, 5157588, 5158164, 5159537, 5160315, 5160783, 5161262, + 5161723, 5161803, 5161902, 5162077, 5162097, 5162188, 5162512, 5162645, 5162851, 5163799, + 5164390, 5164466, 5164582, 5164706, 5164862, 5164903, 5164916, 5165101, 5165734, 5166009, + 5166177, 5166184, 5166516, 5166819, 5168491, 5170691, 5171728, 5172078, 5172387, 5172485, + 5173048, 5173171, 5173210, 5173237, 5173572, 5173623, 5173930, 5174035, 5174358, 5174550, + 5175496, 5175865, 5176472, 5176517, 5176937, 5177358, 5177568, 5178127, 5178155, 5178195, + 5178800, 5178940, 5180199, 5180225, 5183234, 5188140, 5188843, 5192726, 5193011, 5193309, + 5195561, 5196220, 5197079, 5197159, 5197517, 5197796, 5198034, 5200499, 5201734, 5202215, + 5202534, 5202765, 5203127, 5203506, 5205377, 5205849, 5206379, 5206606, 5207069, 5207490, + 5207728, 5211303, 5213681, 5216895, 5218802, 5219287, 5219488, 5219501, 5219585, 5219619, + 5220798, 5221077, 5221341, 5221637, 5221659, 5221703, 5221931, 5223358, 5223593, 5223672, + 5223681, 5223869, 5224082, 5224151, 5224949, 5225507, 5225627, 5225631, 5225809, 5225857, + 5226534, 5229794, 5231851, 5232741, 5234372, 5235024, 5240509, 5241248, 5244080, 5244267, + 5245193, 5245387, 5246835, 5247415, 5249871, 5250201, 5251436, 5253219, 5253352, 5253710, + 5254218, 5254962, 5255068, 5257029, 5257754, 5258296, 5258393, 5258957, 5261457, 5261585, + 5261969, 5262596, 5262630, 5262634, 5262649, 5262838, 5263045, 5264049, 5264223, 5264381, + 5264870, 5265228, 5265499, 5265702, 5265838, 5267403, 5268249, 5272893, 5273812, 5274644, + 5275020, 5275191, 5278005, 5278052, 5278120, 5278159, 5278420, 5278422, 5279436, 5280814, + 5280822, 5280854, 5281551, 5282804, 5282835, 5283054, 5283837, 5284756, 5287262, 5287565, + 5288636, 5288661, 5288786, 5289282, 5293083, 5293183, 5293996, 5294167, 5294810, 5294902, + 5294937, 5295143, 5295177, 5295903, 5295985, 5296802, 5301067, 5301388, 5303705, 5303752, + 5304391, 5306611, 5307540, 5308305, 5308480, 5308655, 5309842, 5309858, 5310193, 5311433, + 5312544, 5312913, 5313457, 5314328, 5316201, 5316205, 5316428, 5316890, 5317058, 5317071, + 5318313, 5322053, 5322400, 5322551, 5322553, 5322737, 5322850, 5323060, 5323163, 5323525, + 5323566, 5323694, 5323810, 5324105, 5324200, 5324363, 5324477, 5324802, 5324862, 5324903, + 5325011, 5325111, 5325187, 5325327, 5325372, 5325423, 5325738, 5325866, 5326032, 5326297, + 5326305, 5326561, 5326563, 5327098, 5327298, 5327319, 5327422, 5327455, 5327550, 5327684, + 5328041, 5329408, 5329649, 5330167, 5330567, 5330582, 5330642, 5331575, 5331835, 5331920, + 5332593, 5332698, 5333180, 5333282, 5333689, 5334223, 5334336, 5334519, 5334799, 5334928, + 5335006, 5335650, 5335663, 5336269, 5336537, 5336545, 5336667, 5336899, 5337561, 5337696, + 5337908, 5338122, 5338166, 5338683, 5338783, 5339066, 5339111, 5339539, 5339631, 5339663, + 5339840, 5340175, 5341051, 5341114, 5341145, 5341256, 5341430, 5341483, 5341531, 5341704, + 5342485, 5342710, 5342992, 5343171, 5343303, 5343858, 5344147, 5344157, 5344817, 5344942, + 5344994, 5345032, 5345529, 5345609, 5345623, 5345679, 5345743, 5345860, 5346111, 5346646, + 5346827, 5347287, 5347335, 5347578, 5349613, 5349705, 5349755, 5349803, 5350159, 5350207, + 5350734, 5350937, 5351247, 5351428, 5351515, 5351549, 5352214, 5352350, 5352423, 5352439, + 5352963, 5353530, 5354172, 5354819, 5355180, 5355828, 5355933, 5356277, 5356451, 5356521, + 5356576, 5356868, 5357499, 5357527, 5358705, 5358736, 5359054, 5359446, 5359488, 5359777, + 5359864, 5363859, 5363922, 5363943, 5363990, 5364007, 5364022, 5364059, 5364066, 5364079, + 5364134, 5364199, 5364226, 5364271, 5364275, 5364306, 5364329, 5364369, 5364499, 5364514, + 5364782, 5364855, 5364916, 5364940, 5365425, 5365603, 5365893, 5365918, 5365937, 5366375, + 5366531, 5367314, 5367440, 5367565, 5367696, 5367767, 5367788, 5367929, 5368335, 5368361, + 5368453, 5368518, 5369367, 5369568, 5370082, 5370164, 5370493, 5370868, 5371261, 5371858, + 5372205, 5372223, 5372253, 5373129, 5373327, 5373492, 5373763, 5373900, 5374175, 5374232, + 5374322, 5374361, 5374406, 5374648, 5374671, 5374732, 5374764, 5375480, 5375911, 5376095, + 5376200, 5376803, 5376890, 5377100, 5377199, 5377613, 5377640, 5377995, 5378044, 5378500, + 5378538, 5378566, 5378771, 5378870, 5379439, 5379513, 5379566, 5379609, 5379678, 5379759, + 5380184, 5380202, 5380420, 5380437, 5380626, 5380668, 5380698, 5380748, 5381002, 5381110, + 5381396, 5381438, 5381515, 5382146, 5382232, 5382496, 5383187, 5383465, 5383527, 5383720, + 5383777, 5384170, 5384339, 5384471, 5384690, 5385082, 5385793, 5385941, 5385955, 5386015, + 5386035, 5386053, 5386082, 5386754, 5386785, 5386834, 5386984, 5387288, 5387428, 5387494, + 5387687, 5387844, 5387877, 5388319, 5388564, 5388735, 5388867, 5388873, 5388881, 5389126, + 5389213, 5389489, 5391295, 5391710, 5391749, 5391760, 5391791, 5391811, 5391891, 5391945, + 5391959, 5392034, 5392090, 5392171, 5392229, 5392263, 5392281, 5392323, 5392368, 5392423, + 5392508, 5392528, 5392567, 5392593, 5392868, 5392900, 5392952, 5393015, 5393049, 5393052, + 5393128, 5393180, 5393212, 5393245, 5393287, 5393429, 5393485, 5394086, 5394136, 5394329, + 5394842, 5395244, 5396003, 5397018, 5397376, 5397603, 5397664, 5397717, 5397765, 5397777, + 5397841, 5397851, 5398277, 5398630, 5399020, 5399629, 5399901, 5400075, 5401395, 5401469, + 5402405, 5403022, 5403191, 5403676, 5403783, 5404024, 5404119, 5404122, 5404198, 5404476, + 5404554, 5404794, 5404915, 5405228, 5405326, 5405380, 5405878, 5406222, 5406421, 5406567, + 5406602, 5406976, 5406990, 5407529, 5407908, 5407933, 5408076, 5408191, 5408211, 5408406, + 5408431, 5409059, 5409260, 5409768, 5410004, 5410129, 5410430, 5410902, 5411015, 5411046, + 5411079, 5412199, 5412347, 5414941, 5415035, 5416005, 5416329, 5416357, 5416541, 5417041, + 5417258, 5417598, 5417657, 5417737, 5419384, 5420241, 5421250, 5422191, 5423294, 5423573, + 5425043, 5427207, 5427771, 5427946, 5429032, 5429522, 5431710, 5433124, 5434006, 5435464, + 5435477, 5438567, 5439752, 5441492, 5443910, 5443948, 5445298, 5445439, 5445820, 5454627, + 5454711, 5460459, 5462393, 5467328, 5468773, 5471578, 5475352, 5487811, 5488441, 5490263, + 5492450, 5500539, 5501344, 5503766, 5504003, 5505411, 5506956, 5508180, 5509403, 5509851, + 5509952, 5511077, 5512827, 5512862, 5512909, 5513307, 5513343, 5515110, 5515345, 5516233, + 5517061, 5520076, 5520677, 5520993, 5523074, 5523369, 5525577, 5526337, 5527554, 5527953, + 5528450, 5530022, 5530932, 5530937, 5533366, 5536630, 5546220, 5549222, 5550368, 5551498, + 5551535, 5552301, 5554072, 5558953, 5559320, 5563397, 5567770, 5570160, 5572400, 5574991, + 5576859, 5576909, 5577147, 5577592, 5579276, 5579368, 5583509, 5586437, 5587698, 5589173, + 5591778, 5596475, 5597955, 5598538, 5598542, 5600685, 5601538, 5601933, 5604045, 5604353, + 5605242, 5610810, 5640350, 5641727, 5642934, 5655240, 5656882, 5660340, 5666639, 5688025, + 5688789, 5690366, 5690532, 5697939, 5699404, 5703670, 5710756, 5711099, 5711149, 5711789, + 5713376, 5713587, 5713759, 5717758, 5718601, 5720495, 5720727, 5725846, 5727190, 5727382, + 5729080, 5729485, 5730675, 5731070, 5731371, 5734711, 5735238, 5735724, 5736218, 5736378, + 5739936, 5740099, 5740900, 5742726, 5743731, 5744253, 5745380, 5746545, 5747882, 5749352, + 5750162, 5751632, 5754005, 5756758, 5757477, 5757506, 5760009, 5761287, 5761708, 5768233, + 5771826, 5771960, 5772654, 5772959, 5773001, 5773304, 5774001, 5774215, 5774301, 5774662, + 5775782, 5775863, 5776008, 5776715, 5776727, 5777107, 5777224, 5777544, 5777793, 5778244, + 5778352, 5778755, 5779036, 5779068, 5779206, 5779334, 5779548, 5779816, 5780026, 5780557, + 5780802, 5780993, 5781061, 5781070, 5781087, 5781765, 5781770, 5781783, 5781794, 5781860, + 5781993, 5782391, 5782476, 5783695, 5784549, 5784607, 5785243, 5785657, 5785868, 5785965, + 5786485, 5786882, 5786899, 5787776, 5787829, 5788054, 5788516, 5788822, 5789683, 5790971, + 5791159, 5792244, 5793427, 5793639, 5793933, 5794097, 5794245, 5794559, 5795011, 5795906, + 5796984, 5798487, 5799587, 5799610, 5799625, 5799841, 5800112, 5800317, 5800420, 5801617, + 5802049, 5802340, 5802493, 5802570, 5803139, 5803457, 5803786, 5803990, 5804127, 5804191, + 5804306, 5804953, 5805441, 5805687, 5805782, 5805815, 5806253, 5806298, 5807212, 5807540, + 5807575, 5808079, 5808189, 5808276, 5809333, 5809402, 5809805, 5809844, 5810301, 5810490, + 5811456, 5811581, 5811696, 5811729, 5812604, 5812944, 5814043, 5814095, 5814450, 5814616, + 5814916, 5815135, 5815342, 5815538, 5815539, 5816320, 5816605, 5820705, 5821086, 5826027, + 5830062, 5836898, 5838198, 5844096, 5847411, 5847486, 5848189, 5849297, 5851030, 5852275, + 5853992, 5854496, 5854686, 5855070, 5855927, 5856195, 5861897, 5879400, 5879898, 5881576, + 5881791, 5882799, 5882873, 5884083, 5884588, 5889745, 5894171, 5895650, 5897885, 5898138, + 5903510, 5905132, 5906267, 5907180, 5907364, 5907896, 5907983, 5907990, 5909294, 5909629, + 5911592, 5911606, 5913490, 5913695, 5914132, 5914653, 5914826, 5919566, 5920288, 5920433, + 5920450, 5921357, 5923101, 5924579, 5924618, 5925975, 5926511, 5927689, 5927969, 5928065, + 5928488, 5930890, 5931800, 5935277, 5937615, 5938513, 5939219, 5940956, 5941925, 5942845, + 5943865, 5946768, 5950267, 5955815, 5955895, 5955960, 5957776, 5959974, 5961564, 5964215, + 5964347, 5964700, 5965812, 5967629, 5969093, 5969785, 5978765, 5987650, 5989045, 5989818, + 5990579, 5991056, 5991370, 5992500, 5992830, 5992996, 6049388, 6049429, 6049430, 6049863, + 6050263, 6050610, 6051123, 6051562, 6053154, 6058024, 6058560, 6059891, 6064180, 6065686, + 6066513, 6067494, 6071618, 6073363, 6075061, 6075081, 6075293, 6075357, 6076211, 6077243, + 6077315, 6078112, 6082231, 6085772, 6087579, 6087701, 6087844, 6087892, 6089125, 6089404, + 6089426, 6089661, 6090785, 6091104, 6092122, 6094201, 6094325, 6094578, 6094817, 6095645, + 6098642, 6100832, 6101141, 6101645, 6104111, 6105815, 6107325, 6111632, 6111704, 6111962, + 6113335, 6113355, 6113365, 6115355, 6118158, 6119109, 6119518, 6122085, 6122091, 6128577, + 6137270, 6137489, 6137540, 6137633, 6137781, 6137941, 6138121, 6138175, 6138374, 6138495, + 6138501, 6138517, 6138599, 6138610, 6138617, 6139289, 6139416, 6141190, 6141256, 6141439, + 6144312, 6145489, 6146143, 6146279, 6151352, 6154383, 6155033, 6155721, 6157977, 6158357, + 6159905, 6162949, 6163012, 6165719, 6166142, 6166739, 6167865, 6169141, 6169587, 6173017, + 6173331, 6173508, 6173570, 6173577, 6173864, 6174041, 6174151, 6176823, 6177869, 6179226, + 6180550, 6180961, 6182962, 6183235, 6184365, 6185377, 6185607, 6230919, 6240770, 6241325, + 6243926, 6244895, 6246634, 6252065, 6254843, 6269470, 6295498, 6295504, 6295512, 6295513, + 6295520, 6295523, 6295531, 6295532, 6295533, 6295534, 6295536, 6295539, 6295540, 6295542, + 6295548, 6295550, 6301965, 6316406, 6316729, 6317344, 6317464, 6317953, 6318165, 6318694, + 6324376, 6324534, 6324621, 6324644, 6324729, 6324733, 6325494, 6325521, 6331908, 6331909, + 6332309, 6332439, 6354895, 6354897, 6354908, 6354969, 6354984, 6355013, 6362987, 6395804, + 6414184, 6417459, 6457378, 6457398, 6458708, 6534203, 6534212, 6534216, 6534226, 6534228, + 6534232, 6534235, 6534240, 6534252, 6534253, 6534256, 6534257, 6534267, 6534268, 6534275, + 6534280, 6534284, 6543862, 6544105, 6544106, 6544881, 6545023, 6545243, 6545349, 6546693, + 6550659, 6558039, 6559503, 6559559, 6559641, 6611854, 6615440, 6615442, 6615443, 6615444, + 6615536, 6615539, 6618486, 6618856, 6618983, 6619277, 6619347, 6619708, 6620293, 6620355, + 6620360, 6640028, 6640202, 6690602, 6690863, 6690866, 6690867, 6690870, 6690871, 6690877, + 6690989, 6691219, 6691227, 6691235, 6691640, 6691766, 6691831, 6691884, 6691927, 6692413, + 6692471, 6692524, 6693088, 6693122, 6693230, 6693470, 6693674, 6693679, 6693771, 6693804, + 6694821, 6695247, 6695754, 6696686, 6696767, 6696918, 6696932, 6697039, 6697344, 6697380, + 6697563, 6697993, 6697994, 6698360, 6822096, 6822108, 6822131, 6822146, 6822181, 6822217, + 6822219, 6825489, 6853140, 6903078, 6929992, 6930327, 6930414, 6940394, 6941055, 6941080, + 6941099, 6941548, 6941937, 6942372, 6943537, 6943558, 6943660, 6943827, 6944296, 6945426, + 6946409, 6947041, 6947168, 6947480, 6947481, 6947482, 6947483, 6947637, 6947639, 6947640, + 6947641, 6947756, 6949678, 6954929, 6955345, 6967865, 6967990, 6992326, 7084521, 7091861, + 7091912, 7115111, 7116866, 7117880, 7117885, 7158935, 7169710, 7176035, 7176039, 7217356, + 7257422, 7257991, 7257992, 7258965, 7259084, 7259265, 7259705, 7259780, 7259823, 7260019, + 7260219, 7260233, 7260327, 7260548, 7260806, 7260966, 7261029, 7261268, 7261291, 7261476, + 7261553, 7261759, 7262349, 7262428, 7262518, 7262622, 7262761, 7262790, 7266440, 7268049, + 7274677, 7279570, 7279571, 7279595, 7279597, 7279599, 7279600, 7279734, 7279735, 7279739, + 7279741, 7279742, 7279746, 7279747, 7279752, 7279754, 7280414, 7280463, 7280711, 7280718, + 7281017, 7281020, 7281782, 7281807, 7281819, 7281838, 7281839, 7281850, 7281931, 7281936, + 7283386, 7284803, 7284820, 7284823, 7284824, 7284825, 7284826, 7284827, 7284829, 7284830, + 7284831, 7284832, 7284833, 7284834, 7284835, 7284836, 7284837, 7284838, 7284839, 7284840, + 7284841, 7284842, 7284843, 7287775, 7289614, 7289676, 7290013, 7290015, 7290243, 7290245, + 7290251, 7290252, 7290253, 7290254, 7290255, 7290401, 7290614, 7290697, 7302130, 7302259, + 7302484, 7302628, 7302631, 7302642, 7302647, 7302786, 7302806, 7302808, 7302810, 7302812, + 7302815, 7302825, 7302826, 7302828, 7302829, 7302830, 7302833, 7302836, 7302838, 7302844, + 7302845, 7302846, 7302847, 7302849, 7302851, 7302853, 7302854, 7302855, 7302856, 7302857, + 7302859, 7302861, 7302862, 7303248, 7303419, 7303641, 7303786, 7303944, 7304020, 7304591, + 7310164, 7506758, 7521348, 7521822, 7521936, 7525990, 7535661, 7535681, 7601921, 7602078, + 7602670, 7626291, 7626465, 7627067, 7628416, 7628419, 7628420, 7645176, 7647007, 7648817, + 7669012, 7701384, 7732959, 7828758, 7838895, 7839240, 7870153, 7874479, 7874492, 7911309, + 7932342, 7932385, 7932386, 7932612, 7932629, 7932636, 7932638, 7932646, 7932651, 7932654, + 8015209, 8015353, 8020218, 8030162, 8050879, 8050888, 8063096, 8125829, 8198709, 8199378, + 8199394, 8224624, 8224782, 8224783, 8224933, 8224935, 8260318, 10722858, 71296900, +];