#include "chibicc.h"

static Node *expr(Token **rest, Token *tok);
static Node *equality(Token **rest, Token *tok);
static Node *relational(Token **rest, Token *tok);
static Node *add(Token **rest, Token *tok);
static Node *mul(Token **rest, Token *tok);
static Node *unary(Token **rest, Token *tok);
static Node *primary(Token **rest, Token *tok);

static Node *new_node(NodeKind kind) {
  Node *node = calloc(1, sizeof(Node));
  node->kind = kind;
  return node;
}

static Node *new_binary(NodeKind kind, Node *lhs, Node *rhs) {
  Node *node = new_node(kind);
  node->lhs = lhs;
  node->rhs = rhs;
  return node;
}

static Node *new_unary(NodeKind kind, Node *expr) {
  Node *node = new_node(kind);
  node->lhs = expr;
  return node;
}

static Node *new_num(int val) {
  Node *node = new_node(ND_NUM);
  node->val = val;
  return node;
}

// expr = equality
static Node *expr(Token **rest, Token *tok) {
  return equality(rest, tok);
}

// equality = relational ("==" relational | "!=" relational)*
static Node *equality(Token **rest, Token *tok) {
  Node *node = relational(&tok, tok);

  for (;;) {
    if (equal(tok, "==")) {
      node = new_binary(ND_EQ, node, relational(&tok, tok->next));
      continue;
    }

    if (equal(tok, "!=")) {
      node = new_binary(ND_NE, node, relational(&tok, tok->next));
      continue;
    }

    *rest = tok;
    return node;
  }
}

// relational = add ("<" add | "<=" add | ">" add | ">=" add)*
static Node *relational(Token **rest, Token *tok) {
  Node *node = add(&tok, tok);

  for (;;) {
    if (equal(tok, "<")) {
      node = new_binary(ND_LT, node, add(&tok, tok->next));
      continue;
    }

    if (equal(tok, "<=")) {
      node = new_binary(ND_LE, node, add(&tok, tok->next));
      continue;
    }

    if (equal(tok, ">")) {
      node = new_binary(ND_LT, add(&tok, tok->next), node);
      continue;
    }

    if (equal(tok, ">=")) {
      node = new_binary(ND_LE, add(&tok, tok->next), node);
      continue;
    }

    *rest = tok;
    return node;
  }
}

// add = mul ("+" mul | "-" mul)*
static Node *add(Token **rest, Token *tok) {
  Node *node = mul(&tok, tok);

  for (;;) {
    if (equal(tok, "+")) {
      node = new_binary(ND_ADD, node, mul(&tok, tok->next));
      continue;
    }

    if (equal(tok, "-")) {
      node = new_binary(ND_SUB, node, mul(&tok, tok->next));
      continue;
    }

    *rest = tok;
    return node;
  }
}

// mul = unary ("*" unary | "/" unary)*
static Node *mul(Token **rest, Token *tok) {
  Node *node = unary(&tok, tok);

  for (;;) {
    if (equal(tok, "*")) {
      node = new_binary(ND_MUL, node, unary(&tok, tok->next));
      continue;
    }

    if (equal(tok, "/")) {
      node = new_binary(ND_DIV, node, unary(&tok, tok->next));
      continue;
    }

    *rest = tok;
    return node;
  }
}

// unary = ("+" | "-") unary
//       | primary
static Node *unary(Token **rest, Token *tok) {
  if (equal(tok, "+"))
    return unary(rest, tok->next);

  if (equal(tok, "-"))
    return new_unary(ND_NEG, unary(rest, tok->next));

  return primary(rest, tok);
}

// primary = "(" expr ")" | num
static Node *primary(Token **rest, Token *tok) {
  if (equal(tok, "(")) {
    Node *node = expr(&tok, tok->next);
    *rest = skip(tok, ")");
    return node;
  }

  if (tok->kind == TK_NUM) {
    Node *node = new_num(tok->val);
    *rest = tok->next;
    return node;
  }

  error_tok(tok, "expected an expression");
}

Node *parse(Token *tok) {
  Node *node = expr(&tok, tok);
  if (tok->kind != TK_EOF)
    error_tok(tok, "extra token");
  return node;
}

#include "chibicc.h"

static int depth;

static void push(void) {
  printf("  push %%rax\n");
  depth++;
}

static void pop(char *arg) {
  printf("  pop %s\n", arg);
  depth--;
}

static void gen_expr(Node *node) {
  switch (node->kind) {
  case ND_NUM:
    printf("  mov $%d, %%rax\n", node->val);
    return;
  case ND_NEG:
    gen_expr(node->lhs);
    printf("  neg %%rax\n");
    return;
  }

  gen_expr(node->rhs);
  push();
  gen_expr(node->lhs);
  pop("%rdi");

  switch (node->kind) {
  case ND_ADD:
    printf("  add %%rdi, %%rax\n");
    return;
  case ND_SUB:
    printf("  sub %%rdi, %%rax\n");
    return;
  case ND_MUL:
    printf("  imul %%rdi, %%rax\n");
    return;
  case ND_DIV:
    printf("  cqo\n");
    printf("  idiv %%rdi\n");
    return;
  case ND_EQ:
  case ND_NE:
  case ND_LT:
  case ND_LE:
    printf("  cmp %%rdi, %%rax\n");

    if (node->kind == ND_EQ)
      printf("  sete %%al\n");
    else if (node->kind == ND_NE)
      printf("  setne %%al\n");
    else if (node->kind == ND_LT)
      printf("  setl %%al\n");
    else if (node->kind == ND_LE)
      printf("  setle %%al\n");

    printf("  movzb %%al, %%rax\n");
    return;
  }

  error("invalid expression");
}

void codegen(Node *node) {
  printf("  .globl main\n");
  printf("main:\n");

  gen_expr(node);
  printf("  ret\n");

  assert(depth == 0);
}

#include "chibicc.h"

int main(int argc, char **argv) {
  if (argc != 2)
    error("%s: invalid number of arguments", argv[0]);

  Token *tok = tokenize(argv[1]);
  Node *node = parse(tok);
  codegen(node);
  return 0;
}

#include "bnflite/bnflite.h"
#include <iostream>

typedef bnf::Interface<double> Calc;
/* pass number result */
Calc DoNumber(std::vector<Calc>& res)
{
	char* lst;
	double value = strtod(res[0].text, &lst); // formaly it is not correct for not 0-terminated strings
	Calc ret(value, res);
	if (lst - res[0].text - ret.length != 0) {
		std::cout << "number parse error:"; std::cout.write(ret.text, ret.length);
	}
	return ret;
}

int main_bnflite(int argc, char* argv[]) {
	//int argc1 = 3;
	//char* argv1[3] = { "sjijasd", "测试", "。，.,,.." };
	//main_prettyprint(argc1, argv1);

	bnf::Token token('0', '9');
	bnf::Lexem number = 6 * token;
	bnf::Rule positiveNum = !bnf::Token('-') | number;
	bnf::Bind(positiveNum, DoNumber);
	const char* tail = 0;

	typedef bnf::Interface<double> Calc;
	Calc result;
	std::string clc("123456");
	int tst = bnf::Analyze(positiveNum, clc.c_str(), &tail, result);
	if (tst > 0)
		std::cout << "Result of " << clc << " = " << result.data << std::endl;
	else
		std::cout << "Parsing errors detected, status = " << std::hex << tst << std::endl
		<< "stopped at: " << tail << std::endl;
	return 0;
}

#include<iostream>
using namespace std;
template <class T>
void Merge(T data[],int start,int mid,int end)
{
	int len1 = mid - start + 1, len2 = end - mid;
	int i, j, k;
	T* left = new int[len1];
	T* right = new int[len2];
	for (i = 0; i < len1; i++)
		left[i] = data[i + start];
	for (i = 0; i < len2; i++)
		right[i] = data[i + mid + 1];
	i = 0, j = 0;
	for (k = start; k < end; k++)
	{
		if (i == len1 || j == len2)
			break;
		if (left[i] <= right[j])
			data[k] = left[i++];
		else
			data[k] = right[j++];
	}
	while (i < len1)
		data[k++] = left[i++];
	while (j < len2)
		data[k++] = right[j++];
	delete[] left;
	delete[] right;
}
template <class T>
void MergeSort(T data[], int start, int end)
{
	if (start < end)
	{
		int mid = (start + end) / 2;
		MergeSort(data, start,mid);
		MergeSort(data, mid + 1, end);
		Merge(data, start, mid, end);
	}
}
void show(int*temp,int n)
{
	for (int i = 0; i < n; i++)
		cout << temp[i] << "  ";
}
void main()
{
	int temp[8];
	for (int i = 0; i < 8; i++)
		cin >> temp[i];
	MergeSort<int>(temp, 0,7);
	show(temp, 8);
}

#include <stdio.h>  
  
int main()  
{  
    int i,p,temp;  
    int array[10] = {2,6,1,9,4,7,5,8,3,0};  
    printf("Display this array:\n");  
    for(i=0;i<10;i++)  
    {  
        printf("%d ",array[i]);  
    }  
    for(i = 1;i < 10; ++i)
{
   for(p = 0; p < 10; ++p)
  {
       if(array[i]>array[p])
      {
	array[i] = 	array[i]^array[p];
	array[p] = array[i]^array[p];	
	array[i] = array[i]^array[p];
      }
  }
}
    printf("\n");  
    printf("After sorting,this array is:\n");  
    for(i=0;i<10;i++)  
    {  
        printf("%d ",array[i]);  
    }     
    printf("\n");  
    return 0;  
}

#include <stdio.h>  
  
int main()  
{  
    int i,p,temp;  
    int array[10] = {2,6,1,9,4,7,5,8,3,0};  
    printf("Display this array:\n");  
    for(i=0;i<10;i++)  
    {  
        printf("%d ",array[i]);  
    }  
      	//选择第一个数做为起始排序
	for(i = 1; i < 10; ++i)
	{
		temp = array[i];	//待插入排序数
		for(p = i-1; p >=0 && array[p]>temp; --p)
		{//遍历已排序数列表
			{//如果当前数大小在已排序范围中，开始向右位移一个数让出空间
				array[p+1] = array[p];	
			}
		}
		//找到待排序数的位置，在让出的空间直接插入		
		array[p+1]=temp;			
	}
    printf("\n");  
    printf("After sorting,this array is:\n");  
    for(i=0;i<10;i++)  
    {  
        printf("%d ",array[i]);  
    }     
    printf("\n");  
    return 0;  
}

#include <stdio.h>  
  
int main()  
{  
    int i,j,t;  
    int array[10]={2,7,1,8,5,9,3,4,0,6};  
    printf("\nDisplay this array:\n");  
    for(i=0;i<10;i++)  
    {  
        printf("%d ",array[i]);  
    }  
    printf("\n");  
    for(i=1;i<=9;i++)  
    {  //遍历
        int t = i-1;  //假设当前数为最小数
        for(j=i;j<10;j++)  
        {  
            if(array[j]<array[t])  
            {  //遍历找到最小的数,保存最小数索引
                t=j;  
            }  
        }  
        if(t!=(i-1))  
        {  //交换最小数与假设最小数
            int temp = 0;  
            temp=array[i-1];  
            array[i-1]=array[t];  
            array[t]=temp;  
        }  
    }  
    printf("After sorting,this array is:\n");  
    for(i=0;i<10;i++)  
    {  
        printf("%d ",array[i]);  
    }  
    printf("\n");  
    return 0;  
}

#include <ctype.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef enum {
  TK_PUNCT, // Punctuators
  TK_NUM,   // Numeric literals
  TK_EOF,   // End-of-file markers
} TokenKind;

// Token type
typedef struct Token Token;
struct Token {
  TokenKind kind; // Token kind
  Token *next;    // Next token
  int val;        // If kind is TK_NUM, its value
  char *loc;      // Token location
  int len;        // Token length
};

// Input string
static char *current_input;

// Reports an error and exit.
static void error(char *fmt, ...) {
  va_list ap;
  va_start(ap, fmt);
  vfprintf(stderr, fmt, ap);
  fprintf(stderr, "\n");
  exit(1);
}

// Reports an error location and exit.
static void verror_at(char *loc, char *fmt, va_list ap) {
  int pos = loc - current_input;
  fprintf(stderr, "%s\n", current_input);
  fprintf(stderr, "%*s", pos, ""); // print pos spaces.
  fprintf(stderr, "^ ");
  vfprintf(stderr, fmt, ap);
  fprintf(stderr, "\n");
  exit(1);
}

static void error_at(char *loc, char *fmt, ...) {
  va_list ap;
  va_start(ap, fmt);
  verror_at(loc, fmt, ap);
}

static void error_tok(Token *tok, char *fmt, ...) {
  va_list ap;
  va_start(ap, fmt);
  verror_at(tok->loc, fmt, ap);
}

// Consumes the current token if it matches `s`.
static bool equal(Token *tok, char *op) {
  return memcmp(tok->loc, op, tok->len) == 0 && op[tok->len] == '\0';
}

// Ensure that the current token is `s`.
static Token *skip(Token *tok, char *s) {
  if (!equal(tok, s))
    error_tok(tok, "expected '%s'", s);
  return tok->next;
}

// Ensure that the current token is TK_NUM.
static int get_number(Token *tok) {
  if (tok->kind != TK_NUM)
    error_tok(tok, "expected a number");
  return tok->val;
}

// Create a new token.
static Token *new_token(TokenKind kind, char *start, char *end) {
  Token *tok = calloc(1, sizeof(Token));
  tok->kind = kind;
  tok->loc = start;
  tok->len = end - start;
  return tok;
}

// Tokenize `current_input` and returns new tokens.
static Token *tokenize(void) {
  char *p = current_input;
  Token head = {};
  Token *cur = &head;

  while (*p) {
    // Skip whitespace characters.
    if (isspace(*p)) {
      p++;
      continue;
    }

    // Numeric literal
    if (isdigit(*p)) {
      cur = cur->next = new_token(TK_NUM, p, p);
      char *q = p;
      cur->val = strtoul(p, &p, 10);
      cur->len = p - q;
      continue;
    }

    // Punctuator
    if (*p == '+' || *p == '-') {
      cur = cur->next = new_token(TK_PUNCT, p, p + 1);
      p++;
      continue;
    }

    error_at(p, "invalid token");
  }

  cur = cur->next = new_token(TK_EOF, p, p);
  return head.next;
}

int main(int argc, char **argv) {
  if (argc != 2)
    error("%s: invalid number of arguments", argv[0]);

  current_input = argv[1];
  Token *tok = tokenize();

  printf("  .globl main\n");
  printf("main:\n");

  // The first token must be a number
  printf("  mov $%d, %%rax\n", get_number(tok));
  tok = tok->next;

  // ... followed by either `+ <number>` or `- <number>`.
  while (tok->kind != TK_EOF) {
    if (equal(tok, "+")) {
      printf("  add $%d, %%rax\n", get_number(tok->next));
      tok = tok->next->next;
      continue;
    }

    tok = skip(tok, "-");
    printf("  sub $%d, %%rax\n", get_number(tok));
    tok = tok->next;
  }

  printf("  ret\n");
  return 0;
}

int main() {
  return 42;
}

#include <stdio.h>
#include <stdlib.h>
int main(int argc, char **argv) {
  if (argc != 2) {
    fprintf(stderr, "Please input a Number:\n");
    return 1;
  }
  printf(".intel_syntax noprefix\n");
  printf(".globl main\n");
  printf("main:\n");
  printf("  mov rax, %d\n", atoi(argv[1]));
  printf("  ret\n");
  return 0;
}

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv) {
  if (argc != 2) {
    fprintf(stderr, "Please input a Number\n");
    return 1;
  }

  char *p = argv[1];

  printf(".intel_syntax noprefix\n");
  printf(".globl main\n");
  printf("main:\n");
  printf("  mov rax, %ld\n", strtol(p, &p, 10));
  // strtol读取数字，读完自动跳到下个符号
  while (*p) {
    if (*p == '+') {
      p++;
      printf("  add rax, %ld\n", strtol(p, &p, 10));
      continue;
    }

    if (*p == '-') {
      p++;
      printf("  sub rax, %ld\n", strtol(p, &p, 10));
      continue;
    }

    fprintf(stderr, "illegal sign '%c'\n", *p);
    return 1;
  }

  printf("  ret\n");
  return 0;
}

#include "easylogging++.h"
#include "easylogging++.cc"
#include <chrono>

INITIALIZE_EASYLOGGINGPP

const char* getIp(const el::LogMessage*) {
	return "192.168.1.1";
}

void myCrashHandler(int sig) {
	LOG(ERROR) << "Woops! Crashed!";
	// FOLLOWING LINE IS ABSOLUTELY NEEDED AT THE END IN ORDER TO ABORT APPLICATION
	//el::Helpers::crashAbort(sig);
}

class Integer : public el::Loggable {
public:
	Integer(int i) : m_underlyingInt(i) {
	}
	Integer& operator=(const Integer& integer) {
		m_underlyingInt = integer.m_underlyingInt;
		return *this;
	}
	// Following line does the trick!
	// Note: el::base::type::ostream_t is either std::wostream or std::ostream depending on unicode enabled or not
	virtual void log(el::base::type::ostream_t& os) const {
		os << m_underlyingInt;
	}
private:
	int m_underlyingInt;
};

class Integer2 {
public:
	Integer2(int i) : m_underlyingInt(i) {
	}
	Integer2& operator=(const Integer2& integer) {
		m_underlyingInt = integer.m_underlyingInt;
		return *this;
	}
	int getInt(void) const { return m_underlyingInt; }
private:
	int m_underlyingInt;
};

// Following line does the trick!
inline MAKE_LOGGABLE(Integer2, integer, os) {
	os << integer.getInt();
	return os;
}

inline MAKE_LOGGABLE(std::chrono::system_clock::time_point, when, os) {
	time_t t = std::chrono::system_clock::to_time_t(when);
	auto tm = std::localtime(&t);
	char buf[1024];
	strftime(buf, sizeof(buf), "%F %T (%Z)", tm);
	os << buf;
	return os;
}

int main_log(int argc, char* argv[]) {
	START_EASYLOGGINGPP(argc, argv);
	LOG(INFO) << "My first info log";

	//// Load configuration from file
	//el::Configurations conf("../../../log.conf");
	//// Reconfigure single logger
	//el::Loggers::reconfigureLogger("default", conf);
	//// Actually reconfigure all loggers instead
	//el::Loggers::reconfigureAllLoggers(conf);
	//// Now all the loggers will use configuration from file

	//Using el::Configurations Class
	el::Configurations defaultConf;
	defaultConf.setToDefault();
	// Values are always std::string
	defaultConf.set(el::Level::Info,
		el::ConfigurationType::Format, "%datetime %level %msg");
	// default logger uses default configurations
	el::Loggers::reconfigureLogger("default", defaultConf);
	LOG(INFO) << "Log using default file";
	// To set GLOBAL configurations you may use
	defaultConf.setGlobally(
		el::ConfigurationType::Format, "%date %msg");
	el::Loggers::reconfigureLogger("default", defaultConf);

	el::Configurations c;
	c.setToDefault();
	c.parseFromText("*GLOBAL:\n FORMAT = %level %msg");

	el::Loggers::configureFromGlobal("global.conf");

	el::Helpers::installCustomFormatSpecifier(el::CustomFormatSpecifier("%ip_addr", getIp));
	el::Loggers::reconfigureAllLoggers(el::ConfigurationType::Format, "%datetime %level %ip_addr : %msg");
	LOG(INFO) << "This is request from client";

	el::Logger* l = el::Loggers::getLogger("default");
	bool enabled = l->typedConfigurations()->enabled(el::Level::Info);
	// Or to read log format/pattern
	std::string format =
		l->typedConfigurations()->logFormat(el::Level::Info).format();

	LOG(INFO) << "This is info log";
	CLOG(ERROR, "performance") << "This is info log using performance logger";

	for (int i = 1; i <= 10; ++i) {
		LOG_EVERY_N(2, INFO) << "Logged every second iter";
	}
	// 5 logs written; 2, 4, 6, 7, 10

	for (int i = 1; i <= 10; ++i) {
		LOG_AFTER_N(2, INFO) << "Log after 2 hits; " << i;
	}
	// 8 logs written; 3, 4, 5, 6, 7, 8, 9, 10

	for (int i = 1; i <= 100; ++i) {
		LOG_N_TIMES(3, INFO) << "Log only 3 times; " << i;
	}
	// 3 logs writter; 1, 2, 3

	//info(const char*, const T&, const Args&...)
	//warn(const char*, const T&, const Args&...)
	//error(const char*, const T&, const Args&...)
	//debug(const char*, const T&, const Args&...)
	//fatal(const char*, const T&, const Args&...)
	//trace(const char*, const T&, const Args&...)
	//verbose(int vlevel, const char*, const T&, const Args&...)

	// Use default logger
	el::Logger* defaultLogger = el::Loggers::getLogger("default");

	// STL logging (`ELPP_STL_LOGGING` should be defined)
	std::vector<int> i;
	i.push_back(1);
	defaultLogger->warn("My first ultimate log message %v %v %v", 123, 222, i);

	// Escaping
	defaultLogger->info("My first ultimate log message %% %%v %v %v", 123, 222);
	// %file, %func %line and %loc

	if (VLOG_IS_ON(2)) {
		// Verbosity level 2 is on for this file
	}
	el::Loggers::unregisterLogger("logger-id");
	//el::Loggers::populateAllLoggerIds(std::vector<std::string>&);
	//SHARE_EASYLOGGINGPP(aa)
	//el::Helpers::setStorage(el::base::type::StoragePointer);

	//installPerformanceTrackingCallback<T>(const std::string & id)
	//uninstallPerformanceTrackingCallback<T>(const std::string & id)
	//el::Helpers::installPreRollOutCallback(const PreRollOutCallback & handler)

	//el::Helpers::setCrashHandler(myCrashHandler);
	//LOG(INFO) << "My crash handler!";
	//int* i;
	//*i = 0; // Crash!

	//ELPP_INITIALIZE_SYSLOG("my_proc", LOG_PID | LOG_CONS | LOG_PERROR, LOG_USER) // This is optional, you may not add it if you dont want to specify options
	//// Alternatively you may do
	//// el::SysLogInitializer elSyslogInit("my_proc", LOG_PID | LOG_CONS | LOG_PERROR, LOG_USER);
	//SYSLOG(INFO) << "This is syslog - read it from /var/log/syslog"

	//el::Logger::flush();
	el::Loggers::flushAll();
}

//void performHeavyTask(int iter) {
//	TIMED_FUNC(timerObj);
//	// Some initializations
//	// Some more heavy tasks
//	usleep(5000);
//	while (iter-- > 0) {
//		TIMED_SCOPE(timerBlkObj, "heavy-iter");
//		// Perform some heavy task in each iter
//		// Notice following sleep varies with each iter
//		usleep(iter * 1000);
//		if (iter % 3) {
//			PERFORMANCE_CHECKPOINT(timerBlkObj);
//		}
//	}
//}
//
//06:33 : 07, 558 INFO Executed[heavy - iter] in[9 ms]
//06 : 33 : 07, 566 INFO Performance checkpoint for block[heavy - iter] : [8 ms]
//06 : 33 : 07, 566 INFO Executed[heavy - iter] in[8 ms]
//06 : 33 : 07, 573 INFO Performance checkpoint for block[heavy - iter] : [7 ms]
//06 : 33 : 07, 573 INFO Executed[heavy - iter] in[7 ms]
//06 : 33 : 07, 579 INFO Executed[heavy - iter] in[6 ms]
//06 : 33 : 07, 584 INFO Performance checkpoint for block[heavy - iter] : [5 ms]
//06 : 33 : 07, 584 INFO Executed[heavy - iter] in[5 ms]
//06 : 33 : 07, 589 INFO Performance checkpoint for block[heavy - iter] : [4 ms]
//06 : 33 : 07, 589 INFO Executed[heavy - iter] in[4 ms]
//06 : 33 : 07, 592 INFO Executed[heavy - iter] in[3 ms]
//06 : 33 : 07, 594 INFO Performance checkpoint for block[heavy - iter] : [2 ms]
//06 : 33 : 07, 594 INFO Executed[heavy - iter] in[2 ms]
//06 : 33 : 07, 595 INFO Performance checkpoint for block[heavy - iter] : [1 ms]
//06 : 33 : 07, 595 INFO Executed[heavy - iter] in[1 ms]
//06 : 33 : 07, 595 INFO Executed[heavy - iter] in[0 ms]
//06 : 33 : 07, 595 INFO Executed[void performHeavyTask(int)] in[51 ms]

//void performHeavyTask(int iter) {
//	// enable performance tracking for verbosity level 4 or higher
//	TIMED_FUNC_IF(timerObj, VLOG_IS_ON(4));
//	// Some more heavy tasks
//}

//ELPP_STL_LOGGING

//
//class NetworkDispatcher : public el::LogDispatchCallback
//{
//public:
//	void updateServer(const std::string& host, int port) {
//		m_client = std::unique_ptr<Client>(new Client(&m_svc, host, std::to_string(port)));
//	}
//protected:
//	void handle(const el::LogDispatchData* data) noexcept override {
//		m_data = data;
//		// Dispatch using default log builder of logger
//		dispatch(m_data->logMessage()->logger()->logBuilder()->build(m_data->logMessage(),
//			m_data->dispatchAction() == el::base::DispatchAction::NormalLog));
//	}
//private:
//	const el::LogDispatchData* m_data;
//	boost::asio::io_service m_svc;
//	std::unique_ptr<Client> m_client;
//
//	void dispatch(el::base::type::string_t&& logLine) noexcept
//	{
//		m_client->send(logLine);
//	}
//};
//
//
//int main() {
//	el::Helpers::installLogDispatchCallback<NetworkDispatcher>("NetworkDispatcher");
//	// you can uninstall default one by
//	// el::Helpers::uninstallLogDispatchCallback<el::base::DefaultLogDispatchCallback>("DefaultLogDispatchCallback");
//	// Set server params
//	NetworkDispatcher* dispatcher = el::Helpers::logDispatchCallback<NetworkDispatcher>("NetworkDispatcher");
//	dispatcher->setEnabled(true);
//	dispatcher->updateServer("127.0.0.1", 9090);
//
//	// Start logging and normal program...
//	LOG(INFO) << "First network log";
//
//	// You can even use a different logger, say "network" and send using a different log pattern
//}

#define JUCE_GLOBAL_MODULE_SETTINGS_INCLUDED

#include <juce_gui_extra/juce_gui_extra.h>
#define JUCE_APPLICATION_NAME_STRING "test"
#define JUCE_APPLICATION_VERSION_STRING "1.0"

class MainComponent final : public juce::Component
{
public:
    //==============================================================================
    MainComponent();

    //==============================================================================
    void paint(juce::Graphics&) override;
    void resized() override;

private:
    //==============================================================================
    // Your private member variables go here...

    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(MainComponent)
};

//==============================================================================
MainComponent::MainComponent()
{
    setSize(600, 400);
}

//==============================================================================
void MainComponent::paint(juce::Graphics& g)
{
    // (Our component is opaque, so we must completely fill the background with a solid colour)
    g.fillAll(getLookAndFeel().findColour(juce::ResizableWindow::backgroundColourId));

    //g.setFont(juce::FontOptions(16.0f));
    g.setColour(juce::Colours::white);
    g.drawText("Hello World!", getLocalBounds(), juce::Justification::centred, true);
}

void MainComponent::resized()
{
    // This is called when the MainComponent is resized.
    // If you add any child components, this is where you should
    // update their positions.
}


//==============================================================================
class GuiAppApplication final : public juce::JUCEApplication
{
public:
    //==============================================================================
    GuiAppApplication() {}

    // We inject these as compile definitions from the CMakeLists.txt
    // If you've enabled the juce header with `juce_generate_juce_header(<thisTarget>)`
    // you could `#include <JuceHeader.h>` and use `ProjectInfo::projectName` etc. instead.
    const juce::String getApplicationName() override { return JUCE_APPLICATION_NAME_STRING; }
    const juce::String getApplicationVersion() override { return JUCE_APPLICATION_VERSION_STRING; }
    bool moreThanOneInstanceAllowed() override { return true; }

    //==============================================================================
    void initialise(const juce::String& commandLine) override
    {
        // This method is where you should put your application's initialisation code..
        juce::ignoreUnused(commandLine);

        mainWindow.reset(new MainWindow(getApplicationName()));
    }

    void shutdown() override
    {
        // Add your application's shutdown code here..

        mainWindow = nullptr; // (deletes our window)
    }

    //==============================================================================
    void systemRequestedQuit() override
    {
        // This is called when the app is being asked to quit: you can ignore this
        // request and let the app carry on running, or call quit() to allow the app to close.
        quit();
    }

    void anotherInstanceStarted(const juce::String& commandLine) override
    {
        // When another instance of the app is launched while this one is running,
        // this method is invoked, and the commandLine parameter tells you what
        // the other instance's command-line arguments were.
        juce::ignoreUnused(commandLine);
    }

    //==============================================================================
    /*
        This class implements the desktop window that contains an instance of
        our MainComponent class.
    */
    class MainWindow final : public juce::DocumentWindow
    {
    public:
        explicit MainWindow(juce::String name)
            : DocumentWindow(name,
                juce::Desktop::getInstance().getDefaultLookAndFeel()
                .findColour(ResizableWindow::backgroundColourId),
                DocumentWindow::allButtons)
        {
            setUsingNativeTitleBar(true);
            setContentOwned(new MainComponent(), true);

#if JUCE_IOS || JUCE_ANDROID
            setFullScreen(true);
#else
            setResizable(true, true);
            centreWithSize(getWidth(), getHeight());
#endif

            setVisible(true);
        }

        void closeButtonPressed() override
        {
            // This is called when the user tries to close this window. Here, we'll just
            // ask the app to quit when this happens, but you can change this to do
            // whatever you need.
            JUCEApplication::getInstance()->systemRequestedQuit();
        }

        /* Note: Be careful if you override any DocumentWindow methods - the base
           class uses a lot of them, so by overriding you might break its functionality.
           It's best to do all your work in your content component instead, but if
           you really have to override any DocumentWindow methods, make sure your
           subclass also calls the superclass's method.
        */

    private:
        JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(MainWindow)
    };

private:
    std::unique_ptr<MainWindow> mainWindow;
};

juce::JUCEApplicationBase* juce_CreateApplication() {
    return new GuiAppApplication();
}
void test() {
    juce::JUCEApplicationBase::createInstance = &juce_CreateApplication; 
    GuiAppApplication::main();
}

#pragma once
#include <cctype>
#include <vector>
#include <memory>
#include <sstream>
#include <type_traits>
#include <string_view>
#include <algorithm>

namespace cpv {
	/** Return whether string starts with given pattern */
	static inline bool startsWith(std::string_view str, std::string_view pattern) {
		return (str.size() >= pattern.size() &&
			str.substr(0, pattern.size()) == pattern);
	}

	/** Return whether string ends with given pattern */
	static inline bool endsWith(std::string_view str, std::string_view pattern) {
		return (str.size() >= pattern.size() &&
			str.substr(str.size() - pattern.size()) == pattern);
	}

	/**
	 * Split string with specified characters.
	 * Call func(parts, count) while split.
	 * Default split characters are empty characters.
	 */
	template <class Func>
	void splitString(
		std::string_view str, const Func& func, const char* delimiter = " \t\r\n") {
		std::size_t startIndex = 0;
		std::size_t count = 0;
		while (startIndex < str.size()) {
			auto index = str.find_first_of(delimiter, startIndex);
			auto endIndex = (index == str.npos) ? str.size() : index;
			func(str.substr(startIndex, endIndex - startIndex), count);
			index = str.find_first_not_of(delimiter, endIndex);
			startIndex = (index == str.npos) ? str.size() : index;
			++count;
		}
	}

	/**
	 * Split string with specified characters.
	 * Call func(parts, count) while split.
	 * Single char version for better performance.
	 */
	template <class Func>
	void splitString(std::string_view str, const Func& func, char delimiter) {
		std::size_t startIndex = 0;
		std::size_t count = 0;
		while (startIndex < str.size()) {
			auto index = str.find_first_of(delimiter, startIndex);
			auto endIndex = (index == str.npos) ? str.size() : index;
			func(str.substr(startIndex, endIndex - startIndex), count);
			index = str.find_first_not_of(delimiter, endIndex);
			startIndex = (index == str.npos) ? str.size() : index;
			++count;
		}
	}

	/**
	 * Join arguments into string.
	 * This function is very slow, don't call it where performance is important.
	 */
	template <class Delimiter, class... Args>
	std::string joinString(Delimiter&& delimiter, Args&&... args) {
		std::ostringstream stream;
		bool isFirst = true;
		auto func = [&stream, &isFirst, &delimiter](auto&& arg) {
			if (isFirst) {
				isFirst = false;
			} else {
				stream << delimiter;
			}
			stream << arg;
			return 0;
		};
		int dummy[sizeof...(Args)] = { func(std::forward<Args>(args))... };
		return stream.str();
	}

	/**
	 * Return sub string view that removes given prefix and suffix.
	 */
	template <bool TrimPrefix = true, bool TrimSuffix = true>
	std::string_view trimString(std::string_view str, const char* removes = " \t\r\n") {
		const char* ptr = str.begin();
		const char* ptrEnd = str.end();
		std::string_view rm(removes);
		if constexpr (TrimPrefix) {
			for (;ptr < ptrEnd && rm.find_first_of(*ptr) != rm.npos; ++ptr) { }
		}
		if constexpr (TrimSuffix) {
			for (;ptr < ptrEnd && rm.find_first_of(*(ptrEnd - 1)) != rm.npos;--ptrEnd) { }
		}
		return std::string_view(ptr, ptrEnd - ptr);
	}

	/**
	 * Return sub string view that removes given prefix and suffix.
	 * Single char version for better performance.
	 */
	template <bool TrimPrefix = true, bool TrimSuffix = true>
	std::string_view trimString(std::string_view str, char removes) {
		const char* ptr = str.begin();
		const char* ptrEnd = str.end();
		if constexpr (TrimPrefix) {
			for (;ptr < ptrEnd && *ptr == removes; ++ptr) { }
		}
		if constexpr (TrimSuffix) {
			for (;ptr < ptrEnd && *(ptrEnd - 1) == removes; --ptrEnd) { }
		}
		return std::string_view(ptr, ptrEnd - ptr);
	}

	/**
	 * Convert integer to hex and write to string.
	 * IntType can be any of int??_t and uint??_t.
	 * Also see stackoverflow 5100718.
	 */
	template <class IntType, class StringType>
	void dumpIntToHex(IntType value, StringType& str) {
		static const constexpr char digits[] = "0123456789ABCDEF";
		static const constexpr std::size_t hexLen = sizeof(IntType) * 2;
		for (std::size_t i = 0, j = (hexLen - 1) * 4; i < hexLen; ++i, j -= 4) {
			str.append(1, digits[(value >> j) & 0xf]);
		}
	}

	/**
	 * Convert integer to decimal and write to string.
	 * IntType can be any of int??_t and uint??_t.
	 */
	template <class IntType, class StringType>
	void dumpIntToDec(IntType value, StringType& str) {
		static const constexpr char digits[] = "0123456789";
		if constexpr (std::numeric_limits<IntType>::is_signed) {
			if (value < 0) {
				str.append(1, '-');
			}
		}
		std::size_t prevSize = str.size();
		do {
			IntType rem = value % 10;
			value /= 10;
			str.append(1, digits[rem >= 0 ? rem : -rem]);
		} while (value != 0);
		std::reverse(str.begin() + prevSize, str.end());
	}

	/** Convert bytes to hex and write to string */
	template <class StringType>
	void dumpBytesToHex(const char* bytes, std::size_t length, StringType& str) {
		const char* start = bytes;
		const char* end = bytes + length;
		while (start < end) {
			std::uint8_t byte = static_cast<std::uint8_t>(*start++);
			dumpIntToHex(byte, str);
		}
	}

	/**
	 * Convert dynamic size hex string to integer.
	 * Return whether the coversion is successful.
	 */
	template <class IntType>
	bool loadIntFromHex(const char* hex, std::size_t hexLen, IntType& value) {
		using UnsignedIntType = std::make_unsigned_t<IntType>;
		std::uint8_t diff = 0;
		UnsignedIntType uvalue = 0; // avoid sanitizer warning: left shift of negative value
		const char* hexEnd = hex + hexLen;
		for (; hex < hexEnd; ++hex) {
			std::uint8_t c = static_cast<std::uint8_t>(*hex);
			if (c == 0) {
				return false;
			} else if ((diff = c - '0') <= 9) {
				uvalue = (uvalue << 4) | diff;
			} else if ((diff = c - 'a') <= 5) {
				uvalue = (uvalue << 4) | (diff + 0xa);
			} else if ((diff = c - 'A') <= 5) {
				uvalue = (uvalue << 4) | (diff + 0xa);
			} else {
				return false;
			}
		}
		value = static_cast<IntType>(uvalue);
		return true;
	}

	/**
	 * Convert fixed size (sizeof(IntType)*2) hex string to integer.
	 * Return whether the coversion is successful.
	 */
	template <class IntType>
	bool loadIntFromHex(const char* hex, IntType& value) {
		return loadIntFromHex<IntType>(hex, sizeof(IntType)*2, value);
	}

	/**
	 * Convert decimal string to integer.
	 * Return whether the coversion is successful.
	 * Notice convert minus decimal string to unsigned integer is an error,
	 * but overflow isn't an error (the overhead of overflow detection is high).
	 */
	template <class IntType>
	bool loadIntFromDec(const char* dec, std::size_t decLength, IntType& value) {
		const char* decEnd = dec + decLength;
		bool minus = false;
		if (CPV_UNLIKELY(dec < decEnd && *dec == '-')) {
			minus = true;
			++dec;
		}
		std::uint8_t diff = 0;
		value = 0;
		while (CPV_LIKELY(dec < decEnd)) {
			if (CPV_LIKELY((diff = *dec - '0') <= 9)) {
				value *= 10;
				value += diff;
				++dec;
			} else {
				return false;
			}
		}
		if constexpr (!std::numeric_limits<IntType>::is_signed) {
			if (minus) {
				return false;
			}
		} else if (minus) {
			value = -value;
		}
		return true;
	}

	/**
	 * Convert hex string to bytes.
	 * Return whether the coversion is successful.
	 */
	template <class StringType>
	bool loadBytesFromHex(const char* hex, std::size_t hexLength, StringType& str) {
		const char* start = hex;
		const char* end = hex + hexLength;
		char c = 0;
		while (start < end && *start != 0) {
			if (!loadIntFromHex<char>(start, c)) {
				return false;
			}
			str.append(1, c);
			start += 2;
		}
		return start == end;
	}

	/** Compare two string case insensitive */
	bool caseInsensitiveEquals(std::string_view a, std::string_view b);

	/** Get size of string contents */
	template <class StringType>
	std::size_t sizeofString(StringType&& str) {
		return std::size(str);
	}

	/** Get size of c string contents (exclude tailing zero) */
	template <std::size_t Size>
	std::size_t sizeofString(const char(&)[Size]) {
		static_assert(Size > 0, "size of c string should not be 0");
		return Size - 1;
	}

	/** Construct string with fixed size, string may contains \x00 */
	template <std::size_t Size>
	std::string makeBinaryString(const char(&str)[Size]) {
		static_assert(Size > 0, "string must be null terminated");
		return std::string(str, Size - 1);
	}
}