From 0e90d6047c9347c6f66ccea95e6471caae502c72 Mon Sep 17 00:00:00 2001 From: VaclavT Date: Mon, 23 Aug 2021 18:14:05 +0200 Subject: [PATCH] usql update --- CMakeLists.txt | 3 +- ml_string.h | 2 - ml_usql.cpp | 17 +- ml_util.cpp | 2 +- usql/Readme.md | 16 +- usql/clib/date.h | 1 - usql/csvreader.cpp | 203 ++- usql/csvreader.h | 16 +- usql/data.csv | 3 - usql/lexer.cpp | 116 +- usql/lexer.h | 14 +- usql/main.cpp | 223 ++- usql/ml_date.cpp | 59 - usql/ml_date.h | 17 - usql/parser.cpp | 363 +++-- usql/parser.h | 156 +- usql/prices.csv | 3061 --------------------------------------- usql/row.cpp | 234 ++- usql/row.h | 154 +- usql/settings.cpp | 51 + usql/settings.h | 23 + usql/table.cpp | 229 ++- usql/table.h | 27 +- usql/usql.cpp | 351 +++-- usql/usql.h | 18 +- utils/local_install.sh | 2 +- utils/remote_install.sh | 2 +- utils/resetCLion.sh | 34 + 28 files changed, 1623 insertions(+), 3774 deletions(-) delete mode 120000 usql/clib/date.h delete mode 100644 usql/data.csv delete mode 100644 usql/ml_date.cpp delete mode 100644 usql/ml_date.h delete mode 100644 usql/prices.csv create mode 100644 usql/settings.cpp create mode 100644 usql/settings.h create mode 100644 utils/resetCLion.sh diff --git a/CMakeLists.txt b/CMakeLists.txt index 0c1f0ea..85ce23a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -16,7 +16,7 @@ set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-stack_size -Wl,0x1000 # set(CMAKE_CXX_FLAGS "-Wall -Wextra") # set(CMAKE_CXX_FLAGS_RELEASE "-O3") -include_directories(/usr/local/opt/openssl/include ${CMAKE_SOURCE_DIR}/clib ${CMAKE_SOURCE_DIR} ) +include_directories(/usr/local/opt/openssl/include ${CMAKE_SOURCE_DIR}/clib ${CMAKE_SOURCE_DIR}) link_directories(/usr/local/lib /usr/local/opt/openssl/lib) @@ -45,6 +45,7 @@ set(SOURCE usql/table.h usql/row.cpp usql/csvreader.cpp + usql/settings.cpp usql/usql.cpp) add_executable(${PROJECT_NAME} ${SOURCE}) diff --git a/ml_string.h b/ml_string.h index 0a11ced..025b75b 100644 --- a/ml_string.h +++ b/ml_string.h @@ -1,8 +1,6 @@ #pragma once -#include "ml.h" - #include #include diff --git a/ml_usql.cpp b/ml_usql.cpp index d7825f3..09e750a 100644 --- a/ml_usql.cpp +++ b/ml_usql.cpp @@ -13,20 +13,25 @@ MlValue uSQL::ivaluize(const usql::Table *table) { std::vector rows; std::vector columns; + columns.reserve(table->columns_count()); + rows.reserve(table->rows_count()); + for (auto row : table->m_rows) { columns.clear(); for (int i = 0; i < table->columns_count(); i++) { - auto c = row.ith_column(i); + auto & c = row[i]; auto type = table->m_col_defs[i].type; - if (type == ColumnType::integer_type) { - columns.push_back(MlValue(c->getIntValue())); + if (type == ColumnType::integer_type || type == ColumnType::date_type) { + columns.push_back(MlValue(c.getIntValue())); + } else if (type == ColumnType::bool_type) { + columns.push_back(c.getBoolValue() ? MlValue(c.getIntValue()) : MlValue::nil()); } else if (type == ColumnType::float_type) { - columns.push_back(MlValue(c->getDoubleValue())); + columns.push_back(MlValue(c.getDoubleValue())); } else { - columns.push_back(MlValue::string(c->getStringValue())); + columns.push_back(MlValue::string(c.getStringValue())); } } - rows.push_back(columns); + rows.emplace_back(columns); } return rows; } diff --git a/ml_util.cpp b/ml_util.cpp index ba35495..cbdbf32 100644 --- a/ml_util.cpp +++ b/ml_util.cpp @@ -4,7 +4,7 @@ #include #include - const std::vector commands { +const std::vector commands { "eval", "type", "parse", "do", "if", "for", "while", "scope", "quote", "defun", "define", "lambda", "benchmark", "=", "!=", ">", "<", ">=", "<=", "+", "-", "*", "/", "%", "list", "insert", "index", "remove", "len", "push", "pop", "head", "tail", "first", "last", diff --git a/usql/Readme.md b/usql/Readme.md index 1d34a6b..b0d6821 100644 --- a/usql/Readme.md +++ b/usql/Readme.md @@ -1,10 +1,14 @@ ### TODO -- support for * -- support for order by, offset, limit -- add pipe | token +- coalesce, date functions now, add_date; string functions rtrim, ltrim, rpad, lpad; math function round +- add pipe | concatenation + +- support for order by, offset, limit (allow column name in order by, validate) +- support for uniqueue indexes (primary key) +- support for btree indexes +- support for joining - add count min and max functions, eg aggregate functions -- maybe to create iterator on table -- add exceptions and rename it to UsqlException -- class members should have prefix m_ + - add const wherever should be +- PERF in Row::Row(const Row &other), could be more efficient (memory and cpu) +- use references where pointer cannot be nullptr diff --git a/usql/clib/date.h b/usql/clib/date.h deleted file mode 120000 index a6b3df1..0000000 --- a/usql/clib/date.h +++ /dev/null @@ -1 +0,0 @@ -../../clib/date.h \ No newline at end of file diff --git a/usql/csvreader.cpp b/usql/csvreader.cpp index 22afd62..d81d8f0 100644 --- a/usql/csvreader.cpp +++ b/usql/csvreader.cpp @@ -1,5 +1,7 @@ #include "csvreader.h" +#include "parser.h" + namespace usql { @@ -10,78 +12,139 @@ namespace usql { line_separator = line_sep; line_separator2 = line_sep2; - header_skiped = false; - } - - std::vector> CsvReader::parseCSV(const std::string &csvSource) { - int linesRead = 0; - bool inQuote(false); - bool newLine(false); - std::string field; - - std::vector> parsed_data; - parsed_data.reserve(128); - - std::vector line; - line.reserve(32); - - std::string::const_iterator aChar = csvSource.begin(); - while (aChar != csvSource.end()) { - if (*aChar == quote_character) { - newLine = false; - inQuote = !inQuote; - } else if (*aChar == field_separator) { - newLine = false; - if (inQuote == true) { - field += *aChar; - } else { - line.push_back(field); - field.clear(); - } - } else if (*aChar == line_separator || *aChar == line_separator2) { - if (inQuote == true) { - field += *aChar; - } else { - if (newLine == false) { - line.push_back(field); - add_line(line, parsed_data); - field.clear(); - line.clear(); - linesRead++; - if (linesRead == 16) { - int linesEstimation = - csvSource.size() / - (std::distance(csvSource.begin(), aChar) / linesRead); - if (linesEstimation > parsed_data.capacity()) - parsed_data.reserve(linesEstimation); - } - newLine = true; - } - } - } else { - newLine = false; - field.push_back(*aChar); - } - - aChar++; - } - - if (field.size()) - line.push_back(field); - - add_line(line, parsed_data); - - return parsed_data; + header_skiped = !skip_hdr; } - void CsvReader::add_line(const std::vector &line, std::vector> &lines) { - if (skip_header && !header_skiped) { - header_skiped = true; - } else { - if (line.size()) - lines.push_back(line); - } - } +int CsvReader::parseCSV(const std::string &filename, std::vector &cols_def, Table &table) { + std::vector cdefs; + cdefs.reserve(cols_def.size()); + for (auto &cd : cols_def) { + cdefs.emplace_back(table.get_column_def(cd.name)); + } + int row_cnt = 0; + bool inQuote(false); + std::string field; + + std::vector line; + line.reserve(32); + + FILE* fp = fopen(filename.c_str(), "r"); + if (fp == NULL) + exit(EXIT_FAILURE); + + char* line_str = NULL; + size_t len = 0; + + + int read_chars; + while ((read_chars = getline(&line_str, &len, fp)) != -1) { + if (skip_header && !header_skiped) { + header_skiped = true; + continue; + } + if (read_chars > 0 && line_str[read_chars - 1] == '\n') { + line_str[read_chars - 1] = '\0'; + --read_chars; + } + std::string csvSource{line_str}; + + std::string::const_iterator aChar = csvSource.begin(); + std::string::const_iterator strEnd = csvSource.end(); + while (aChar != strEnd) { + if (*aChar == quote_character) { + inQuote = !inQuote; + } else if (*aChar == field_separator) { + if (inQuote == true) { + field += *aChar; + } else { + line.push_back(field); + field.clear(); + } + } else { + field.push_back(*aChar); + } + + ++aChar; + } + + if (!field.empty()) + line.push_back(field); + + table.create_row_from_vector(cols_def, line); + row_cnt++; + + field.clear(); + line.clear(); +// DEBUG +// if (row_cnt > 50000) break; +// + } + + fclose(fp); + if (line_str) + free(line_str); + + + return row_cnt; } + + int CsvReader::parseCSV2(const std::string &csvSource, std::vector &cols_def, Table& table) { + int row_cnt = 0; + bool inQuote(false); + bool newLine(false); + std::string field; + + std::vector line; + line.reserve(32); + + std::string::const_iterator aChar = csvSource.begin(); + while (aChar != csvSource.end()) { + if (*aChar == quote_character) { + newLine = false; + inQuote = !inQuote; + } else if (*aChar == field_separator) { + newLine = false; + if (inQuote == true) { + field += *aChar; + } else { + line.push_back(field); + field.clear(); + } + } else if (*aChar == line_separator || *aChar == line_separator2) { + if (inQuote == true) { + field += *aChar; + } else { + if (newLine == false) { + line.push_back(field); + if (header_skiped) { + table.create_row_from_vector(cols_def, line); + row_cnt++; + } + header_skiped = true; + field.clear(); + line.clear(); + newLine = true; + } + } + } else { + newLine = false; + field.push_back(*aChar); + } + + aChar++; + } + + if (!field.empty()) line.push_back(field); + + if (header_skiped) { + table.create_row_from_vector(cols_def, line); + row_cnt++; + header_skiped = true; + } + + return row_cnt; +} + +} // namespace diff --git a/usql/csvreader.h b/usql/csvreader.h index 8166583..7940606 100644 --- a/usql/csvreader.h +++ b/usql/csvreader.h @@ -5,6 +5,10 @@ #include #include #include +#include + +#include "parser.h" +#include "table.h" namespace usql { @@ -20,12 +24,12 @@ namespace usql { bool header_skiped; public: - CsvReader(bool skip_hdr = false, char field_sep = ',', char quote_ch = '"', char line_sep = '\r', - char line_sep2 = '\n'); + CsvReader(bool skip_hdr = true, char field_sep = ',', char quote_ch = '"', char line_sep = '\r', char line_sep2 = '\n'); - std::vector> parseCSV(const std::string &csvSource); + int parseCSV2(const std::string &csvSource, std::vector &cols_def, Table& table); + + int parseCSV(const std::string &filename, std::vector &cols_def, Table& table); - private: - void add_line(const std::vector &line, std::vector> &lines); }; -} + +} // namespace diff --git a/usql/data.csv b/usql/data.csv deleted file mode 100644 index 177e13f..0000000 --- a/usql/data.csv +++ /dev/null @@ -1,3 +0,0 @@ -Ticker,Price -FDX,257.3 -C,59.85 \ No newline at end of file diff --git a/usql/lexer.cpp b/usql/lexer.cpp index adac66c..0316c15 100644 --- a/usql/lexer.cpp +++ b/usql/lexer.cpp @@ -14,7 +14,7 @@ namespace usql { Lexer::Lexer() { k_words_regex = "[-+]?[0-9]+\\.[0-9]+|[-+]?[0-9][0-9_]+[0-9]|[0-9]+|[A-Za-z]+[A-Za-z0-9_#]*|[\\(\\)\\[\\]\\{\\}]|[-\\+\\*/" - ",;:\?]|==|>=|<=|~=|>|<|=|;|~|\\||or|and|\n|\r|\r\n|'([^']|'')*'|\".*?\"|%.*?\n"; + ",;:\?]|!=|<>|==|>=|<=|~=|>|<|=|;|~|\\||or|and|\n|\r|\r\n|'([^']|'')*'|\".*?\"|%.*?\n"; k_int_regex = "[-+]?[0-9]+"; k_int_underscored_regex = "[-+]?[0-9][0-9_]+[0-9]"; k_double_regex = "[-+]?[0-9]+\\.[0-9]+"; @@ -22,16 +22,15 @@ namespace usql { } void Lexer::parse(const std::string &code) { - // TODO handle empty code - m_tokens.clear(); + if (code.empty()) + throw Exception("empty code"); + + m_tokens.clear(); + m_tokens.reserve(64); - // PERF something like this to preallocate ?? - if (code.size() > 100) { - m_tokens.reserve(code.size() / 10); - } m_code_str = code; if (!m_code_str.empty() && m_code_str.back() != '\n') { - m_code_str.append("\n"); // TODO temp solution to prevent possible situation when last line is a comment + m_code_str.append("\n"); // temp solution to prevent possible situation when last line is a comment } auto words_begin = std::sregex_iterator(m_code_str.begin(), m_code_str.end(), k_words_regex); @@ -45,7 +44,7 @@ namespace usql { match_str = stringLiteral(match_str); if (token_type != TokenType::newline) - m_tokens.push_back(Token{match_str, token_type}); + m_tokens.emplace_back(match_str, token_type); } // DEBUG IT @@ -56,8 +55,8 @@ namespace usql { void Lexer::debugTokens() { int i = 0; - for (std::vector::iterator it = m_tokens.begin(); it != m_tokens.end(); ++it) { - std::cerr << i << "\t" << it->token_string << std::endl; + for (auto & m_token : m_tokens) { + std::cerr << i << "\t" << m_token.token_string << std::endl; i++; } } @@ -97,8 +96,6 @@ namespace usql { return m_index < m_tokens.size() - 1 ? m_tokens[m_index + 1].type : TokenType::eof; } - TokenType Lexer::prevTokenType() { return m_index > 0 ? m_tokens[m_index - 1].type : TokenType::undef; } - bool Lexer::isRelationalOperator(TokenType token_type) { return (token_type == TokenType::equal || token_type == TokenType::not_equal || token_type == TokenType::greater || token_type == TokenType::greater_equal || @@ -116,118 +113,101 @@ namespace usql { } TokenType Lexer::type(const std::string &token) { - // TODO, FIXME 'one is evaluated as identifier + // FIXME 'one is evaluated as identifier if (token == ";") return TokenType::semicolon; - if (token == "+") return TokenType::plus; - if (token == "-") return TokenType::minus; - if (token == "*") return TokenType::multiply; - if (token == "/") return TokenType::divide; - if (token == "(") return TokenType::open_paren; - if (token == ")") return TokenType::close_paren; - if (token == "=") return TokenType::equal; - - if (token == "!=") + if (token == "!=" || token == "<>") return TokenType::not_equal; - if (token == ">") return TokenType::greater; - if (token == ">=") return TokenType::greater_equal; - if (token == "<") return TokenType::lesser; - if (token == "<=") return TokenType::lesser_equal; - if (token == "as") return TokenType::keyword_as; - if (token == "create") return TokenType::keyword_create; - if (token == "drop") return TokenType::keyword_drop; - if (token == "where") return TokenType::keyword_where; - + if (token == "order") + return TokenType::keyword_order; + if (token == "by") + return TokenType::keyword_by; + if (token == "offset") + return TokenType::keyword_offset; + if (token == "limit") + return TokenType::keyword_limit; + if (token == "asc") + return TokenType::keyword_asc; + if (token == "desc") + return TokenType::keyword_desc; if (token == "from") return TokenType::keyword_from; - if (token == "delete") return TokenType::keyword_delete; - if (token == "table") return TokenType::keyword_table; - if (token == "insert") return TokenType::keyword_insert; - if (token == "into") return TokenType::keyword_into; - if (token == "values") return TokenType::keyword_values; - if (token == "select") return TokenType::keyword_select; - if (token == "set") return TokenType::keyword_set; - if (token == "copy") return TokenType::keyword_copy; - if (token == "update") return TokenType::keyword_update; - if (token == "load") return TokenType::keyword_load; - if (token == "save") return TokenType::keyword_save; - if (token == "not") return TokenType::keyword_not; - if (token == "null") return TokenType::keyword_null; - if (token == "integer") return TokenType::keyword_integer; - if (token == "float") return TokenType::keyword_float; - if (token == "varchar") return TokenType::keyword_varchar; - + if (token == "date") + return TokenType::keyword_date; + if (token == "boolean") + return TokenType::keyword_bool; + if (token == "distinct") + return TokenType::keyword_distinct; + if (token == "show") + return TokenType::keyword_show; if (token == "or") return TokenType::logical_or; - if (token == "and") return TokenType::logical_and; - if (token == ",") return TokenType::comma; - if (token == "\n" || token == "\r\n" || token == "\r") return TokenType::newline; @@ -267,7 +247,7 @@ namespace usql { if (!replace) { return str; } - std::string out = ""; + std::string out; out.reserve(str.size()); @@ -347,6 +327,24 @@ namespace usql { case TokenType::keyword_where: txt = "where"; break; + case TokenType::keyword_order: + txt = "order"; + break; + case TokenType::keyword_by: + txt = "by"; + break; + case TokenType::keyword_offset: + txt = "offset"; + break; + case TokenType::keyword_limit: + txt = "limit"; + break; + case TokenType::keyword_asc: + txt = "asc"; + break; + case TokenType::keyword_desc: + txt = "desc"; + break; case TokenType::keyword_table: txt = "table"; break; @@ -389,6 +387,18 @@ namespace usql { case TokenType::keyword_varchar: txt = "varchar"; break; + case TokenType::keyword_date: + txt = "date"; + break; + case TokenType::keyword_bool: + txt = "boolean"; + break; + case TokenType::keyword_distinct: + txt = "distinct"; + break; + case TokenType::keyword_show: + txt = "show"; + break; case TokenType::int_number: txt = "int number"; break; diff --git a/usql/lexer.h b/usql/lexer.h index 2fbabb9..2552ae2 100644 --- a/usql/lexer.h +++ b/usql/lexer.h @@ -25,6 +25,12 @@ namespace usql { keyword_drop, keyword_table, keyword_where, + keyword_order, + keyword_by, + keyword_offset, + keyword_limit, + keyword_asc, + keyword_desc, keyword_delete, keyword_update, keyword_load, @@ -41,6 +47,10 @@ namespace usql { keyword_integer, keyword_float, keyword_varchar, + keyword_date, + keyword_bool, + keyword_distinct, + keyword_show, int_number, double_number, string_literal, @@ -85,8 +95,6 @@ namespace usql { TokenType nextTokenType(); - TokenType prevTokenType(); - static bool isRelationalOperator(TokenType token_type); static bool isLogicalOperator(TokenType token_type); @@ -96,7 +104,7 @@ namespace usql { private: TokenType type(const std::string &token); - std::string stringLiteral(std::string token); + static std::string stringLiteral(std::string token); static std::string typeToString(TokenType token_type); diff --git a/usql/main.cpp b/usql/main.cpp index c3db0ad..530b274 100644 --- a/usql/main.cpp +++ b/usql/main.cpp @@ -1,61 +1,206 @@ #include "parser.h" #include "usql.h" +#include "linenoise.h" + // https://dev.to/joaoh82/what-would-sqlite-look-like-if-written-in-rust-part-1-2np4 using namespace std::chrono; -int main(int argc, char *argv[]) { - std::vector sql_commands{ - "create table a (i integer not null, s varchar(64), f float null)", - "insert into a (i, s) values(1, upper('one'))", - "update table a set s = 'null string aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'", -// "update table a set i = null", - "insert into a (i, s) values(2, 'two')", - "insert into a (i, s) values(3, 'two')", - "insert into a (i, s) values(4, lower('FOUR'))", - "insert into a (i, s) values(5, 'five')", - "insert into a (i, s) values(to_date('20.12.1973', '%d.%m.%Y'), 'six')", - "save table a into '/tmp/a.csv'", - "select i, s from a where i > 2", - "select i, s from a where i = 1", - "select i, s from a where s = 'two'", - "select i, s from a where i <= 3 and s = 'one'", - "select i, s from a where i > 0", - "delete from a where i = 4", - "select i, s from a where i > 0", - "update a set f = 9.99 where i = 3", - "select i, s, f from a where i = 3", - "update a set s = 'three', f = f + 0.01 where i = 3", - "select i, s, f from a where i = 3", - "create table data (ticker varchar(8), price float null)", - "load data from '/Users/vaclavt/Library/Mobile Documents/com~apple~CloudDocs/Development/usql/data.csv')", - "select ticker, price from data", - "select i, s, f from a where i < 300", - "create table x as select i, s, f from a where i < 300", - "select i, s, f from x where i < 300", - "drop table x", - "select i, s, f from a where i > 300", - "select i, to_string(i, '%d.%m.%Y'), s, f from a where i > 300", - "create table prices (datetime integer, symbol varchar(8), prev_close float, open float, price float, change float, change_prct varchar(16))", - "load prices from '/Users/vaclavt/Library/Mobile Documents/com~apple~CloudDocs/Development/usql/prices.csv'", - "insert into prices (datetime, symbol, prev_close, open, price, change, change_prct) values (1626979443, 'MPC', 54.08, 53.82, 53.63, -0.832101, '-0.83 %')", - "select to_string(datetime, '%d.%m.%Y %H:%M:%S'), symbol, prev_close, open, price, change, change_prct from prices where symbol = 'SYF'" - }; +const std::vector commands { + "select", "create", "load", "table" +}; +std::string get_history_file_dir() { + std::string file{"/.usql_history.txt"}; + const char *t = std::getenv("HOME"); + + if (t == nullptr) return "/tmp/" + file; + else return std::string{t} + "/" + file; +} + + +size_t last_token_index( std::string str ) { + // remove trailing white space + while( !str.empty() && std::isspace( str.back() ) ) str.pop_back() ; + + // locate the last white space + return str.find_last_of( "() \t\n" ) ; +} + + +void completion(const char *buf, linenoiseCompletions *lc) { + if (buf != nullptr) { + std::string str{buf}; + + const auto pos = last_token_index(str); + if (pos == std::string::npos) + return; // cannot find what to complete + + std::string token = str.substr(pos + 1); + std::string begining = str.substr(0, pos + 1); + + for (const auto & command : commands) { + if (command.find(token) == 0) { + std::string completion_string = begining + command; + linenoiseAddCompletion(lc, completion_string.c_str()); + } + } + } +} + +char *hints(const char *buf, int *color, int *bold) { + // if (!strcasecmp(buf,"hello")) { + // *color = 35; + // *bold = 0; + // return " World"; + // } + return nullptr; +} + + +void setup_linenoise() { + std::string history_file = get_history_file_dir(); + + linenoiseHistorySetMaxLen(500); + linenoiseSetCompletionCallback(completion); + linenoiseSetHintsCallback(hints); + linenoiseSetMultiLine(1); + linenoiseHistoryLoad(history_file.c_str()); +} + +void linenoise_line_read(char *line) { + linenoiseHistoryAdd(line); +} + +void close_linenoise() { + std::string history_file = get_history_file_dir(); + + linenoiseHistorySave(history_file.c_str()); +} + + +void repl() { + std::string code; + std::string input; + + setup_linenoise(); usql::USql uSql{}; - for (auto command : sql_commands) { + + while (true) { + char *line = linenoise(">>> "); + if (line == nullptr) break; + + linenoise_line_read(line); + + input = std::string(line); + + if (input == "!quit" || input == "!q") + break; + else if (input == "!export" || input == "!x") { + std::cout << "File to export to: "; + std::getline(std::cin, input); + + //write_file_contents(input, code); + } else if (!input.empty()) { + try { + time_point start_time = high_resolution_clock::now(); + auto result = uSql.execute(input); + time_point end_time = high_resolution_clock::now(); + + std::cout << input << std::endl; + std::cout << "run time: " << duration_cast(end_time - start_time).count() << " ms " << std::endl <print(); + + code += input + "\n"; + } catch (std::exception &e) { + std::cerr << e.what() << std::endl; + } + } + } + + close_linenoise(); +} + +void debug() { + std::vector sql_commands{ +// "create table ticker ( tablee varchar(5) not null, permaticker integer, ticker varchar(10) not null, name varchar(256) not null, exchange varchar(32), isdelisted boolean, category varchar(32), cusips varchar(256), siccode integer, sicsector varchar(256), sicindustry varchar(256), famasector varchar(256), famaindustry varchar(256), sector varchar(128), industry varchar(128), scalemarketcap varchar(64), scalerevenue varchar(64), relatedtickers varchar(128), currency varchar(3), location varchar(64), lastupdated date, firstadded date, firstpricedate date, lastpricedate date, firstquarter date, lastquarter date, secfilings varchar(256), companysite varchar(256))", +// "load ticker from '/Users/vaclavt/Library/Mobile Documents/com~apple~CloudDocs/Development/usql/tickers.csv')", +// "select * from ticker where ticker = 'WFC' and tablee = 'SF1'", +// "set 'DATE_FORMAT' = '%Y-%m-%d'", +// "show 'DATE_FORMAT'", + "create table sf1 ( ticker varchar(8), dimension varchar(3), calendar_date date, date_key date, report_period date, last_updated date, accoci float, assets float, assetsavg float, assetsc float, assetsnc float, assetturnover float, bvps float, capex float, cashneq float, cashnequsd float, cor float, consolinc float, currentratio float, de float, debt float, debtc float, debtnc float, debtusd float, deferredrev float, depamor float, deposits float, divyield float, dps float, ebit float, ebitda float, ebitdamargin float, ebitdausd float, ebitusd float, ebt float, eps float, epsdil float, epsusd float, equity float, equityavg float, equityusd float, ev float, evebit float, evebitda float, fcf float, fcfps float, fxusd float, gp float, grossmargin float, intangibles float, intexp float, invcap float, invcapavg float, inventory float, investments float, investmentsc float, investmentsnc float, liabilities float, liabilitiesc float, liabilitiesnc float, marketcap float, ncf float, ncfbus float, ncfcommon float, ncfdebt float, ncfdiv float, ncff float, ncfi float, ncfinv float, ncfo float, ncfx float, netinc float, netinccmn float, netinccmnusd float, netincdis float, netincnci float, netmargin float, opex float, opinc float, payables float, payoutratio float, pb float, pe float, pe1 float, ppnenet float, prefdivis float, price float, ps float, ps1 float, receivables float, retearn float, revenue float, revenueusd float, rnd float, roa float, roe float, roic float, ros float, sbcomp float, sgna float, sharefactor float, sharesbas float, shareswa float, shareswadil float, sps float, tangibles float, taxassets float, taxexp float, taxliabilities float, tbvps float, workingcapital float)", + "load sf1 from '/tmp/sf1.csv'", +// "select ticker, calendar_date from sf1 where calendar_date > to_date('2019-01-01', '%Y-%m-%d') limit 1", +// "select ticker, dimension, calendar_date, eps, dps, roa*100 as roa, roe*100 as roe, pp(revenue), netinc from sf1 where (ticker = 'AIG' or ticker = 'WFC') and dimension = 'MRY' and calendar_date > to_date('2019-01-01', '%Y-%m-%d') order by 3 desc + "select ticker, dimension, calendar_date, eps, dps, roa*100 as roa, roe*100 as roe, pp(revenue) as revenue, pp(netinc) as netinc from sf1 where (ticker = 'AIG' or ticker = 'WFC') and dimension = 'MRY' and calendar_date > to_date('2019-01-01', '%Y-%m-%d') order by 3 desc", +// "create table a (i integer not null, s varchar(64), f float null, d date null, b boolean)", +// "insert into a (i, s, b) values(1, upper('one'), 'Y')", +// "insert into a (i, s, b, f) values(1 + 10000, upper('one'), 'Y', 3.1415)", +// "update a set i = i * 100, f = f + 0.01 where i > 1", +// "select to_string(i, '%d.%m.%Y %H:%M:%S'), i, s from a where i < to_date('20.12.2019', '%d.%m.%Y')", +// "select i + 2 as first, i, s, b, f from a where i >=1 order by 1 desc offset 0 limit 1", +// "update table a set s = 'null string aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'", +// "update table a set i = null", +// "insert into a (i, s) values(2, 'two')", +// "insert into a (i, s) values(3, 'two')", +// "insert into a (i, s) values(4, lower('FOUR'))", +// "insert into a (i, s) values(5, 'five')", +// "insert into a (i, s) values(to_date('20.12.1973', '%d.%m.%Y'), 'six')", + // tohle zpusobi kresh "insert into a (i, d) values(6', '2006-10-04')", +// "insert into a (i, d) values(6, '2006-10-04')", +// "save table a into '/tmp/a.csv'", +// "select i, s from a where i > 2 order by 1 desc offset 1 limit 1", +// "select distinct s, d from a", +// "select i, s from a where i = 1", +// "select i, s from a where s = 'two'", +// "select i, s from a where i <= 3 and s = 'one'", +// "select i, s from a where i > 0", +// "delete from a where i = 4", +// "select i, s from a where i > 0", +// "update a set f = 9.99 where i = 3", +// "select i, s, f from a where i = 3", +// "update a set s = 'three', f = f + 0.01 where i = 3", +// "select i, s, f from a where i = 3", +// "create table data (ticker varchar(8), price float null)", +// "load data from '/Users/vaclavt/Library/Mobile Documents/com~apple~CloudDocs/Development/usql/data.csv')", +// "select ticker, price from data", +// "select i, s, f from a where i < 300", +// "create table x as select i, s, f from a where i < 300", +// "select i, s, f from x where i < 300", +// "drop table x", +// "select i, s, f from a where i > 300", +// "select i, to_string(i, '%d.%m.%Y'), s, f from a where i > 300", +// "create table prices (datetime integer, symbol varchar(8), prev_close float, open float, price float, change float, change_prct varchar(16))", +// "load prices from '/Users/vaclavt/Library/Mobile Documents/com~apple~CloudDocs/Development/usql/prices.csv'", +// "insert into prices (datetime, symbol, prev_close, open, price, change, change_prct) values (1626979443, 'MPC', 54.08, 53.82, 53.63, -0.832101, '-0.83 %')", +// "select to_string(datetime, '%d.%m.%Y %H:%M:%S'), symbol, prev_close, open, price, change, change_prct, datetime from prices where symbol = 'SYF' order by 8 desc limit 10" + }; + + usql::USql uSql{}; + + for (const auto &command : sql_commands) { time_point start_time = high_resolution_clock::now(); auto result = uSql.execute(command); time_point end_time = high_resolution_clock::now(); std::cout << command << std::endl; - std::cout << "run time: " << duration_cast(end_time - start_time).count() << " ms " << std::endl; + std::cout << "run time: " << duration_cast(end_time - start_time).count() << " ms " + << std::endl << std::endl; result->print(); } + std::cout << std::endl << std::endl; +} + +int main(int argc, char *argv[]) { + + // debug(); + repl(); + return 0; } diff --git a/usql/ml_date.cpp b/usql/ml_date.cpp deleted file mode 100644 index e6ff561..0000000 --- a/usql/ml_date.cpp +++ /dev/null @@ -1,59 +0,0 @@ - -#include "ml_date.h" - -long now() { - // get-universal-time - time_t t = std::time(0); - long int now = static_cast(t); - - return now; -} - -std::string date_to_string(const long datetime, const std::string format) { - // std::locale::global(std::locale("en-US.UTF8")); - - time_t timestamp = datetime; - char mbstr[128]; - - if (std::strftime(mbstr, sizeof(mbstr), format.c_str(), std::localtime(×tamp))) { - std::string result = {mbstr}; - return result; - } - // TODO exception here - return "invalid argument"; -} - -long string_to_date(const std::string &datestr, const std::string &format) { - // format for example "%d.%m.%Y"; - - std::istringstream in{datestr.c_str()}; - date::sys_seconds tp; - in >> date::parse(format, tp); - return tp.time_since_epoch().count(); -} - -long add_to_date(const long datetime, const long quantity, const std::string &part) { - // part is one of 'year', 'month', 'day', 'hour', 'minute' or 'second' - - // very basic implementation, just for now - no timezones DST etc - time_t base = datetime; - struct tm *tm = localtime(&base); - - if (part == "year") { - tm->tm_year += quantity; - } else if (part == "month") { - tm->tm_mon += quantity; - } else if (part == "day") { - tm->tm_mday += quantity; - } else if (part == "hour") { - tm->tm_hour += quantity; - } else if (part == "minute") { - tm->tm_min += quantity; - } else if (part == "second") { - tm->tm_sec += quantity; - } else { - // TODO exception here - } - - return mktime(tm); -} diff --git a/usql/ml_date.h b/usql/ml_date.h deleted file mode 100644 index 5353d23..0000000 --- a/usql/ml_date.h +++ /dev/null @@ -1,17 +0,0 @@ - -#pragma once - -#include "clib/date.h" - -#include -#include - - -long now(); - -std::string date_to_string(const long datetime, const std::string format); - -long string_to_date(const std::string &datestr, const std::string &format); - -long add_to_date(const long datetime, const long quantity, const std::string &part); - diff --git a/usql/parser.cpp b/usql/parser.cpp index 2f926dc..c98b772 100644 --- a/usql/parser.cpp +++ b/usql/parser.cpp @@ -15,6 +15,9 @@ namespace usql { if (m_lexer.tokenType() == TokenType::keyword_create && m_lexer.nextTokenType() == TokenType::keyword_table) return parse_create_table(); + if (m_lexer.tokenType() == TokenType::keyword_drop) + return parse_drop_table(); + if (m_lexer.tokenType() == TokenType::keyword_insert) return parse_insert_into_table(); if (m_lexer.tokenType() == TokenType::keyword_select) @@ -23,12 +26,16 @@ namespace usql { return parse_delete_from_table(); if (m_lexer.tokenType() == TokenType::keyword_update) return parse_update_table(); + if (m_lexer.tokenType() == TokenType::keyword_load) return parse_load_table(); if (m_lexer.tokenType() == TokenType::keyword_save) return parse_save_table(); - if (m_lexer.tokenType() == TokenType::keyword_drop) - return parse_drop_table(); + + if (m_lexer.tokenType() == TokenType::keyword_set) + return parse_set(); + if (m_lexer.tokenType() == TokenType::keyword_show) + return parse_show(); std::cout << "ERROR, token:" << m_lexer.currentToken().token_string << std::endl; return std::make_unique(NodeType::error); @@ -40,7 +47,9 @@ namespace usql { m_lexer.skipToken(TokenType::keyword_create); m_lexer.skipToken(TokenType::keyword_table); - if (m_lexer.tokenType() != TokenType::identifier) { /* TODO handle error */ } + if (m_lexer.tokenType() != TokenType::identifier) + throw Exception("syntax error, expecting identifier but found " + m_lexer.currentToken().token_string); + std::string table_name = m_lexer.consumeCurrentToken().token_string; // create as select @@ -54,16 +63,16 @@ namespace usql { m_lexer.skipToken(TokenType::open_paren); int column_order = 0; do { - std::string column_name; + std::string database_value; ColumnType column_type; - int column_len{1}; - bool column_nullable{true}; + int column_len = 1; + bool column_nullable = true; // column name if (m_lexer.tokenType() != TokenType::identifier) { throw Exception("syntax error, expected identifier"); } - column_name = m_lexer.consumeCurrentToken().token_string; + database_value = m_lexer.consumeCurrentToken().token_string; // column type and optionally len if (m_lexer.tokenType() == TokenType::keyword_integer) { @@ -82,8 +91,14 @@ namespace usql { throw Exception("syntax error, expected int number"); } m_lexer.skipToken(TokenType::close_paren); + } else if (m_lexer.tokenType() == TokenType::keyword_date) { + column_type = ColumnType::date_type; + m_lexer.nextToken(); + } else if (m_lexer.tokenType() == TokenType::keyword_bool) { + column_type = ColumnType::bool_type; + m_lexer.nextToken(); } else { - throw Exception("syntax error, column type expected"); + throw Exception("syntax error, column type expected, found " + m_lexer.currentToken().token_string); } if (m_lexer.tokenType() == TokenType::keyword_not) { @@ -94,11 +109,12 @@ namespace usql { m_lexer.nextToken(); } - cols_def.push_back( ColDefNode(column_name, column_type, column_order++, column_len, column_nullable)); + cols_def.emplace_back(database_value, column_type, column_order++, column_len, column_nullable); m_lexer.skipTokenOptional(TokenType::comma); - // TODO in future constraints + //constraints + //defaults } while (m_lexer.tokenType() != TokenType::close_paren); return std::make_unique(table_name, cols_def); @@ -139,23 +155,50 @@ namespace usql { return std::make_unique(table_name); } + + std::unique_ptr Parser::parse_set() { + m_lexer.skipToken(TokenType::keyword_set); + + if (m_lexer.currentToken().type!=TokenType::string_literal) throw Exception("Expecting literal in set name"); + std::string name = m_lexer.consumeCurrentToken().token_string; + + m_lexer.skipTokenOptional(TokenType::equal); + + if (m_lexer.currentToken().type!=TokenType::string_literal) throw Exception("Expecting literal in set value"); + std::string value = m_lexer.consumeCurrentToken().token_string; + + return std::make_unique(name, value); + } + + std::unique_ptr Parser::parse_show() { + m_lexer.skipToken(TokenType::keyword_show); + + if (m_lexer.currentToken().type!=TokenType::string_literal) throw Exception("Expecting literal on show parameter name"); + std::string name = m_lexer.consumeCurrentToken().token_string; + + return std::make_unique(name); + } std::unique_ptr Parser::parse_insert_into_table() { - std::vector column_names{}; + std::vector database_values{}; std::vector> column_values{}; m_lexer.skipToken(TokenType::keyword_insert); m_lexer.skipToken(TokenType::keyword_into); // table name - if (m_lexer.tokenType() != TokenType::identifier) { /* TODO handle error */ } + if (m_lexer.tokenType() != TokenType::identifier) + throw Exception("syntax error, expecting identifier but found " + m_lexer.currentToken().token_string); + std::string table_name = m_lexer.consumeCurrentToken().token_string; // column names m_lexer.skipToken(TokenType::open_paren); do { - if (m_lexer.tokenType() != TokenType::identifier) { /* TODO handle error */ } - column_names.push_back(m_lexer.consumeCurrentToken().token_string); + if (m_lexer.tokenType() != TokenType::identifier) + throw Exception("syntax error, expecting identifier but found " + m_lexer.currentToken().token_string); + + database_values.emplace_back(m_lexer.consumeCurrentToken().token_string); m_lexer.skipTokenOptional(TokenType::comma); } while (m_lexer.tokenType() != TokenType::close_paren); @@ -166,65 +209,53 @@ namespace usql { // column values m_lexer.skipToken(TokenType::open_paren); do { - auto col_value = parse_value(); + auto col_value = parse_expression(); column_values.push_back(std::move(col_value)); m_lexer.skipTokenOptional(TokenType::comma); } while (m_lexer.tokenType() != TokenType::close_paren); m_lexer.skipToken(TokenType::close_paren); - return std::make_unique(table_name, column_names, std::move(column_values)); + return std::make_unique(table_name, database_values, std::move(column_values)); } -std::unique_ptr Parser::parse_value() { - if (m_lexer.tokenType() == TokenType::int_number) { - return std::make_unique(std::stoi(m_lexer.consumeCurrentToken().token_string)); - } - if (m_lexer.tokenType() == TokenType::double_number) { - return std::make_unique(std::stof(m_lexer.consumeCurrentToken().token_string)); - } - if (m_lexer.tokenType() == TokenType::string_literal) { - return std::make_unique(m_lexer.consumeCurrentToken().token_string); - } - if (m_lexer.tokenType() == TokenType::identifier && m_lexer.nextTokenType() == TokenType::open_paren) { - // function - std::string function_name = m_lexer.consumeCurrentToken().token_string; - std::vector> pars; - - m_lexer.skipToken(TokenType::open_paren); - while (m_lexer.tokenType() != TokenType::close_paren) { // TODO handle errors - pars.push_back(parse_value()); - m_lexer.skipTokenOptional(TokenType::comma); - } - m_lexer.skipToken(TokenType::close_paren); - return std::make_unique(function_name, std::move(pars)); - } - if (m_lexer.tokenType() == TokenType::identifier) { - std::string name = m_lexer.consumeCurrentToken().token_string; - return std::make_unique(name); - } - - throw Exception("Syntax error, current token: " + m_lexer.currentToken().token_string); -} - -std::unique_ptr Parser::parse_select_from_table() { + std::unique_ptr Parser::parse_select_from_table() { + bool distinct = false; auto cols = std::make_unique>(); m_lexer.skipToken(TokenType::keyword_select); + if (m_lexer.tokenType() == TokenType::keyword_distinct) { + distinct = true; + m_lexer.skipToken(TokenType::keyword_distinct); + } + int i = 1; while (m_lexer.tokenType() != TokenType::keyword_from) { - auto column_value = parse_value(); - std::string column_alias; + if (m_lexer.tokenType()==TokenType::multiply) { + std::string name = m_lexer.consumeCurrentToken().token_string; + auto multiply_char = std::make_unique(name); - if (column_value->node_type == NodeType::column_name) { - column_alias = ((ColNameNode*) column_value.get())->name; + cols->push_back(SelectColNode{std::move(multiply_char), "*"}); } else { - column_alias = "c" + std::to_string(i); - i++; + auto column_value = parse_expression(); + std::string column_alias; + + if (m_lexer.tokenType() == TokenType::keyword_as) { + m_lexer.skipToken(TokenType::keyword_as); + column_alias = m_lexer.consumeCurrentToken().token_string; + } else { + if (column_value->node_type == NodeType::database_value) { + column_alias = ((DatabaseValueNode*) column_value.get())->col_name; + } else { + column_alias = "c" + std::to_string(i); + i++; + } + } + + cols->push_back(SelectColNode{std::move(column_value), column_alias}); } - cols->push_back(SelectColNode{std::move(column_value), column_alias}); m_lexer.skipTokenOptional(TokenType::comma); } @@ -235,12 +266,13 @@ std::unique_ptr Parser::parse_select_from_table() { std::unique_ptr where_node = parse_where_clause(); -// if (m_lexer.tokenType() == TokenType::keyword_order_by) {} -// if (m_lexer.tokenType() == TokenType::keyword_offset) {} -// if (m_lexer.tokenType() == TokenType::keyword_limit) {} + std::vector orderby_node = parse_order_by_clause(); - return std::make_unique(table_name, std::move(cols), std::move(where_node)); -} + OffsetLimitNode offsetlimit_node = parse_offset_limit_clause(); + + + return std::make_unique(table_name, std::move(cols), std::move(where_node), orderby_node, offsetlimit_node, distinct); + } std::unique_ptr Parser::parse_delete_from_table() { m_lexer.skipToken(TokenType::keyword_delete); @@ -261,24 +293,22 @@ std::unique_ptr Parser::parse_select_from_table() { m_lexer.skipToken(TokenType::keyword_set); - std::vector cols_names; + std::vector cols_names; std::vector> values; do { - cols_names.push_back(m_lexer.consumeCurrentToken().token_string); + cols_names.emplace_back(m_lexer.consumeCurrentToken().token_string); m_lexer.skipToken(TokenType::equal); - std::unique_ptr left = Parser::parse_operand_node(); + std::unique_ptr left = Parser::parse_value(); if (Lexer::isArithmeticalOperator(m_lexer.tokenType())) { ArithmeticalOperatorType op = parse_arithmetical_operator(); - std::unique_ptr right = Parser::parse_operand_node(); + std::unique_ptr right = Parser::parse_value(); - values.push_back(std::make_unique(op, std::move(left), - std::move(right))); + values.push_back(std::make_unique(op, std::move(left), std::move(right))); } else { std::unique_ptr right = std::make_unique(0); - values.push_back( - std::make_unique(ArithmeticalOperatorType::copy_value, + values.push_back(std::make_unique(ArithmeticalOperatorType::copy_value, std::move(left), std::move(right))); } m_lexer.skipTokenOptional(TokenType::comma); @@ -290,55 +320,163 @@ std::unique_ptr Parser::parse_select_from_table() { return std::make_unique(table_name, cols_names, std::move(values), std::move(where_node)); } + + std::vector Parser::parse_order_by_clause() { + std::vector order_cols; + + if (m_lexer.tokenType() == TokenType::keyword_order) { + m_lexer.skipToken(TokenType::keyword_order); + m_lexer.skipToken(TokenType::keyword_by); + + do { + int col_index = FUNCTION_CALL; + bool asc = true; + + auto token_type = m_lexer.tokenType(); + std::string tokenString = m_lexer.consumeCurrentToken().token_string; + switch (token_type) { + case TokenType::int_number: + col_index = std::stoi(tokenString); + break; + default: + throw Exception("column index allowed in order by clause at this moment"); + } + + if (m_lexer.tokenType() == TokenType::keyword_asc) { + m_lexer.skipToken(TokenType::keyword_asc); + } else if (m_lexer.tokenType() == TokenType::keyword_desc) { + m_lexer.skipToken(TokenType::keyword_desc); + asc = false; + } + + order_cols.emplace_back(col_index, asc); + + m_lexer.skipTokenOptional(TokenType::comma); + + } while (m_lexer.tokenType() != TokenType::eof && m_lexer.tokenType() != TokenType::keyword_offset && m_lexer.tokenType() != TokenType::keyword_limit); + } + + return order_cols; + } + + OffsetLimitNode Parser::parse_offset_limit_clause() { + int offset = 0; + int limit = 999999999; + + if (m_lexer.tokenType() == TokenType::keyword_offset) { + m_lexer.skipToken(TokenType::keyword_offset); + + if (m_lexer.tokenType() != TokenType::int_number) + throw Exception("expecting integer in offset clause"); + + offset = std::stoi(m_lexer.consumeCurrentToken().token_string); + } + + if (m_lexer.tokenType() == TokenType::keyword_limit) { + m_lexer.skipToken(TokenType::keyword_limit); + + if (m_lexer.tokenType() != TokenType::int_number) + throw Exception("expecting integer in limit clause"); + + limit = std::stoi(m_lexer.consumeCurrentToken().token_string); + } + + return OffsetLimitNode{offset, limit}; + } + + std::unique_ptr Parser::parse_where_clause() { - // TODO add support for multiple filters - // TODO add support for parenthesis + if (m_lexer.tokenType() != TokenType::keyword_where) { + return std::make_unique(); + } - if (m_lexer.tokenType() != TokenType::keyword_where) { - return std::make_unique(); + m_lexer.skipToken(TokenType::keyword_where); + + std::unique_ptr left = parse_expression(); + do { + left = parse_expression(std::move(left)); + + } while (m_lexer.tokenType() != TokenType::eof && m_lexer.tokenType() != TokenType::keyword_order && m_lexer.tokenType() != TokenType::keyword_offset && m_lexer.tokenType() != TokenType::keyword_limit); + + return left; + } + + std::unique_ptr Parser::parse_expression() { + std::unique_ptr left = parse_value(); + + return parse_expression(std::move(left)); + } + + std::unique_ptr Parser::parse_expression(std::unique_ptr left) { + if (Lexer::isRelationalOperator(m_lexer.tokenType())) { + auto operation = parse_relational_operator(); + auto right = parse_value(); + return std::make_unique(operation, std::move(left), std::move(right)); + } else if (Lexer::isLogicalOperator(m_lexer.tokenType())) { + auto operation = parse_logical_operator(); + auto right = parse_expression(); + return std::make_unique(operation, std::move(left), std::move(right)); + } else if (Lexer::isArithmeticalOperator(m_lexer.tokenType())) { + auto operation = parse_arithmetical_operator(); + auto right = parse_value(); + + return std::make_unique(operation, std::move(left), std::move(right)); + } else if (m_lexer.tokenType() == TokenType::int_number || m_lexer.tokenType() == TokenType::double_number ||m_lexer.tokenType() == TokenType::string_literal ||m_lexer.tokenType() == TokenType::identifier || m_lexer.tokenType() == TokenType::keyword_null || m_lexer.tokenType() == TokenType::open_paren) { + return parse_value(); } - - std::unique_ptr node; - m_lexer.skipToken(TokenType::keyword_where); - do { - node = parse_relational_expression(); - - if (Lexer::isLogicalOperator(m_lexer.tokenType())) { - auto operation = parse_logical_operator(); - std::unique_ptr node2 = parse_relational_expression(); - node = std::make_unique(operation, std::move(node), std::move(node2)); - } - } while (m_lexer.tokenType() != TokenType::eof); // until whole where clause parsed - - return node; + + return left; } - std::unique_ptr Parser::parse_relational_expression() { - auto left = parse_operand_node(); - auto operation = parse_relational_operator(); - auto right = parse_operand_node(); - - return std::make_unique(operation, std::move(left), std::move(right)); - } - - std::unique_ptr Parser::parse_operand_node() { - // while not end or order or limit + std::unique_ptr Parser::parse_value() { auto token_type = m_lexer.tokenType(); - std::string tokenString = m_lexer.consumeCurrentToken().token_string; - switch (token_type) { - case TokenType::int_number: - return std::make_unique(std::stoi(tokenString)); - case TokenType::double_number: - return std::make_unique(std::stod(tokenString)); - case TokenType::string_literal: - return std::make_unique(tokenString); - case TokenType::identifier: - return std::make_unique(tokenString); - case TokenType::keyword_null: - return std::make_unique(); - default:; - throw Exception("Unknown operand node"); + + // parenthesised expression + if (token_type == TokenType::open_paren) { + m_lexer.skipToken(TokenType::open_paren); + + auto left = parse_expression(); + do { + left = parse_expression(std::move(left)); + } while (m_lexer.tokenType() != TokenType::close_paren && m_lexer.tokenType() != TokenType::eof); + + m_lexer.skipToken(TokenType::close_paren); + return left; } + + // function call + if (token_type == TokenType::identifier && m_lexer.nextTokenType() == TokenType::open_paren) { + std::string function_name = m_lexer.consumeCurrentToken().token_string; + std::vector> pars; + + m_lexer.skipToken(TokenType::open_paren); + while (m_lexer.tokenType() != TokenType::close_paren && m_lexer.tokenType() != TokenType::eof) { + pars.push_back(parse_value()); + m_lexer.skipTokenOptional(TokenType::comma); + } + m_lexer.skipToken(TokenType::close_paren); + return std::make_unique(function_name, std::move(pars)); + } + + // numbers and strings + std::string tokenString = m_lexer.consumeCurrentToken().token_string; + + if (token_type == TokenType::int_number) + return std::make_unique(std::stoi(tokenString)); + if (token_type == TokenType::double_number) + return std::make_unique(std::stod(tokenString)); + if (token_type == TokenType::string_literal) + return std::make_unique(tokenString); + + // db column + if (token_type == TokenType::identifier) + return std::make_unique(tokenString); + + // null + if (token_type == TokenType::keyword_null) + return std::make_unique(); + + throw Exception("Unknown operand node " + tokenString); } RelationalOperatorType Parser::parse_relational_operator() { @@ -357,7 +495,7 @@ std::unique_ptr Parser::parse_select_from_table() { case TokenType::lesser_equal: return RelationalOperatorType::lesser_equal; default: - throw Exception("Unknown relational operator"); + throw Exception("Unknown relational operator " + op.token_string); } } @@ -389,4 +527,5 @@ std::unique_ptr Parser::parse_select_from_table() { } } -} \ No newline at end of file +} // namespace + diff --git a/usql/parser.h b/usql/parser.h index ead5e65..a5f2d65 100644 --- a/usql/parser.h +++ b/usql/parser.h @@ -2,16 +2,22 @@ #include "lexer.h" #include "exception.h" -#include +#include "ml_date.h" +#include "settings.h" +#include #include +static const int FUNCTION_CALL = -1; + namespace usql { enum class ColumnType { integer_type, float_type, - varchar_type + varchar_type, + date_type, + bool_type }; enum class NodeType { @@ -20,7 +26,7 @@ namespace usql { int_value, float_value, string_value, - database_value, + bool_value, logical_operator, relational_operator, arithmetical_operator, @@ -33,7 +39,11 @@ namespace usql { load_table, save_table, drop_table, - column_name, + set, + show, + database_value, + offset_limit, + column_order, column_value, function, column_def, @@ -43,21 +53,35 @@ namespace usql { struct Node { NodeType node_type; - Node(const NodeType type) : node_type(type) {} + explicit Node(const NodeType type) : node_type(type) {} }; - struct ColNameNode : Node { - std::string name; - ColNameNode(const std::string col_name) : Node(NodeType::column_name), name(col_name) {} + struct ColOrderNode : Node { + std::string col_name; + int col_index; + bool ascending; + + ColOrderNode(const std::string& name, bool asc) : Node(NodeType::column_order), col_name(name), col_index(-1), ascending(asc) {} + ColOrderNode(int index, bool asc) : Node(NodeType::database_value), col_name(""), col_index(index), ascending(asc) {} }; + + + struct OffsetLimitNode : Node { + int offset; + int limit; + + OffsetLimitNode(int off, int lim) : Node(NodeType::offset_limit), offset(off), limit(lim) {} + }; + + struct SelectColNode : Node { std::unique_ptr value; std::string name; - SelectColNode(std::unique_ptr column, const std::string& alias) : - Node(NodeType::column_name), value(std::move(column)), name(alias) {} + SelectColNode(std::unique_ptr column, const std::string &alias) : + Node(NodeType::database_value), value(std::move(column)), name(alias) {} }; struct ColDefNode : Node { @@ -67,16 +91,16 @@ namespace usql { int length; bool null; - ColDefNode(const std::string col_name, ColumnType col_type, int col_order, int col_len, bool nullable) : + ColDefNode(const std::string& col_name, ColumnType col_type, int col_order, int col_len, bool nullable) : Node(NodeType::column_def), name(col_name), type(col_type), order(col_order), length(col_len), null(nullable) {} }; struct FunctionNode : Node { - std::string function; + std::string function; // TODO use enum std::vector> params; - FunctionNode(const std::string func_name, std::vector> pars) : + FunctionNode(const std::string& func_name, std::vector> pars) : Node(NodeType::function), function(func_name), params(std::move(pars)) {} }; @@ -85,14 +109,16 @@ namespace usql { }; struct ValueNode : Node { - ValueNode(NodeType type) : Node(type) {} + explicit ValueNode(NodeType type) : Node(type) {} virtual bool isNull() { return false; } - virtual long getIntValue() = 0; + virtual long getIntegerValue() = 0; virtual double getDoubleValue() = 0; virtual std::string getStringValue() = 0; + virtual long getDateValue() = 0; + virtual bool getBooleanValue() = 0; - virtual ~ValueNode() {}; + virtual ~ValueNode() = default; }; struct NullValueNode : ValueNode { @@ -101,45 +127,66 @@ namespace usql { bool isNull() override { return true; } - long getIntValue() override { throw Exception("not supported on null value"); }; - double getDoubleValue() override { throw Exception("not supported on null value"); }; - std::string getStringValue() override { throw Exception("not supported on null value"); }; + long getIntegerValue() override { throw Exception("getIntegerValue not supported on NullValueNode"); }; + double getDoubleValue() override { throw Exception("getDoubleValue not supported on NullValueNode"); }; + std::string getStringValue() override { throw Exception("getStringValue not supported on NullValueNode"); }; + long getDateValue() override { throw Exception("getDateValue not supported on NullValueNode"); }; + bool getBooleanValue() override { throw Exception("getBooleanValue not supported on NullValueNode"); }; }; struct IntValueNode : ValueNode { long value; - IntValueNode(long value) : ValueNode(NodeType::int_value), value(value) {} + explicit IntValueNode(long value) : ValueNode(NodeType::int_value), value(value) {} - long getIntValue() override { return value; }; + long getIntegerValue() override { return value; }; double getDoubleValue() override { return (double) value; }; std::string getStringValue() override { return std::to_string(value); } + long getDateValue() override { return value; }; + bool getBooleanValue() override { return value != 0; }; }; struct DoubleValueNode : ValueNode { double value; - DoubleValueNode(double value) : ValueNode(NodeType::float_value), value(value) {} + explicit DoubleValueNode(double value) : ValueNode(NodeType::float_value), value(value) {} - long getIntValue() override { return (long) value; }; + long getIntegerValue() override { return (long) value; }; double getDoubleValue() override { return value; }; std::string getStringValue() override { return std::to_string(value); } + long getDateValue() override { return (long) value; }; + bool getBooleanValue() override { return value != 0.0; }; }; struct StringValueNode : ValueNode { std::string value; - StringValueNode(std::string value) : ValueNode(NodeType::string_value), value(value) {} + explicit StringValueNode(const std::string &value) : ValueNode(NodeType::string_value), value(value) {} - long getIntValue() override { return std::stoi(value); }; + long getIntegerValue() override { return std::stoi(value); }; double getDoubleValue() override { return std::stod(value); }; std::string getStringValue() override { return value; }; + long getDateValue() override { return Settings::string_to_date(value); }; + bool getBooleanValue() override { return value == "true"; }; }; + struct BooleanValueNode : ValueNode { + bool value; + + explicit BooleanValueNode(bool value) : ValueNode(NodeType::bool_value), value(value) {} + + long getIntegerValue() override { return (long) value; }; + double getDoubleValue() override { return (double) value; }; + std::string getStringValue() override { return value ? "true" : "false"; } + long getDateValue() override { return (long) value; }; + bool getBooleanValue() override { return value; }; + }; + + struct DatabaseValueNode : Node { std::string col_name; - DatabaseValueNode(std::string name) : Node(NodeType::database_value), col_name(name) {} + explicit DatabaseValueNode(const std::string &name) : Node(NodeType::database_value), col_name(name) {} }; enum class LogicalOperatorType { @@ -200,42 +247,45 @@ namespace usql { std::vector cols_defs; CreateTableNode(const std::string& name, std::vector defs) : - Node(NodeType::create_table), table_name(name), cols_defs(defs) {} + Node(NodeType::create_table), table_name(name), cols_defs(std::move(defs)) {} }; struct InsertIntoTableNode : Node { std::string table_name; - std::vector cols_names; + std::vector cols_names; std::vector> cols_values; - InsertIntoTableNode(const std::string name, std::vector names, std::vector> values) : - Node(NodeType::insert_into), table_name(name), cols_names(names), cols_values(std::move(values)) {} + InsertIntoTableNode(const std::string& name, std::vector names, std::vector> values) : + Node(NodeType::insert_into), table_name(name), cols_names(std::move(names)), cols_values(std::move(values)) {} }; struct SelectFromTableNode : Node { std::string table_name; std::unique_ptr> cols_names; std::unique_ptr where; + std::vector order_by; + OffsetLimitNode offset_limit; + bool distinct; - SelectFromTableNode(std::string name, std::unique_ptr> names, std::unique_ptr where_clause) : - Node(NodeType::select_from), table_name(name), cols_names(std::move(names)), where(std::move(where_clause)) {} + SelectFromTableNode(std::string name, std::unique_ptr> names, std::unique_ptr where_clause, std::vector orderby, OffsetLimitNode offlim, bool distinct_): + Node(NodeType::select_from), table_name(std::move(name)), cols_names(std::move(names)), where(std::move(where_clause)), order_by(std::move(orderby)), offset_limit(offlim), distinct(distinct_) {} }; struct CreateTableAsSelectNode : Node { std::string table_name; std::unique_ptr select_table; - CreateTableAsSelectNode(const std::string name, std::unique_ptr table) : + CreateTableAsSelectNode(const std::string& name, std::unique_ptr table) : Node(NodeType::create_table_as_select), table_name(name), select_table(std::move(table)) {} }; struct UpdateTableNode : Node { std::string table_name; - std::vector cols_names; + std::vector cols_names; std::vector> values; std::unique_ptr where; - UpdateTableNode(std::string name, std::vector names, std::vector> vals, + UpdateTableNode(const std::string &name, std::vector names, std::vector> vals, std::unique_ptr where_clause) : Node(NodeType::update_table), table_name(name), cols_names(names), values(std::move(vals)), where(std::move(where_clause)) {} @@ -245,7 +295,7 @@ namespace usql { std::string table_name; std::string filename; - LoadIntoTableNode(const std::string name, std::string file) : + LoadIntoTableNode(const std::string& name, const std::string &file) : Node(NodeType::load_table), table_name(name), filename(file) {} }; @@ -253,14 +303,14 @@ namespace usql { std::string table_name; std::string filename; - SaveTableNode(const std::string& name, std::string file) : + SaveTableNode(const std::string& name, const std::string &file) : Node(NodeType::save_table), table_name(name), filename(file) {} }; struct DropTableNode : Node { std::string table_name; - DropTableNode(const std::string& name) : Node(NodeType::drop_table), table_name(name) {} + explicit DropTableNode(const std::string& name) : Node(NodeType::drop_table), table_name(name) {} }; struct DeleteFromTableNode : Node { @@ -271,6 +321,21 @@ namespace usql { Node(NodeType::delete_from), table_name(name), where(std::move(where_clause)) {} }; + struct SetNode : Node { + std::string name; + std::string value; + + SetNode(const std::string& name_, const std::string& value_) : + Node(NodeType::set), name(name_), value(value_) {} + }; + + struct ShowNode : Node { + std::string name; + + explicit ShowNode(const std::string& name_) : Node(NodeType::show), name(name_) {} + }; + + class Parser { private: @@ -282,17 +347,24 @@ namespace usql { private: std::unique_ptr parse_create_table(); + std::unique_ptr parse_drop_table(); std::unique_ptr parse_load_table(); std::unique_ptr parse_save_table(); - std::unique_ptr parse_drop_table(); + std::unique_ptr parse_set(); + std::unique_ptr parse_show(); std::unique_ptr parse_insert_into_table(); std::unique_ptr parse_select_from_table(); std::unique_ptr parse_delete_from_table(); std::unique_ptr parse_update_table(); + std::vector parse_order_by_clause(); + OffsetLimitNode parse_offset_limit_clause(); + std::unique_ptr parse_where_clause(); - std::unique_ptr parse_operand_node(); + std::unique_ptr parse_expression(); + std::unique_ptr parse_expression(std::unique_ptr left); + std::unique_ptr parse_value(); RelationalOperatorType parse_relational_operator(); LogicalOperatorType parse_logical_operator(); @@ -300,8 +372,6 @@ namespace usql { private: Lexer m_lexer; - - std::unique_ptr parse_relational_expression(); }; -} \ No newline at end of file +} // namespace diff --git a/usql/prices.csv b/usql/prices.csv deleted file mode 100644 index ae9232d..0000000 --- a/usql/prices.csv +++ /dev/null @@ -1,3061 +0,0 @@ -datetime,symbol,prev_close,open,price,change,change_prct -1627316521,FDX,297.070007,296.089996,296.679993,-0.131282,-0.13 % -1627316521,C,66.709999,66.459999,67.209999,0.749513,+0.75 % -1627316521,AIG,47.310001,47.279999,47.419998,0.232509,+0.23 % -1627316521,BAC,37.700001,37.660000,38.035000,0.888594,+0.89 % -1627316521,BK,49.630001,49.500000,50.299999,1.349990,+1.35 % -1627316521,PBF,9.010000,9.070000,9.430000,4.661490,+4.66 % -1627316521,PBFX,13.500000,13.400000,13.495000,-0.037037,-0.04 % -1627316521,SYF,46.509998,46.490002,47.049999,1.161040,+1.16 % -1627316521,WFC,44.590000,44.470001,44.750099,0.359049,+0.36 % -1627316521,TEVA,8.810000,8.850000,8.908000,1.112370,+1.11 % -1627316521,XOM,57.040001,57.160000,58.110001,1.875880,+1.88 % -1627316521,MPC,53.430000,53.830002,54.320000,1.665730,+1.67 % -1627316844,FDX,297.070007,296.089996,296.959015,-0.037399,-0.04 % -1627316844,C,66.709999,66.459999,67.250000,0.809474,+0.81 % -1627316844,AIG,47.310001,47.279999,47.520000,0.443881,+0.44 % -1627316844,BAC,37.700001,37.660000,38.084999,1.021220,+1.02 % -1627316844,BK,49.630001,49.500000,50.299999,1.349990,+1.35 % -1627316844,PBF,9.010000,9.070000,9.435000,4.716980,+4.72 % -1627316844,PBFX,13.500000,13.400000,13.495000,-0.037037,-0.04 % -1627316844,SYF,46.509998,46.490002,47.055000,1.171790,+1.17 % -1627316844,WFC,44.590000,45.099998,44.814999,0.504597,+0.50 % -1627316844,TEVA,8.810000,8.850000,8.915000,1.191830,+1.19 % -1627316844,XOM,57.040001,57.160000,58.125000,1.902170,+1.90 % -1627316844,MPC,53.430000,53.830002,54.299999,1.628300,+1.63 % -1627317086,FDX,297.070007,296.089996,297.140015,0.023564,+0.02 % -1627317086,C,66.709999,66.459999,67.294998,0.876930,+0.88 % -1627317086,AIG,47.310001,47.279999,47.549999,0.507292,+0.51 % -1627317086,BAC,37.700001,37.660000,38.105000,1.074270,+1.07 % -1627317086,BK,49.630001,49.500000,50.369999,1.491030,+1.49 % -1627317086,PBF,9.010000,9.070000,9.445000,4.827970,+4.83 % -1627317086,PBFX,13.500000,13.400000,13.451000,-0.362963,-0.36 % -1627317086,SYF,46.509998,46.490002,47.049999,1.161040,+1.16 % -1627317086,WFC,44.590000,45.099998,44.820000,0.515811,+0.52 % -1627317086,TEVA,8.810000,8.850000,8.915000,1.191830,+1.19 % -1627317086,XOM,57.040001,57.160000,58.153801,1.952660,+1.95 % -1627317086,MPC,53.430000,53.830002,54.349998,1.721880,+1.72 % -1627317155,FDX,297.070007,296.089996,297.200012,0.043761,+0.04 % -1627317155,C,66.709999,66.459999,67.260002,0.824464,+0.82 % -1627317155,AIG,47.310001,47.279999,47.520000,0.443881,+0.44 % -1627317155,BAC,37.700001,37.660000,38.100300,1.061800,+1.06 % -1627317155,BK,49.630001,49.500000,50.360001,1.470880,+1.47 % -1627317155,PBF,9.010000,9.070000,9.450000,4.883460,+4.88 % -1627317155,PBFX,13.500000,13.400000,13.451000,-0.362963,-0.36 % -1627317155,SYF,46.509998,46.490002,47.049999,1.161040,+1.16 % -1627317155,WFC,44.590000,44.470001,44.794998,0.459744,+0.46 % -1627317155,TEVA,8.810000,8.850000,8.919100,1.238370,+1.24 % -1627317155,XOM,57.040001,57.160000,58.130001,1.910940,+1.91 % -1627317155,MPC,53.430000,53.830002,54.355000,1.731240,+1.73 % -1627317217,FDX,297.070007,296.089996,297.109985,0.013465,+0.01 % -1627317217,C,66.709999,66.459999,67.257004,0.819967,+0.82 % -1627317217,AIG,47.310001,47.279999,47.520000,0.443881,+0.44 % -1627317217,BAC,37.700001,37.660000,38.080002,1.007960,+1.01 % -1627317217,BK,49.630001,49.500000,50.360001,1.470880,+1.47 % -1627317217,PBF,9.010000,9.070000,9.445000,4.827970,+4.83 % -1627317217,PBFX,13.500000,13.400000,13.451000,-0.362963,-0.36 % -1627317217,SYF,46.509998,46.490002,46.990002,1.032040,+1.03 % -1627317217,WFC,44.590000,44.470001,44.781700,0.429917,+0.43 % -1627317217,TEVA,8.810000,8.850000,8.905000,1.078320,+1.08 % -1627317217,XOM,57.040001,57.160000,58.115002,1.884640,+1.88 % -1627317217,MPC,53.430000,53.830002,54.270000,1.572150,+1.57 % -1627317280,FDX,297.070007,296.089996,297.149994,0.026930,+0.03 % -1627317280,C,66.709999,66.459999,67.257004,0.819967,+0.82 % -1627317280,AIG,47.310001,47.279999,47.520000,0.443881,+0.44 % -1627317280,BAC,37.700001,37.660000,38.080002,1.007960,+1.01 % -1627317280,BK,49.630001,49.500000,50.365002,1.480960,+1.48 % -1627317280,PBF,9.010000,9.070000,9.430000,4.661490,+4.66 % -1627317280,PBFX,13.500000,13.400000,13.451000,-0.362963,-0.36 % -1627317280,SYF,46.509998,46.490002,47.014999,1.085790,+1.09 % -1627317280,WFC,44.590000,44.470001,44.781700,0.429917,+0.43 % -1627317280,TEVA,8.810000,8.850000,8.895000,0.964813,+0.96 % -1627317280,XOM,57.040001,57.160000,58.099998,1.858350,+1.86 % -1627317280,MPC,53.430000,53.830002,54.299999,1.628300,+1.63 % -1627317342,FDX,297.070007,296.089996,297.149994,0.026930,+0.03 % -1627317342,C,66.709999,66.459999,67.294998,0.876930,+0.88 % -1627317342,AIG,47.310001,47.279999,47.509998,0.422744,+0.42 % -1627317342,BAC,37.700001,37.660000,38.084400,1.019630,+1.02 % -1627317342,BK,49.630001,49.500000,50.365002,1.480960,+1.48 % -1627317342,PBF,9.010000,9.070000,9.440000,4.772480,+4.77 % -1627317342,PBFX,13.500000,13.400000,13.451000,-0.362963,-0.36 % -1627317342,SYF,46.509998,46.490002,47.014999,1.085790,+1.09 % -1627317342,WFC,44.590000,44.470001,44.775002,0.414891,+0.41 % -1627317342,TEVA,8.810000,8.850000,8.895000,0.964813,+0.96 % -1627317342,XOM,57.040001,57.160000,58.154999,1.954770,+1.95 % -1627317342,MPC,53.430000,53.830002,54.310001,1.647010,+1.65 % -1627317404,FDX,297.070007,296.089996,297.269989,0.067324,+0.07 % -1627317404,C,66.709999,66.459999,67.330002,0.929396,+0.93 % -1627317404,AIG,47.310001,47.279999,47.570000,0.549567,+0.55 % -1627317404,BAC,37.700001,37.660000,38.160000,1.220160,+1.22 % -1627317404,BK,49.630001,49.500000,50.400002,1.551480,+1.55 % -1627317404,PBF,9.010000,9.070000,9.450000,4.883460,+4.88 % -1627317404,PBFX,13.500000,13.400000,13.451000,-0.362963,-0.36 % -1627317404,SYF,46.509998,46.490002,47.055000,1.171790,+1.17 % -1627317404,WFC,44.590000,44.470001,44.830002,0.538237,+0.54 % -1627317404,TEVA,8.810000,8.850000,8.909900,1.133940,+1.13 % -1627317404,XOM,57.040001,57.160000,58.169998,1.981070,+1.98 % -1627317404,MPC,53.430000,53.830002,54.369999,1.759310,+1.76 % -1627317466,FDX,297.070007,296.089996,297.220001,0.050493,+0.05 % -1627317466,C,66.709999,66.459999,67.330002,0.929396,+0.93 % -1627317466,AIG,47.310001,47.279999,47.570000,0.549567,+0.55 % -1627317466,BAC,37.700001,37.660000,38.160000,1.220160,+1.22 % -1627317466,BK,49.630001,49.500000,50.424999,1.601850,+1.60 % -1627317466,PBF,9.010000,9.070000,9.450000,4.883460,+4.88 % -1627317466,PBFX,13.500000,13.400000,13.451000,-0.362963,-0.36 % -1627317466,SYF,46.509998,46.490002,47.080002,1.225540,+1.23 % -1627317466,WFC,44.590000,44.470001,44.860001,0.605517,+0.61 % -1627317466,TEVA,8.810000,8.850000,8.915000,1.191830,+1.19 % -1627317466,XOM,57.040001,57.160000,58.134998,1.919710,+1.92 % -1627317466,MPC,53.430000,53.830002,54.320000,1.665730,+1.67 % -1627317528,FDX,297.070007,296.089996,297.420013,0.117817,+0.12 % -1627317528,C,66.709999,66.459999,67.379997,1.004350,+1.00 % -1627317528,AIG,47.310001,47.279999,47.590000,0.591841,+0.59 % -1627317528,BAC,37.700001,37.660000,38.195000,1.313000,+1.31 % -1627317528,BK,49.630001,49.500000,50.445000,1.642150,+1.64 % -1627317528,PBF,9.010000,9.070000,9.445000,4.827970,+4.83 % -1627317528,PBFX,13.500000,13.400000,13.451000,-0.362963,-0.36 % -1627317528,SYF,46.509998,46.490002,47.105000,1.279290,+1.28 % -1627317528,WFC,44.590000,44.470001,44.860001,0.605517,+0.61 % -1627317528,TEVA,8.810000,8.850000,8.910000,1.135070,+1.14 % -1627317528,XOM,57.040001,57.160000,58.179901,1.998420,+2.00 % -1627317528,MPC,53.430000,53.830002,54.340000,1.703160,+1.70 % -1627317590,FDX,297.070007,296.089996,297.390015,0.107719,+0.11 % -1627317590,C,66.709999,66.459999,67.339996,0.944386,+0.94 % -1627317590,AIG,47.310001,47.279999,47.599998,0.612978,+0.61 % -1627317590,BAC,37.700001,37.660000,38.187599,1.293370,+1.29 % -1627317590,BK,49.630001,49.500000,50.445000,1.642150,+1.64 % -1627317590,PBF,9.010000,9.070000,9.440000,4.772480,+4.77 % -1627317590,PBFX,13.500000,13.400000,13.451000,-0.362963,-0.36 % -1627317590,SYF,46.509998,46.490002,47.119999,1.311550,+1.31 % -1627317590,WFC,44.590000,44.470001,44.810001,0.493384,+0.49 % -1627317590,TEVA,8.810000,8.850000,8.915000,1.191830,+1.19 % -1627317590,XOM,57.040001,57.160000,58.209900,2.051020,+2.05 % -1627317590,MPC,53.430000,53.830002,54.352001,1.725620,+1.73 % -1627317653,FDX,297.070007,296.089996,297.244995,0.058909,+0.06 % -1627317653,C,66.709999,66.459999,67.312202,0.902713,+0.90 % -1627317653,AIG,47.310001,47.279999,47.560001,0.528430,+0.53 % -1627317653,BAC,37.700001,37.660000,38.160099,1.220420,+1.22 % -1627317653,BK,49.630001,49.500000,50.380001,1.511180,+1.51 % -1627317653,PBF,9.010000,9.070000,9.440000,4.772480,+4.77 % -1627317653,PBFX,13.500000,13.400000,13.451000,-0.362963,-0.36 % -1627317653,SYF,46.509998,46.490002,47.110001,1.290050,+1.29 % -1627317653,WFC,44.590000,44.470001,44.810001,0.493384,+0.49 % -1627317653,TEVA,8.810000,8.850000,8.915000,1.191830,+1.19 % -1627317653,XOM,57.040001,57.160000,58.209999,2.051190,+2.05 % -1627317653,MPC,53.430000,53.830002,54.330002,1.684450,+1.68 % -1627317715,FDX,297.070007,296.089996,297.244995,0.058909,+0.06 % -1627317715,C,66.709999,66.459999,67.334999,0.936891,+0.94 % -1627317715,AIG,47.310001,47.279999,47.570000,0.549567,+0.55 % -1627317715,BAC,37.700001,37.660000,38.189999,1.299730,+1.30 % -1627317715,BK,49.630001,49.500000,50.420101,1.591980,+1.59 % -1627317715,PBF,9.010000,9.070000,9.440000,4.772480,+4.77 % -1627317715,PBFX,13.500000,13.400000,13.451000,-0.362963,-0.36 % -1627317715,SYF,46.509998,46.490002,47.080002,1.225540,+1.23 % -1627317715,WFC,44.590000,44.470001,44.799999,0.470958,+0.47 % -1627317715,TEVA,8.810000,8.850000,8.915000,1.191830,+1.19 % -1627317715,XOM,57.040001,57.160000,58.209999,2.051190,+2.05 % -1627317715,MPC,53.430000,53.830002,54.310001,1.647010,+1.65 % -1627317777,FDX,297.070007,296.089996,297.190002,0.040394,+0.04 % -1627317777,C,66.709999,66.459999,67.269897,0.839304,+0.84 % -1627317777,AIG,47.310001,47.279999,47.529999,0.465018,+0.47 % -1627317777,BAC,37.700001,37.660000,38.159302,1.218300,+1.22 % -1627317777,BK,49.630001,49.500000,50.420101,1.591980,+1.59 % -1627317777,PBF,9.010000,9.070000,9.422000,4.572700,+4.57 % -1627317777,PBFX,13.500000,13.400000,13.451000,-0.362963,-0.36 % -1627317777,SYF,46.509998,46.490002,47.040001,1.139540,+1.14 % -1627317777,WFC,44.590000,44.470001,44.770000,0.403678,+0.40 % -1627317777,TEVA,8.810000,8.850000,8.905000,1.078320,+1.08 % -1627317777,XOM,57.040001,57.160000,58.154999,1.954770,+1.95 % -1627317777,MPC,53.430000,53.830002,54.290001,1.609580,+1.61 % -1627317840,FDX,297.070007,296.089996,297.190002,0.040394,+0.04 % -1627317840,C,66.709999,66.459999,67.330002,0.929396,+0.93 % -1627317840,AIG,47.310001,47.279999,47.529999,0.465018,+0.47 % -1627317840,BAC,37.700001,37.660000,38.159302,1.218300,+1.22 % -1627317840,BK,49.630001,49.500000,50.419998,1.591780,+1.59 % -1627317840,PBF,9.010000,9.070000,9.430000,4.661490,+4.66 % -1627317840,PBFX,13.500000,13.400000,13.451000,-0.362963,-0.36 % -1627317840,SYF,46.509998,46.490002,47.063999,1.191140,+1.19 % -1627317840,WFC,44.590000,44.470001,44.770000,0.403678,+0.40 % -1627317840,TEVA,8.810000,8.850000,8.915000,1.191830,+1.19 % -1627317840,XOM,57.040001,57.160000,58.200001,2.033660,+2.03 % -1627317840,MPC,53.430000,53.830002,54.320000,1.665730,+1.67 % -1627317902,FDX,297.070007,296.089996,297.089996,0.006732,+0.01 % -1627317902,C,66.709999,66.459999,67.330002,0.929396,+0.93 % -1627317902,AIG,47.310001,47.279999,47.544998,0.496724,+0.50 % -1627317902,BAC,37.700001,37.660000,38.139999,1.167110,+1.17 % -1627317902,BK,49.630001,49.500000,50.419998,1.591780,+1.59 % -1627317902,PBF,9.010000,9.070000,9.425000,4.605990,+4.61 % -1627317902,PBFX,13.500000,13.400000,13.451000,-0.362963,-0.36 % -1627317902,SYF,46.509998,46.490002,47.063999,1.191140,+1.19 % -1627317902,WFC,44.590000,45.099998,44.770000,0.403678,+0.40 % -1627317902,TEVA,8.810000,8.850000,8.915000,1.191830,+1.19 % -1627317902,XOM,57.040001,57.160000,58.194199,2.023490,+2.02 % -1627317902,MPC,53.430000,53.830002,54.320000,1.665730,+1.67 % -1627317964,FDX,297.070007,296.089996,297.089996,0.006732,+0.01 % -1627317964,C,66.709999,66.459999,67.381500,1.006600,+1.01 % -1627317964,AIG,47.310001,47.279999,47.544998,0.496724,+0.50 % -1627317964,BAC,37.700001,37.660000,38.174999,1.259950,+1.26 % -1627317964,BK,49.630001,49.500000,50.384998,1.521260,+1.52 % -1627317964,PBF,9.010000,9.070000,9.420000,4.550500,+4.55 % -1627317964,PBFX,13.500000,13.400000,13.460000,-0.296296,-0.30 % -1627317964,SYF,46.509998,46.490002,47.049999,1.161040,+1.16 % -1627317964,WFC,44.590000,45.099998,44.810001,0.493384,+0.49 % -1627317964,TEVA,8.810000,8.850000,8.915000,1.191830,+1.19 % -1627317964,XOM,57.040001,57.160000,58.165001,1.972300,+1.97 % -1627317964,MPC,53.430000,53.830002,54.349998,1.721880,+1.72 % -1627318026,FDX,297.070007,296.089996,297.000000,-0.023564,-0.02 % -1627318026,C,66.709999,66.459999,67.360001,0.974367,+0.97 % -1627318026,AIG,47.310001,47.279999,47.590000,0.591841,+0.59 % -1627318026,BAC,37.700001,37.660000,38.150002,1.193630,+1.19 % -1627318026,BK,49.630001,49.500000,50.389999,1.531330,+1.53 % -1627318026,PBF,9.010000,9.070000,9.450000,4.883460,+4.88 % -1627318026,PBFX,13.500000,13.400000,13.460000,-0.296296,-0.30 % -1627318026,SYF,46.509998,46.490002,47.064999,1.193290,+1.19 % -1627318026,WFC,44.590000,45.099998,44.775002,0.414891,+0.41 % -1627318026,TEVA,8.810000,8.850000,8.915000,1.191830,+1.19 % -1627318026,XOM,57.040001,57.160000,58.195000,2.024890,+2.02 % -1627318026,MPC,53.430000,53.830002,54.384998,1.787390,+1.79 % -1627318088,FDX,297.070007,296.089996,297.000000,-0.023564,-0.02 % -1627318088,C,66.709999,66.459999,67.360001,0.974367,+0.97 % -1627318088,AIG,47.310001,47.279999,47.590000,0.591841,+0.59 % -1627318088,BAC,37.700001,37.660000,38.150002,1.193630,+1.19 % -1627318088,BK,49.630001,49.500000,50.369999,1.491030,+1.49 % -1627318088,PBF,9.010000,9.070000,9.450000,4.883460,+4.88 % -1627318088,PBFX,13.500000,13.400000,13.460000,-0.296296,-0.30 % -1627318088,SYF,46.509998,46.490002,47.075001,1.214790,+1.21 % -1627318088,WFC,44.590000,45.099998,44.775002,0.414891,+0.41 % -1627318088,TEVA,8.810000,8.850000,8.917400,1.219070,+1.22 % -1627318088,XOM,57.040001,57.160000,58.215000,2.059960,+2.06 % -1627318088,MPC,53.430000,53.830002,54.389999,1.796740,+1.80 % -1627318151,FDX,297.070007,296.089996,296.869995,-0.067324,-0.07 % -1627318151,C,66.709999,66.459999,67.364998,0.981862,+0.98 % -1627318151,AIG,47.310001,47.279999,47.560001,0.528430,+0.53 % -1627318151,BAC,37.700001,37.660000,38.154999,1.206900,+1.21 % -1627318151,BK,49.630001,49.500000,50.375000,1.501110,+1.50 % -1627318151,PBF,9.010000,9.070000,9.440000,4.772480,+4.77 % -1627318151,PBFX,13.500000,13.400000,13.460000,-0.296296,-0.30 % -1627318151,SYF,46.509998,46.490002,47.080002,1.225540,+1.23 % -1627318151,WFC,44.590000,44.470001,44.799999,0.470958,+0.47 % -1627318151,TEVA,8.810000,8.850000,8.905000,1.078320,+1.08 % -1627318151,XOM,57.040001,57.160000,58.215000,2.059960,+2.06 % -1627318151,MPC,53.430000,53.830002,54.439899,1.890140,+1.89 % -1627318213,FDX,297.070007,296.089996,296.945007,-0.042078,-0.04 % -1627318213,C,66.709999,66.459999,67.410004,1.049320,+1.05 % -1627318213,AIG,47.310001,47.279999,47.560001,0.528430,+0.53 % -1627318213,BAC,37.700001,37.660000,38.153301,1.202390,+1.20 % -1627318213,BK,49.630001,49.500000,50.375000,1.501110,+1.50 % -1627318213,PBF,9.010000,9.070000,9.455000,4.938960,+4.94 % -1627318213,PBFX,13.500000,13.400000,13.460000,-0.296296,-0.30 % -1627318213,SYF,46.509998,46.490002,47.105000,1.279290,+1.28 % -1627318213,WFC,44.590000,45.099998,44.790001,0.448531,+0.45 % -1627318213,TEVA,8.810000,8.850000,8.905000,1.078320,+1.08 % -1627318213,XOM,57.040001,57.160000,58.230000,2.086260,+2.09 % -1627318213,MPC,53.430000,53.830002,54.465000,1.937110,+1.94 % -1627318276,FDX,297.070007,296.089996,296.865997,-0.068536,-0.07 % -1627318276,C,66.709999,66.459999,67.416603,1.059210,+1.06 % -1627318276,AIG,47.310001,47.279999,47.570000,0.549567,+0.55 % -1627318276,BAC,37.700001,37.660000,38.180698,1.275070,+1.28 % -1627318276,BK,49.630001,49.500000,50.396900,1.545230,+1.55 % -1627318276,PBF,9.010000,9.070000,9.450000,4.883460,+4.88 % -1627318276,PBFX,13.500000,13.400000,13.460000,-0.296296,-0.30 % -1627318276,SYF,46.509998,46.490002,47.105000,1.279290,+1.28 % -1627318276,WFC,44.590000,45.099998,44.790001,0.448531,+0.45 % -1627318276,TEVA,8.810000,8.850000,8.910000,1.135070,+1.14 % -1627318276,XOM,57.040001,57.160000,58.240002,2.103790,+2.10 % -1627318276,MPC,53.430000,53.830002,54.459999,1.927760,+1.93 % -1627318338,FDX,297.070007,296.089996,296.799988,-0.090888,-0.09 % -1627318338,C,66.709999,66.459999,67.404999,1.041820,+1.04 % -1627318338,AIG,47.310001,47.279999,47.570000,0.549567,+0.55 % -1627318338,BAC,37.700001,37.660000,38.169998,1.246680,+1.25 % -1627318338,BK,49.630001,49.500000,50.396900,1.545230,+1.55 % -1627318338,PBF,9.010000,9.070000,9.445000,4.827970,+4.83 % -1627318338,PBFX,13.500000,13.400000,13.460000,-0.296296,-0.30 % -1627318338,SYF,46.509998,46.490002,47.082600,1.231130,+1.23 % -1627318338,WFC,44.590000,45.099998,44.805000,0.482171,+0.48 % -1627318338,TEVA,8.810000,8.850000,8.910000,1.135070,+1.14 % -1627318338,XOM,57.040001,57.160000,58.220001,2.068720,+2.07 % -1627318338,MPC,53.430000,53.830002,54.455002,1.918400,+1.92 % -1627318401,FDX,297.070007,296.089996,296.799988,-0.090888,-0.09 % -1627318401,C,66.709999,66.459999,67.385002,1.011840,+1.01 % -1627318401,AIG,47.310001,47.279999,47.570000,0.549567,+0.55 % -1627318401,BAC,37.700001,37.660000,38.169998,1.246680,+1.25 % -1627318401,BK,49.630001,49.500000,50.380001,1.511180,+1.51 % -1627318401,PBF,9.010000,9.070000,9.445000,4.827970,+4.83 % -1627318401,PBFX,13.500000,13.400000,13.460000,-0.296296,-0.30 % -1627318401,SYF,46.509998,46.490002,47.082600,1.231130,+1.23 % -1627318401,WFC,44.590000,45.099998,44.805000,0.482171,+0.48 % -1627318401,TEVA,8.810000,8.850000,8.915000,1.191830,+1.19 % -1627318401,XOM,57.040001,57.160000,58.200001,2.033660,+2.03 % -1627318401,MPC,53.430000,53.830002,54.455002,1.918400,+1.92 % -1627318463,FDX,297.070007,296.089996,296.799988,-0.090888,-0.09 % -1627318463,C,66.709999,66.459999,67.345001,0.951881,+0.95 % -1627318463,AIG,47.310001,47.279999,47.500000,0.401606,+0.40 % -1627318463,BAC,37.700001,37.660000,38.130001,1.140580,+1.14 % -1627318463,BK,49.630001,49.500000,50.380001,1.511180,+1.51 % -1627318463,PBF,9.010000,9.070000,9.420000,4.550500,+4.55 % -1627318463,PBFX,13.500000,13.400000,13.460000,-0.296296,-0.30 % -1627318463,SYF,46.509998,46.490002,46.965000,0.978284,+0.98 % -1627318463,WFC,44.590000,45.099998,44.764999,0.392465,+0.39 % -1627318463,TEVA,8.810000,8.850000,8.915000,1.191830,+1.19 % -1627318463,XOM,57.040001,57.160000,58.160000,1.963530,+1.96 % -1627318463,MPC,53.430000,53.830002,54.349998,1.721880,+1.72 % -1627318526,FDX,297.070007,296.089996,296.799988,-0.090888,-0.09 % -1627318526,C,66.709999,66.459999,67.350098,0.959526,+0.96 % -1627318526,AIG,47.310001,47.279999,47.500000,0.401606,+0.40 % -1627318526,BAC,37.700001,37.660000,38.131001,1.143240,+1.14 % -1627318526,BK,49.630001,49.500000,50.360001,1.470880,+1.47 % -1627318526,PBF,9.010000,9.070000,9.420000,4.550500,+4.55 % -1627318526,PBFX,13.500000,13.400000,13.460000,-0.296296,-0.30 % -1627318526,SYF,46.509998,46.490002,47.000000,1.053540,+1.05 % -1627318526,WFC,44.590000,44.470001,44.770000,0.403678,+0.40 % -1627318526,TEVA,8.810000,8.850000,8.905000,1.078320,+1.08 % -1627318526,XOM,57.040001,57.160000,58.180000,1.998600,+2.00 % -1627318526,MPC,53.430000,53.830002,54.369999,1.759310,+1.76 % -1627318588,FDX,297.070007,296.089996,296.924988,-0.048810,-0.05 % -1627318588,C,66.709999,66.459999,67.379997,1.004350,+1.00 % -1627318588,AIG,47.310001,47.279999,47.540001,0.486155,+0.49 % -1627318588,BAC,37.700001,37.660000,38.134998,1.153850,+1.15 % -1627318588,BK,49.630001,49.500000,50.375000,1.501110,+1.50 % -1627318588,PBF,9.010000,9.070000,9.410000,4.439510,+4.44 % -1627318588,PBFX,13.500000,13.400000,13.460000,-0.296296,-0.30 % -1627318588,SYF,46.509998,46.490002,47.000000,1.053540,+1.05 % -1627318588,WFC,44.590000,44.470001,44.779999,0.426105,+0.43 % -1627318588,TEVA,8.810000,8.850000,8.900000,1.021570,+1.02 % -1627318588,XOM,57.040001,57.160000,58.195000,2.024890,+2.02 % -1627318588,MPC,53.430000,53.830002,54.360001,1.740600,+1.74 % -1627318650,FDX,297.070007,296.089996,296.839996,-0.077423,-0.08 % -1627318650,C,66.709999,66.459999,67.383598,1.009740,+1.01 % -1627318650,AIG,47.310001,47.279999,47.549999,0.507292,+0.51 % -1627318650,BAC,37.700001,37.660000,38.134998,1.153850,+1.15 % -1627318650,BK,49.630001,49.500000,50.355000,1.460810,+1.46 % -1627318650,PBF,9.010000,9.070000,9.430000,4.661490,+4.66 % -1627318650,PBFX,13.500000,13.400000,13.460000,-0.296296,-0.30 % -1627318650,SYF,46.509998,46.490002,47.000000,1.053540,+1.05 % -1627318650,WFC,44.590000,44.470001,44.779999,0.426105,+0.43 % -1627318650,TEVA,8.810000,8.850000,8.905000,1.078320,+1.08 % -1627318650,XOM,57.040001,57.160000,58.169998,1.981070,+1.98 % -1627318650,MPC,53.430000,53.830002,54.365002,1.749950,+1.75 % -1627318712,FDX,297.070007,296.089996,296.790009,-0.094254,-0.09 % -1627318712,C,66.709999,66.459999,67.320000,0.914406,+0.91 % -1627318712,AIG,47.310001,47.279999,47.509998,0.422744,+0.42 % -1627318712,BAC,37.700001,37.660000,38.115002,1.100800,+1.10 % -1627318712,BK,49.630001,49.500000,50.299999,1.349990,+1.35 % -1627318712,PBF,9.010000,9.070000,9.419900,4.549390,+4.55 % -1627318712,PBFX,13.500000,13.400000,13.460000,-0.296296,-0.30 % -1627318712,SYF,46.509998,46.490002,46.980000,1.010540,+1.01 % -1627318712,WFC,44.590000,45.099998,44.759998,0.381251,+0.38 % -1627318712,TEVA,8.810000,8.850000,8.905000,1.078320,+1.08 % -1627318712,XOM,57.040001,57.160000,58.169998,1.981070,+1.98 % -1627318712,MPC,53.430000,53.830002,54.310001,1.647010,+1.65 % -1627318774,FDX,297.070007,296.089996,296.714996,-0.119500,-0.12 % -1627318774,C,66.709999,66.459999,67.309998,0.899415,+0.90 % -1627318774,AIG,47.310001,47.279999,47.529999,0.465018,+0.47 % -1627318774,BAC,37.700001,37.660000,38.099300,1.059150,+1.06 % -1627318774,BK,49.630001,49.500000,50.299999,1.349990,+1.35 % -1627318774,PBF,9.010000,9.070000,9.420000,4.550500,+4.55 % -1627318774,PBFX,13.500000,13.400000,13.460000,-0.296296,-0.30 % -1627318774,SYF,46.509998,46.490002,46.939999,0.924532,+0.92 % -1627318774,WFC,44.590000,44.470001,44.750000,0.358825,+0.36 % -1627318774,TEVA,8.810000,8.850000,8.905000,1.078320,+1.08 % -1627318774,XOM,57.040001,57.160000,58.189999,2.016130,+2.02 % -1627318774,MPC,53.430000,53.830002,54.325802,1.676590,+1.68 % -1627318837,FDX,297.070007,296.089996,296.714996,-0.119500,-0.12 % -1627318837,C,66.709999,66.459999,67.364998,0.981862,+0.98 % -1627318837,AIG,47.310001,47.279999,47.529999,0.465018,+0.47 % -1627318837,BAC,37.700001,37.660000,38.115002,1.100800,+1.10 % -1627318837,BK,49.630001,49.500000,50.340000,1.430590,+1.43 % -1627318837,PBF,9.010000,9.070000,9.430000,4.661490,+4.66 % -1627318837,PBFX,13.500000,13.400000,13.460000,-0.296296,-0.30 % -1627318837,SYF,46.509998,46.490002,46.970001,0.989035,+0.99 % -1627318837,WFC,44.590000,44.470001,44.759998,0.381251,+0.38 % -1627318837,TEVA,8.810000,8.850000,8.915000,1.191830,+1.19 % -1627318837,XOM,57.040001,57.160000,58.180000,1.998600,+2.00 % -1627318837,MPC,53.430000,53.830002,54.336300,1.696240,+1.70 % -1627318899,FDX,297.070007,296.089996,296.750000,-0.107719,-0.11 % -1627318899,C,66.709999,66.459999,67.375000,0.996852,+1.00 % -1627318899,AIG,47.310001,47.279999,47.540001,0.486155,+0.49 % -1627318899,BAC,37.700001,37.660000,38.130001,1.140580,+1.14 % -1627318899,BK,49.630001,49.500000,50.365002,1.480960,+1.48 % -1627318899,PBF,9.010000,9.070000,9.430000,4.661490,+4.66 % -1627318899,PBFX,13.500000,13.400000,13.460000,-0.296296,-0.30 % -1627318899,SYF,46.509998,46.490002,46.985001,1.021290,+1.02 % -1627318899,WFC,44.590000,44.470001,44.759998,0.381251,+0.38 % -1627318899,TEVA,8.810000,8.850000,8.915000,1.191830,+1.19 % -1627318899,XOM,57.040001,57.160000,58.200001,2.033660,+2.03 % -1627318899,MPC,53.430000,53.830002,54.360001,1.740600,+1.74 % -1627318961,FDX,297.070007,296.089996,296.750000,-0.107719,-0.11 % -1627318961,C,66.709999,66.459999,67.375000,0.996852,+1.00 % -1627318961,AIG,47.310001,47.279999,47.520000,0.443881,+0.44 % -1627318961,BAC,37.700001,37.660000,38.127399,1.133690,+1.13 % -1627318961,BK,49.630001,49.500000,50.375000,1.501110,+1.50 % -1627318961,PBF,9.010000,9.070000,9.430000,4.661490,+4.66 % -1627318961,PBFX,13.500000,13.400000,13.500000,0.000000,+0.00 % -1627318961,SYF,46.509998,46.490002,46.970001,0.989035,+0.99 % -1627318961,WFC,44.590000,44.470001,44.764999,0.392465,+0.39 % -1627318961,TEVA,8.810000,8.850000,8.915000,1.191830,+1.19 % -1627318961,XOM,57.040001,57.160000,58.194401,2.023840,+2.02 % -1627318961,MPC,53.430000,53.830002,54.360001,1.740600,+1.74 % -1627319023,FDX,297.070007,296.089996,296.700012,-0.124550,-0.12 % -1627319023,C,66.709999,66.459999,67.349998,0.959376,+0.96 % -1627319023,AIG,47.310001,47.279999,47.490002,0.380469,+0.38 % -1627319023,BAC,37.700001,37.660000,38.134998,1.153850,+1.15 % -1627319023,BK,49.630001,49.500000,50.375000,1.501110,+1.50 % -1627319023,PBF,9.010000,9.070000,9.420000,4.550500,+4.55 % -1627319023,PBFX,13.500000,13.400000,13.500000,0.000000,+0.00 % -1627319023,SYF,46.509998,46.490002,46.939999,0.924532,+0.92 % -1627319023,WFC,44.590000,45.099998,44.750000,0.358825,+0.36 % -1627319023,TEVA,8.810000,8.850000,8.915000,1.191830,+1.19 % -1627319023,XOM,57.040001,57.160000,58.194401,2.023840,+2.02 % -1627319023,MPC,53.430000,53.830002,54.369999,1.759310,+1.76 % -1627319086,FDX,297.070007,296.089996,296.700012,-0.124550,-0.12 % -1627319086,C,66.709999,66.459999,67.360001,0.974367,+0.97 % -1627319086,AIG,47.310001,47.279999,47.490002,0.380469,+0.38 % -1627319086,BAC,37.700001,37.660000,38.134998,1.153850,+1.15 % -1627319086,BK,49.630001,49.500000,50.365002,1.480960,+1.48 % -1627319086,PBF,9.010000,9.070000,9.430000,4.661490,+4.66 % -1627319086,PBFX,13.500000,13.400000,13.500000,0.000000,+0.00 % -1627319086,SYF,46.509998,46.490002,46.939999,0.924532,+0.92 % -1627319086,WFC,44.590000,45.099998,44.750000,0.358825,+0.36 % -1627319086,TEVA,8.810000,8.850000,8.905000,1.078320,+1.08 % -1627319086,XOM,57.040001,57.160000,58.209999,2.051190,+2.05 % -1627319086,MPC,53.430000,53.830002,54.369999,1.759310,+1.76 % -1627319148,FDX,297.070007,296.089996,296.649994,-0.141381,-0.14 % -1627319148,C,66.709999,66.459999,67.355003,0.966872,+0.97 % -1627319148,AIG,47.310001,47.279999,47.490002,0.380469,+0.38 % -1627319148,BAC,37.700001,37.660000,38.130001,1.140580,+1.14 % -1627319148,BK,49.630001,49.500000,50.365002,1.480960,+1.48 % -1627319148,PBF,9.010000,9.070000,9.440000,4.772480,+4.77 % -1627319148,PBFX,13.500000,13.400000,13.500000,0.000000,+0.00 % -1627319148,SYF,46.509998,46.490002,46.935398,0.914642,+0.91 % -1627319148,WFC,44.590000,44.470001,44.770000,0.403678,+0.40 % -1627319148,TEVA,8.810000,8.850000,8.905000,1.078320,+1.08 % -1627319148,XOM,57.040001,57.160000,58.220001,2.068720,+2.07 % -1627319148,MPC,53.430000,53.830002,54.383701,1.784950,+1.78 % -1627319211,FDX,297.070007,296.089996,296.649994,-0.141381,-0.14 % -1627319211,C,66.709999,66.459999,67.330002,0.929396,+0.93 % -1627319211,AIG,47.310001,47.279999,47.490002,0.380469,+0.38 % -1627319211,BAC,37.700001,37.660000,38.130001,1.140580,+1.14 % -1627319211,BK,49.630001,49.500000,50.349998,1.450740,+1.45 % -1627319211,PBF,9.010000,9.070000,9.401000,4.339620,+4.34 % -1627319211,PBFX,13.500000,13.400000,13.500000,0.000000,+0.00 % -1627319211,SYF,46.509998,46.490002,46.919998,0.881531,+0.88 % -1627319211,WFC,44.590000,45.099998,44.744999,0.347612,+0.35 % -1627319211,TEVA,8.810000,8.850000,8.895000,0.964813,+0.96 % -1627319211,XOM,57.040001,57.160000,58.177502,1.994210,+1.99 % -1627319211,MPC,53.430000,53.830002,54.349998,1.721880,+1.72 % -1627319273,FDX,297.070007,296.089996,296.799988,-0.090888,-0.09 % -1627319273,C,66.709999,66.459999,67.387802,1.016040,+1.02 % -1627319273,AIG,47.310001,47.279999,47.509998,0.422744,+0.42 % -1627319273,BAC,37.700001,37.660000,38.130001,1.140580,+1.14 % -1627319273,BK,49.630001,49.500000,50.360001,1.470880,+1.47 % -1627319273,PBF,9.010000,9.070000,9.410000,4.439510,+4.44 % -1627319273,PBFX,13.500000,13.400000,13.500000,0.000000,+0.00 % -1627319273,SYF,46.509998,46.490002,46.915001,0.870780,+0.87 % -1627319273,WFC,44.590000,45.099998,44.779999,0.426105,+0.43 % -1627319273,TEVA,8.810000,8.850000,8.895000,0.964813,+0.96 % -1627319273,XOM,57.040001,57.160000,58.205002,2.042430,+2.04 % -1627319273,MPC,53.430000,53.830002,54.389999,1.796740,+1.80 % -1627319336,FDX,297.070007,296.089996,296.799988,-0.090888,-0.09 % -1627319336,C,66.709999,66.459999,67.404999,1.041820,+1.04 % -1627319336,AIG,47.310001,47.279999,47.549999,0.507292,+0.51 % -1627319336,BAC,37.700001,37.660000,38.134998,1.153850,+1.15 % -1627319336,BK,49.630001,49.500000,50.380001,1.511180,+1.51 % -1627319336,PBF,9.010000,9.070000,9.425000,4.605990,+4.61 % -1627319336,PBFX,13.500000,13.400000,13.500000,0.000000,+0.00 % -1627319336,SYF,46.509998,46.490002,46.959999,0.967534,+0.97 % -1627319336,WFC,44.590000,45.099998,44.790001,0.448531,+0.45 % -1627319336,TEVA,8.810000,8.850000,8.895000,0.964813,+0.96 % -1627319336,XOM,57.040001,57.160000,58.200001,2.033660,+2.03 % -1627319336,MPC,53.430000,53.830002,54.380001,1.778030,+1.78 % -1627319398,FDX,297.070007,296.089996,296.769989,-0.100986,-0.10 % -1627319398,C,66.709999,66.459999,67.379997,1.004350,+1.00 % -1627319398,AIG,47.310001,47.279999,47.560001,0.528430,+0.53 % -1627319398,BAC,37.700001,37.660000,38.130501,1.141910,+1.14 % -1627319398,BK,49.630001,49.500000,50.395000,1.541410,+1.54 % -1627319398,PBF,9.010000,9.070000,9.420000,4.550500,+4.55 % -1627319398,PBFX,13.500000,13.400000,13.500000,0.000000,+0.00 % -1627319398,SYF,46.509998,46.490002,46.962799,0.973554,+0.97 % -1627319398,WFC,44.590000,44.470001,44.805000,0.482171,+0.48 % -1627319398,TEVA,8.810000,8.850000,8.895000,0.964813,+0.96 % -1627319398,XOM,57.040001,57.160000,58.180000,1.998600,+2.00 % -1627319398,MPC,53.430000,53.830002,54.369999,1.759310,+1.76 % -1627319461,FDX,297.070007,296.089996,296.739990,-0.111085,-0.11 % -1627319461,C,66.709999,66.459999,67.349998,0.959376,+0.96 % -1627319461,AIG,47.310001,47.279999,47.549999,0.507292,+0.51 % -1627319461,BAC,37.700001,37.660000,38.099998,1.061010,+1.06 % -1627319461,BK,49.630001,49.500000,50.415001,1.581700,+1.58 % -1627319461,PBF,9.010000,9.070000,9.400000,4.328520,+4.33 % -1627319461,PBFX,13.500000,13.400000,13.500000,0.000000,+0.00 % -1627319461,SYF,46.509998,46.490002,46.935001,0.913782,+0.91 % -1627319461,WFC,44.590000,44.470001,44.790001,0.448531,+0.45 % -1627319461,TEVA,8.810000,8.850000,8.895000,0.964813,+0.96 % -1627319461,XOM,57.040001,57.160000,58.150002,1.946000,+1.95 % -1627319461,MPC,53.430000,53.830002,54.310001,1.647010,+1.65 % -1627319523,FDX,297.070007,296.089996,296.739990,-0.111085,-0.11 % -1627319523,C,66.709999,66.459999,67.315002,0.906911,+0.91 % -1627319523,AIG,47.310001,47.279999,47.520000,0.443881,+0.44 % -1627319523,BAC,37.700001,37.660000,38.099998,1.061010,+1.06 % -1627319523,BK,49.630001,49.500000,50.330002,1.410440,+1.41 % -1627319523,PBF,9.010000,9.070000,9.400000,4.328520,+4.33 % -1627319523,PBFX,13.500000,13.400000,13.470000,-0.222222,-0.22 % -1627319523,SYF,46.509998,46.490002,46.935001,0.913782,+0.91 % -1627319523,WFC,44.590000,44.470001,44.759998,0.381251,+0.38 % -1627319523,TEVA,8.810000,8.850000,8.895000,0.964813,+0.96 % -1627319523,XOM,57.040001,57.160000,58.110001,1.875880,+1.88 % -1627319523,MPC,53.430000,53.830002,54.310001,1.647010,+1.65 % -1627319585,FDX,297.070007,296.089996,296.630005,-0.148113,-0.15 % -1627319585,C,66.709999,66.459999,67.320000,0.914406,+0.91 % -1627319585,AIG,47.310001,47.279999,47.470001,0.338195,+0.34 % -1627319585,BAC,37.700001,37.660000,38.095001,1.047750,+1.05 % -1627319585,BK,49.630001,49.500000,50.330002,1.410440,+1.41 % -1627319585,PBF,9.010000,9.070000,9.400000,4.328520,+4.33 % -1627319585,PBFX,13.500000,13.400000,13.470000,-0.222222,-0.22 % -1627319585,SYF,46.509998,46.490002,46.900002,0.838529,+0.84 % -1627319585,WFC,44.590000,44.470001,44.770199,0.404126,+0.40 % -1627319585,TEVA,8.810000,8.850000,8.895000,0.964813,+0.96 % -1627319585,XOM,57.040001,57.160000,58.110001,1.875880,+1.88 % -1627319585,MPC,53.430000,53.830002,54.279999,1.590870,+1.59 % -1627319648,FDX,297.070007,296.089996,296.817993,-0.084761,-0.08 % -1627319648,C,66.709999,66.459999,67.305397,0.892520,+0.89 % -1627319648,AIG,47.310001,47.279999,47.485001,0.369901,+0.37 % -1627319648,BAC,37.700001,37.660000,38.109901,1.087270,+1.09 % -1627319648,BK,49.630001,49.500000,50.355000,1.460810,+1.46 % -1627319648,PBF,9.010000,9.070000,9.390000,4.217540,+4.22 % -1627319648,PBFX,13.500000,13.400000,13.470000,-0.222222,-0.22 % -1627319648,SYF,46.509998,46.490002,46.924999,0.892281,+0.89 % -1627319648,WFC,44.590000,44.470001,44.763199,0.388428,+0.39 % -1627319648,TEVA,8.810000,8.850000,8.895000,0.964813,+0.96 % -1627319648,XOM,57.040001,57.160000,58.130001,1.910940,+1.91 % -1627319648,MPC,53.430000,53.830002,54.279999,1.590870,+1.59 % -1627319710,FDX,297.070007,296.089996,296.799988,-0.090888,-0.09 % -1627319710,C,66.709999,66.459999,67.334000,0.935392,+0.94 % -1627319710,AIG,47.310001,47.279999,47.480000,0.359332,+0.36 % -1627319710,BAC,37.700001,37.660000,38.100700,1.062860,+1.06 % -1627319710,BK,49.630001,49.500000,50.355000,1.460810,+1.46 % -1627319710,PBF,9.010000,9.070000,9.425000,4.605990,+4.61 % -1627319710,PBFX,13.500000,13.400000,13.470000,-0.222222,-0.22 % -1627319710,SYF,46.509998,46.490002,46.924999,0.892281,+0.89 % -1627319710,WFC,44.590000,44.470001,44.764999,0.392465,+0.39 % -1627319710,TEVA,8.810000,8.850000,8.895000,0.964813,+0.96 % -1627319710,XOM,57.040001,57.160000,58.125000,1.902170,+1.90 % -1627319710,MPC,53.430000,53.830002,54.279999,1.590870,+1.59 % -1627319772,FDX,297.070007,296.089996,296.799988,-0.090888,-0.09 % -1627319772,C,66.709999,66.459999,67.334000,0.935392,+0.94 % -1627319772,AIG,47.310001,47.279999,47.509998,0.422744,+0.42 % -1627319772,BAC,37.700001,37.660000,38.105999,1.076920,+1.08 % -1627319772,BK,49.630001,49.500000,50.349998,1.450740,+1.45 % -1627319772,PBF,9.010000,9.070000,9.425000,4.605990,+4.61 % -1627319772,PBFX,13.500000,13.400000,13.470000,-0.222222,-0.22 % -1627319772,SYF,46.509998,46.490002,46.939999,0.924532,+0.92 % -1627319772,WFC,44.590000,44.470001,44.764999,0.392465,+0.39 % -1627319772,TEVA,8.810000,8.850000,8.895000,0.964813,+0.96 % -1627319772,XOM,57.040001,57.160000,58.145000,1.937240,+1.94 % -1627319772,MPC,53.430000,53.830002,54.314999,1.656370,+1.66 % -1627319834,FDX,297.070007,296.089996,296.799988,-0.090888,-0.09 % -1627319834,C,66.709999,66.459999,67.360001,0.974367,+0.97 % -1627319834,AIG,47.310001,47.279999,47.509998,0.422744,+0.42 % -1627319834,BAC,37.700001,37.660000,38.105999,1.076920,+1.08 % -1627319834,BK,49.630001,49.500000,50.349998,1.450740,+1.45 % -1627319834,PBF,9.010000,9.070000,9.440000,4.772480,+4.77 % -1627319834,PBFX,13.500000,13.400000,13.470000,-0.222222,-0.22 % -1627319834,SYF,46.509998,46.490002,46.939999,0.924532,+0.92 % -1627319834,WFC,44.590000,45.099998,44.779999,0.426105,+0.43 % -1627319834,TEVA,8.810000,8.850000,8.895000,0.964813,+0.96 % -1627319834,XOM,57.040001,57.160000,58.134998,1.919710,+1.92 % -1627319834,MPC,53.430000,53.830002,54.314999,1.656370,+1.66 % -1627319897,FDX,297.070007,296.089996,296.690002,-0.127916,-0.13 % -1627319897,C,66.709999,66.459999,67.360001,0.974367,+0.97 % -1627319897,AIG,47.310001,47.279999,47.455002,0.306489,+0.31 % -1627319897,BAC,37.700001,37.660000,38.090000,1.034480,+1.03 % -1627319897,BK,49.630001,49.500000,50.325001,1.400360,+1.40 % -1627319897,PBF,9.010000,9.070000,9.440000,4.772480,+4.77 % -1627319897,PBFX,13.500000,13.400000,13.470000,-0.222222,-0.22 % -1627319897,SYF,46.509998,46.490002,46.919998,0.881531,+0.88 % -1627319897,WFC,44.590000,45.099998,44.779999,0.426105,+0.43 % -1627319897,TEVA,8.810000,8.850000,8.900000,1.021570,+1.02 % -1627319897,XOM,57.040001,57.160000,58.130001,1.910940,+1.91 % -1627319897,MPC,53.430000,53.830002,54.290001,1.609580,+1.61 % -1627319958,FDX,297.070007,296.089996,296.651001,-0.141179,-0.14 % -1627319958,C,66.709999,66.459999,67.339996,0.944386,+0.94 % -1627319958,AIG,47.310001,47.279999,47.450001,0.295921,+0.30 % -1627319958,BAC,37.700001,37.660000,38.100101,1.061270,+1.06 % -1627319958,BK,49.630001,49.500000,50.314999,1.380210,+1.38 % -1627319958,PBF,9.010000,9.070000,9.440000,4.772480,+4.77 % -1627319958,PBFX,13.500000,13.400000,13.470000,-0.222222,-0.22 % -1627319958,SYF,46.509998,46.490002,46.930000,0.903032,+0.90 % -1627319958,WFC,44.590000,45.099998,44.785000,0.437318,+0.44 % -1627319958,TEVA,8.810000,8.850000,8.900000,1.021570,+1.02 % -1627319958,XOM,57.040001,57.160000,58.130001,1.910940,+1.91 % -1627319958,MPC,53.430000,53.830002,54.299999,1.628300,+1.63 % -1627320021,FDX,297.070007,296.089996,296.651001,-0.141179,-0.14 % -1627320021,C,66.709999,66.459999,67.355003,0.966872,+0.97 % -1627320021,AIG,47.310001,47.279999,47.455002,0.306489,+0.31 % -1627320021,BAC,37.700001,37.660000,38.100101,1.061270,+1.06 % -1627320021,BK,49.630001,49.500000,50.340000,1.430590,+1.43 % -1627320021,PBF,9.010000,9.070000,9.440000,4.772480,+4.77 % -1627320021,PBFX,13.500000,13.400000,13.470000,-0.222222,-0.22 % -1627320021,SYF,46.509998,46.490002,46.930000,0.903032,+0.90 % -1627320021,WFC,44.590000,44.470001,44.799999,0.470958,+0.47 % -1627320021,TEVA,8.810000,8.850000,8.900000,1.021570,+1.02 % -1627320021,XOM,57.040001,57.160000,58.154999,1.954770,+1.95 % -1627320021,MPC,53.430000,53.830002,54.299999,1.628300,+1.63 % -1627320083,FDX,297.070007,296.089996,296.750000,-0.107719,-0.11 % -1627320083,C,66.709999,66.459999,67.360001,0.974367,+0.97 % -1627320083,AIG,47.310001,47.279999,47.485001,0.369901,+0.37 % -1627320083,BAC,37.700001,37.660000,38.095001,1.047750,+1.05 % -1627320083,BK,49.630001,49.500000,50.314999,1.380210,+1.38 % -1627320083,PBF,9.010000,9.070000,9.455000,4.938960,+4.94 % -1627320083,PBFX,13.500000,13.400000,13.470000,-0.222222,-0.22 % -1627320083,SYF,46.509998,46.490002,46.923302,0.888626,+0.89 % -1627320083,WFC,44.590000,45.099998,44.799999,0.470958,+0.47 % -1627320083,TEVA,8.810000,8.850000,8.900000,1.021570,+1.02 % -1627320083,XOM,57.040001,57.160000,58.154999,1.954770,+1.95 % -1627320083,MPC,53.430000,53.830002,54.320000,1.665730,+1.67 % -1627320145,FDX,297.070007,296.089996,296.739990,-0.111085,-0.11 % -1627320145,C,66.709999,66.459999,67.449997,1.109280,+1.11 % -1627320145,AIG,47.310001,47.279999,47.470001,0.338195,+0.34 % -1627320145,BAC,37.700001,37.660000,38.105000,1.074270,+1.07 % -1627320145,BK,49.630001,49.500000,50.345001,1.440660,+1.44 % -1627320145,PBF,9.010000,9.070000,9.465000,5.049940,+5.05 % -1627320145,PBFX,13.500000,13.400000,13.470000,-0.222222,-0.22 % -1627320145,SYF,46.509998,46.490002,46.924999,0.892281,+0.89 % -1627320145,WFC,44.590000,44.470001,44.825001,0.527024,+0.53 % -1627320145,TEVA,8.810000,8.850000,8.885000,0.851305,+0.85 % -1627320145,XOM,57.040001,57.160000,58.174999,1.989830,+1.99 % -1627320145,MPC,53.430000,53.830002,54.349998,1.721880,+1.72 % -1627320208,FDX,297.070007,296.089996,296.750000,-0.107719,-0.11 % -1627320208,C,66.709999,66.459999,67.445000,1.101780,+1.10 % -1627320208,AIG,47.310001,47.279999,47.470001,0.338195,+0.34 % -1627320208,BAC,37.700001,37.660000,38.134998,1.153850,+1.15 % -1627320208,BK,49.630001,49.500000,50.334999,1.420510,+1.42 % -1627320208,PBF,9.010000,9.070000,9.475000,5.160930,+5.16 % -1627320208,PBFX,13.500000,13.400000,13.470000,-0.222222,-0.22 % -1627320208,SYF,46.509998,46.490002,46.945000,0.935283,+0.94 % -1627320208,WFC,44.590000,44.470001,44.830002,0.538237,+0.54 % -1627320208,TEVA,8.810000,8.850000,8.880000,0.794552,+0.79 % -1627320208,XOM,57.040001,57.160000,58.206100,2.044350,+2.04 % -1627320208,MPC,53.430000,53.830002,54.380001,1.778030,+1.78 % -1627320270,FDX,297.070007,296.089996,296.750000,-0.107719,-0.11 % -1627320270,C,66.709999,66.459999,67.435997,1.088290,+1.09 % -1627320270,AIG,47.310001,47.279999,47.465000,0.327626,+0.33 % -1627320270,BAC,37.700001,37.660000,38.130001,1.140580,+1.14 % -1627320270,BK,49.630001,49.500000,50.334999,1.420510,+1.42 % -1627320270,PBF,9.010000,9.070000,9.485000,5.271920,+5.27 % -1627320270,PBFX,13.500000,13.400000,13.470000,-0.222222,-0.22 % -1627320270,SYF,46.509998,46.490002,46.924999,0.892281,+0.89 % -1627320270,WFC,44.590000,44.470001,44.814999,0.504597,+0.50 % -1627320270,TEVA,8.810000,8.850000,8.870000,0.681044,+0.68 % -1627320270,XOM,57.040001,57.160000,58.205002,2.042430,+2.04 % -1627320270,MPC,53.430000,53.830002,54.360001,1.740600,+1.74 % -1627320333,FDX,297.070007,296.089996,296.839996,-0.077423,-0.08 % -1627320333,C,66.709999,66.459999,67.435997,1.088290,+1.09 % -1627320333,AIG,47.310001,47.279999,47.450001,0.295921,+0.30 % -1627320333,BAC,37.700001,37.660000,38.125000,1.127320,+1.13 % -1627320333,BK,49.630001,49.500000,50.345001,1.440660,+1.44 % -1627320333,PBF,9.010000,9.070000,9.485000,5.271920,+5.27 % -1627320333,PBFX,13.500000,13.400000,13.470000,-0.222222,-0.22 % -1627320333,SYF,46.509998,46.490002,46.945000,0.935283,+0.94 % -1627320333,WFC,44.590000,44.470001,44.810001,0.493384,+0.49 % -1627320333,TEVA,8.810000,8.850000,8.875000,0.737798,+0.74 % -1627320333,XOM,57.040001,57.160000,58.185001,2.007360,+2.01 % -1627320333,MPC,53.430000,53.830002,54.349998,1.721880,+1.72 % -1627320395,FDX,297.070007,296.089996,296.850006,-0.074057,-0.07 % -1627320395,C,66.709999,66.459999,67.430000,1.079300,+1.08 % -1627320395,AIG,47.310001,47.279999,47.470001,0.338195,+0.34 % -1627320395,BAC,37.700001,37.660000,38.120098,1.114320,+1.11 % -1627320395,BK,49.630001,49.500000,50.334999,1.420510,+1.42 % -1627320395,PBF,9.010000,9.070000,9.490000,5.327410,+5.33 % -1627320395,PBFX,13.500000,13.400000,13.470000,-0.222222,-0.22 % -1627320395,SYF,46.509998,46.490002,46.970001,0.989035,+0.99 % -1627320395,WFC,44.590000,44.470001,44.810001,0.493384,+0.49 % -1627320395,TEVA,8.810000,8.850000,8.870000,0.681044,+0.68 % -1627320395,XOM,57.040001,57.160000,58.169998,1.981070,+1.98 % -1627320395,MPC,53.430000,53.830002,54.384998,1.787390,+1.79 % -1627320457,FDX,297.070007,296.089996,296.820007,-0.084155,-0.08 % -1627320457,C,66.709999,66.459999,67.449997,1.109280,+1.11 % -1627320457,AIG,47.310001,47.279999,47.470001,0.338195,+0.34 % -1627320457,BAC,37.700001,37.660000,38.120098,1.114320,+1.11 % -1627320457,BK,49.630001,49.500000,50.299999,1.349990,+1.35 % -1627320457,PBF,9.010000,9.070000,9.490000,5.327410,+5.33 % -1627320457,PBFX,13.500000,13.400000,13.500000,0.000000,+0.00 % -1627320457,SYF,46.509998,46.490002,46.954201,0.955063,+0.96 % -1627320457,WFC,44.590000,44.470001,44.831799,0.542274,+0.54 % -1627320457,TEVA,8.810000,8.850000,8.875000,0.737798,+0.74 % -1627320457,XOM,57.040001,57.160000,58.180000,1.998600,+2.00 % -1627320457,MPC,53.430000,53.830002,54.362598,1.745460,+1.75 % -1627320519,FDX,297.070007,296.089996,296.821014,-0.083819,-0.08 % -1627320519,C,66.709999,66.459999,67.425003,1.071800,+1.07 % -1627320519,AIG,47.310001,47.279999,47.459999,0.317058,+0.32 % -1627320519,BAC,37.700001,37.660000,38.125000,1.127320,+1.13 % -1627320519,BK,49.630001,49.500000,50.299999,1.349990,+1.35 % -1627320519,PBF,9.010000,9.070000,9.495000,5.382910,+5.38 % -1627320519,PBFX,13.500000,13.400000,13.500000,0.000000,+0.00 % -1627320519,SYF,46.509998,46.490002,46.954201,0.955063,+0.96 % -1627320519,WFC,44.590000,44.470001,44.814999,0.504597,+0.50 % -1627320519,TEVA,8.810000,8.850000,8.875000,0.737798,+0.74 % -1627320519,XOM,57.040001,57.160000,58.189999,2.016130,+2.02 % -1627320519,MPC,53.430000,53.830002,54.355000,1.731240,+1.73 % -1627320581,FDX,297.070007,296.089996,296.869995,-0.067324,-0.07 % -1627320581,C,66.709999,66.459999,67.425003,1.071800,+1.07 % -1627320581,AIG,47.310001,47.279999,47.450001,0.295921,+0.30 % -1627320581,BAC,37.700001,37.660000,38.130001,1.140580,+1.14 % -1627320581,BK,49.630001,49.500000,50.305000,1.360060,+1.36 % -1627320581,PBF,9.010000,9.070000,9.495000,5.382910,+5.38 % -1627320581,PBFX,13.500000,13.400000,13.529500,0.218519,+0.22 % -1627320581,SYF,46.509998,46.490002,46.950001,0.946033,+0.95 % -1627320581,WFC,44.590000,45.099998,44.820000,0.515811,+0.52 % -1627320581,TEVA,8.810000,8.850000,8.885000,0.851305,+0.85 % -1627320581,XOM,57.040001,57.160000,58.195000,2.024890,+2.02 % -1627320581,MPC,53.430000,53.830002,54.360001,1.740600,+1.74 % -1627320644,FDX,297.070007,296.089996,296.880005,-0.063958,-0.06 % -1627320644,C,66.709999,66.459999,67.440002,1.094290,+1.09 % -1627320644,AIG,47.310001,47.279999,47.450699,0.297400,+0.30 % -1627320644,BAC,37.700001,37.660000,38.125000,1.127320,+1.13 % -1627320644,BK,49.630001,49.500000,50.305000,1.360060,+1.36 % -1627320644,PBF,9.010000,9.070000,9.490000,5.327410,+5.33 % -1627320644,PBFX,13.500000,13.400000,13.529500,0.218519,+0.22 % -1627320644,SYF,46.509998,46.490002,46.950001,0.946033,+0.95 % -1627320644,WFC,44.590000,45.099998,44.799999,0.470958,+0.47 % -1627320644,TEVA,8.810000,8.850000,8.885000,0.851305,+0.85 % -1627320644,XOM,57.040001,57.160000,58.209999,2.051190,+2.05 % -1627320644,MPC,53.430000,53.830002,54.384998,1.787390,+1.79 % -1627320711,FDX,297.070007,296.089996,296.850006,-0.074057,-0.07 % -1627320711,C,66.709999,66.459999,67.440002,1.094290,+1.09 % -1627320711,AIG,47.310001,47.279999,47.455002,0.306489,+0.31 % -1627320711,BAC,37.700001,37.660000,38.119999,1.114060,+1.11 % -1627320711,BK,49.630001,49.500000,50.275002,1.299620,+1.30 % -1627320711,PBF,9.010000,9.070000,9.490000,5.327410,+5.33 % -1627320711,PBFX,13.500000,13.400000,13.529500,0.218519,+0.22 % -1627320711,SYF,46.509998,46.490002,46.939999,0.924532,+0.92 % -1627320711,WFC,44.590000,44.470001,44.817402,0.509980,+0.51 % -1627320711,TEVA,8.810000,8.850000,8.890000,0.908059,+0.91 % -1627320711,XOM,57.040001,57.160000,58.200001,2.033660,+2.03 % -1627320711,MPC,53.430000,53.830002,54.369999,1.759310,+1.76 % -1627392402,FDX,297.070007,296.089996,297.500000,0.144747,+0.14 % -1627392402,C,66.709999,66.459999,67.769997,1.588970,+1.59 % -1627392402,AIG,47.310001,47.279999,47.709999,0.845487,+0.85 % -1627392402,BAC,37.700001,37.660000,38.130001,1.140580,+1.14 % -1627392402,BK,49.630001,49.500000,50.250000,1.249240,+1.25 % -1627392402,PBF,9.010000,9.070000,9.570000,6.215320,+6.22 % -1627392402,PBFX,13.500000,13.400000,13.580000,0.592593,+0.59 % -1627392402,SYF,46.509998,46.490002,47.139999,1.354550,+1.35 % -1627392402,WFC,44.590000,44.470001,45.009998,0.941915,+0.94 % -1627392402,TEVA,8.810000,8.850000,8.940000,1.475600,+1.48 % -1627392402,XOM,57.040001,57.160000,58.480000,2.524540,+2.52 % -1627392402,MPC,53.430000,53.830002,54.660000,2.302080,+2.30 % -1627392467,FDX,297.070007,296.089996,297.500000,0.144747,+0.14 % -1627392467,C,66.709999,66.459999,67.769997,1.588970,+1.59 % -1627392467,AIG,47.310001,47.279999,47.709999,0.845487,+0.85 % -1627392467,BAC,37.700001,37.660000,38.130001,1.140580,+1.14 % -1627392467,BK,49.630001,49.500000,50.250000,1.249240,+1.25 % -1627392467,PBF,9.010000,9.070000,9.570000,6.215320,+6.22 % -1627392467,PBFX,13.500000,13.400000,13.580000,0.592593,+0.59 % -1627392467,SYF,46.509998,46.490002,47.139999,1.354550,+1.35 % -1627392467,WFC,44.590000,45.099998,45.009998,0.941915,+0.94 % -1627392467,TEVA,8.810000,8.850000,8.940000,1.475600,+1.48 % -1627392467,XOM,57.040001,57.160000,58.480000,2.524540,+2.52 % -1627392467,MPC,53.430000,53.830002,54.660000,2.302080,+2.30 % -1627392530,FDX,297.070007,296.089996,297.500000,0.144747,+0.14 % -1627392530,C,66.709999,66.459999,67.769997,1.588970,+1.59 % -1627392530,AIG,47.310001,47.279999,47.709999,0.845487,+0.85 % -1627392530,BAC,37.700001,37.660000,38.130001,1.140580,+1.14 % -1627392530,BK,49.630001,49.500000,50.250000,1.249240,+1.25 % -1627392530,PBF,9.010000,9.070000,9.570000,6.215320,+6.22 % -1627392530,PBFX,13.500000,13.400000,13.580000,0.592593,+0.59 % -1627392530,SYF,46.509998,46.490002,47.139999,1.354550,+1.35 % -1627392530,WFC,44.590000,45.099998,45.009998,0.941915,+0.94 % -1627392530,TEVA,8.810000,8.850000,8.940000,1.475600,+1.48 % -1627392530,XOM,57.040001,57.160000,58.480000,2.524540,+2.52 % -1627392530,MPC,53.430000,53.830002,54.660000,2.302080,+2.30 % -1627392592,FDX,297.070007,296.089996,297.500000,0.144747,+0.14 % -1627392592,C,66.709999,66.459999,67.769997,1.588970,+1.59 % -1627392592,AIG,47.310001,47.279999,47.709999,0.845487,+0.85 % -1627392592,BAC,37.700001,37.660000,38.130001,1.140580,+1.14 % -1627392592,BK,49.630001,49.500000,50.250000,1.249240,+1.25 % -1627392592,PBF,9.010000,9.070000,9.570000,6.215320,+6.22 % -1627392592,PBFX,13.500000,13.400000,13.580000,0.592593,+0.59 % -1627392592,SYF,46.509998,46.490002,47.139999,1.354550,+1.35 % -1627392592,WFC,44.590000,44.470001,45.009998,0.941915,+0.94 % -1627392592,TEVA,8.810000,8.850000,8.940000,1.475600,+1.48 % -1627392592,XOM,57.040001,57.160000,58.480000,2.524540,+2.52 % -1627392592,MPC,53.430000,53.830002,54.660000,2.302080,+2.30 % -1627392654,FDX,297.500000,296.089996,287.964996,-3.205040,-3.21 % -1627392654,C,67.769997,66.459999,66.809998,-1.416560,-1.42 % -1627392654,AIG,47.310001,47.279999,47.709999,0.845487,+0.85 % -1627392654,BAC,38.130001,37.660000,37.514999,-1.612900,-1.61 % -1627392654,BK,50.250000,49.500000,49.549999,-1.393030,-1.39 % -1627392654,PBF,9.570000,9.070000,9.135000,-4.545450,-4.55 % -1627392654,PBFX,13.500000,13.400000,13.580000,0.592593,+0.59 % -1627392654,SYF,47.139999,46.490002,46.380001,-1.612220,-1.61 % -1627392654,WFC,44.590000,45.099998,45.009998,0.941915,+0.94 % -1627392654,TEVA,8.810000,8.850000,8.940000,1.475600,+1.48 % -1627392654,XOM,58.480000,57.160000,57.599998,-1.504790,-1.50 % -1627392654,MPC,54.660000,53.830002,53.840000,-1.500180,-1.50 % -1627392717,FDX,297.500000,296.089996,287.880005,-3.233610,-3.23 % -1627392717,C,67.769997,66.459999,66.809998,-1.416560,-1.42 % -1627392717,AIG,47.709999,47.279999,46.994999,-1.498640,-1.50 % -1627392717,BAC,38.130001,37.660000,37.625000,-1.324420,-1.32 % -1627392717,BK,50.250000,49.500000,49.669998,-1.154230,-1.15 % -1627392717,PBF,9.570000,9.070000,9.160000,-4.284220,-4.28 % -1627392717,PBFX,13.500000,13.400000,13.580000,0.592593,+0.59 % -1627392717,SYF,47.139999,46.490002,46.490002,-1.378870,-1.38 % -1627392717,WFC,45.009998,44.470001,44.474998,-1.188620,-1.19 % -1627392717,TEVA,8.940000,8.850000,8.890000,-0.559284,-0.56 % -1627392717,XOM,58.480000,57.160000,57.410000,-1.829690,-1.83 % -1627392717,MPC,54.660000,53.830002,53.840000,-1.500180,-1.50 % -1627392779,FDX,297.500000,296.089996,287.809998,-3.257140,-3.26 % -1627392779,C,67.769997,66.459999,67.349998,-0.619743,-0.62 % -1627392779,AIG,47.709999,47.279999,46.810001,-1.886400,-1.89 % -1627392779,BAC,38.130001,37.660000,37.625000,-1.324420,-1.32 % -1627392779,BK,50.250000,49.500000,49.430000,-1.631840,-1.63 % -1627392779,PBF,9.570000,9.070000,9.160000,-4.284220,-4.28 % -1627392779,PBFX,13.580000,13.400000,13.510000,-0.515464,-0.52 % -1627392779,SYF,47.139999,46.490002,46.369999,-1.633430,-1.63 % -1627392779,WFC,45.009998,44.470001,44.430000,-1.288600,-1.29 % -1627392779,TEVA,8.940000,8.850000,8.860000,-0.894855,-0.89 % -1627392779,XOM,58.480000,57.160000,57.410000,-1.829690,-1.83 % -1627392779,MPC,54.660000,53.830002,53.840000,-1.500180,-1.50 % -1627392842,FDX,297.500000,296.089996,287.700012,-3.294120,-3.29 % -1627392842,C,67.769997,66.459999,67.470001,-0.442674,-0.44 % -1627392842,AIG,47.709999,47.279999,46.810001,-1.886400,-1.89 % -1627392842,BAC,38.130001,37.660000,37.525002,-1.586680,-1.59 % -1627392842,BK,50.250000,49.500000,49.619999,-1.253730,-1.25 % -1627392842,PBF,9.570000,9.070000,9.140000,-4.493210,-4.49 % -1627392842,PBFX,13.580000,13.400000,13.510000,-0.515464,-0.52 % -1627392842,SYF,47.139999,46.490002,46.410000,-1.548580,-1.55 % -1627392842,WFC,45.009998,44.470001,44.455002,-1.233060,-1.23 % -1627392842,TEVA,8.940000,8.850000,8.825000,-1.286350,-1.29 % -1627392842,XOM,58.480000,57.160000,57.470001,-1.727090,-1.73 % -1627392842,MPC,54.660000,53.830002,53.900002,-1.390410,-1.39 % -1627392904,FDX,297.500000,296.089996,287.660004,-3.307560,-3.31 % -1627392904,C,67.769997,66.459999,67.690002,-0.118046,-0.12 % -1627392904,AIG,47.709999,47.279999,46.860001,-1.781600,-1.78 % -1627392904,BAC,38.130001,37.660000,37.669998,-1.206400,-1.21 % -1627392904,BK,50.250000,49.500000,49.830002,-0.835821,-0.84 % -1627392904,PBF,9.570000,9.070000,9.225000,-3.605020,-3.61 % -1627392904,PBFX,13.580000,13.400000,13.510000,-0.515464,-0.52 % -1627392904,SYF,47.139999,46.490002,46.689999,-0.954603,-0.95 % -1627392904,WFC,45.009998,44.470001,44.610001,-0.888691,-0.89 % -1627392904,TEVA,8.940000,8.850000,8.845000,-1.062640,-1.06 % -1627392904,XOM,58.480000,57.160000,57.549999,-1.590290,-1.59 % -1627392904,MPC,54.660000,53.830002,54.020000,-1.170870,-1.17 % -1627392967,FDX,297.500000,296.089996,287.660004,-3.307560,-3.31 % -1627392967,C,67.769997,66.459999,67.660004,-0.162314,-0.16 % -1627392967,AIG,47.709999,47.279999,47.180000,-1.110880,-1.11 % -1627392967,BAC,38.130001,37.660000,37.689999,-1.153950,-1.15 % -1627392967,BK,50.250000,49.500000,49.830002,-0.835821,-0.84 % -1627392967,PBF,9.570000,9.070000,9.340000,-2.403340,-2.40 % -1627392967,PBFX,13.580000,13.400000,13.510000,-0.515464,-0.52 % -1627392967,SYF,47.139999,46.490002,46.689999,-0.954603,-0.95 % -1627392967,WFC,45.009998,44.470001,44.740002,-0.599867,-0.60 % -1627392967,TEVA,8.940000,8.850000,8.839900,-1.119690,-1.12 % -1627392967,XOM,58.480000,57.160000,57.660000,-1.402190,-1.40 % -1627392967,MPC,54.660000,53.830002,54.320000,-0.622027,-0.62 % -1627393029,FDX,297.500000,296.089996,287.350006,-3.411760,-3.41 % -1627393029,C,67.769997,66.459999,67.470001,-0.442674,-0.44 % -1627393029,AIG,47.709999,47.279999,47.180000,-1.110880,-1.11 % -1627393029,BAC,38.130001,37.660000,37.599998,-1.389980,-1.39 % -1627393029,BK,50.250000,49.500000,49.730000,-1.034830,-1.03 % -1627393029,PBF,9.570000,9.070000,9.245000,-3.396030,-3.40 % -1627393029,PBFX,13.580000,13.400000,13.510000,-0.515464,-0.52 % -1627393029,SYF,47.139999,46.490002,46.610001,-1.124310,-1.12 % -1627393029,WFC,45.009998,44.470001,44.615002,-0.877583,-0.88 % -1627393029,TEVA,8.940000,8.850000,8.839900,-1.119690,-1.12 % -1627393029,XOM,58.480000,57.160000,57.340000,-1.949380,-1.95 % -1627393029,MPC,54.660000,53.830002,53.990002,-1.225760,-1.23 % -1627393092,FDX,297.500000,296.089996,286.429993,-3.721010,-3.72 % -1627393092,C,67.769997,66.459999,67.360001,-0.604987,-0.60 % -1627393092,AIG,47.709999,47.279999,46.990002,-1.509120,-1.51 % -1627393092,BAC,38.130001,37.660000,37.590000,-1.416210,-1.42 % -1627393092,BK,50.250000,49.500000,49.730000,-1.034830,-1.03 % -1627393092,PBF,9.570000,9.070000,9.200000,-3.866250,-3.87 % -1627393092,PBFX,13.580000,13.400000,13.510000,-0.515464,-0.52 % -1627393092,SYF,47.139999,46.490002,46.700001,-0.933390,-0.93 % -1627393092,WFC,45.009998,44.470001,44.509998,-1.110860,-1.11 % -1627393092,TEVA,8.940000,8.850000,8.820000,-1.342280,-1.34 % -1627393092,XOM,58.480000,57.160000,57.349998,-1.932280,-1.93 % -1627393092,MPC,54.660000,53.830002,53.930000,-1.335530,-1.34 % -1627393154,FDX,297.500000,296.089996,286.700012,-3.630250,-3.63 % -1627393154,C,67.769997,66.459999,67.449997,-0.472185,-0.47 % -1627393154,AIG,47.709999,47.279999,46.980000,-1.530080,-1.53 % -1627393154,BAC,38.130001,37.660000,37.629398,-1.312880,-1.31 % -1627393154,BK,50.250000,49.500000,49.720001,-1.054730,-1.05 % -1627393154,PBF,9.570000,9.070000,9.190000,-3.970740,-3.97 % -1627393154,PBFX,13.580000,13.400000,13.510000,-0.515464,-0.52 % -1627393154,SYF,47.139999,46.490002,46.889999,-0.530335,-0.53 % -1627393154,WFC,45.009998,44.470001,44.639900,-0.822262,-0.82 % -1627393154,TEVA,8.940000,8.850000,8.789900,-1.678970,-1.68 % -1627393154,XOM,58.480000,57.160000,57.395000,-1.855340,-1.86 % -1627393154,MPC,54.660000,53.830002,53.919998,-1.353820,-1.35 % -1627393216,FDX,297.500000,296.089996,286.070007,-3.842020,-3.84 % -1627393216,C,67.769997,66.459999,67.580002,-0.280360,-0.28 % -1627393216,AIG,47.709999,47.279999,47.040001,-1.404320,-1.40 % -1627393216,BAC,38.130001,37.660000,37.584999,-1.429320,-1.43 % -1627393216,BK,50.250000,49.500000,49.779999,-0.935323,-0.94 % -1627393216,PBF,9.570000,9.070000,9.180000,-4.075240,-4.08 % -1627393216,PBFX,13.580000,13.400000,13.321700,-1.902060,-1.90 % -1627393216,SYF,47.139999,46.490002,46.740002,-0.848536,-0.85 % -1627393216,WFC,45.009998,44.470001,44.660000,-0.777605,-0.78 % -1627393216,TEVA,8.940000,8.850000,8.790000,-1.677850,-1.68 % -1627393216,XOM,58.480000,57.160000,57.389999,-1.863890,-1.86 % -1627393216,MPC,54.660000,53.830002,53.939999,-1.317230,-1.32 % -1627393278,FDX,297.500000,296.089996,285.179993,-4.141180,-4.14 % -1627393278,C,67.769997,66.459999,67.279999,-0.723034,-0.72 % -1627393278,AIG,47.709999,47.279999,46.950001,-1.592960,-1.59 % -1627393278,BAC,38.130001,37.660000,37.540001,-1.547340,-1.55 % -1627393278,BK,50.250000,49.500000,49.689999,-1.114430,-1.11 % -1627393278,PBF,9.570000,9.070000,9.195000,-3.918500,-3.92 % -1627393278,PBFX,13.580000,13.400000,13.321700,-1.902060,-1.90 % -1627393278,SYF,47.139999,46.490002,46.700001,-0.933390,-0.93 % -1627393278,WFC,45.009998,44.470001,44.490002,-1.155300,-1.16 % -1627393278,TEVA,8.940000,8.850000,8.780000,-1.789710,-1.79 % -1627393278,XOM,58.480000,57.160000,57.359901,-1.915360,-1.92 % -1627393278,MPC,54.660000,53.830002,53.810001,-1.555070,-1.56 % -1627393341,FDX,297.500000,296.089996,285.144989,-4.152940,-4.15 % -1627393341,C,67.769997,66.459999,67.419998,-0.516453,-0.52 % -1627393341,AIG,47.709999,47.279999,46.970001,-1.551040,-1.55 % -1627393341,BAC,38.130001,37.660000,37.615002,-1.350640,-1.35 % -1627393341,BK,50.250000,49.500000,49.740002,-1.014930,-1.01 % -1627393341,PBF,9.570000,9.070000,9.195000,-3.918500,-3.92 % -1627393341,PBFX,13.580000,13.400000,13.321700,-1.902060,-1.90 % -1627393341,SYF,47.139999,46.490002,46.570000,-1.209160,-1.21 % -1627393341,WFC,45.009998,44.470001,44.474998,-1.188620,-1.19 % -1627393341,TEVA,8.940000,8.850000,8.780000,-1.789710,-1.79 % -1627393341,XOM,58.480000,57.160000,57.514999,-1.650140,-1.65 % -1627393341,MPC,54.660000,53.830002,53.849998,-1.481890,-1.48 % -1627393403,FDX,297.500000,296.089996,285.619995,-3.993280,-3.99 % -1627393403,C,67.769997,66.459999,67.419998,-0.516453,-0.52 % -1627393403,AIG,47.709999,47.279999,47.080002,-1.320480,-1.32 % -1627393403,BAC,38.130001,37.660000,37.599998,-1.389980,-1.39 % -1627393403,BK,50.250000,49.500000,49.889999,-0.716418,-0.72 % -1627393403,PBF,9.570000,9.070000,9.240000,-3.448280,-3.45 % -1627393403,PBFX,13.580000,13.400000,13.321700,-1.902060,-1.90 % -1627393403,SYF,47.139999,46.490002,46.759998,-0.806109,-0.81 % -1627393403,WFC,45.009998,44.470001,44.584999,-0.944235,-0.94 % -1627393403,TEVA,8.940000,8.850000,8.770000,-1.901570,-1.90 % -1627393403,XOM,58.480000,57.160000,57.520000,-1.641590,-1.64 % -1627393403,MPC,54.660000,53.830002,53.849998,-1.481890,-1.48 % -1627393466,FDX,297.500000,296.089996,285.649994,-3.983290,-3.98 % -1627393466,C,67.769997,66.459999,67.540001,-0.339383,-0.34 % -1627393466,AIG,47.709999,47.279999,47.049999,-1.383360,-1.38 % -1627393466,BAC,38.130001,37.660000,37.584999,-1.429320,-1.43 % -1627393466,BK,50.250000,49.500000,49.840000,-0.815920,-0.82 % -1627393466,PBF,9.570000,9.070000,9.240000,-3.448280,-3.45 % -1627393466,PBFX,13.580000,13.400000,13.321700,-1.902060,-1.90 % -1627393466,SYF,47.139999,46.490002,46.740002,-0.848536,-0.85 % -1627393466,WFC,45.009998,44.470001,44.584999,-0.944235,-0.94 % -1627393466,TEVA,8.940000,8.850000,8.770000,-1.901570,-1.90 % -1627393466,XOM,58.480000,57.160000,57.540001,-1.607390,-1.61 % -1627393466,MPC,54.660000,53.830002,53.932999,-1.330040,-1.33 % -1627393529,FDX,297.500000,296.089996,284.141998,-4.489920,-4.49 % -1627393529,C,67.769997,66.459999,67.434998,-0.494319,-0.49 % -1627393529,AIG,47.709999,47.279999,47.049999,-1.383360,-1.38 % -1627393529,BAC,38.130001,37.660000,37.570000,-1.468660,-1.47 % -1627393529,BK,50.250000,49.500000,49.779999,-0.935323,-0.94 % -1627393529,PBF,9.570000,9.070000,9.185000,-4.022990,-4.02 % -1627393529,PBFX,13.580000,13.400000,13.321700,-1.902060,-1.90 % -1627393529,SYF,47.139999,46.490002,46.735001,-0.859143,-0.86 % -1627393529,WFC,45.009998,44.470001,44.580002,-0.955343,-0.96 % -1627393529,TEVA,8.940000,8.850000,8.780000,-1.789710,-1.79 % -1627393529,XOM,58.480000,57.160000,57.452999,-1.756160,-1.76 % -1627393529,MPC,54.660000,53.830002,53.794998,-1.582510,-1.58 % -1627393592,FDX,297.500000,296.089996,284.141998,-4.489920,-4.49 % -1627393592,C,67.769997,66.459999,67.519997,-0.368895,-0.37 % -1627393592,AIG,47.709999,47.279999,47.099998,-1.278560,-1.28 % -1627393592,BAC,38.130001,37.660000,37.599998,-1.389980,-1.39 % -1627393592,BK,50.250000,49.500000,49.779999,-0.935323,-0.94 % -1627393592,PBF,9.570000,9.070000,9.235000,-3.500520,-3.50 % -1627393592,PBFX,13.580000,13.400000,13.321700,-1.902060,-1.90 % -1627393592,SYF,47.139999,46.650002,46.790001,-0.742469,-0.74 % -1627393592,WFC,45.009998,44.470001,44.654999,-0.788714,-0.79 % -1627393592,TEVA,8.940000,8.850000,8.786000,-1.722600,-1.72 % -1627393592,XOM,58.480000,57.160000,57.560001,-1.573190,-1.57 % -1627393592,MPC,54.660000,53.830002,53.939999,-1.317230,-1.32 % -1627393655,FDX,297.500000,296.089996,283.954010,-4.553140,-4.55 % -1627393655,C,67.769997,66.459999,67.519997,-0.368895,-0.37 % -1627393655,AIG,47.709999,47.279999,47.209999,-1.048000,-1.05 % -1627393655,BAC,38.130001,37.660000,37.599998,-1.389980,-1.39 % -1627393655,BK,50.250000,49.500000,49.840000,-0.815920,-0.82 % -1627393655,PBF,9.570000,9.070000,9.250000,-3.343780,-3.34 % -1627393655,PBFX,13.580000,13.400000,13.321700,-1.902060,-1.90 % -1627393655,SYF,47.139999,46.650002,46.830002,-0.657616,-0.66 % -1627393655,WFC,45.009998,44.470001,44.654999,-0.788714,-0.79 % -1627393655,TEVA,8.940000,8.930000,8.783500,-1.750560,-1.75 % -1627393655,XOM,58.480000,57.160000,57.560001,-1.573190,-1.57 % -1627393655,MPC,54.660000,53.830002,53.939999,-1.317230,-1.32 % -1627393717,FDX,297.500000,296.089996,283.954010,-4.553140,-4.55 % -1627393717,C,67.769997,66.459999,67.555000,-0.317250,-0.32 % -1627393717,AIG,47.709999,47.279999,47.220001,-1.027040,-1.03 % -1627393717,BAC,38.130001,37.660000,37.705002,-1.114610,-1.11 % -1627393717,BK,50.250000,49.500000,49.840000,-0.815920,-0.82 % -1627393717,PBF,9.570000,9.070000,9.215000,-3.709510,-3.71 % -1627393717,PBFX,13.580000,13.400000,13.321700,-1.902060,-1.90 % -1627393717,SYF,47.139999,46.650002,46.950001,-0.403055,-0.40 % -1627393717,WFC,45.009998,44.590000,44.639999,-0.822040,-0.82 % -1627393717,TEVA,8.940000,8.930000,8.783500,-1.750560,-1.75 % -1627393717,XOM,58.480000,58.009998,57.590000,-1.521890,-1.52 % -1627393717,MPC,54.660000,53.830002,53.939999,-1.317230,-1.32 % -1627393779,FDX,297.500000,296.089996,284.809998,-4.265550,-4.27 % -1627393779,C,67.769997,66.459999,67.555000,-0.317250,-0.32 % -1627393779,AIG,47.709999,47.080002,47.320000,-0.817439,-0.82 % -1627393779,BAC,38.130001,37.660000,37.705002,-1.114610,-1.11 % -1627393779,BK,50.250000,49.500000,49.910000,-0.676617,-0.68 % -1627393779,PBF,9.570000,9.070000,9.215000,-3.709510,-3.71 % -1627393779,PBFX,13.580000,13.400000,13.321700,-1.902060,-1.90 % -1627393779,SYF,47.139999,46.650002,46.959999,-0.381841,-0.38 % -1627393779,WFC,45.009998,44.590000,44.639999,-0.822040,-0.82 % -1627393779,TEVA,8.940000,8.930000,8.770000,-1.901570,-1.90 % -1627393779,XOM,58.480000,58.009998,57.590000,-1.521890,-1.52 % -1627393779,MPC,54.660000,53.830002,53.939999,-1.317230,-1.32 % -1627393841,FDX,297.500000,296.089996,284.755005,-4.284030,-4.28 % -1627393841,C,67.769997,66.459999,67.665001,-0.154936,-0.15 % -1627393841,AIG,47.709999,47.080002,47.320000,-0.817439,-0.82 % -1627393841,BAC,38.130001,37.720001,37.705002,-1.114610,-1.11 % -1627393841,BK,50.250000,49.639999,49.970001,-0.557214,-0.56 % -1627393841,PBF,9.570000,9.070000,9.210000,-3.761760,-3.76 % -1627393841,PBFX,13.580000,13.400000,13.321700,-1.902060,-1.90 % -1627393841,SYF,47.139999,46.650002,46.970001,-0.360628,-0.36 % -1627393841,WFC,45.009998,44.590000,44.719898,-0.644523,-0.64 % -1627393841,TEVA,8.940000,8.930000,8.825000,-1.286350,-1.29 % -1627393841,XOM,58.480000,58.009998,57.610001,-1.487690,-1.49 % -1627393841,MPC,54.660000,53.830002,53.970001,-1.262350,-1.26 % -1627393904,FDX,297.500000,296.089996,284.755005,-4.284030,-4.28 % -1627393904,C,67.769997,67.080002,67.589996,-0.265604,-0.27 % -1627393904,AIG,47.709999,47.080002,47.389999,-0.670719,-0.67 % -1627393904,BAC,38.130001,37.720001,37.705002,-1.114610,-1.11 % -1627393904,BK,50.250000,49.639999,49.970001,-0.557214,-0.56 % -1627393904,PBF,9.570000,9.070000,9.210000,-3.761760,-3.76 % -1627393904,PBFX,13.580000,13.400000,13.362400,-1.602360,-1.60 % -1627393904,SYF,47.139999,46.650002,46.970001,-0.360628,-0.36 % -1627393904,WFC,45.009998,44.590000,44.709999,-0.666519,-0.67 % -1627393904,TEVA,8.940000,8.930000,8.820000,-1.342280,-1.34 % -1627393904,XOM,58.480000,58.009998,57.610001,-1.487690,-1.49 % -1627393904,MPC,54.660000,53.830002,53.970001,-1.262350,-1.26 % -1627393966,FDX,297.500000,296.089996,284.132996,-4.492970,-4.49 % -1627393966,C,67.769997,67.080002,67.559998,-0.309872,-0.31 % -1627393966,AIG,47.709999,47.080002,47.209999,-1.048000,-1.05 % -1627393966,BAC,38.130001,37.720001,37.650002,-1.258850,-1.26 % -1627393966,BK,50.250000,49.639999,49.869999,-0.756219,-0.76 % -1627393966,PBF,9.570000,9.070000,9.150000,-4.388710,-4.39 % -1627393966,PBFX,13.580000,13.400000,13.362400,-1.602360,-1.60 % -1627393966,SYF,47.139999,46.650002,46.919998,-0.466695,-0.47 % -1627393966,WFC,45.009998,44.590000,44.709999,-0.666519,-0.67 % -1627393966,TEVA,8.940000,8.930000,8.820000,-1.342280,-1.34 % -1627393966,XOM,58.480000,58.009998,57.480000,-1.709990,-1.71 % -1627393966,MPC,54.660000,53.830002,53.849998,-1.481890,-1.48 % -1627394028,FDX,297.500000,287.500000,284.040009,-4.524370,-4.52 % -1627394028,C,67.769997,67.080002,67.589996,-0.265604,-0.27 % -1627394028,AIG,47.709999,47.080002,47.270000,-0.922239,-0.92 % -1627394028,BAC,38.130001,37.720001,37.680000,-1.180170,-1.18 % -1627394028,BK,50.250000,49.639999,49.919998,-0.656716,-0.66 % -1627394028,PBF,9.570000,9.070000,9.130000,-4.597700,-4.60 % -1627394028,PBFX,13.580000,13.400000,13.362400,-1.602360,-1.60 % -1627394028,SYF,47.139999,46.650002,47.000000,-0.296988,-0.30 % -1627394028,WFC,45.009998,44.590000,44.674999,-0.744279,-0.74 % -1627394028,TEVA,8.940000,8.930000,8.835000,-1.174500,-1.17 % -1627394028,XOM,58.480000,58.009998,57.509998,-1.658690,-1.66 % -1627394028,MPC,54.660000,53.830002,53.869999,-1.445300,-1.45 % -1627394091,FDX,297.500000,287.500000,283.790009,-4.608400,-4.61 % -1627394091,C,67.769997,67.080002,67.696404,-0.108603,-0.11 % -1627394091,AIG,47.709999,47.080002,47.320000,-0.817439,-0.82 % -1627394091,BAC,38.130001,37.720001,37.680000,-1.180170,-1.18 % -1627394091,BK,50.250000,49.639999,49.919998,-0.656716,-0.66 % -1627394091,PBF,9.570000,9.070000,9.110000,-4.806690,-4.81 % -1627394091,PBFX,13.580000,13.400000,13.457500,-0.902062,-0.90 % -1627394091,SYF,47.139999,46.650002,47.020000,-0.254561,-0.25 % -1627394091,WFC,45.009998,44.590000,44.764999,-0.544323,-0.54 % -1627394091,TEVA,8.940000,8.930000,8.825000,-1.286350,-1.29 % -1627394091,XOM,58.480000,58.009998,57.535000,-1.615940,-1.62 % -1627394091,MPC,54.660000,53.830002,53.980000,-1.244050,-1.24 % -1627394153,FDX,297.500000,287.500000,284.005005,-4.536130,-4.54 % -1627394153,C,67.769997,67.080002,67.709999,-0.088535,-0.09 % -1627394153,AIG,47.709999,47.080002,47.220001,-1.027040,-1.03 % -1627394153,BAC,38.130001,37.720001,37.689999,-1.153950,-1.15 % -1627394153,BK,50.250000,49.639999,49.939999,-0.616915,-0.62 % -1627394153,PBF,9.570000,9.070000,9.070000,-5.224660,-5.22 % -1627394153,PBFX,13.580000,13.400000,13.590000,0.073638,+0.07 % -1627394153,SYF,47.139999,46.650002,46.959999,-0.381841,-0.38 % -1627394153,WFC,45.009998,44.590000,44.720001,-0.644301,-0.64 % -1627394153,TEVA,8.940000,8.930000,8.825000,-1.286350,-1.29 % -1627394153,XOM,58.480000,57.160000,57.465000,-1.735640,-1.74 % -1627394153,MPC,54.660000,53.830002,53.880001,-1.427000,-1.43 % -1627394215,FDX,297.500000,287.500000,283.933014,-4.560500,-4.56 % -1627394215,C,67.769997,67.080002,67.625000,-0.213959,-0.21 % -1627394215,AIG,47.709999,47.080002,47.180000,-1.110880,-1.11 % -1627394215,BAC,38.130001,37.720001,37.685001,-1.167060,-1.17 % -1627394215,BK,50.250000,49.639999,49.930000,-0.636816,-0.64 % -1627394215,PBF,9.570000,9.070000,9.060000,-5.329150,-5.33 % -1627394215,PBFX,13.580000,13.400000,13.590000,0.073638,+0.07 % -1627394215,SYF,47.139999,46.650002,46.988602,-0.321171,-0.32 % -1627394215,WFC,45.009998,44.590000,44.689999,-0.710953,-0.71 % -1627394215,TEVA,8.940000,8.930000,8.825000,-1.286350,-1.29 % -1627394215,XOM,58.480000,58.009998,57.459999,-1.744190,-1.74 % -1627394215,MPC,54.660000,53.830002,53.880001,-1.427000,-1.43 % -1627394277,FDX,297.500000,287.500000,284.059998,-4.517650,-4.52 % -1627394277,C,67.769997,67.080002,67.625000,-0.213959,-0.21 % -1627394277,AIG,47.709999,47.080002,47.270000,-0.922239,-0.92 % -1627394277,BAC,38.130001,37.720001,37.685001,-1.167060,-1.17 % -1627394277,BK,50.250000,49.639999,49.950001,-0.597015,-0.60 % -1627394277,PBF,9.570000,9.070000,9.060000,-5.329150,-5.33 % -1627394277,PBFX,13.580000,13.400000,13.575000,-0.036819,-0.04 % -1627394277,SYF,47.139999,46.650002,46.988602,-0.321171,-0.32 % -1627394277,WFC,45.009998,44.590000,44.770000,-0.533215,-0.53 % -1627394277,TEVA,8.940000,8.930000,8.815000,-1.398210,-1.40 % -1627394277,XOM,58.480000,58.009998,57.459999,-1.744190,-1.74 % -1627394277,MPC,54.660000,53.830002,53.880001,-1.427000,-1.43 % -1627394339,FDX,297.500000,287.500000,284.010010,-4.534450,-4.53 % -1627394339,C,67.769997,67.080002,67.620003,-0.221337,-0.22 % -1627394339,AIG,47.709999,47.080002,47.270000,-0.922239,-0.92 % -1627394339,BAC,38.130001,37.720001,37.660000,-1.232630,-1.23 % -1627394339,BK,50.250000,49.639999,49.889999,-0.716418,-0.72 % -1627394339,PBF,9.570000,9.090000,9.070000,-5.224660,-5.22 % -1627394339,PBFX,13.580000,13.400000,13.575000,-0.036819,-0.04 % -1627394339,SYF,47.139999,46.650002,46.910000,-0.487908,-0.49 % -1627394339,WFC,45.009998,44.590000,44.730000,-0.622084,-0.62 % -1627394339,TEVA,8.940000,8.930000,8.790000,-1.677850,-1.68 % -1627394339,XOM,58.480000,57.160000,57.430000,-1.795490,-1.80 % -1627394339,MPC,54.660000,53.830002,53.830002,-1.518480,-1.52 % -1627394402,FDX,297.500000,287.500000,284.170013,-4.480670,-4.48 % -1627394402,C,67.769997,67.080002,67.480003,-0.427918,-0.43 % -1627394402,AIG,47.709999,47.080002,47.180000,-1.110880,-1.11 % -1627394402,BAC,38.130001,37.720001,37.601299,-1.386570,-1.39 % -1627394402,BK,50.250000,49.639999,49.919998,-0.656716,-0.66 % -1627394402,PBF,9.570000,9.090000,9.025000,-5.694880,-5.69 % -1627394402,PBFX,13.580000,13.550000,13.510000,-0.515464,-0.52 % -1627394402,SYF,47.139999,46.650002,46.910000,-0.487908,-0.49 % -1627394402,WFC,45.009998,44.590000,44.669998,-0.755388,-0.76 % -1627394402,TEVA,8.940000,8.930000,8.785000,-1.733780,-1.73 % -1627394402,XOM,58.480000,57.160000,57.292500,-2.030610,-2.03 % -1627394402,MPC,54.660000,53.830002,53.645000,-1.856930,-1.86 % -1627394465,FDX,297.500000,287.500000,284.170013,-4.480670,-4.48 % -1627394465,C,67.769997,67.080002,67.480003,-0.427918,-0.43 % -1627394465,AIG,47.709999,47.080002,47.180000,-1.110880,-1.11 % -1627394465,BAC,38.130001,37.720001,37.660000,-1.232630,-1.23 % -1627394465,BK,50.250000,49.639999,49.919998,-0.656716,-0.66 % -1627394465,PBF,9.570000,9.090000,9.000000,-5.956110,-5.96 % -1627394465,PBFX,13.580000,13.550000,13.510000,-0.515464,-0.52 % -1627394465,SYF,47.139999,46.650002,46.904999,-0.498515,-0.50 % -1627394465,WFC,45.009998,44.590000,44.750000,-0.577649,-0.58 % -1627394465,TEVA,8.940000,8.930000,8.785000,-1.733780,-1.73 % -1627394465,XOM,58.480000,58.009998,57.410000,-1.829690,-1.83 % -1627394465,MPC,54.660000,53.990002,53.730000,-1.701430,-1.70 % -1627394527,FDX,297.500000,287.500000,284.738007,-4.289750,-4.29 % -1627394527,C,67.769997,67.080002,67.480003,-0.427918,-0.43 % -1627394527,AIG,47.709999,47.080002,47.290001,-0.880319,-0.88 % -1627394527,BAC,38.130001,37.720001,37.660000,-1.232630,-1.23 % -1627394527,BK,50.250000,49.639999,49.939999,-0.616915,-0.62 % -1627394527,PBF,9.570000,9.090000,9.000000,-5.956110,-5.96 % -1627394527,PBFX,13.580000,13.550000,13.510000,-0.515464,-0.52 % -1627394527,SYF,47.139999,46.650002,46.900002,-0.509122,-0.51 % -1627394527,WFC,45.009998,44.590000,44.799999,-0.466563,-0.47 % -1627394527,TEVA,8.940000,8.930000,8.765000,-1.957490,-1.96 % -1627394527,XOM,58.480000,58.009998,57.410000,-1.829690,-1.83 % -1627394527,MPC,54.660000,53.990002,53.730000,-1.701430,-1.70 % -1627394589,FDX,297.500000,287.500000,283.929993,-4.561340,-4.56 % -1627394589,C,67.769997,67.080002,67.555000,-0.317250,-0.32 % -1627394589,AIG,47.709999,47.080002,47.240002,-0.985118,-0.99 % -1627394589,BAC,38.130001,37.720001,37.674999,-1.193290,-1.19 % -1627394589,BK,50.250000,49.639999,50.025002,-0.447761,-0.45 % -1627394589,PBF,9.570000,9.090000,8.990000,-6.060610,-6.06 % -1627394589,PBFX,13.580000,13.550000,13.510000,-0.515464,-0.52 % -1627394589,SYF,47.139999,46.650002,46.930000,-0.445482,-0.45 % -1627394589,WFC,45.009998,44.590000,44.799999,-0.466563,-0.47 % -1627394589,TEVA,8.940000,8.930000,8.765000,-1.957490,-1.96 % -1627394589,XOM,58.480000,57.160000,57.485001,-1.701440,-1.70 % -1627394589,MPC,54.660000,53.830002,53.781300,-1.607570,-1.61 % -1627394651,FDX,297.500000,287.500000,283.760010,-4.618490,-4.62 % -1627394651,C,67.769997,67.080002,67.529999,-0.354139,-0.35 % -1627394651,AIG,47.709999,47.080002,47.235001,-0.995598,-1.00 % -1627394651,BAC,38.130001,37.720001,37.674999,-1.193290,-1.19 % -1627394651,BK,50.250000,49.639999,50.009998,-0.477612,-0.48 % -1627394651,PBF,9.570000,9.090000,8.990000,-6.060610,-6.06 % -1627394651,PBFX,13.580000,13.550000,13.505000,-0.552283,-0.55 % -1627394651,SYF,47.139999,46.650002,46.930000,-0.445482,-0.45 % -1627394651,WFC,45.009998,44.590000,44.830002,-0.399911,-0.40 % -1627394651,TEVA,8.940000,8.930000,8.730000,-2.348990,-2.35 % -1627394651,XOM,58.480000,58.009998,57.410000,-1.829690,-1.83 % -1627394651,MPC,54.660000,53.830002,53.709999,-1.738020,-1.74 % -1627394714,FDX,297.500000,287.500000,283.165009,-4.818490,-4.82 % -1627394714,C,67.769997,67.080002,67.500000,-0.398406,-0.40 % -1627394714,AIG,47.709999,47.080002,47.189999,-1.089920,-1.09 % -1627394714,BAC,38.130001,37.720001,37.650002,-1.258850,-1.26 % -1627394714,BK,50.250000,49.639999,50.004299,-0.488955,-0.49 % -1627394714,PBF,9.570000,9.090000,9.000000,-5.956110,-5.96 % -1627394714,PBFX,13.580000,13.550000,13.505000,-0.552283,-0.55 % -1627394714,SYF,47.139999,46.650002,46.910000,-0.487908,-0.49 % -1627394714,WFC,45.009998,44.590000,44.750000,-0.577649,-0.58 % -1627394714,TEVA,8.940000,8.930000,8.735000,-2.293060,-2.29 % -1627394714,XOM,58.480000,58.009998,57.424999,-1.804040,-1.80 % -1627394714,MPC,54.660000,53.990002,53.790001,-1.591660,-1.59 % -1627394776,FDX,297.500000,287.500000,283.467987,-4.716640,-4.72 % -1627394776,C,67.769997,67.080002,67.599998,-0.250848,-0.25 % -1627394776,AIG,47.709999,47.080002,47.240002,-0.985118,-0.99 % -1627394776,BAC,38.130001,37.720001,37.680000,-1.180170,-1.18 % -1627394776,BK,50.250000,49.639999,50.029999,-0.437811,-0.44 % -1627394776,PBF,9.570000,9.090000,9.060000,-5.329150,-5.33 % -1627394776,PBFX,13.580000,13.550000,13.505000,-0.552283,-0.55 % -1627394776,SYF,47.139999,46.650002,46.980000,-0.339415,-0.34 % -1627394776,WFC,45.009998,44.590000,44.860001,-0.333259,-0.33 % -1627394776,TEVA,8.940000,8.930000,8.727300,-2.379190,-2.38 % -1627394776,XOM,58.480000,57.160000,57.520000,-1.641590,-1.64 % -1627394776,MPC,54.660000,53.830002,53.909599,-1.372850,-1.37 % -1627394839,FDX,297.500000,287.500000,282.959991,-4.887390,-4.89 % -1627394839,C,67.769997,67.080002,67.589996,-0.265604,-0.27 % -1627394839,AIG,47.709999,47.080002,47.290001,-0.880319,-0.88 % -1627394839,BAC,38.130001,37.720001,37.709999,-1.101490,-1.10 % -1627394839,BK,50.250000,49.639999,50.094299,-0.309851,-0.31 % -1627394839,PBF,9.570000,9.090000,9.040000,-5.538140,-5.54 % -1627394839,PBFX,13.580000,13.550000,13.440100,-1.030190,-1.03 % -1627394839,SYF,47.139999,46.650002,46.980000,-0.339415,-0.34 % -1627394839,WFC,45.009998,44.590000,44.855000,-0.344368,-0.34 % -1627394839,TEVA,8.940000,8.930000,8.727300,-2.379190,-2.38 % -1627394839,XOM,58.480000,58.009998,57.514999,-1.650140,-1.65 % -1627394839,MPC,54.660000,53.990002,53.910000,-1.372120,-1.37 % -1627394902,FDX,297.500000,287.500000,283.329987,-4.763030,-4.76 % -1627394902,C,67.769997,67.080002,67.599998,-0.250848,-0.25 % -1627394902,AIG,47.709999,47.080002,47.279999,-0.901279,-0.90 % -1627394902,BAC,38.130001,37.720001,37.709999,-1.101490,-1.10 % -1627394902,BK,50.250000,49.639999,50.075001,-0.348259,-0.35 % -1627394902,PBF,9.570000,9.090000,9.040000,-5.538140,-5.54 % -1627394902,PBFX,13.580000,13.550000,13.510000,-0.515464,-0.52 % -1627394902,SYF,47.139999,46.650002,47.029999,-0.233347,-0.23 % -1627394902,WFC,45.009998,44.590000,44.889000,-0.268829,-0.27 % -1627394902,TEVA,8.940000,8.930000,8.720000,-2.460850,-2.46 % -1627394902,XOM,58.480000,57.160000,57.470001,-1.727090,-1.73 % -1627394902,MPC,54.660000,53.830002,53.880001,-1.427000,-1.43 % -1627394964,FDX,297.500000,287.500000,283.546997,-4.690080,-4.69 % -1627394964,C,67.769997,67.080002,67.589996,-0.265604,-0.27 % -1627394964,AIG,47.709999,47.080002,47.400002,-0.649759,-0.65 % -1627394964,BAC,38.130001,37.720001,37.720001,-1.075270,-1.08 % -1627394964,BK,50.250000,49.639999,50.154999,-0.189055,-0.19 % -1627394964,PBF,9.570000,9.090000,9.060000,-5.329150,-5.33 % -1627394964,PBFX,13.580000,13.550000,13.510000,-0.515464,-0.52 % -1627394964,SYF,47.139999,46.650002,47.099998,-0.084854,-0.08 % -1627394964,WFC,45.009998,44.590000,44.924999,-0.188847,-0.19 % -1627394964,TEVA,8.940000,8.930000,8.720000,-2.460850,-2.46 % -1627394964,XOM,58.480000,57.160000,57.501999,-1.672370,-1.67 % -1627394964,MPC,54.660000,53.830002,53.910000,-1.372120,-1.37 % -1627395026,FDX,297.500000,287.500000,283.195007,-4.808300,-4.81 % -1627395026,C,67.769997,67.080002,67.589996,-0.265604,-0.27 % -1627395026,AIG,47.709999,47.080002,47.340000,-0.775519,-0.78 % -1627395026,BAC,38.130001,37.720001,37.755001,-0.983478,-0.98 % -1627395026,BK,50.250000,49.639999,50.150002,-0.199005,-0.20 % -1627395026,PBF,9.570000,9.090000,9.075000,-5.172410,-5.17 % -1627395026,PBFX,13.580000,13.550000,13.515000,-0.478645,-0.48 % -1627395026,SYF,47.139999,46.650002,47.115002,-0.053034,-0.05 % -1627395026,WFC,45.009998,44.590000,44.950001,-0.133304,-0.13 % -1627395026,TEVA,8.940000,8.930000,8.725000,-2.404920,-2.40 % -1627395026,XOM,58.480000,58.009998,57.520000,-1.641590,-1.64 % -1627395026,MPC,54.660000,53.990002,53.919998,-1.353820,-1.35 % -1627395089,FDX,297.500000,287.500000,282.975006,-4.882350,-4.88 % -1627395089,C,67.769997,67.080002,67.559998,-0.309872,-0.31 % -1627395089,AIG,47.709999,47.080002,47.340000,-0.775519,-0.78 % -1627395089,BAC,38.130001,37.720001,37.740002,-1.022820,-1.02 % -1627395089,BK,50.250000,49.639999,50.119999,-0.258706,-0.26 % -1627395089,PBF,9.570000,9.090000,9.040000,-5.538140,-5.54 % -1627395089,PBFX,13.580000,13.550000,13.515000,-0.478645,-0.48 % -1627395089,SYF,47.139999,46.650002,47.060001,-0.169707,-0.17 % -1627395089,WFC,45.009998,44.590000,44.900002,-0.244390,-0.24 % -1627395089,TEVA,8.940000,8.930000,8.715000,-2.516780,-2.52 % -1627395089,XOM,58.480000,57.160000,57.470001,-1.727090,-1.73 % -1627395089,MPC,54.660000,53.830002,53.860001,-1.463590,-1.46 % -1627395151,FDX,297.500000,287.500000,283.424988,-4.731090,-4.73 % -1627395151,C,67.769997,67.080002,67.540001,-0.339383,-0.34 % -1627395151,AIG,47.709999,47.080002,47.290001,-0.880319,-0.88 % -1627395151,BAC,38.130001,37.720001,37.740002,-1.022820,-1.02 % -1627395151,BK,50.250000,49.639999,50.169998,-0.159204,-0.16 % -1627395151,PBF,9.570000,9.090000,9.040000,-5.538140,-5.54 % -1627395151,PBFX,13.580000,13.550000,13.515000,-0.478645,-0.48 % -1627395151,SYF,47.139999,46.650002,47.080002,-0.127280,-0.13 % -1627395151,WFC,45.009998,44.590000,44.889999,-0.266607,-0.27 % -1627395151,TEVA,8.940000,8.930000,8.710000,-2.572710,-2.57 % -1627395151,XOM,58.480000,58.009998,57.420502,-1.811730,-1.81 % -1627395151,MPC,54.660000,53.990002,53.830002,-1.518480,-1.52 % -1627395213,FDX,297.500000,287.500000,283.285004,-4.778150,-4.78 % -1627395213,C,67.769997,67.080002,67.514999,-0.376273,-0.38 % -1627395213,AIG,47.709999,47.080002,47.290001,-0.880319,-0.88 % -1627395213,BAC,38.130001,37.720001,37.695000,-1.140830,-1.14 % -1627395213,BK,50.250000,49.639999,50.119999,-0.258706,-0.26 % -1627395213,PBF,9.570000,9.090000,8.980000,-6.165100,-6.17 % -1627395213,PBFX,13.580000,13.550000,13.515000,-0.478645,-0.48 % -1627395213,SYF,47.139999,46.650002,47.005001,-0.286381,-0.29 % -1627395213,WFC,45.009998,44.590000,44.840099,-0.377472,-0.38 % -1627395213,TEVA,8.940000,8.930000,8.715000,-2.516780,-2.52 % -1627395213,XOM,58.480000,57.160000,57.389999,-1.863890,-1.86 % -1627395213,MPC,54.660000,53.830002,53.704601,-1.747900,-1.75 % -1627395275,FDX,297.500000,287.500000,283.404999,-4.737820,-4.74 % -1627395275,C,67.769997,67.080002,67.514999,-0.376273,-0.38 % -1627395275,AIG,47.709999,47.080002,47.330002,-0.796479,-0.80 % -1627395275,BAC,38.130001,37.720001,37.695000,-1.140830,-1.14 % -1627395275,BK,50.250000,49.639999,50.110001,-0.278607,-0.28 % -1627395275,PBF,9.570000,9.090000,8.980000,-6.165100,-6.17 % -1627395275,PBFX,13.580000,13.550000,13.515000,-0.478645,-0.48 % -1627395275,SYF,47.139999,46.650002,47.005001,-0.286381,-0.29 % -1627395275,WFC,45.009998,44.590000,44.889999,-0.266607,-0.27 % -1627395275,TEVA,8.940000,8.930000,8.690000,-2.796420,-2.80 % -1627395275,XOM,58.480000,57.160000,57.389999,-1.863890,-1.86 % -1627395275,MPC,54.660000,53.830002,53.704601,-1.747900,-1.75 % -1627395337,FDX,297.500000,287.500000,283.000000,-4.873950,-4.87 % -1627395337,C,67.769997,67.080002,67.510002,-0.383651,-0.38 % -1627395337,AIG,47.709999,47.080002,47.320000,-0.817439,-0.82 % -1627395337,BAC,38.130001,37.720001,37.705002,-1.114610,-1.11 % -1627395337,BK,50.250000,49.639999,50.119999,-0.258706,-0.26 % -1627395337,PBF,9.570000,9.090000,8.940000,-6.583070,-6.58 % -1627395337,PBFX,13.580000,13.550000,13.515000,-0.478645,-0.48 % -1627395337,SYF,47.139999,46.650002,47.009998,-0.275774,-0.28 % -1627395337,WFC,45.009998,44.590000,44.889999,-0.266607,-0.27 % -1627395337,TEVA,8.940000,8.930000,8.690000,-2.796420,-2.80 % -1627395337,XOM,58.480000,57.160000,57.360001,-1.915180,-1.92 % -1627395337,MPC,54.660000,53.830002,53.709999,-1.738020,-1.74 % -1627395400,FDX,297.500000,287.500000,282.920013,-4.900840,-4.90 % -1627395400,C,67.769997,67.080002,67.610001,-0.236093,-0.24 % -1627395400,AIG,47.709999,47.080002,47.320000,-0.817439,-0.82 % -1627395400,BAC,38.130001,37.720001,37.810001,-0.839234,-0.84 % -1627395400,BK,50.250000,49.639999,50.174999,-0.149254,-0.15 % -1627395400,PBF,9.570000,9.090000,8.970000,-6.269590,-6.27 % -1627395400,PBFX,13.580000,13.550000,13.515000,-0.478645,-0.48 % -1627395400,SYF,47.139999,46.650002,47.090000,-0.106067,-0.11 % -1627395400,WFC,45.009998,44.590000,44.980000,-0.066652,-0.07 % -1627395400,TEVA,8.940000,8.930000,8.690000,-2.796420,-2.80 % -1627395400,XOM,58.480000,58.009998,57.384998,-1.872440,-1.87 % -1627395400,MPC,54.660000,53.990002,53.740002,-1.683130,-1.68 % -1627395462,FDX,297.500000,287.500000,282.910004,-4.904200,-4.90 % -1627395462,C,67.769997,67.080002,67.610001,-0.236093,-0.24 % -1627395462,AIG,47.709999,47.080002,47.380001,-0.691679,-0.69 % -1627395462,BAC,38.130001,37.720001,37.810001,-0.839234,-0.84 % -1627395462,BK,50.250000,49.639999,50.224998,-0.049751,-0.05 % -1627395462,PBF,9.570000,9.090000,8.995000,-6.008360,-6.01 % -1627395462,PBFX,13.580000,13.550000,13.515000,-0.478645,-0.48 % -1627395462,SYF,47.139999,46.650002,47.110001,-0.063640,-0.06 % -1627395462,WFC,45.009998,44.590000,44.980000,-0.066652,-0.07 % -1627395462,TEVA,8.940000,8.930000,8.705000,-2.628640,-2.63 % -1627395462,XOM,58.480000,58.009998,57.384998,-1.872440,-1.87 % -1627395462,MPC,54.660000,53.990002,53.740002,-1.683130,-1.68 % -1627395524,FDX,297.500000,287.500000,282.799988,-4.941180,-4.94 % -1627395524,C,67.769997,67.080002,67.589996,-0.265604,-0.27 % -1627395524,AIG,47.709999,47.080002,47.360001,-0.733599,-0.73 % -1627395524,BAC,38.130001,37.720001,37.837299,-0.767637,-0.77 % -1627395524,BK,50.250000,49.639999,50.174999,-0.149254,-0.15 % -1627395524,PBF,9.570000,9.090000,9.020000,-5.747130,-5.75 % -1627395524,PBFX,13.580000,13.550000,13.515000,-0.478645,-0.48 % -1627395524,SYF,47.139999,46.650002,47.130001,-0.021213,-0.02 % -1627395524,WFC,45.009998,44.590000,44.990002,-0.044435,-0.04 % -1627395524,TEVA,8.940000,8.930000,8.695000,-2.740490,-2.74 % -1627395524,XOM,58.480000,58.009998,57.430000,-1.795490,-1.80 % -1627395524,MPC,54.660000,53.990002,53.820000,-1.536770,-1.54 % -1627395587,FDX,297.500000,287.500000,282.959991,-4.887390,-4.89 % -1627395587,C,67.769997,67.080002,67.610001,-0.236093,-0.24 % -1627395587,AIG,47.709999,47.080002,47.340000,-0.775519,-0.78 % -1627395587,BAC,38.130001,37.720001,37.840000,-0.760556,-0.76 % -1627395587,BK,50.250000,49.639999,50.169998,-0.159204,-0.16 % -1627395587,PBF,9.570000,9.090000,9.025000,-5.694880,-5.69 % -1627395587,PBFX,13.580000,13.550000,13.515000,-0.478645,-0.48 % -1627395587,SYF,47.139999,46.650002,47.099998,-0.084854,-0.08 % -1627395587,WFC,45.009998,44.590000,44.970001,-0.088869,-0.09 % -1627395587,TEVA,8.940000,8.930000,8.695000,-2.740490,-2.74 % -1627395587,XOM,58.480000,58.009998,57.480000,-1.709990,-1.71 % -1627395587,MPC,54.660000,53.990002,53.919998,-1.353820,-1.35 % -1627395649,FDX,297.500000,287.500000,283.329987,-4.763030,-4.76 % -1627395649,C,67.769997,67.080002,67.641602,-0.189464,-0.19 % -1627395649,AIG,47.709999,47.080002,47.419998,-0.607839,-0.61 % -1627395649,BAC,38.130001,37.720001,37.860001,-0.708104,-0.71 % -1627395649,BK,50.250000,49.639999,50.264999,0.029851,+0.03 % -1627395649,PBF,9.570000,9.090000,9.025000,-5.694880,-5.69 % -1627395649,PBFX,13.580000,13.550000,13.515000,-0.478645,-0.48 % -1627395649,SYF,47.139999,46.650002,47.160000,0.042427,+0.04 % -1627395649,WFC,45.009998,44.590000,44.990101,-0.044212,-0.04 % -1627395649,TEVA,8.940000,8.930000,8.705000,-2.628640,-2.63 % -1627395649,XOM,58.480000,57.160000,57.520000,-1.641590,-1.64 % -1627395649,MPC,54.660000,53.990002,53.980000,-1.244050,-1.24 % -1627395711,FDX,297.500000,287.500000,283.304993,-4.771430,-4.77 % -1627395711,C,67.769997,67.080002,67.669998,-0.147558,-0.15 % -1627395711,AIG,47.709999,47.080002,47.529999,-0.377279,-0.38 % -1627395711,BAC,38.130001,37.720001,37.880100,-0.655389,-0.66 % -1627395711,BK,50.250000,49.639999,50.270000,0.039801,+0.04 % -1627395711,PBF,9.570000,9.090000,9.035000,-5.590390,-5.59 % -1627395711,PBFX,13.580000,13.550000,13.515000,-0.478645,-0.48 % -1627395711,SYF,47.139999,46.650002,47.220001,0.169707,+0.17 % -1627395711,WFC,45.009998,44.590000,45.029999,0.044435,+0.04 % -1627395711,TEVA,8.940000,8.930000,8.690000,-2.796420,-2.80 % -1627395711,XOM,58.480000,57.160000,57.590000,-1.521890,-1.52 % -1627395711,MPC,54.660000,53.830002,54.020000,-1.170870,-1.17 % -1627395774,FDX,297.500000,287.500000,283.679993,-4.645380,-4.65 % -1627395774,C,67.769997,67.080002,67.750099,-0.029364,-0.03 % -1627395774,AIG,47.709999,47.080002,47.540001,-0.356319,-0.36 % -1627395774,BAC,38.130001,37.720001,37.929501,-0.525833,-0.53 % -1627395774,BK,50.250000,49.639999,50.310101,0.119602,+0.12 % -1627395774,PBF,9.570000,9.090000,9.060000,-5.329150,-5.33 % -1627395774,PBFX,13.580000,13.550000,13.515000,-0.478645,-0.48 % -1627395774,SYF,47.139999,46.650002,47.275002,0.286381,+0.29 % -1627395774,WFC,45.009998,44.590000,45.049999,0.088869,+0.09 % -1627395774,TEVA,8.940000,8.930000,8.705000,-2.628640,-2.63 % -1627395774,XOM,58.480000,57.160000,57.665001,-1.393640,-1.39 % -1627395774,MPC,54.660000,53.830002,54.130001,-0.969630,-0.97 % -1627395836,FDX,297.500000,287.500000,283.756989,-4.619330,-4.62 % -1627395836,C,67.769997,67.080002,67.809998,0.059023,+0.06 % -1627395836,AIG,47.709999,47.080002,47.560001,-0.314399,-0.31 % -1627395836,BAC,38.130001,37.720001,37.939999,-0.498295,-0.50 % -1627395836,BK,50.250000,49.639999,50.320000,0.139303,+0.14 % -1627395836,PBF,9.570000,9.090000,9.030000,-5.642630,-5.64 % -1627395836,PBFX,13.580000,13.550000,13.515000,-0.478645,-0.48 % -1627395836,SYF,47.139999,46.650002,47.299999,0.339415,+0.34 % -1627395836,WFC,45.009998,44.590000,45.090000,0.177738,+0.18 % -1627395836,TEVA,8.940000,8.930000,8.705000,-2.628640,-2.63 % -1627395836,XOM,58.480000,57.160000,57.660000,-1.402190,-1.40 % -1627395836,MPC,54.660000,53.830002,54.110001,-1.006220,-1.01 % -1627395898,FDX,297.500000,287.500000,283.756989,-4.619330,-4.62 % -1627395898,C,67.769997,67.080002,67.820000,0.073779,+0.07 % -1627395898,AIG,47.709999,47.080002,47.560001,-0.314399,-0.31 % -1627395898,BAC,38.130001,37.720001,37.965000,-0.432730,-0.43 % -1627395898,BK,50.250000,49.639999,50.320000,0.139303,+0.14 % -1627395898,PBF,9.570000,9.090000,9.055000,-5.381400,-5.38 % -1627395898,PBFX,13.580000,13.550000,13.515000,-0.478645,-0.48 % -1627395898,SYF,47.139999,46.650002,47.365002,0.477302,+0.48 % -1627395898,WFC,45.009998,44.590000,45.090000,0.177738,+0.18 % -1627395898,TEVA,8.940000,8.930000,8.705000,-2.628640,-2.63 % -1627395898,XOM,58.480000,58.009998,57.669998,-1.385090,-1.39 % -1627395898,MPC,54.660000,53.990002,54.117199,-0.993048,-0.99 % -1627395961,FDX,297.500000,287.500000,284.000000,-4.537820,-4.54 % -1627395961,C,67.769997,67.080002,67.751404,-0.027446,-0.03 % -1627395961,AIG,47.709999,47.080002,47.560001,-0.314399,-0.31 % -1627395961,BAC,38.130001,37.720001,37.935001,-0.511408,-0.51 % -1627395961,BK,50.250000,49.639999,50.365002,0.228856,+0.23 % -1627395961,PBF,9.570000,9.090000,9.005000,-5.903870,-5.90 % -1627395961,PBFX,13.580000,13.550000,13.515000,-0.478645,-0.48 % -1627395961,SYF,47.139999,46.650002,47.365002,0.477302,+0.48 % -1627395961,WFC,45.009998,44.590000,45.040001,0.066652,+0.07 % -1627395961,TEVA,8.940000,8.930000,8.705000,-2.628640,-2.63 % -1627395961,XOM,58.480000,58.009998,57.610001,-1.487690,-1.49 % -1627395961,MPC,54.660000,53.990002,54.009998,-1.189170,-1.19 % -1627396023,FDX,297.500000,287.500000,284.066010,-4.515760,-4.52 % -1627396023,C,67.769997,67.080002,67.751404,-0.027446,-0.03 % -1627396023,AIG,47.709999,47.080002,47.590000,-0.251520,-0.25 % -1627396023,BAC,38.130001,37.720001,37.935001,-0.511408,-0.51 % -1627396023,BK,50.250000,49.639999,50.380001,0.258706,+0.26 % -1627396023,PBF,9.570000,9.090000,9.005000,-5.903870,-5.90 % -1627396023,PBFX,13.580000,13.550000,13.515000,-0.478645,-0.48 % -1627396023,SYF,47.139999,46.650002,47.349998,0.445482,+0.45 % -1627396023,WFC,45.009998,44.590000,45.042500,0.072206,+0.07 % -1627396023,TEVA,8.940000,8.930000,8.675000,-2.964210,-2.96 % -1627396023,XOM,58.480000,58.009998,57.610001,-1.487690,-1.49 % -1627396023,MPC,54.660000,53.990002,54.009998,-1.189170,-1.19 % -1627396085,FDX,297.500000,287.500000,283.750000,-4.621850,-4.62 % -1627396085,C,67.769997,67.080002,67.764999,-0.007378,-0.01 % -1627396085,AIG,47.709999,47.080002,47.590000,-0.251520,-0.25 % -1627396085,BAC,38.130001,37.720001,37.967899,-0.425125,-0.43 % -1627396085,BK,50.250000,49.639999,50.435001,0.368159,+0.37 % -1627396085,PBF,9.570000,9.090000,9.030000,-5.642630,-5.64 % -1627396085,PBFX,13.580000,13.550000,13.515000,-0.478645,-0.48 % -1627396085,SYF,47.139999,46.650002,47.419998,0.593975,+0.59 % -1627396085,WFC,45.009998,44.590000,45.042500,0.072206,+0.07 % -1627396085,TEVA,8.940000,8.930000,8.675000,-2.964210,-2.96 % -1627396085,XOM,58.480000,58.009998,57.702499,-1.329510,-1.33 % -1627396085,MPC,54.660000,53.990002,54.090000,-1.042810,-1.04 % -1627396147,FDX,297.500000,287.500000,283.750000,-4.621850,-4.62 % -1627396147,C,67.769997,67.080002,67.870003,0.147558,+0.15 % -1627396147,AIG,47.709999,47.080002,47.630001,-0.167680,-0.17 % -1627396147,BAC,38.130001,37.720001,38.039902,-0.236297,-0.24 % -1627396147,BK,50.250000,49.639999,50.435001,0.368159,+0.37 % -1627396147,PBF,9.570000,9.090000,9.110000,-4.806690,-4.81 % -1627396147,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627396147,SYF,47.139999,46.650002,47.490002,0.742469,+0.74 % -1627396147,WFC,45.009998,44.590000,45.171700,0.359253,+0.36 % -1627396147,TEVA,8.940000,8.930000,8.675000,-2.964210,-2.96 % -1627396147,XOM,58.480000,57.160000,57.773399,-1.208280,-1.21 % -1627396147,MPC,54.660000,53.830002,54.160000,-0.914746,-0.91 % -1627396210,FDX,297.500000,287.500000,283.850006,-4.588240,-4.59 % -1627396210,C,67.769997,67.080002,67.815002,0.066401,+0.07 % -1627396210,AIG,47.709999,47.080002,47.630001,-0.167680,-0.17 % -1627396210,BAC,38.130001,37.720001,38.014999,-0.301600,-0.30 % -1627396210,BK,50.250000,49.639999,50.430000,0.358209,+0.36 % -1627396210,PBF,9.570000,9.090000,9.098000,-4.932080,-4.93 % -1627396210,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627396210,SYF,47.139999,46.650002,47.494999,0.753076,+0.75 % -1627396210,WFC,45.009998,44.590000,45.165001,0.344368,+0.34 % -1627396210,TEVA,8.940000,8.930000,8.665000,-3.076060,-3.08 % -1627396210,XOM,58.480000,58.009998,57.759998,-1.231190,-1.23 % -1627396210,MPC,54.660000,53.990002,54.150002,-0.933041,-0.93 % -1627396272,FDX,297.500000,287.500000,284.119995,-4.497480,-4.50 % -1627396272,C,67.769997,67.080002,67.820000,0.073779,+0.07 % -1627396272,AIG,47.709999,47.080002,47.619999,-0.188640,-0.19 % -1627396272,BAC,38.130001,37.720001,38.014999,-0.301600,-0.30 % -1627396272,BK,50.250000,49.639999,50.450001,0.398010,+0.40 % -1627396272,PBF,9.570000,9.090000,9.070100,-5.223620,-5.22 % -1627396272,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627396272,SYF,47.139999,46.650002,47.459999,0.678829,+0.68 % -1627396272,WFC,45.009998,44.590000,45.154999,0.322151,+0.32 % -1627396272,TEVA,8.940000,8.930000,8.665000,-3.076060,-3.08 % -1627396272,XOM,58.480000,58.009998,57.730000,-1.282490,-1.28 % -1627396272,MPC,54.660000,53.990002,54.160000,-0.914746,-0.91 % -1627396334,FDX,297.500000,287.500000,284.019989,-4.531060,-4.53 % -1627396334,C,67.769997,67.080002,67.889999,0.177069,+0.18 % -1627396334,AIG,47.709999,47.080002,47.630001,-0.167680,-0.17 % -1627396334,BAC,38.130001,37.720001,38.056499,-0.192762,-0.19 % -1627396334,BK,50.250000,49.639999,50.480000,0.457711,+0.46 % -1627396334,PBF,9.570000,9.090000,9.050000,-5.433650,-5.43 % -1627396334,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627396334,SYF,47.139999,46.650002,47.500000,0.763683,+0.76 % -1627396334,WFC,45.009998,44.590000,45.154999,0.322151,+0.32 % -1627396334,TEVA,8.940000,8.930000,8.675000,-2.964210,-2.96 % -1627396334,XOM,58.480000,58.009998,57.801300,-1.160570,-1.16 % -1627396334,MPC,54.660000,53.990002,54.174999,-0.887303,-0.89 % -1627396397,FDX,297.500000,287.500000,283.924988,-4.563030,-4.56 % -1627396397,C,67.769997,67.080002,67.834999,0.095913,+0.10 % -1627396397,AIG,47.709999,47.080002,47.599998,-0.230560,-0.23 % -1627396397,BAC,38.130001,37.720001,38.014999,-0.301600,-0.30 % -1627396397,BK,50.250000,49.639999,50.450001,0.398010,+0.40 % -1627396397,PBF,9.570000,9.090000,9.004300,-5.911180,-5.91 % -1627396397,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627396397,SYF,47.139999,46.650002,47.485001,0.731863,+0.73 % -1627396397,WFC,45.009998,44.590000,45.119999,0.244390,+0.24 % -1627396397,TEVA,8.940000,8.930000,8.665000,-3.076060,-3.08 % -1627396397,XOM,58.480000,58.009998,57.737701,-1.269320,-1.27 % -1627396397,MPC,54.660000,53.990002,54.150002,-0.933041,-0.93 % -1627396459,FDX,297.500000,287.500000,283.250000,-4.789920,-4.79 % -1627396459,C,67.769997,67.080002,67.839996,0.103291,+0.10 % -1627396459,AIG,47.709999,47.080002,47.560001,-0.314399,-0.31 % -1627396459,BAC,38.130001,37.720001,38.027500,-0.268817,-0.27 % -1627396459,BK,50.250000,49.639999,50.439999,0.378109,+0.38 % -1627396459,PBF,9.570000,9.090000,9.010000,-5.851620,-5.85 % -1627396459,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627396459,SYF,47.139999,46.650002,47.480000,0.721256,+0.72 % -1627396459,WFC,45.009998,44.590000,45.119999,0.244390,+0.24 % -1627396459,TEVA,8.940000,8.930000,8.680000,-2.908280,-2.91 % -1627396459,XOM,58.480000,58.009998,57.674999,-1.376540,-1.38 % -1627396459,MPC,54.660000,53.990002,54.099998,-1.024520,-1.02 % -1627396521,FDX,297.500000,287.500000,283.559998,-4.685710,-4.69 % -1627396521,C,67.769997,67.080002,67.839996,0.103291,+0.10 % -1627396521,AIG,47.709999,47.080002,47.560001,-0.314399,-0.31 % -1627396521,BAC,38.130001,37.720001,38.038700,-0.239444,-0.24 % -1627396521,BK,50.250000,49.639999,50.470001,0.437811,+0.44 % -1627396521,PBF,9.570000,9.090000,9.040000,-5.538140,-5.54 % -1627396521,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627396521,SYF,47.139999,46.650002,47.505001,0.774289,+0.77 % -1627396521,WFC,45.009998,44.590000,45.134998,0.277716,+0.28 % -1627396521,TEVA,8.940000,8.930000,8.680000,-2.908280,-2.91 % -1627396521,XOM,58.480000,58.009998,57.750000,-1.248290,-1.25 % -1627396521,MPC,54.660000,53.990002,54.160000,-0.914746,-0.91 % -1627396583,FDX,297.500000,287.500000,283.635010,-4.660500,-4.66 % -1627396583,C,67.769997,67.080002,67.873901,0.153313,+0.15 % -1627396583,AIG,47.709999,47.080002,47.680000,-0.062880,-0.06 % -1627396583,BAC,38.130001,37.720001,38.090000,-0.104904,-0.10 % -1627396583,BK,50.250000,49.639999,50.500000,0.497512,+0.50 % -1627396583,PBF,9.570000,9.090000,9.035000,-5.590390,-5.59 % -1627396583,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627396583,SYF,47.139999,46.650002,47.590000,0.954603,+0.95 % -1627396583,WFC,45.009998,44.590000,45.180000,0.377694,+0.38 % -1627396583,TEVA,8.940000,8.930000,8.680000,-2.908280,-2.91 % -1627396583,XOM,58.480000,57.160000,57.783199,-1.191520,-1.19 % -1627396583,MPC,54.660000,53.990002,54.169998,-0.896451,-0.90 % -1627396645,FDX,297.500000,287.500000,283.839996,-4.591600,-4.59 % -1627396645,C,67.769997,67.080002,67.873901,0.153313,+0.15 % -1627396645,AIG,47.709999,47.080002,47.660000,-0.104800,-0.10 % -1627396645,BAC,38.130001,37.720001,38.090000,-0.104904,-0.10 % -1627396645,BK,50.250000,49.639999,50.470001,0.437811,+0.44 % -1627396645,PBF,9.570000,9.090000,9.035000,-5.590390,-5.59 % -1627396645,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627396645,SYF,47.139999,46.650002,47.590000,0.954603,+0.95 % -1627396645,WFC,45.009998,44.590000,45.165001,0.344368,+0.34 % -1627396645,TEVA,8.940000,8.930000,8.675000,-2.964210,-2.96 % -1627396645,XOM,58.480000,57.160000,57.783199,-1.191520,-1.19 % -1627396645,MPC,54.660000,53.990002,54.169998,-0.896451,-0.90 % -1627396707,FDX,297.500000,287.500000,283.720001,-4.631930,-4.63 % -1627396707,C,67.769997,67.080002,67.839996,0.103291,+0.10 % -1627396707,AIG,47.709999,47.080002,47.630001,-0.167680,-0.17 % -1627396707,BAC,38.130001,37.720001,38.090000,-0.104904,-0.10 % -1627396707,BK,50.250000,49.639999,50.509998,0.517413,+0.52 % -1627396707,PBF,9.570000,9.090000,9.014700,-5.802510,-5.80 % -1627396707,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627396707,SYF,47.139999,46.650002,47.599998,0.975817,+0.98 % -1627396707,WFC,45.009998,44.590000,45.200001,0.422128,+0.42 % -1627396707,TEVA,8.940000,8.930000,8.675000,-2.964210,-2.96 % -1627396707,XOM,58.480000,58.009998,57.720001,-1.299590,-1.30 % -1627396707,MPC,54.660000,53.990002,54.080002,-1.061110,-1.06 % -1627396770,FDX,297.500000,287.500000,283.679993,-4.645380,-4.65 % -1627396770,C,67.769997,67.080002,67.930000,0.236093,+0.24 % -1627396770,AIG,47.709999,47.080002,47.630001,-0.167680,-0.17 % -1627396770,BAC,38.130001,37.720001,38.090000,-0.104904,-0.10 % -1627396770,BK,50.250000,49.639999,50.580002,0.656716,+0.66 % -1627396770,PBF,9.570000,9.090000,9.015000,-5.799370,-5.80 % -1627396770,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627396770,SYF,47.139999,46.650002,47.580002,0.933390,+0.93 % -1627396770,WFC,45.009998,44.590000,45.200001,0.422128,+0.42 % -1627396770,TEVA,8.940000,8.930000,8.675000,-2.964210,-2.96 % -1627396770,XOM,58.480000,57.160000,57.750000,-1.248290,-1.25 % -1627396770,MPC,54.660000,53.830002,54.080002,-1.061110,-1.06 % -1627396833,FDX,297.500000,287.500000,283.391998,-4.742050,-4.74 % -1627396833,C,67.769997,67.080002,67.940102,0.250996,+0.25 % -1627396833,AIG,47.709999,47.080002,47.669998,-0.083840,-0.08 % -1627396833,BAC,38.130001,37.720001,38.134998,0.013113,+0.01 % -1627396833,BK,50.250000,49.639999,50.580002,0.656716,+0.66 % -1627396833,PBF,9.570000,9.090000,9.020000,-5.747130,-5.75 % -1627396833,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627396833,SYF,47.139999,46.650002,47.590000,0.954603,+0.95 % -1627396833,WFC,45.009998,44.590000,45.232700,0.494779,+0.49 % -1627396833,TEVA,8.940000,8.930000,8.675000,-2.964210,-2.96 % -1627396833,XOM,58.480000,58.009998,57.805000,-1.154240,-1.15 % -1627396833,MPC,54.660000,53.990002,54.130001,-0.969630,-0.97 % -1627396895,FDX,297.500000,287.500000,283.575012,-4.680670,-4.68 % -1627396895,C,67.769997,67.080002,68.074997,0.450052,+0.45 % -1627396895,AIG,47.709999,47.080002,47.669998,-0.083840,-0.08 % -1627396895,BAC,38.130001,37.720001,38.185001,0.144243,+0.14 % -1627396895,BK,50.250000,49.639999,50.669998,0.835821,+0.84 % -1627396895,PBF,9.570000,9.090000,9.015000,-5.799370,-5.80 % -1627396895,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627396895,SYF,47.139999,46.650002,47.509998,0.784896,+0.78 % -1627396895,WFC,45.009998,44.590000,45.279900,0.599645,+0.60 % -1627396895,TEVA,8.940000,8.930000,8.655000,-3.187920,-3.19 % -1627396895,XOM,58.480000,58.009998,57.825001,-1.120040,-1.12 % -1627396895,MPC,54.660000,53.990002,54.160000,-0.914746,-0.91 % -1627396957,FDX,297.500000,287.500000,283.575012,-4.680670,-4.68 % -1627396957,C,67.769997,67.080002,68.080002,0.457430,+0.46 % -1627396957,AIG,47.709999,47.080002,47.730000,0.041920,+0.04 % -1627396957,BAC,38.130001,37.720001,38.185001,0.144243,+0.14 % -1627396957,BK,50.250000,49.639999,50.669998,0.835821,+0.84 % -1627396957,PBF,9.570000,9.090000,9.015000,-5.799370,-5.80 % -1627396957,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627396957,SYF,47.139999,46.650002,47.509998,0.784896,+0.78 % -1627396957,WFC,45.009998,44.590000,45.290001,0.622084,+0.62 % -1627396957,TEVA,8.940000,8.930000,8.655000,-3.187920,-3.19 % -1627396957,XOM,58.480000,57.160000,57.799999,-1.162790,-1.16 % -1627396957,MPC,54.660000,53.990002,54.080002,-1.061110,-1.06 % -1627397019,FDX,297.500000,287.500000,283.500000,-4.705880,-4.71 % -1627397019,C,67.769997,67.080002,68.042603,0.402243,+0.40 % -1627397019,AIG,47.709999,47.080002,47.669998,-0.083840,-0.08 % -1627397019,BAC,38.130001,37.720001,38.169998,0.104904,+0.10 % -1627397019,BK,50.250000,49.639999,50.630001,0.756219,+0.76 % -1627397019,PBF,9.570000,9.090000,9.020000,-5.747130,-5.75 % -1627397019,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627397019,SYF,47.139999,46.650002,47.419998,0.593975,+0.59 % -1627397019,WFC,45.009998,44.590000,45.270000,0.577649,+0.58 % -1627397019,TEVA,8.940000,8.930000,8.645000,-3.299780,-3.30 % -1627397019,XOM,58.480000,58.009998,57.775002,-1.205540,-1.21 % -1627397019,MPC,54.660000,53.990002,54.040001,-1.134280,-1.13 % -1627397082,FDX,297.500000,287.500000,283.244995,-4.791600,-4.79 % -1627397082,C,67.769997,67.080002,68.019997,0.368895,+0.37 % -1627397082,AIG,47.709999,47.080002,47.599998,-0.230560,-0.23 % -1627397082,BAC,38.130001,37.720001,38.154999,0.065565,+0.07 % -1627397082,BK,50.250000,49.639999,50.560001,0.616915,+0.62 % -1627397082,PBF,9.570000,9.090000,8.990000,-6.060610,-6.06 % -1627397082,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627397082,SYF,47.139999,46.650002,47.340000,0.424268,+0.42 % -1627397082,WFC,45.009998,44.590000,45.268799,0.574983,+0.57 % -1627397082,TEVA,8.940000,8.930000,8.655000,-3.187920,-3.19 % -1627397082,XOM,58.480000,58.009998,57.805000,-1.154240,-1.15 % -1627397082,MPC,54.660000,53.990002,54.000000,-1.207460,-1.21 % -1627397144,FDX,297.500000,287.500000,283.225006,-4.798320,-4.80 % -1627397144,C,67.769997,67.080002,68.010002,0.354139,+0.35 % -1627397144,AIG,47.709999,47.080002,47.630001,-0.167680,-0.17 % -1627397144,BAC,38.130001,37.720001,38.125000,-0.013113,-0.01 % -1627397144,BK,50.250000,49.639999,50.570000,0.636816,+0.64 % -1627397144,PBF,9.570000,9.090000,9.035000,-5.590390,-5.59 % -1627397144,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627397144,SYF,47.139999,46.650002,47.270000,0.275774,+0.28 % -1627397144,WFC,45.009998,44.590000,45.220001,0.466563,+0.47 % -1627397144,TEVA,8.940000,8.930000,8.659900,-3.133110,-3.13 % -1627397144,XOM,58.480000,58.009998,57.775002,-1.205540,-1.21 % -1627397144,MPC,54.660000,53.990002,53.930000,-1.335530,-1.34 % -1627397206,FDX,297.500000,287.500000,283.500000,-4.705880,-4.71 % -1627397206,C,67.769997,67.080002,67.980003,0.309872,+0.31 % -1627397206,AIG,47.709999,47.080002,47.650002,-0.125760,-0.13 % -1627397206,BAC,38.130001,37.720001,38.080002,-0.131130,-0.13 % -1627397206,BK,50.250000,49.639999,50.570000,0.636816,+0.64 % -1627397206,PBF,9.570000,9.090000,9.040000,-5.538140,-5.54 % -1627397206,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627397206,SYF,47.139999,46.650002,47.209999,0.148494,+0.15 % -1627397206,WFC,45.009998,44.590000,45.240002,0.510998,+0.51 % -1627397206,TEVA,8.940000,8.930000,8.669900,-3.021250,-3.02 % -1627397206,XOM,58.480000,58.009998,57.750000,-1.248290,-1.25 % -1627397206,MPC,54.660000,53.990002,53.889999,-1.408710,-1.41 % -1627397269,FDX,297.500000,287.500000,283.365997,-4.750860,-4.75 % -1627397269,C,67.769997,67.080002,67.980003,0.309872,+0.31 % -1627397269,AIG,47.709999,47.080002,47.540001,-0.356319,-0.36 % -1627397269,BAC,38.130001,37.720001,38.080002,-0.131130,-0.13 % -1627397269,BK,50.250000,49.639999,50.450001,0.398010,+0.40 % -1627397269,PBF,9.570000,9.090000,9.040000,-5.538140,-5.54 % -1627397269,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627397269,SYF,47.139999,46.650002,47.209999,0.148494,+0.15 % -1627397269,WFC,45.009998,44.590000,45.080002,0.155521,+0.16 % -1627397269,TEVA,8.940000,8.930000,8.660000,-3.131990,-3.13 % -1627397269,XOM,58.480000,58.009998,57.750000,-1.248290,-1.25 % -1627397269,MPC,54.660000,53.990002,53.889999,-1.408710,-1.41 % -1627397331,FDX,297.500000,287.500000,283.299988,-4.773110,-4.77 % -1627397331,C,67.769997,67.080002,67.879997,0.162314,+0.16 % -1627397331,AIG,47.709999,47.080002,47.570000,-0.293440,-0.29 % -1627397331,BAC,38.130001,37.720001,38.035000,-0.249148,-0.25 % -1627397331,BK,50.250000,49.639999,50.480000,0.457711,+0.46 % -1627397331,PBF,9.570000,9.090000,9.030000,-5.642630,-5.64 % -1627397331,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627397331,SYF,47.139999,46.650002,47.250000,0.233347,+0.23 % -1627397331,WFC,45.009998,44.590000,45.115002,0.233281,+0.23 % -1627397331,TEVA,8.940000,8.930000,8.670000,-3.020130,-3.02 % -1627397331,XOM,58.480000,58.009998,57.639999,-1.436390,-1.44 % -1627397331,MPC,54.660000,53.830002,53.810001,-1.555070,-1.56 % -1627397394,FDX,297.500000,287.500000,283.459991,-4.719330,-4.72 % -1627397394,C,67.769997,67.080002,67.915001,0.213959,+0.21 % -1627397394,AIG,47.709999,47.080002,47.570000,-0.293440,-0.29 % -1627397394,BAC,38.130001,37.720001,38.040001,-0.236035,-0.24 % -1627397394,BK,50.250000,49.639999,50.540001,0.577114,+0.58 % -1627397394,PBF,9.570000,9.090000,9.030000,-5.642630,-5.64 % -1627397394,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627397394,SYF,47.139999,46.650002,47.310001,0.360628,+0.36 % -1627397394,WFC,45.009998,44.590000,45.139900,0.288603,+0.29 % -1627397394,TEVA,8.940000,8.930000,8.670000,-3.020130,-3.02 % -1627397394,XOM,58.480000,58.009998,57.660000,-1.402190,-1.40 % -1627397394,MPC,54.660000,53.990002,53.799999,-1.573360,-1.57 % -1627397456,FDX,297.500000,287.500000,283.459991,-4.719330,-4.72 % -1627397456,C,67.769997,67.080002,67.910004,0.206581,+0.21 % -1627397456,AIG,47.709999,47.080002,47.630001,-0.167680,-0.17 % -1627397456,BAC,38.130001,37.720001,38.040001,-0.236035,-0.24 % -1627397456,BK,50.250000,49.639999,50.540001,0.577114,+0.58 % -1627397456,PBF,9.570000,9.090000,9.030000,-5.642630,-5.64 % -1627397456,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627397456,SYF,47.139999,46.650002,47.310001,0.360628,+0.36 % -1627397456,WFC,45.009998,44.590000,45.110001,0.222173,+0.22 % -1627397456,TEVA,8.940000,8.930000,8.695000,-2.740490,-2.74 % -1627397456,XOM,58.480000,58.009998,57.590000,-1.521890,-1.52 % -1627397456,MPC,54.660000,53.990002,53.799999,-1.573360,-1.57 % -1627397518,FDX,297.500000,287.500000,283.380005,-4.746220,-4.75 % -1627397518,C,67.769997,67.080002,67.910004,0.206581,+0.21 % -1627397518,AIG,47.709999,47.080002,47.645000,-0.136240,-0.14 % -1627397518,BAC,38.130001,37.720001,38.009998,-0.314713,-0.31 % -1627397518,BK,50.250000,49.639999,50.480000,0.457711,+0.46 % -1627397518,PBF,9.570000,9.090000,9.010000,-5.851620,-5.85 % -1627397518,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627397518,SYF,47.139999,46.650002,47.299999,0.339415,+0.34 % -1627397518,WFC,45.009998,44.590000,45.134998,0.277716,+0.28 % -1627397518,TEVA,8.940000,8.930000,8.700000,-2.684560,-2.68 % -1627397518,XOM,58.480000,58.009998,57.590000,-1.521890,-1.52 % -1627397518,MPC,54.660000,53.990002,53.799999,-1.573360,-1.57 % -1627397580,FDX,297.500000,287.500000,283.614990,-4.667230,-4.67 % -1627397580,C,67.769997,67.080002,67.964996,0.287738,+0.29 % -1627397580,AIG,47.709999,47.080002,47.650002,-0.125760,-0.13 % -1627397580,BAC,38.130001,37.720001,38.064999,-0.170469,-0.17 % -1627397580,BK,50.250000,49.639999,50.549999,0.597015,+0.60 % -1627397580,PBF,9.570000,9.090000,9.010000,-5.851620,-5.85 % -1627397580,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627397580,SYF,47.139999,46.650002,47.360001,0.466695,+0.47 % -1627397580,WFC,45.009998,44.590000,45.134998,0.277716,+0.28 % -1627397580,TEVA,8.940000,8.930000,8.675000,-2.964210,-2.96 % -1627397580,XOM,58.480000,58.009998,57.592499,-1.517610,-1.52 % -1627397580,MPC,54.660000,53.990002,53.919998,-1.353820,-1.35 % -1627397642,FDX,297.500000,287.500000,283.510010,-4.702520,-4.70 % -1627397642,C,67.769997,67.080002,68.029999,0.383651,+0.38 % -1627397642,AIG,47.709999,47.080002,47.689999,-0.041920,-0.04 % -1627397642,BAC,38.130001,37.720001,38.084999,-0.118017,-0.12 % -1627397642,BK,50.250000,49.639999,50.599998,0.696517,+0.70 % -1627397642,PBF,9.570000,9.090000,9.015000,-5.799370,-5.80 % -1627397642,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627397642,SYF,47.139999,46.650002,47.419998,0.593975,+0.59 % -1627397642,WFC,45.009998,44.590000,45.169998,0.355477,+0.36 % -1627397642,TEVA,8.940000,8.930000,8.685400,-2.847870,-2.85 % -1627397642,XOM,58.480000,57.160000,57.599998,-1.504790,-1.50 % -1627397642,MPC,54.660000,53.830002,53.939999,-1.317230,-1.32 % -1627397705,FDX,297.500000,287.500000,283.320007,-4.766390,-4.77 % -1627397705,C,67.769997,67.080002,68.110100,0.501844,+0.50 % -1627397705,AIG,47.709999,47.080002,47.680000,-0.062880,-0.06 % -1627397705,BAC,38.130001,37.720001,38.099998,-0.078678,-0.08 % -1627397705,BK,50.250000,49.639999,50.630001,0.756219,+0.76 % -1627397705,PBF,9.570000,9.090000,9.020000,-5.747130,-5.75 % -1627397705,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627397705,SYF,47.139999,46.650002,47.410000,0.572762,+0.57 % -1627397705,WFC,45.009998,44.590000,45.230000,0.488780,+0.49 % -1627397705,TEVA,8.940000,8.930000,8.701300,-2.670020,-2.67 % -1627397705,XOM,58.480000,58.009998,57.665001,-1.393640,-1.39 % -1627397705,MPC,54.660000,53.830002,54.043999,-1.126970,-1.13 % -1627397768,FDX,297.500000,287.500000,283.695007,-4.640340,-4.64 % -1627397768,C,67.769997,67.080002,68.190002,0.619743,+0.62 % -1627397768,AIG,47.709999,47.080002,47.724998,0.031440,+0.03 % -1627397768,BAC,38.130001,37.720001,38.119999,-0.026226,-0.03 % -1627397768,BK,50.250000,49.639999,50.680000,0.855721,+0.86 % -1627397768,PBF,9.570000,9.090000,9.030000,-5.642630,-5.64 % -1627397768,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627397768,SYF,47.139999,46.650002,47.430000,0.615189,+0.62 % -1627397768,WFC,45.009998,44.590000,45.240002,0.510998,+0.51 % -1627397768,TEVA,8.940000,8.930000,8.710000,-2.572710,-2.57 % -1627397768,XOM,58.480000,58.009998,57.720001,-1.299590,-1.30 % -1627397768,MPC,54.660000,53.990002,54.099998,-1.024520,-1.02 % -1627397830,FDX,297.500000,287.500000,283.440002,-4.726050,-4.73 % -1627397830,C,67.769997,67.080002,68.190002,0.619743,+0.62 % -1627397830,AIG,47.709999,47.080002,47.720001,0.020960,+0.02 % -1627397830,BAC,38.130001,37.720001,38.139999,0.026226,+0.03 % -1627397830,BK,50.250000,49.639999,50.674999,0.845771,+0.85 % -1627397830,PBF,9.570000,9.090000,9.019900,-5.748170,-5.75 % -1627397830,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627397830,SYF,47.139999,46.650002,47.430000,0.615189,+0.62 % -1627397830,WFC,45.009998,44.590000,45.259998,0.555432,+0.56 % -1627397830,TEVA,8.940000,8.930000,8.700000,-2.684560,-2.68 % -1627397830,XOM,58.480000,58.009998,57.720001,-1.299590,-1.30 % -1627397830,MPC,54.660000,53.990002,54.099998,-1.024520,-1.02 % -1627397892,FDX,297.500000,287.500000,283.934998,-4.559660,-4.56 % -1627397892,C,67.769997,67.080002,68.169998,0.590232,+0.59 % -1627397892,AIG,47.709999,47.080002,47.730000,0.041920,+0.04 % -1627397892,BAC,38.130001,37.720001,38.139999,0.026226,+0.03 % -1627397892,BK,50.250000,49.639999,50.639999,0.776119,+0.78 % -1627397892,PBF,9.570000,9.090000,9.040000,-5.538140,-5.54 % -1627397892,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627397892,SYF,47.139999,46.650002,47.430000,0.615189,+0.62 % -1627397892,WFC,45.009998,44.590000,45.250000,0.533215,+0.53 % -1627397892,TEVA,8.940000,8.930000,8.700000,-2.684560,-2.68 % -1627397892,XOM,58.480000,58.009998,57.790001,-1.179890,-1.18 % -1627397892,MPC,54.660000,53.990002,54.110001,-1.006220,-1.01 % -1627397954,FDX,297.500000,287.500000,283.934998,-4.559660,-4.56 % -1627397954,C,67.769997,67.080002,68.230103,0.678914,+0.68 % -1627397954,AIG,47.709999,47.080002,47.720001,0.020960,+0.02 % -1627397954,BAC,38.130001,37.720001,38.189899,0.157094,+0.16 % -1627397954,BK,50.250000,49.639999,50.674999,0.845771,+0.85 % -1627397954,PBF,9.570000,9.090000,9.073100,-5.192270,-5.19 % -1627397954,PBFX,13.580000,13.550000,13.485000,-0.699558,-0.70 % -1627397954,SYF,47.139999,46.650002,47.450001,0.657616,+0.66 % -1627397954,WFC,45.009998,44.590000,45.259998,0.555432,+0.56 % -1627397954,TEVA,8.940000,8.930000,8.720000,-2.460850,-2.46 % -1627397954,XOM,58.480000,57.160000,57.849998,-1.077290,-1.08 % -1627397954,MPC,54.660000,53.830002,54.230000,-0.786681,-0.79 % -1627398016,FDX,297.500000,287.500000,283.579987,-4.678990,-4.68 % -1627398016,C,67.769997,67.080002,68.199997,0.634499,+0.63 % -1627398016,AIG,47.709999,47.080002,47.764999,0.115280,+0.12 % -1627398016,BAC,38.130001,37.720001,38.126701,-0.008655,-0.01 % -1627398016,BK,50.250000,49.639999,50.700001,0.895522,+0.90 % -1627398016,PBF,9.570000,9.090000,9.070000,-5.224660,-5.22 % -1627398016,PBFX,13.580000,13.550000,13.485000,-0.699558,-0.70 % -1627398016,SYF,47.139999,46.650002,47.369999,0.487908,+0.49 % -1627398016,WFC,45.009998,44.590000,45.259998,0.555432,+0.56 % -1627398016,TEVA,8.940000,8.930000,8.725000,-2.404920,-2.40 % -1627398016,XOM,58.480000,57.160000,57.814999,-1.137140,-1.14 % -1627398016,MPC,54.660000,53.830002,54.230000,-0.786681,-0.79 % -1627398078,FDX,297.500000,287.500000,283.579987,-4.678990,-4.68 % -1627398078,C,67.769997,67.080002,68.269997,0.737790,+0.74 % -1627398078,AIG,47.709999,47.080002,47.759998,0.104800,+0.10 % -1627398078,BAC,38.130001,37.720001,38.169998,0.104904,+0.10 % -1627398078,BK,50.250000,49.639999,50.700001,0.895522,+0.90 % -1627398078,PBF,9.570000,9.090000,9.085000,-5.067920,-5.07 % -1627398078,PBFX,13.580000,13.550000,13.485000,-0.699558,-0.70 % -1627398078,SYF,47.139999,46.650002,47.419998,0.593975,+0.59 % -1627398078,WFC,45.009998,44.590000,45.305000,0.655410,+0.66 % -1627398078,TEVA,8.940000,8.930000,8.715000,-2.516780,-2.52 % -1627398078,XOM,58.480000,57.160000,57.865002,-1.051640,-1.05 % -1627398078,MPC,54.660000,53.830002,54.259998,-0.731797,-0.73 % -1627398140,FDX,297.500000,287.500000,283.515015,-4.700840,-4.70 % -1627398140,C,67.769997,67.080002,68.260002,0.723034,+0.72 % -1627398140,AIG,47.709999,47.080002,47.759998,0.104800,+0.10 % -1627398140,BAC,38.130001,37.720001,38.160000,0.078678,+0.08 % -1627398140,BK,50.250000,49.639999,50.744999,0.985075,+0.99 % -1627398140,PBF,9.570000,9.090000,9.080000,-5.120170,-5.12 % -1627398140,PBFX,13.580000,13.550000,13.485000,-0.699558,-0.70 % -1627398140,SYF,47.139999,46.650002,47.439999,0.636402,+0.64 % -1627398140,WFC,45.009998,44.590000,45.305000,0.655410,+0.66 % -1627398140,TEVA,8.940000,8.930000,8.745000,-2.181210,-2.18 % -1627398140,XOM,58.480000,58.009998,57.889999,-1.008890,-1.01 % -1627398140,MPC,54.660000,53.990002,54.310001,-0.640322,-0.64 % -1627398203,FDX,297.500000,287.500000,283.515015,-4.700840,-4.70 % -1627398203,C,67.769997,67.080002,68.279999,0.752545,+0.75 % -1627398203,AIG,47.709999,47.080002,47.705002,-0.010480,-0.01 % -1627398203,BAC,38.130001,37.720001,38.160000,0.078678,+0.08 % -1627398203,BK,50.250000,49.639999,50.715000,0.925373,+0.93 % -1627398203,PBF,9.570000,9.090000,9.080000,-5.120170,-5.12 % -1627398203,PBFX,13.580000,13.550000,13.495000,-0.625920,-0.63 % -1627398203,SYF,47.139999,46.650002,47.439999,0.636402,+0.64 % -1627398203,WFC,45.009998,44.590000,45.294998,0.633193,+0.63 % -1627398203,TEVA,8.940000,8.930000,8.745000,-2.181210,-2.18 % -1627398203,XOM,58.480000,58.009998,57.860001,-1.060190,-1.06 % -1627398203,MPC,54.660000,53.990002,54.279999,-0.695207,-0.70 % -1627398265,FDX,297.500000,287.500000,283.625000,-4.663870,-4.66 % -1627398265,C,67.769997,67.080002,68.279999,0.752545,+0.75 % -1627398265,AIG,47.709999,47.080002,47.669998,-0.083840,-0.08 % -1627398265,BAC,38.130001,37.720001,38.145000,0.039339,+0.04 % -1627398265,BK,50.250000,49.639999,50.730000,0.955224,+0.96 % -1627398265,PBF,9.570000,9.090000,9.065000,-5.276910,-5.28 % -1627398265,PBFX,13.580000,13.550000,13.460000,-0.883652,-0.88 % -1627398265,SYF,47.139999,46.650002,47.459999,0.678829,+0.68 % -1627398265,WFC,45.009998,44.590000,45.330002,0.710953,+0.71 % -1627398265,TEVA,8.940000,8.930000,8.740000,-2.237140,-2.24 % -1627398265,XOM,58.480000,58.009998,57.860001,-1.060190,-1.06 % -1627398265,MPC,54.660000,53.990002,54.279999,-0.695207,-0.70 % -1627398327,FDX,297.500000,287.500000,283.380005,-4.746220,-4.75 % -1627398327,C,67.769997,67.080002,68.300003,0.782057,+0.78 % -1627398327,AIG,47.709999,47.080002,47.705002,-0.010480,-0.01 % -1627398327,BAC,38.130001,37.720001,38.160000,0.078678,+0.08 % -1627398327,BK,50.250000,49.639999,50.730000,0.955224,+0.96 % -1627398327,PBF,9.570000,9.090000,9.075000,-5.172410,-5.17 % -1627398327,PBFX,13.580000,13.550000,13.460100,-0.882916,-0.88 % -1627398327,SYF,47.139999,46.650002,47.485001,0.731863,+0.73 % -1627398327,WFC,45.009998,44.590000,45.310001,0.666519,+0.67 % -1627398327,TEVA,8.940000,8.930000,8.740000,-2.237140,-2.24 % -1627398327,XOM,58.480000,57.160000,57.880001,-1.025990,-1.03 % -1627398327,MPC,54.660000,53.830002,54.369999,-0.530553,-0.53 % -1627398389,FDX,297.500000,287.500000,283.345001,-4.757980,-4.76 % -1627398389,C,67.769997,67.080002,68.290001,0.767301,+0.77 % -1627398389,AIG,47.709999,47.080002,47.680000,-0.062880,-0.06 % -1627398389,BAC,38.130001,37.720001,38.160000,0.078678,+0.08 % -1627398389,BK,50.250000,49.639999,50.730000,0.955224,+0.96 % -1627398389,PBF,9.570000,9.090000,9.075000,-5.172410,-5.17 % -1627398389,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627398389,SYF,47.139999,46.650002,47.470001,0.700042,+0.70 % -1627398389,WFC,45.009998,44.590000,45.320000,0.688736,+0.69 % -1627398389,TEVA,8.940000,8.930000,8.745000,-2.181210,-2.18 % -1627398389,XOM,58.480000,58.009998,57.875000,-1.034540,-1.03 % -1627398389,MPC,54.660000,53.830002,54.419998,-0.439078,-0.44 % -1627398451,FDX,297.500000,287.500000,283.019989,-4.867230,-4.87 % -1627398451,C,67.769997,67.080002,68.324997,0.818946,+0.82 % -1627398451,AIG,47.709999,47.080002,47.709999,0.000000,+0.00 % -1627398451,BAC,38.130001,37.720001,38.165001,0.091791,+0.09 % -1627398451,BK,50.250000,49.639999,50.759998,1.014930,+1.01 % -1627398451,PBF,9.570000,9.090000,9.135000,-4.545450,-4.55 % -1627398451,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627398451,SYF,47.139999,46.650002,47.500000,0.763683,+0.76 % -1627398451,WFC,45.009998,44.590000,45.320000,0.688736,+0.69 % -1627398451,TEVA,8.940000,8.930000,8.755000,-2.069350,-2.07 % -1627398451,XOM,58.480000,58.009998,57.893902,-1.002220,-1.00 % -1627398451,MPC,54.660000,53.990002,54.415001,-0.448225,-0.45 % -1627398514,FDX,297.500000,287.500000,282.494995,-5.043700,-5.04 % -1627398514,C,67.769997,67.080002,68.315002,0.804191,+0.80 % -1627398514,AIG,47.709999,47.080002,47.720001,0.020960,+0.02 % -1627398514,BAC,38.130001,37.720001,38.139999,0.026226,+0.03 % -1627398514,BK,50.250000,49.639999,50.770000,1.034830,+1.03 % -1627398514,PBF,9.570000,9.090000,9.105000,-4.858930,-4.86 % -1627398514,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627398514,SYF,47.139999,46.650002,47.490002,0.742469,+0.74 % -1627398514,WFC,45.009998,44.590000,45.320000,0.688736,+0.69 % -1627398514,TEVA,8.940000,8.930000,8.765000,-1.957490,-1.96 % -1627398514,XOM,58.480000,58.009998,57.910000,-0.974692,-0.97 % -1627398514,MPC,54.660000,53.990002,54.400002,-0.475668,-0.48 % -1627398576,FDX,297.500000,287.500000,282.279999,-5.115970,-5.12 % -1627398576,C,67.769997,67.080002,68.315002,0.804191,+0.80 % -1627398576,AIG,47.709999,47.080002,47.669998,-0.083840,-0.08 % -1627398576,BAC,38.130001,37.720001,38.139999,0.026226,+0.03 % -1627398576,BK,50.250000,49.639999,50.757900,1.010750,+1.01 % -1627398576,PBF,9.570000,9.090000,9.105000,-4.858930,-4.86 % -1627398576,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627398576,SYF,47.139999,46.650002,47.525002,0.816716,+0.82 % -1627398576,WFC,45.009998,44.590000,45.294998,0.633193,+0.63 % -1627398576,TEVA,8.940000,8.930000,8.760000,-2.013420,-2.01 % -1627398576,XOM,58.480000,58.009998,57.910000,-0.974692,-0.97 % -1627398576,MPC,54.660000,53.990002,54.400002,-0.475668,-0.48 % -1627398638,FDX,297.500000,287.500000,282.605011,-5.006720,-5.01 % -1627398638,C,67.769997,67.080002,68.315002,0.804191,+0.80 % -1627398638,AIG,47.709999,47.080002,47.669998,-0.083840,-0.08 % -1627398638,BAC,38.130001,37.720001,38.149899,0.052190,+0.05 % -1627398638,BK,50.250000,49.639999,50.770000,1.034830,+1.03 % -1627398638,PBF,9.570000,9.090000,9.110000,-4.806690,-4.81 % -1627398638,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627398638,SYF,47.139999,46.650002,47.525002,0.816716,+0.82 % -1627398638,WFC,45.009998,44.590000,45.330002,0.710953,+0.71 % -1627398638,TEVA,8.940000,8.930000,8.762200,-1.988810,-1.99 % -1627398638,XOM,58.480000,58.009998,57.880001,-1.025990,-1.03 % -1627398638,MPC,54.660000,53.990002,54.424999,-0.429930,-0.43 % -1627398700,FDX,297.500000,287.500000,282.545013,-5.026890,-5.03 % -1627398700,C,67.769997,67.080002,68.334999,0.833702,+0.83 % -1627398700,AIG,47.709999,47.080002,47.700001,-0.020960,-0.02 % -1627398700,BAC,38.130001,37.720001,38.145000,0.039339,+0.04 % -1627398700,BK,50.250000,49.639999,50.814999,1.124380,+1.12 % -1627398700,PBF,9.570000,9.090000,9.110000,-4.806690,-4.81 % -1627398700,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627398700,SYF,47.139999,46.650002,47.500000,0.763683,+0.76 % -1627398700,WFC,45.009998,44.590000,45.306400,0.658520,+0.66 % -1627398700,TEVA,8.940000,8.930000,8.762200,-1.988810,-1.99 % -1627398700,XOM,58.480000,58.009998,57.900002,-0.991792,-0.99 % -1627398700,MPC,54.660000,53.990002,54.423199,-0.433224,-0.43 % -1627398762,FDX,297.500000,287.500000,282.390015,-5.078990,-5.08 % -1627398762,C,67.769997,67.080002,68.300003,0.782057,+0.78 % -1627398762,AIG,47.709999,47.080002,47.720001,0.020960,+0.02 % -1627398762,BAC,38.130001,37.720001,38.145000,0.039339,+0.04 % -1627398762,BK,50.250000,49.639999,50.814999,1.124380,+1.12 % -1627398762,PBF,9.570000,9.090000,9.125000,-4.649950,-4.65 % -1627398762,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627398762,SYF,47.139999,46.650002,47.575001,0.922783,+0.92 % -1627398762,WFC,45.009998,44.590000,45.310001,0.666519,+0.67 % -1627398762,TEVA,8.940000,8.930000,8.770000,-1.901570,-1.90 % -1627398762,XOM,58.480000,58.009998,57.904999,-0.983242,-0.98 % -1627398762,MPC,54.660000,53.830002,54.435001,-0.411636,-0.41 % -1627398825,FDX,297.500000,287.500000,282.334991,-5.097480,-5.10 % -1627398825,C,67.769997,67.080002,68.330002,0.826324,+0.83 % -1627398825,AIG,47.709999,47.080002,47.735001,0.052400,+0.05 % -1627398825,BAC,38.130001,37.720001,38.150002,0.052452,+0.05 % -1627398825,BK,50.250000,49.639999,50.799999,1.094530,+1.09 % -1627398825,PBF,9.570000,9.090000,9.095000,-4.963430,-4.96 % -1627398825,PBFX,13.580000,13.550000,13.488300,-0.675258,-0.68 % -1627398825,SYF,47.139999,46.650002,47.560001,0.890963,+0.89 % -1627398825,WFC,45.009998,44.590000,45.342098,0.737836,+0.74 % -1627398825,TEVA,8.940000,8.930000,8.765000,-1.957490,-1.96 % -1627398825,XOM,58.480000,58.009998,57.895000,-1.000340,-1.00 % -1627398825,MPC,54.660000,53.990002,54.419998,-0.439078,-0.44 % -1627398887,FDX,297.500000,287.500000,282.375000,-5.084030,-5.08 % -1627398887,C,67.769997,67.080002,68.330002,0.826324,+0.83 % -1627398887,AIG,47.709999,47.080002,47.730000,0.041920,+0.04 % -1627398887,BAC,38.130001,37.720001,38.150002,0.052452,+0.05 % -1627398887,BK,50.250000,49.639999,50.810001,1.114430,+1.11 % -1627398887,PBF,9.570000,9.090000,9.095000,-4.963430,-4.96 % -1627398887,PBFX,13.580000,13.550000,13.488300,-0.675258,-0.68 % -1627398887,SYF,47.139999,46.650002,47.560001,0.890963,+0.89 % -1627398887,WFC,45.009998,44.590000,45.333500,0.718729,+0.72 % -1627398887,TEVA,8.940000,8.930000,8.750000,-2.125280,-2.13 % -1627398887,XOM,58.480000,58.009998,57.895000,-1.000340,-1.00 % -1627398887,MPC,54.660000,53.990002,54.419998,-0.439078,-0.44 % -1627398950,FDX,297.500000,287.500000,282.220001,-5.136130,-5.14 % -1627398950,C,67.769997,67.080002,68.355003,0.863214,+0.86 % -1627398950,AIG,47.709999,47.080002,47.709999,0.000000,+0.00 % -1627398950,BAC,38.130001,37.720001,38.160000,0.078678,+0.08 % -1627398950,BK,50.250000,49.639999,50.779999,1.054730,+1.05 % -1627398950,PBF,9.570000,9.090000,9.070000,-5.224660,-5.22 % -1627398950,PBFX,13.580000,13.550000,13.488300,-0.675258,-0.68 % -1627398950,SYF,47.139999,46.650002,47.555000,0.880356,+0.88 % -1627398950,WFC,45.009998,44.590000,45.311001,0.668740,+0.67 % -1627398950,TEVA,8.940000,8.930000,8.740000,-2.237140,-2.24 % -1627398950,XOM,58.480000,57.160000,57.895000,-1.000340,-1.00 % -1627398950,MPC,54.660000,53.830002,54.410000,-0.457373,-0.46 % -1627399012,FDX,297.500000,287.500000,282.000000,-5.210080,-5.21 % -1627399012,C,67.769997,67.080002,68.300003,0.782057,+0.78 % -1627399012,AIG,47.709999,47.080002,47.700001,-0.020960,-0.02 % -1627399012,BAC,38.130001,37.720001,38.130001,0.000000,+0.00 % -1627399012,BK,50.250000,49.639999,50.790001,1.074630,+1.07 % -1627399012,PBF,9.570000,9.090000,9.065000,-5.276910,-5.28 % -1627399012,PBFX,13.580000,13.550000,13.488300,-0.675258,-0.68 % -1627399012,SYF,47.139999,46.650002,47.470001,0.700042,+0.70 % -1627399012,WFC,45.009998,44.590000,45.330002,0.710953,+0.71 % -1627399012,TEVA,8.940000,8.930000,8.755000,-2.069350,-2.07 % -1627399012,XOM,58.480000,58.009998,57.830002,-1.111490,-1.11 % -1627399012,MPC,54.660000,53.990002,54.330002,-0.603732,-0.60 % -1627399074,FDX,297.500000,287.500000,281.714996,-5.305880,-5.31 % -1627399074,C,67.769997,67.080002,68.364998,0.877970,+0.88 % -1627399074,AIG,47.709999,47.080002,47.720001,0.020960,+0.02 % -1627399074,BAC,38.130001,37.720001,38.163799,0.088644,+0.09 % -1627399074,BK,50.250000,49.639999,50.820000,1.134330,+1.13 % -1627399074,PBF,9.570000,9.090000,9.075000,-5.172410,-5.17 % -1627399074,PBFX,13.580000,13.550000,13.488300,-0.675258,-0.68 % -1627399074,SYF,47.139999,46.650002,47.509998,0.784896,+0.78 % -1627399074,WFC,45.009998,44.590000,45.360001,0.777605,+0.78 % -1627399074,TEVA,8.940000,8.930000,8.760000,-2.013420,-2.01 % -1627399074,XOM,58.480000,58.009998,57.814999,-1.137140,-1.14 % -1627399074,MPC,54.660000,53.830002,54.270000,-0.713502,-0.71 % -1627399136,FDX,297.500000,287.500000,281.269989,-5.455460,-5.46 % -1627399136,C,67.769997,67.080002,68.300003,0.782057,+0.78 % -1627399136,AIG,47.709999,47.080002,47.740002,0.062880,+0.06 % -1627399136,BAC,38.130001,37.720001,38.150200,0.052977,+0.05 % -1627399136,BK,50.250000,49.639999,50.799999,1.094530,+1.09 % -1627399136,PBF,9.570000,9.090000,9.031500,-5.626960,-5.63 % -1627399136,PBFX,13.580000,13.550000,13.488300,-0.675258,-0.68 % -1627399136,SYF,47.139999,46.650002,47.485001,0.731863,+0.73 % -1627399136,WFC,45.009998,44.590000,45.290699,0.623639,+0.62 % -1627399136,TEVA,8.940000,8.930000,8.775000,-1.845640,-1.85 % -1627399136,XOM,58.480000,58.009998,57.814999,-1.137140,-1.14 % -1627399136,MPC,54.660000,53.830002,54.270000,-0.713502,-0.71 % -1627399199,FDX,297.500000,287.500000,280.940002,-5.566390,-5.57 % -1627399199,C,67.769997,67.080002,68.220001,0.664011,+0.66 % -1627399199,AIG,47.709999,47.080002,47.660000,-0.104800,-0.10 % -1627399199,BAC,38.130001,37.720001,38.070000,-0.157356,-0.16 % -1627399199,BK,50.250000,49.639999,50.750000,0.995025,+1.00 % -1627399199,PBF,9.570000,9.090000,9.035000,-5.590390,-5.59 % -1627399199,PBFX,13.580000,13.550000,13.488300,-0.675258,-0.68 % -1627399199,SYF,47.139999,46.650002,47.410301,0.573398,+0.57 % -1627399199,WFC,45.009998,44.590000,45.270000,0.577649,+0.58 % -1627399199,TEVA,8.940000,8.930000,8.775000,-1.845640,-1.85 % -1627399199,XOM,58.480000,58.009998,57.705002,-1.325240,-1.33 % -1627399199,MPC,54.660000,53.990002,54.160000,-0.914746,-0.91 % -1627399261,FDX,297.500000,287.500000,280.600006,-5.680670,-5.68 % -1627399261,C,67.769997,67.080002,68.220001,0.664011,+0.66 % -1627399261,AIG,47.709999,47.080002,47.650002,-0.125760,-0.13 % -1627399261,BAC,38.130001,37.720001,38.070000,-0.157356,-0.16 % -1627399261,BK,50.250000,49.639999,50.750000,0.995025,+1.00 % -1627399261,PBF,9.570000,9.090000,9.045000,-5.485890,-5.49 % -1627399261,PBFX,13.580000,13.550000,13.488300,-0.675258,-0.68 % -1627399261,SYF,47.139999,46.650002,47.445000,0.647009,+0.65 % -1627399261,WFC,45.009998,44.590000,45.240002,0.510998,+0.51 % -1627399261,TEVA,8.940000,8.930000,8.780000,-1.789710,-1.79 % -1627399261,XOM,58.480000,57.160000,57.700001,-1.333790,-1.33 % -1627399261,MPC,54.660000,53.830002,54.160000,-0.914746,-0.91 % -1627399323,FDX,297.500000,287.500000,280.600006,-5.680670,-5.68 % -1627399323,C,67.769997,67.080002,68.165001,0.582854,+0.58 % -1627399323,AIG,47.709999,47.080002,47.689999,-0.041920,-0.04 % -1627399323,BAC,38.130001,37.720001,38.055901,-0.194335,-0.19 % -1627399323,BK,50.250000,49.639999,50.750000,0.995025,+1.00 % -1627399323,PBF,9.570000,9.090000,9.030000,-5.642630,-5.64 % -1627399323,PBFX,13.580000,13.550000,13.488300,-0.675258,-0.68 % -1627399323,SYF,47.139999,46.650002,47.490002,0.742469,+0.74 % -1627399323,WFC,45.009998,44.590000,45.259998,0.555432,+0.56 % -1627399323,TEVA,8.940000,8.930000,8.785000,-1.733780,-1.73 % -1627399323,XOM,58.480000,58.009998,57.680000,-1.367990,-1.37 % -1627399323,MPC,54.660000,53.990002,54.169998,-0.896451,-0.90 % -1627399386,FDX,297.500000,287.500000,281.010010,-5.542860,-5.54 % -1627399386,C,67.769997,67.080002,68.165001,0.582854,+0.58 % -1627399386,AIG,47.709999,47.080002,47.660000,-0.104800,-0.10 % -1627399386,BAC,38.130001,37.720001,38.055901,-0.194335,-0.19 % -1627399386,BK,50.250000,49.639999,50.744999,0.985075,+0.99 % -1627399386,PBF,9.570000,9.090000,9.030000,-5.642630,-5.64 % -1627399386,PBFX,13.580000,13.550000,13.488300,-0.675258,-0.68 % -1627399386,SYF,47.139999,46.650002,47.485001,0.731863,+0.73 % -1627399386,WFC,45.009998,44.590000,45.259998,0.555432,+0.56 % -1627399386,TEVA,8.940000,8.930000,8.775000,-1.845640,-1.85 % -1627399386,XOM,58.480000,58.009998,57.680000,-1.367990,-1.37 % -1627399386,MPC,54.660000,53.990002,54.169998,-0.896451,-0.90 % -1627399448,FDX,297.500000,287.500000,281.010010,-5.542860,-5.54 % -1627399448,C,67.769997,67.080002,68.089996,0.472185,+0.47 % -1627399448,AIG,47.709999,47.080002,47.630001,-0.167680,-0.17 % -1627399448,BAC,38.130001,37.720001,38.020000,-0.288487,-0.29 % -1627399448,BK,50.250000,49.639999,50.744999,0.985075,+0.99 % -1627399448,PBF,9.570000,9.090000,9.000000,-5.956110,-5.96 % -1627399448,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627399448,SYF,47.139999,46.650002,47.400002,0.551549,+0.55 % -1627399448,WFC,45.009998,44.590000,45.169998,0.355477,+0.36 % -1627399448,TEVA,8.940000,8.930000,8.775000,-1.845640,-1.85 % -1627399448,XOM,58.480000,58.009998,57.615002,-1.479140,-1.48 % -1627399448,MPC,54.660000,53.990002,54.070000,-1.079400,-1.08 % -1627399511,FDX,297.500000,287.500000,281.049988,-5.529410,-5.53 % -1627399511,C,67.769997,67.080002,68.014999,0.361517,+0.36 % -1627399511,AIG,47.709999,47.080002,47.580002,-0.272480,-0.27 % -1627399511,BAC,38.130001,37.720001,37.986801,-0.375557,-0.38 % -1627399511,BK,50.250000,49.639999,50.744999,0.985075,+0.99 % -1627399511,PBF,9.570000,9.090000,9.000000,-5.956110,-5.96 % -1627399511,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627399511,SYF,47.139999,46.650002,47.400002,0.551549,+0.55 % -1627399511,WFC,45.009998,44.590000,45.150002,0.311042,+0.31 % -1627399511,TEVA,8.940000,8.930000,8.780000,-1.789710,-1.79 % -1627399511,XOM,58.480000,58.009998,57.590000,-1.521890,-1.52 % -1627399511,MPC,54.660000,53.990002,54.049999,-1.115990,-1.12 % -1627399573,FDX,297.500000,287.500000,280.589996,-5.684030,-5.68 % -1627399573,C,67.769997,67.080002,67.985001,0.317250,+0.32 % -1627399573,AIG,47.709999,47.080002,47.580002,-0.272480,-0.27 % -1627399573,BAC,38.130001,37.720001,37.986801,-0.375557,-0.38 % -1627399573,BK,50.250000,49.639999,50.695000,0.885572,+0.89 % -1627399573,PBF,9.570000,9.090000,8.990000,-6.060610,-6.06 % -1627399573,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627399573,SYF,47.139999,46.650002,47.330002,0.403055,+0.40 % -1627399573,WFC,45.009998,44.590000,45.145000,0.299933,+0.30 % -1627399573,TEVA,8.940000,8.930000,8.770000,-1.901570,-1.90 % -1627399573,XOM,58.480000,58.009998,57.584999,-1.530440,-1.53 % -1627399573,MPC,54.660000,53.990002,54.029999,-1.152580,-1.15 % -1627399635,FDX,297.500000,287.500000,280.519989,-5.707560,-5.71 % -1627399635,C,67.769997,67.080002,68.000000,0.339383,+0.34 % -1627399635,AIG,47.709999,47.080002,47.560001,-0.314399,-0.31 % -1627399635,BAC,38.130001,37.720001,38.044998,-0.222922,-0.22 % -1627399635,BK,50.250000,49.639999,50.759998,1.014930,+1.01 % -1627399635,PBF,9.570000,9.090000,8.980000,-6.165100,-6.17 % -1627399635,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627399635,SYF,47.139999,46.650002,47.330002,0.403055,+0.40 % -1627399635,WFC,45.009998,44.590000,45.187302,0.393912,+0.39 % -1627399635,TEVA,8.940000,8.930000,8.775000,-1.845640,-1.85 % -1627399635,XOM,58.480000,57.160000,57.654999,-1.410740,-1.41 % -1627399635,MPC,54.660000,53.830002,54.070000,-1.079400,-1.08 % -1627399697,FDX,297.500000,287.500000,280.324005,-5.773450,-5.77 % -1627399697,C,67.769997,67.080002,68.070000,0.442674,+0.44 % -1627399697,AIG,47.709999,47.080002,47.590000,-0.251520,-0.25 % -1627399697,BAC,38.130001,37.720001,38.060001,-0.183582,-0.18 % -1627399697,BK,50.250000,49.639999,50.770000,1.034830,+1.03 % -1627399697,PBF,9.570000,9.090000,8.980000,-6.165100,-6.17 % -1627399697,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627399697,SYF,47.139999,46.650002,47.320000,0.381841,+0.38 % -1627399697,WFC,45.009998,44.590000,45.212200,0.449234,+0.45 % -1627399697,TEVA,8.940000,8.930000,8.785000,-1.733780,-1.73 % -1627399697,XOM,58.480000,58.009998,57.650002,-1.419290,-1.42 % -1627399697,MPC,54.660000,53.990002,54.099998,-1.024520,-1.02 % -1627399759,FDX,297.500000,287.500000,279.869995,-5.926050,-5.93 % -1627399759,C,67.769997,67.080002,68.070000,0.442674,+0.44 % -1627399759,AIG,47.709999,47.080002,47.550999,-0.333263,-0.33 % -1627399759,BAC,38.130001,37.720001,38.039902,-0.236297,-0.24 % -1627399759,BK,50.250000,49.639999,50.735001,0.965174,+0.97 % -1627399759,PBF,9.570000,9.090000,8.980000,-6.165100,-6.17 % -1627399759,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627399759,SYF,47.139999,46.650002,47.290001,0.318201,+0.32 % -1627399759,WFC,45.009998,44.590000,45.212200,0.449234,+0.45 % -1627399759,TEVA,8.940000,8.930000,8.790000,-1.677850,-1.68 % -1627399759,XOM,58.480000,58.009998,57.636200,-1.442890,-1.44 % -1627399759,MPC,54.660000,53.830002,54.080002,-1.061110,-1.06 % -1627399822,FDX,297.500000,287.500000,279.910004,-5.912610,-5.91 % -1627399822,C,67.769997,67.080002,68.029999,0.383651,+0.38 % -1627399822,AIG,47.709999,47.080002,47.540001,-0.356319,-0.36 % -1627399822,BAC,38.130001,37.720001,38.039902,-0.236297,-0.24 % -1627399822,BK,50.250000,49.639999,50.755001,1.004980,+1.00 % -1627399822,PBF,9.570000,9.090000,8.980000,-6.165100,-6.17 % -1627399822,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627399822,SYF,47.139999,46.650002,47.290001,0.318201,+0.32 % -1627399822,WFC,45.009998,44.590000,45.150002,0.311042,+0.31 % -1627399822,TEVA,8.940000,8.930000,8.785000,-1.733780,-1.73 % -1627399822,XOM,58.480000,58.009998,57.636200,-1.442890,-1.44 % -1627399822,MPC,54.660000,53.830002,54.080002,-1.061110,-1.06 % -1627399884,FDX,297.500000,287.500000,280.040009,-5.868910,-5.87 % -1627399884,C,67.769997,67.080002,68.004997,0.346761,+0.35 % -1627399884,AIG,47.709999,47.080002,47.500000,-0.440159,-0.44 % -1627399884,BAC,38.130001,37.720001,38.009998,-0.314713,-0.31 % -1627399884,BK,50.250000,49.639999,50.709999,0.915423,+0.92 % -1627399884,PBF,9.570000,9.090000,8.975000,-6.217350,-6.22 % -1627399884,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627399884,SYF,47.139999,46.650002,47.259998,0.254561,+0.25 % -1627399884,WFC,45.009998,44.590000,45.125000,0.255499,+0.26 % -1627399884,TEVA,8.940000,8.930000,8.780000,-1.789710,-1.79 % -1627399884,XOM,58.480000,58.009998,57.695000,-1.342340,-1.34 % -1627399884,MPC,54.660000,53.990002,54.060001,-1.097690,-1.10 % -1627399946,FDX,297.500000,287.500000,280.390015,-5.751260,-5.75 % -1627399946,C,67.769997,67.080002,67.925003,0.228715,+0.23 % -1627399946,AIG,47.709999,47.080002,47.500000,-0.440159,-0.44 % -1627399946,BAC,38.130001,37.720001,38.005001,-0.327826,-0.33 % -1627399946,BK,50.250000,49.639999,50.599998,0.696517,+0.70 % -1627399946,PBF,9.570000,9.090000,8.940000,-6.583070,-6.58 % -1627399946,PBFX,13.580000,13.550000,13.539900,-0.295287,-0.30 % -1627399946,SYF,47.139999,46.650002,47.200001,0.127280,+0.13 % -1627399946,WFC,45.009998,44.590000,45.109901,0.221951,+0.22 % -1627399946,TEVA,8.940000,8.930000,8.775000,-1.845640,-1.85 % -1627399946,XOM,58.480000,58.009998,57.590000,-1.521890,-1.52 % -1627399946,MPC,54.660000,53.990002,54.040001,-1.134280,-1.13 % -1627400009,FDX,297.500000,287.500000,280.274994,-5.789920,-5.79 % -1627400009,C,67.769997,67.080002,67.855003,0.125424,+0.13 % -1627400009,AIG,47.709999,47.080002,47.459999,-0.523999,-0.52 % -1627400009,BAC,38.130001,37.720001,37.966499,-0.428796,-0.43 % -1627400009,BK,50.250000,49.639999,50.549999,0.597015,+0.60 % -1627400009,PBF,9.570000,9.090000,8.930000,-6.687570,-6.69 % -1627400009,PBFX,13.580000,13.550000,13.539900,-0.295287,-0.30 % -1627400009,SYF,47.139999,46.650002,47.150002,0.021213,+0.02 % -1627400009,WFC,45.009998,44.590000,45.060001,0.111086,+0.11 % -1627400009,TEVA,8.940000,8.930000,8.770000,-1.901570,-1.90 % -1627400009,XOM,58.480000,57.160000,57.570000,-1.556090,-1.56 % -1627400009,MPC,54.660000,53.830002,54.020000,-1.170870,-1.17 % -1627400071,FDX,297.500000,287.500000,280.135010,-5.836970,-5.84 % -1627400071,C,67.769997,67.080002,67.855003,0.125424,+0.13 % -1627400071,AIG,47.709999,47.080002,47.439999,-0.565919,-0.57 % -1627400071,BAC,38.130001,37.720001,37.994999,-0.354052,-0.35 % -1627400071,BK,50.250000,49.639999,50.490002,0.477612,+0.48 % -1627400071,PBF,9.570000,9.090000,8.930000,-6.687570,-6.69 % -1627400071,PBFX,13.580000,13.550000,13.539900,-0.295287,-0.30 % -1627400071,SYF,47.139999,46.650002,47.200001,0.127280,+0.13 % -1627400071,WFC,45.009998,44.590000,45.060001,0.111086,+0.11 % -1627400071,TEVA,8.940000,8.930000,8.760000,-2.013420,-2.01 % -1627400071,XOM,58.480000,58.009998,57.555000,-1.581740,-1.58 % -1627400071,MPC,54.660000,53.990002,54.020000,-1.170870,-1.17 % -1627400133,FDX,297.500000,287.500000,280.135010,-5.836970,-5.84 % -1627400133,C,67.769997,67.080002,67.959999,0.280360,+0.28 % -1627400133,AIG,47.709999,47.080002,47.509998,-0.419199,-0.42 % -1627400133,BAC,38.130001,37.720001,38.000000,-0.340939,-0.34 % -1627400133,BK,50.250000,49.639999,50.549999,0.597015,+0.60 % -1627400133,PBF,9.570000,9.090000,8.920000,-6.792060,-6.79 % -1627400133,PBFX,13.580000,13.550000,13.539900,-0.295287,-0.30 % -1627400133,SYF,47.139999,46.650002,47.200001,0.127280,+0.13 % -1627400133,WFC,45.009998,44.590000,45.110001,0.222173,+0.22 % -1627400133,TEVA,8.940000,8.930000,8.760000,-2.013420,-2.01 % -1627400133,XOM,58.480000,57.160000,57.705002,-1.325240,-1.33 % -1627400133,MPC,54.660000,53.830002,54.150002,-0.933041,-0.93 % -1627400195,FDX,297.500000,287.500000,279.559998,-6.030250,-6.03 % -1627400195,C,67.769997,67.080002,67.952003,0.268555,+0.27 % -1627400195,AIG,47.709999,47.080002,47.509998,-0.419199,-0.42 % -1627400195,BAC,38.130001,37.720001,38.014999,-0.301600,-0.30 % -1627400195,BK,50.250000,49.639999,50.599998,0.696517,+0.70 % -1627400195,PBF,9.570000,9.090000,8.915000,-6.844310,-6.84 % -1627400195,PBFX,13.580000,13.550000,13.539900,-0.295287,-0.30 % -1627400195,SYF,47.139999,46.650002,47.209999,0.148494,+0.15 % -1627400195,WFC,45.009998,44.590000,45.110001,0.222173,+0.22 % -1627400195,TEVA,8.940000,8.930000,8.770000,-1.901570,-1.90 % -1627400195,XOM,58.480000,58.009998,57.715000,-1.308140,-1.31 % -1627400195,MPC,54.660000,53.990002,54.090000,-1.042810,-1.04 % -1627400257,FDX,297.500000,287.500000,279.790009,-5.952940,-5.95 % -1627400257,C,67.769997,67.080002,68.010002,0.354139,+0.35 % -1627400257,AIG,47.709999,47.080002,47.549999,-0.335359,-0.34 % -1627400257,BAC,38.130001,37.720001,37.990002,-0.367165,-0.37 % -1627400257,BK,50.250000,49.639999,50.630001,0.756219,+0.76 % -1627400257,PBF,9.570000,9.090000,8.900000,-7.001040,-7.00 % -1627400257,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627400257,SYF,47.139999,46.650002,47.220001,0.169707,+0.17 % -1627400257,WFC,45.009998,44.590000,45.185001,0.388802,+0.39 % -1627400257,TEVA,8.940000,8.930000,8.770000,-1.901570,-1.90 % -1627400257,XOM,58.480000,57.160000,57.660000,-1.402190,-1.40 % -1627400257,MPC,54.660000,53.830002,54.014999,-1.180020,-1.18 % -1627400320,FDX,297.500000,287.500000,279.899994,-5.915970,-5.92 % -1627400320,C,67.769997,67.080002,67.959999,0.280360,+0.28 % -1627400320,AIG,47.709999,47.080002,47.529999,-0.377279,-0.38 % -1627400320,BAC,38.130001,37.720001,37.990002,-0.367165,-0.37 % -1627400320,BK,50.250000,49.639999,50.525002,0.547264,+0.55 % -1627400320,PBF,9.570000,9.090000,8.900000,-7.001040,-7.00 % -1627400320,PBFX,13.580000,13.550000,13.535000,-0.331370,-0.33 % -1627400320,SYF,47.139999,46.650002,47.220001,0.169707,+0.17 % -1627400320,WFC,45.009998,44.590000,45.150002,0.311042,+0.31 % -1627400320,TEVA,8.940000,8.930000,8.755000,-2.069350,-2.07 % -1627400320,XOM,58.480000,57.160000,57.660000,-1.402190,-1.40 % -1627400320,MPC,54.660000,53.830002,54.014999,-1.180020,-1.18 % -1627400382,FDX,297.500000,287.500000,279.899994,-5.915970,-5.92 % -1627400382,C,67.769997,67.080002,67.919998,0.221337,+0.22 % -1627400382,AIG,47.709999,47.080002,47.490002,-0.461119,-0.46 % -1627400382,BAC,38.130001,37.720001,37.959999,-0.445843,-0.45 % -1627400382,BK,50.250000,49.639999,50.525002,0.547264,+0.55 % -1627400382,PBF,9.570000,9.090000,8.890000,-7.105540,-7.11 % -1627400382,PBFX,13.580000,13.550000,13.530000,-0.368189,-0.37 % -1627400382,SYF,47.139999,46.650002,47.139999,0.000000,+0.00 % -1627400382,WFC,45.009998,44.590000,45.060001,0.111086,+0.11 % -1627400382,TEVA,8.940000,8.930000,8.755000,-2.069350,-2.07 % -1627400382,XOM,58.480000,57.160000,57.650002,-1.419290,-1.42 % -1627400382,MPC,54.660000,53.830002,53.990002,-1.225760,-1.23 % -1627400445,FDX,297.500000,287.500000,279.920013,-5.909240,-5.91 % -1627400445,C,67.769997,67.080002,67.889999,0.177069,+0.18 % -1627400445,AIG,47.709999,47.080002,47.470001,-0.503039,-0.50 % -1627400445,BAC,38.130001,37.720001,37.930000,-0.524521,-0.52 % -1627400445,BK,50.250000,49.639999,50.500000,0.497512,+0.50 % -1627400445,PBF,9.570000,9.090000,8.900000,-7.001040,-7.00 % -1627400445,PBFX,13.580000,13.550000,13.530000,-0.368189,-0.37 % -1627400445,SYF,47.139999,46.650002,47.105000,-0.074247,-0.07 % -1627400445,WFC,45.009998,44.590000,45.060001,0.111086,+0.11 % -1627400445,TEVA,8.940000,8.930000,8.736600,-2.275170,-2.28 % -1627400445,XOM,58.480000,57.160000,57.650002,-1.419290,-1.42 % -1627400445,MPC,54.660000,53.830002,54.029999,-1.152580,-1.15 % -1627400507,FDX,297.500000,287.500000,280.255005,-5.796640,-5.80 % -1627400507,C,67.769997,67.080002,67.900002,0.191825,+0.19 % -1627400507,AIG,47.709999,47.080002,47.470001,-0.503039,-0.50 % -1627400507,BAC,38.130001,37.720001,37.970001,-0.419617,-0.42 % -1627400507,BK,50.250000,49.639999,50.540001,0.577114,+0.58 % -1627400507,PBF,9.570000,9.090000,8.912000,-6.875650,-6.88 % -1627400507,PBFX,13.580000,13.550000,13.530000,-0.368189,-0.37 % -1627400507,SYF,47.139999,46.650002,47.154999,0.031820,+0.03 % -1627400507,WFC,45.009998,44.590000,45.099998,0.199956,+0.20 % -1627400507,TEVA,8.940000,8.930000,8.736600,-2.275170,-2.28 % -1627400507,XOM,58.480000,57.160000,57.730000,-1.282490,-1.28 % -1627400507,MPC,54.660000,53.830002,54.009998,-1.189170,-1.19 % -1627400569,FDX,297.500000,287.500000,280.195007,-5.816810,-5.82 % -1627400569,C,67.769997,67.080002,67.650002,-0.177069,-0.18 % -1627400569,AIG,47.709999,47.080002,47.540001,-0.356319,-0.36 % -1627400569,BAC,38.130001,37.720001,37.945000,-0.485182,-0.49 % -1627400569,BK,50.250000,49.639999,50.500000,0.497512,+0.50 % -1627400569,PBF,9.570000,9.090000,8.930000,-6.687570,-6.69 % -1627400569,PBFX,13.580000,13.550000,13.520000,-0.441826,-0.44 % -1627400569,SYF,47.139999,46.650002,47.160000,0.042427,+0.04 % -1627400569,WFC,45.009998,44.590000,45.119999,0.244390,+0.24 % -1627400569,TEVA,8.940000,8.930000,8.760000,-2.013420,-2.01 % -1627400569,XOM,58.480000,58.009998,57.755001,-1.239740,-1.24 % -1627400569,MPC,54.660000,53.990002,54.099998,-1.024520,-1.02 % -1627400632,FDX,297.500000,287.500000,279.947998,-5.899830,-5.90 % -1627400632,C,67.769997,67.080002,67.720001,-0.073779,-0.07 % -1627400632,AIG,47.709999,47.080002,47.480000,-0.482079,-0.48 % -1627400632,BAC,38.130001,37.720001,37.939999,-0.498295,-0.50 % -1627400632,BK,50.250000,49.639999,50.480000,0.457711,+0.46 % -1627400632,PBF,9.570000,9.090000,8.910000,-6.896550,-6.90 % -1627400632,PBFX,13.580000,13.550000,13.520000,-0.441826,-0.44 % -1627400632,SYF,47.139999,46.650002,47.160000,0.042427,+0.04 % -1627400632,WFC,45.009998,44.590000,45.095001,0.188847,+0.19 % -1627400632,TEVA,8.940000,8.930000,8.765000,-1.957490,-1.96 % -1627400632,XOM,58.480000,57.160000,57.712898,-1.311730,-1.31 % -1627400632,MPC,54.660000,53.830002,54.070000,-1.079400,-1.08 % -1627400695,FDX,297.500000,287.500000,280.070007,-5.858820,-5.86 % -1627400695,C,67.769997,67.080002,67.739998,-0.044267,-0.04 % -1627400695,AIG,47.709999,47.080002,47.490002,-0.461119,-0.46 % -1627400695,BAC,38.130001,37.720001,37.930000,-0.524521,-0.52 % -1627400695,BK,50.250000,49.639999,50.490002,0.477612,+0.48 % -1627400695,PBF,9.570000,9.090000,8.910000,-6.896550,-6.90 % -1627400695,PBFX,13.580000,13.550000,13.520000,-0.441826,-0.44 % -1627400695,SYF,47.139999,46.650002,47.180000,0.084854,+0.08 % -1627400695,WFC,45.009998,44.590000,45.070000,0.133304,+0.13 % -1627400695,TEVA,8.940000,8.930000,8.765000,-1.957490,-1.96 % -1627400695,XOM,58.480000,57.160000,57.720001,-1.299590,-1.30 % -1627400695,MPC,54.660000,53.830002,54.040001,-1.134280,-1.13 % -1627400757,FDX,297.500000,287.500000,280.070007,-5.858820,-5.86 % -1627400757,C,67.769997,67.080002,67.769997,0.000000,+0.00 % -1627400757,AIG,47.709999,47.080002,47.509998,-0.419199,-0.42 % -1627400757,BAC,38.130001,37.720001,37.950001,-0.472069,-0.47 % -1627400757,BK,50.250000,49.639999,50.490002,0.477612,+0.48 % -1627400757,PBF,9.570000,9.090000,8.900000,-7.001040,-7.00 % -1627400757,PBFX,13.580000,13.550000,13.520000,-0.441826,-0.44 % -1627400757,SYF,47.139999,46.650002,47.150002,0.021213,+0.02 % -1627400757,WFC,45.009998,44.590000,45.099998,0.199956,+0.20 % -1627400757,TEVA,8.940000,8.930000,8.770000,-1.901570,-1.90 % -1627400757,XOM,58.480000,58.009998,57.730000,-1.282490,-1.28 % -1627400757,MPC,54.660000,53.990002,54.020000,-1.170870,-1.17 % -1627400819,FDX,297.500000,287.500000,280.320007,-5.774790,-5.77 % -1627400819,C,67.769997,67.080002,67.830002,0.088535,+0.09 % -1627400819,AIG,47.709999,47.080002,47.544998,-0.345839,-0.35 % -1627400819,BAC,38.130001,37.720001,37.965000,-0.432730,-0.43 % -1627400819,BK,50.250000,49.639999,50.490002,0.477612,+0.48 % -1627400819,PBF,9.570000,9.090000,8.900000,-7.001040,-7.00 % -1627400819,PBFX,13.580000,13.550000,13.520000,-0.441826,-0.44 % -1627400819,SYF,47.139999,46.650002,47.195000,0.116674,+0.12 % -1627400819,WFC,45.009998,44.590000,45.110001,0.222173,+0.22 % -1627400819,TEVA,8.940000,8.930000,8.780000,-1.789710,-1.79 % -1627400819,XOM,58.480000,58.009998,57.740002,-1.265390,-1.27 % -1627400819,MPC,54.660000,53.990002,54.049500,-1.116900,-1.12 % -1627400881,FDX,297.500000,287.500000,280.429993,-5.737820,-5.74 % -1627400881,C,67.769997,67.080002,67.843803,0.108898,+0.11 % -1627400881,AIG,47.709999,47.080002,47.511600,-0.415846,-0.42 % -1627400881,BAC,38.130001,37.720001,37.964100,-0.435090,-0.44 % -1627400881,BK,50.250000,49.639999,50.505001,0.507463,+0.51 % -1627400881,PBF,9.570000,9.090000,8.900000,-7.001040,-7.00 % -1627400881,PBFX,13.580000,13.550000,13.440000,-1.030930,-1.03 % -1627400881,SYF,47.139999,46.650002,47.160000,0.042427,+0.04 % -1627400881,WFC,45.009998,44.590000,45.110001,0.222173,+0.22 % -1627400881,TEVA,8.940000,8.930000,8.780000,-1.789710,-1.79 % -1627400881,XOM,58.480000,58.009998,57.718102,-1.302840,-1.30 % -1627400881,MPC,54.660000,53.990002,54.060001,-1.097690,-1.10 % -1627400944,FDX,297.500000,287.500000,280.429993,-5.737820,-5.74 % -1627400944,C,67.769997,67.080002,67.843803,0.108898,+0.11 % -1627400944,AIG,47.709999,47.080002,47.529999,-0.377279,-0.38 % -1627400944,BAC,38.130001,37.720001,37.964100,-0.435090,-0.44 % -1627400944,BK,50.250000,49.639999,50.505001,0.507463,+0.51 % -1627400944,PBF,9.570000,9.090000,8.900000,-7.001040,-7.00 % -1627400944,PBFX,13.580000,13.550000,13.440000,-1.030930,-1.03 % -1627400944,SYF,47.139999,46.650002,47.160000,0.042427,+0.04 % -1627400944,WFC,45.009998,44.590000,45.119999,0.244390,+0.24 % -1627400944,TEVA,8.940000,8.930000,8.775000,-1.845640,-1.85 % -1627400944,XOM,58.480000,58.009998,57.718102,-1.302840,-1.30 % -1627400944,MPC,54.660000,53.990002,54.060001,-1.097690,-1.10 % -1627401006,FDX,297.500000,287.500000,280.225006,-5.806720,-5.81 % -1627401006,C,67.769997,67.080002,67.779999,0.014756,+0.01 % -1627401006,AIG,47.709999,47.080002,47.529999,-0.377279,-0.38 % -1627401006,BAC,38.130001,37.720001,37.955002,-0.458956,-0.46 % -1627401006,BK,50.250000,49.639999,50.520000,0.537313,+0.54 % -1627401006,PBF,9.570000,9.090000,8.890000,-7.105540,-7.11 % -1627401006,PBFX,13.580000,13.550000,13.440000,-1.030930,-1.03 % -1627401006,SYF,47.139999,46.650002,47.150002,0.021213,+0.02 % -1627401006,WFC,45.009998,44.590000,45.119999,0.244390,+0.24 % -1627401006,TEVA,8.940000,8.930000,8.775000,-1.845640,-1.85 % -1627401006,XOM,58.480000,58.009998,57.689999,-1.350890,-1.35 % -1627401006,MPC,54.660000,53.990002,54.070000,-1.079400,-1.08 % -1627401068,FDX,297.500000,287.500000,280.225006,-5.806720,-5.81 % -1627401068,C,67.769997,67.080002,67.910004,0.206581,+0.21 % -1627401068,AIG,47.709999,47.080002,47.540001,-0.356319,-0.36 % -1627401068,BAC,38.130001,37.720001,38.000000,-0.340939,-0.34 % -1627401068,BK,50.250000,49.639999,50.520000,0.537313,+0.54 % -1627401068,PBF,9.570000,9.090000,8.905000,-6.948800,-6.95 % -1627401068,PBFX,13.580000,13.550000,13.440000,-1.030930,-1.03 % -1627401068,SYF,47.139999,46.650002,47.150002,0.021213,+0.02 % -1627401068,WFC,45.009998,44.590000,45.162701,0.339258,+0.34 % -1627401068,TEVA,8.940000,8.930000,8.775000,-1.845640,-1.85 % -1627401068,XOM,58.480000,57.160000,57.779999,-1.196990,-1.20 % -1627401068,MPC,54.660000,53.830002,54.099998,-1.024520,-1.02 % -1627401130,FDX,297.500000,287.500000,280.540009,-5.700840,-5.70 % -1627401130,C,67.769997,67.080002,67.910004,0.206581,+0.21 % -1627401130,AIG,47.709999,47.080002,47.540001,-0.356319,-0.36 % -1627401130,BAC,38.130001,37.720001,38.000000,-0.340939,-0.34 % -1627401130,BK,50.250000,49.639999,50.514999,0.527363,+0.53 % -1627401130,PBF,9.570000,9.090000,8.905000,-6.948800,-6.95 % -1627401130,PBFX,13.580000,13.550000,13.440000,-1.030930,-1.03 % -1627401130,SYF,47.139999,46.650002,47.200001,0.127280,+0.13 % -1627401130,WFC,45.009998,44.590000,45.162701,0.339258,+0.34 % -1627401130,TEVA,8.940000,8.930000,8.760000,-2.013420,-2.01 % -1627401130,XOM,58.480000,57.160000,57.779999,-1.196990,-1.20 % -1627401130,MPC,54.660000,53.830002,54.099998,-1.024520,-1.02 % -1627401192,FDX,297.500000,287.500000,280.880005,-5.586550,-5.59 % -1627401192,C,67.769997,67.080002,67.880997,0.163789,+0.16 % -1627401192,AIG,47.709999,47.080002,47.580002,-0.272480,-0.27 % -1627401192,BAC,38.130001,37.720001,37.994999,-0.354052,-0.35 % -1627401192,BK,50.250000,49.639999,50.485001,0.467662,+0.47 % -1627401192,PBF,9.570000,9.090000,8.890000,-7.105540,-7.11 % -1627401192,PBFX,13.580000,13.550000,13.440000,-1.030930,-1.03 % -1627401192,SYF,47.139999,46.650002,47.205002,0.137887,+0.14 % -1627401192,WFC,45.009998,44.590000,45.169998,0.355477,+0.36 % -1627401192,TEVA,8.940000,8.930000,8.760000,-2.013420,-2.01 % -1627401192,XOM,58.480000,58.009998,57.755001,-1.239740,-1.24 % -1627401192,MPC,54.660000,53.990002,54.105000,-1.015370,-1.02 % -1627401255,FDX,297.500000,287.500000,280.880005,-5.586550,-5.59 % -1627401255,C,67.769997,67.080002,67.864998,0.140180,+0.14 % -1627401255,AIG,47.709999,47.080002,47.570000,-0.293440,-0.29 % -1627401255,BAC,38.130001,37.720001,37.986500,-0.376344,-0.38 % -1627401255,BK,50.250000,49.639999,50.485001,0.467662,+0.47 % -1627401255,PBF,9.570000,9.090000,8.890000,-7.105540,-7.11 % -1627401255,PBFX,13.580000,13.550000,13.440000,-1.030930,-1.03 % -1627401255,SYF,47.139999,46.650002,47.205002,0.137887,+0.14 % -1627401255,WFC,45.009998,44.590000,45.169998,0.355477,+0.36 % -1627401255,TEVA,8.940000,8.930000,8.755000,-2.069350,-2.07 % -1627401255,XOM,58.480000,57.160000,57.700001,-1.333790,-1.33 % -1627401255,MPC,54.660000,53.830002,54.060001,-1.097690,-1.10 % -1627401317,FDX,297.500000,287.500000,280.894989,-5.581510,-5.58 % -1627401317,C,67.769997,67.080002,67.860001,0.132802,+0.13 % -1627401317,AIG,47.709999,47.080002,47.570000,-0.293440,-0.29 % -1627401317,BAC,38.130001,37.720001,37.986500,-0.376344,-0.38 % -1627401317,BK,50.250000,49.639999,50.465000,0.427861,+0.43 % -1627401317,PBF,9.570000,9.090000,8.870000,-7.314520,-7.31 % -1627401317,PBFX,13.580000,13.550000,13.440000,-1.030930,-1.03 % -1627401317,SYF,47.139999,46.650002,47.215000,0.159101,+0.16 % -1627401317,WFC,45.009998,44.590000,45.180000,0.377694,+0.38 % -1627401317,TEVA,8.940000,8.930000,8.755000,-2.069350,-2.07 % -1627401317,XOM,58.480000,58.009998,57.730000,-1.282490,-1.28 % -1627401317,MPC,54.660000,53.990002,54.119999,-0.987925,-0.99 % -1627401380,FDX,297.500000,287.500000,280.799988,-5.613450,-5.61 % -1627401380,C,67.769997,67.080002,67.849998,0.118046,+0.12 % -1627401380,AIG,47.709999,47.080002,47.570000,-0.293440,-0.29 % -1627401380,BAC,38.130001,37.720001,37.980000,-0.393391,-0.39 % -1627401380,BK,50.250000,49.639999,50.435001,0.368159,+0.37 % -1627401380,PBF,9.570000,9.090000,8.889900,-7.106580,-7.11 % -1627401380,PBFX,13.580000,13.550000,13.440000,-1.030930,-1.03 % -1627401380,SYF,47.139999,46.650002,47.227699,0.186042,+0.19 % -1627401380,WFC,45.009998,44.590000,45.165001,0.344368,+0.34 % -1627401380,TEVA,8.940000,8.930000,8.733000,-2.315440,-2.32 % -1627401380,XOM,58.480000,57.160000,57.750000,-1.248290,-1.25 % -1627401380,MPC,54.660000,53.830002,54.119999,-0.987925,-0.99 % -1627401442,FDX,297.500000,287.500000,280.660004,-5.660500,-5.66 % -1627401442,C,67.769997,67.080002,67.862000,0.135753,+0.14 % -1627401442,AIG,47.709999,47.080002,47.529999,-0.377279,-0.38 % -1627401442,BAC,38.130001,37.720001,37.980000,-0.393391,-0.39 % -1627401442,BK,50.250000,49.639999,50.470001,0.437811,+0.44 % -1627401442,PBF,9.570000,9.090000,8.905800,-6.940440,-6.94 % -1627401442,PBFX,13.580000,13.550000,13.440000,-1.030930,-1.03 % -1627401442,SYF,47.139999,46.650002,47.220001,0.169707,+0.17 % -1627401442,WFC,45.009998,44.590000,45.170101,0.355699,+0.36 % -1627401442,TEVA,8.940000,8.930000,8.733000,-2.315440,-2.32 % -1627401442,XOM,58.480000,58.009998,57.755001,-1.239740,-1.24 % -1627401442,MPC,54.660000,53.990002,54.150002,-0.933041,-0.93 % -1627401505,FDX,297.500000,287.500000,280.549988,-5.697480,-5.70 % -1627401505,C,67.769997,67.080002,67.860001,0.132802,+0.13 % -1627401505,AIG,47.709999,47.080002,47.549999,-0.335359,-0.34 % -1627401505,BAC,38.130001,37.720001,37.998100,-0.345922,-0.35 % -1627401505,BK,50.250000,49.639999,50.465000,0.427861,+0.43 % -1627401505,PBF,9.570000,9.090000,8.910000,-6.896550,-6.90 % -1627401505,PBFX,13.580000,13.550000,13.440000,-1.030930,-1.03 % -1627401505,SYF,47.139999,46.650002,47.279999,0.296988,+0.30 % -1627401505,WFC,45.009998,44.590000,45.184299,0.387247,+0.39 % -1627401505,TEVA,8.940000,8.930000,8.746500,-2.164430,-2.16 % -1627401505,XOM,58.480000,58.009998,57.764999,-1.222640,-1.22 % -1627401505,MPC,54.660000,53.830002,54.160000,-0.914746,-0.91 % -1627401567,FDX,297.500000,287.500000,280.160004,-5.828570,-5.83 % -1627401567,C,67.769997,67.080002,67.870003,0.147558,+0.15 % -1627401567,AIG,47.709999,47.080002,47.575001,-0.282960,-0.28 % -1627401567,BAC,38.130001,37.720001,38.020000,-0.288487,-0.29 % -1627401567,BK,50.250000,49.639999,50.459999,0.417910,+0.42 % -1627401567,PBF,9.570000,9.090000,8.907300,-6.924760,-6.92 % -1627401567,PBFX,13.580000,13.550000,13.495000,-0.625920,-0.63 % -1627401567,SYF,47.139999,46.650002,47.279999,0.296988,+0.30 % -1627401567,WFC,45.009998,44.590000,45.185001,0.388802,+0.39 % -1627401567,TEVA,8.940000,8.930000,8.750000,-2.125280,-2.13 % -1627401567,XOM,58.480000,58.009998,57.750000,-1.248290,-1.25 % -1627401567,MPC,54.660000,53.830002,54.160000,-0.914746,-0.91 % -1627401630,FDX,297.500000,287.500000,280.170013,-5.825210,-5.83 % -1627401630,C,67.769997,67.080002,67.870102,0.147705,+0.15 % -1627401630,AIG,47.709999,47.080002,47.580002,-0.272480,-0.27 % -1627401630,BAC,38.130001,37.720001,38.020000,-0.288487,-0.29 % -1627401630,BK,50.250000,49.639999,50.459999,0.417910,+0.42 % -1627401630,PBF,9.570000,9.090000,8.910000,-6.896550,-6.90 % -1627401630,PBFX,13.580000,13.550000,13.495000,-0.625920,-0.63 % -1627401630,SYF,47.139999,46.650002,47.290001,0.318201,+0.32 % -1627401630,WFC,45.009998,44.590000,45.220001,0.466563,+0.47 % -1627401630,TEVA,8.940000,8.930000,8.750000,-2.125280,-2.13 % -1627401630,XOM,58.480000,58.009998,57.750000,-1.248290,-1.25 % -1627401630,MPC,54.660000,53.830002,54.160000,-0.914746,-0.91 % -1627401692,FDX,297.500000,287.500000,279.660004,-5.996640,-6.00 % -1627401692,C,67.769997,67.080002,67.809998,0.059023,+0.06 % -1627401692,AIG,47.709999,47.080002,47.474998,-0.492559,-0.49 % -1627401692,BAC,38.130001,37.720001,37.980000,-0.393391,-0.39 % -1627401692,BK,50.250000,49.639999,50.459999,0.417910,+0.42 % -1627401692,PBF,9.570000,9.090000,8.880000,-7.210030,-7.21 % -1627401692,PBFX,13.580000,13.550000,13.495000,-0.625920,-0.63 % -1627401692,SYF,47.139999,46.650002,47.160000,0.042427,+0.04 % -1627401692,WFC,45.009998,44.590000,45.119999,0.244390,+0.24 % -1627401692,TEVA,8.940000,8.930000,8.750000,-2.125280,-2.13 % -1627401692,XOM,58.480000,57.160000,57.674999,-1.376540,-1.38 % -1627401692,MPC,54.660000,53.830002,54.038700,-1.136660,-1.14 % -1627401754,FDX,297.500000,287.500000,279.690002,-5.986550,-5.99 % -1627401754,C,67.769997,67.080002,67.785797,0.023314,+0.02 % -1627401754,AIG,47.709999,47.080002,47.474998,-0.492559,-0.49 % -1627401754,BAC,38.130001,37.720001,37.946201,-0.482035,-0.48 % -1627401754,BK,50.250000,49.639999,50.410000,0.318408,+0.32 % -1627401754,PBF,9.570000,9.090000,8.850000,-7.523510,-7.52 % -1627401754,PBFX,13.580000,13.550000,13.495000,-0.625920,-0.63 % -1627401754,SYF,47.139999,46.650002,47.139999,0.000000,+0.00 % -1627401754,WFC,45.009998,44.590000,45.119999,0.244390,+0.24 % -1627401754,TEVA,8.940000,8.930000,8.745000,-2.181210,-2.18 % -1627401754,XOM,58.480000,57.160000,57.654999,-1.410740,-1.41 % -1627401754,MPC,54.660000,53.990002,54.055000,-1.106840,-1.11 % -1627401817,FDX,297.500000,287.500000,279.839996,-5.936130,-5.94 % -1627401817,C,67.769997,67.080002,67.810097,0.059171,+0.06 % -1627401817,AIG,47.709999,47.080002,47.490002,-0.461119,-0.46 % -1627401817,BAC,38.130001,37.720001,37.930000,-0.524521,-0.52 % -1627401817,BK,50.250000,49.639999,50.404999,0.308458,+0.31 % -1627401817,PBF,9.570000,9.090000,8.860000,-7.419020,-7.42 % -1627401817,PBFX,13.580000,13.550000,13.495000,-0.625920,-0.63 % -1627401817,SYF,47.139999,46.650002,47.160000,0.042427,+0.04 % -1627401817,WFC,45.009998,44.590000,45.139999,0.288825,+0.29 % -1627401817,TEVA,8.940000,8.930000,8.745000,-2.181210,-2.18 % -1627401817,XOM,58.480000,58.009998,57.634998,-1.444940,-1.44 % -1627401817,MPC,54.660000,53.990002,54.000000,-1.207460,-1.21 % -1627401879,FDX,297.500000,287.500000,279.850006,-5.932770,-5.93 % -1627401879,C,67.769997,67.080002,67.820000,0.073779,+0.07 % -1627401879,AIG,47.709999,47.080002,47.490002,-0.461119,-0.46 % -1627401879,BAC,38.130001,37.720001,37.930000,-0.524521,-0.52 % -1627401879,BK,50.250000,49.639999,50.400002,0.298507,+0.30 % -1627401879,PBF,9.570000,9.090000,8.855000,-7.471260,-7.47 % -1627401879,PBFX,13.580000,13.550000,13.495000,-0.625920,-0.63 % -1627401879,SYF,47.139999,46.650002,47.145000,0.010607,+0.01 % -1627401879,WFC,45.009998,44.590000,45.139999,0.288825,+0.29 % -1627401879,TEVA,8.940000,8.930000,8.745000,-2.181210,-2.18 % -1627401879,XOM,58.480000,58.009998,57.634998,-1.444940,-1.44 % -1627401879,MPC,54.660000,53.990002,54.000000,-1.207460,-1.21 % -1627401891,FDX,297.500000,287.500000,279.850006,-5.932770,-5.93 % -1627401891,C,67.769997,67.080002,67.820000,0.073779,+0.07 % -1627401891,AIG,47.709999,47.080002,47.490002,-0.461119,-0.46 % -1627401891,BAC,38.130001,37.720001,37.930000,-0.524521,-0.52 % -1627401891,BK,50.250000,49.639999,50.400002,0.298507,+0.30 % -1627401891,PBF,9.570000,9.090000,8.855000,-7.471260,-7.47 % -1627401891,PBFX,13.580000,13.550000,13.495000,-0.625920,-0.63 % -1627401891,SYF,47.139999,46.650002,47.145000,0.010607,+0.01 % -1627401891,WFC,45.009998,44.590000,45.099998,0.199956,+0.20 % -1627401891,TEVA,8.940000,8.930000,8.745000,-2.181210,-2.18 % -1627401891,XOM,58.480000,58.009998,57.634998,-1.444940,-1.44 % -1627401891,MPC,54.660000,53.990002,54.000000,-1.207460,-1.21 % -1627401954,FDX,297.500000,287.500000,279.859985,-5.929410,-5.93 % -1627401954,C,67.769997,67.080002,67.720001,-0.073779,-0.07 % -1627401954,AIG,47.709999,47.080002,47.459999,-0.523999,-0.52 % -1627401954,BAC,38.130001,37.720001,37.880001,-0.655652,-0.66 % -1627401954,BK,50.250000,49.639999,50.380001,0.258706,+0.26 % -1627401954,PBF,9.570000,9.090000,8.860000,-7.419020,-7.42 % -1627401954,PBFX,13.580000,13.550000,13.495000,-0.625920,-0.63 % -1627401954,SYF,47.139999,46.650002,47.119999,-0.042427,-0.04 % -1627401954,WFC,45.009998,44.590000,45.110001,0.222173,+0.22 % -1627401954,TEVA,8.940000,8.930000,8.745000,-2.181210,-2.18 % -1627401954,XOM,58.480000,58.009998,57.605000,-1.496240,-1.50 % -1627401954,MPC,54.660000,53.830002,53.970001,-1.262350,-1.26 % -1627402017,FDX,297.500000,287.500000,279.910004,-5.912610,-5.91 % -1627402017,C,67.769997,67.080002,67.639999,-0.191825,-0.19 % -1627402017,AIG,47.709999,47.080002,47.459999,-0.523999,-0.52 % -1627402017,BAC,38.130001,37.720001,37.849998,-0.734330,-0.73 % -1627402017,BK,50.250000,49.639999,50.305000,0.109453,+0.11 % -1627402017,PBF,9.570000,9.090000,8.845000,-7.575760,-7.58 % -1627402017,PBFX,13.580000,13.550000,13.460100,-0.882916,-0.88 % -1627402017,SYF,47.139999,46.650002,47.060001,-0.169707,-0.17 % -1627402017,WFC,45.009998,44.590000,45.029999,0.044435,+0.04 % -1627402017,TEVA,8.940000,8.930000,8.745000,-2.181210,-2.18 % -1627402017,XOM,58.480000,58.009998,57.570000,-1.556090,-1.56 % -1627402017,MPC,54.660000,53.990002,53.889999,-1.408710,-1.41 % -1627402080,FDX,297.500000,287.500000,280.089996,-5.852100,-5.85 % -1627402080,C,67.769997,67.080002,67.639900,-0.191973,-0.19 % -1627402080,AIG,47.709999,47.080002,47.430000,-0.586879,-0.59 % -1627402080,BAC,38.130001,37.720001,37.837898,-0.766063,-0.77 % -1627402080,BK,50.250000,49.639999,50.305000,0.109453,+0.11 % -1627402080,PBF,9.570000,9.090000,8.910000,-6.896550,-6.90 % -1627402080,PBFX,13.580000,13.550000,13.460100,-0.882916,-0.88 % -1627402080,SYF,47.139999,46.650002,47.090000,-0.106067,-0.11 % -1627402080,WFC,45.009998,44.590000,45.029999,0.044435,+0.04 % -1627402080,TEVA,8.940000,8.930000,8.760000,-2.013420,-2.01 % -1627402080,XOM,58.480000,58.009998,57.575001,-1.547540,-1.55 % -1627402080,MPC,54.660000,53.990002,53.980000,-1.244050,-1.24 % -1627402143,FDX,297.500000,287.500000,280.089996,-5.852100,-5.85 % -1627402143,C,67.769997,67.080002,67.680000,-0.132802,-0.13 % -1627402143,AIG,47.709999,47.080002,47.439999,-0.565919,-0.57 % -1627402143,BAC,38.130001,37.720001,37.840000,-0.760556,-0.76 % -1627402143,BK,50.250000,49.639999,50.290001,0.079602,+0.08 % -1627402143,PBF,9.570000,9.090000,8.910000,-6.896550,-6.90 % -1627402143,PBFX,13.580000,13.550000,13.460100,-0.882916,-0.88 % -1627402143,SYF,47.139999,46.650002,47.090000,-0.106067,-0.11 % -1627402143,WFC,45.009998,44.590000,45.040001,0.066652,+0.07 % -1627402143,TEVA,8.940000,8.930000,8.790000,-1.677850,-1.68 % -1627402143,XOM,58.480000,57.160000,57.575001,-1.547540,-1.55 % -1627402143,MPC,54.660000,53.830002,54.009998,-1.189170,-1.19 % -1627402205,FDX,297.500000,287.500000,280.160004,-5.828570,-5.83 % -1627402205,C,67.769997,67.080002,67.689903,-0.118194,-0.12 % -1627402205,AIG,47.709999,47.080002,47.435001,-0.576399,-0.58 % -1627402205,BAC,38.130001,37.720001,37.855000,-0.721217,-0.72 % -1627402205,BK,50.250000,49.639999,50.305000,0.109453,+0.11 % -1627402205,PBF,9.570000,9.090000,8.910000,-6.896550,-6.90 % -1627402205,PBFX,13.580000,13.550000,13.460100,-0.882916,-0.88 % -1627402205,SYF,47.139999,46.650002,47.110001,-0.063640,-0.06 % -1627402205,WFC,45.009998,44.590000,45.040001,0.066652,+0.07 % -1627402205,TEVA,8.940000,8.930000,8.800000,-1.566000,-1.57 % -1627402205,XOM,58.480000,58.009998,57.580002,-1.538990,-1.54 % -1627402205,MPC,54.660000,53.830002,54.009998,-1.189170,-1.19 % -1627402268,FDX,297.500000,287.500000,279.970001,-5.892440,-5.89 % -1627402268,C,67.769997,67.080002,67.639999,-0.191825,-0.19 % -1627402268,AIG,47.709999,47.080002,47.435001,-0.576399,-0.58 % -1627402268,BAC,38.130001,37.720001,37.810001,-0.839234,-0.84 % -1627402268,BK,50.250000,49.639999,50.275002,0.049751,+0.05 % -1627402268,PBF,9.570000,9.090000,8.855000,-7.471260,-7.47 % -1627402268,PBFX,13.580000,13.550000,13.460100,-0.882916,-0.88 % -1627402268,SYF,47.139999,46.650002,47.029999,-0.233347,-0.23 % -1627402268,WFC,45.009998,44.590000,44.974998,-0.077761,-0.08 % -1627402268,TEVA,8.940000,8.930000,8.820000,-1.342280,-1.34 % -1627402268,XOM,58.480000,58.009998,57.505001,-1.667240,-1.67 % -1627402268,MPC,54.660000,53.990002,53.900002,-1.390410,-1.39 % -1627402330,FDX,297.500000,287.500000,279.970001,-5.892440,-5.89 % -1627402330,C,67.769997,67.080002,67.639999,-0.191825,-0.19 % -1627402330,AIG,47.709999,47.080002,47.360001,-0.733599,-0.73 % -1627402330,BAC,38.130001,37.720001,37.810001,-0.839234,-0.84 % -1627402330,BK,50.250000,49.639999,50.305000,0.109453,+0.11 % -1627402330,PBF,9.570000,9.090000,8.855000,-7.471260,-7.47 % -1627402330,PBFX,13.580000,13.550000,13.460100,-0.882916,-0.88 % -1627402330,SYF,47.139999,46.650002,47.029999,-0.233347,-0.23 % -1627402330,WFC,45.009998,44.590000,44.974998,-0.077761,-0.08 % -1627402330,TEVA,8.940000,8.930000,8.840000,-1.118570,-1.12 % -1627402330,XOM,58.480000,58.009998,57.505001,-1.667240,-1.67 % -1627402330,MPC,54.660000,53.990002,53.900002,-1.390410,-1.39 % -1627402392,FDX,297.500000,287.500000,279.834991,-5.937820,-5.94 % -1627402392,C,67.769997,67.080002,67.585899,-0.271654,-0.27 % -1627402392,AIG,47.709999,47.080002,47.349998,-0.754559,-0.75 % -1627402392,BAC,38.130001,37.720001,37.785000,-0.904799,-0.90 % -1627402392,BK,50.250000,49.639999,50.279999,0.059701,+0.06 % -1627402392,PBF,9.570000,9.090000,8.845000,-7.575760,-7.58 % -1627402392,PBFX,13.580000,13.550000,13.460100,-0.882916,-0.88 % -1627402392,SYF,47.139999,46.650002,47.009998,-0.275774,-0.28 % -1627402392,WFC,45.009998,44.590000,44.959999,-0.111086,-0.11 % -1627402392,TEVA,8.940000,8.930000,8.840000,-1.118570,-1.12 % -1627402392,XOM,58.480000,58.009998,57.450001,-1.761290,-1.76 % -1627402392,MPC,54.660000,53.990002,53.830002,-1.518480,-1.52 % -1627402454,FDX,297.500000,287.500000,279.920013,-5.909240,-5.91 % -1627402454,C,67.769997,67.080002,67.610901,-0.234765,-0.23 % -1627402454,AIG,47.709999,47.080002,47.349998,-0.754559,-0.75 % -1627402454,BAC,38.130001,37.720001,37.794998,-0.878573,-0.88 % -1627402454,BK,50.250000,49.639999,50.290001,0.079602,+0.08 % -1627402454,PBF,9.570000,9.090000,8.840000,-7.628000,-7.63 % -1627402454,PBFX,13.580000,13.550000,13.460100,-0.882916,-0.88 % -1627402454,SYF,47.139999,46.650002,47.009998,-0.275774,-0.28 % -1627402454,WFC,45.009998,44.590000,44.960098,-0.110864,-0.11 % -1627402454,TEVA,8.940000,8.930000,8.815000,-1.398210,-1.40 % -1627402454,XOM,58.480000,58.009998,57.470001,-1.727090,-1.73 % -1627402454,MPC,54.660000,53.830002,53.840000,-1.500180,-1.50 % -1627402517,FDX,297.500000,287.500000,279.526001,-6.041710,-6.04 % -1627402517,C,67.769997,67.080002,67.605003,-0.243471,-0.24 % -1627402517,AIG,47.709999,47.080002,47.360001,-0.733599,-0.73 % -1627402517,BAC,38.130001,37.720001,37.779999,-0.917912,-0.92 % -1627402517,BK,50.250000,49.639999,50.300499,0.100498,+0.10 % -1627402517,PBF,9.570000,9.090000,8.836400,-7.665620,-7.67 % -1627402517,PBFX,13.580000,13.550000,13.490000,-0.662739,-0.66 % -1627402517,SYF,47.139999,46.650002,47.009998,-0.275774,-0.28 % -1627402517,WFC,45.009998,44.590000,44.960098,-0.110864,-0.11 % -1627402517,TEVA,8.940000,8.930000,8.825000,-1.286350,-1.29 % -1627402517,XOM,58.480000,58.009998,57.474998,-1.718540,-1.72 % -1627402517,MPC,54.660000,53.990002,53.817101,-1.542080,-1.54 % -1627402579,FDX,297.500000,287.500000,279.602997,-6.015800,-6.02 % -1627402579,C,67.769997,67.080002,67.605003,-0.243471,-0.24 % -1627402579,AIG,47.709999,47.080002,47.349998,-0.754559,-0.75 % -1627402579,BAC,38.130001,37.720001,37.824501,-0.801206,-0.80 % -1627402579,BK,50.250000,49.639999,50.250000,0.000000,+0.00 % -1627402579,PBF,9.570000,9.090000,8.845000,-7.575760,-7.58 % -1627402579,PBFX,13.580000,13.550000,13.490000,-0.662739,-0.66 % -1627402579,SYF,47.139999,46.650002,47.040001,-0.212134,-0.21 % -1627402579,WFC,45.009998,44.590000,44.939899,-0.155743,-0.16 % -1627402579,TEVA,8.940000,8.930000,8.830000,-1.230430,-1.23 % -1627402579,XOM,58.480000,58.009998,57.485001,-1.701440,-1.70 % -1627402579,MPC,54.660000,53.990002,53.860001,-1.463590,-1.46 % -1627402641,FDX,297.500000,287.500000,279.584991,-6.021850,-6.02 % -1627402641,C,67.769997,67.080002,67.555000,-0.317250,-0.32 % -1627402641,AIG,47.709999,47.080002,47.290001,-0.880319,-0.88 % -1627402641,BAC,38.130001,37.720001,37.770000,-0.944138,-0.94 % -1627402641,BK,50.250000,49.639999,50.209999,-0.079602,-0.08 % -1627402641,PBF,9.570000,9.090000,8.810000,-7.941480,-7.94 % -1627402641,PBFX,13.580000,13.550000,13.490000,-0.662739,-0.66 % -1627402641,SYF,47.139999,46.650002,46.965000,-0.371235,-0.37 % -1627402641,WFC,45.009998,44.590000,44.930000,-0.177738,-0.18 % -1627402641,TEVA,8.940000,8.930000,8.825000,-1.286350,-1.29 % -1627402641,XOM,58.480000,58.009998,57.424999,-1.804040,-1.80 % -1627402641,MPC,54.660000,53.990002,53.770100,-1.628060,-1.63 % -1627402703,FDX,297.500000,287.500000,279.589996,-6.020170,-6.02 % -1627402703,C,67.769997,67.080002,67.570000,-0.295116,-0.30 % -1627402703,AIG,47.709999,47.080002,47.320000,-0.817439,-0.82 % -1627402703,BAC,38.130001,37.720001,37.775002,-0.931025,-0.93 % -1627402703,BK,50.250000,49.639999,50.200001,-0.099502,-0.10 % -1627402703,PBF,9.570000,9.090000,8.815000,-7.889240,-7.89 % -1627402703,PBFX,13.580000,13.550000,13.490000,-0.662739,-0.66 % -1627402703,SYF,47.139999,46.650002,47.000000,-0.296988,-0.30 % -1627402703,WFC,45.009998,44.590000,44.942001,-0.151078,-0.15 % -1627402703,TEVA,8.940000,8.930000,8.809200,-1.463090,-1.46 % -1627402703,XOM,58.480000,57.160000,57.455002,-1.752740,-1.75 % -1627402703,MPC,54.660000,53.830002,53.820000,-1.536770,-1.54 % -1627402766,FDX,297.500000,287.500000,279.529999,-6.040340,-6.04 % -1627402766,C,67.769997,67.080002,67.565002,-0.302494,-0.30 % -1627402766,AIG,47.709999,47.080002,47.314301,-0.829386,-0.83 % -1627402766,BAC,38.130001,37.720001,37.775002,-0.931025,-0.93 % -1627402766,BK,50.250000,49.639999,50.209999,-0.079602,-0.08 % -1627402766,PBF,9.570000,9.090000,8.815000,-7.889240,-7.89 % -1627402766,PBFX,13.580000,13.550000,13.490000,-0.662739,-0.66 % -1627402766,SYF,47.139999,46.650002,47.000000,-0.296988,-0.30 % -1627402766,WFC,45.009998,44.590000,44.939999,-0.155521,-0.16 % -1627402766,TEVA,8.940000,8.930000,8.790000,-1.677850,-1.68 % -1627402766,XOM,58.480000,58.009998,57.465000,-1.735640,-1.74 % -1627402766,MPC,54.660000,53.990002,53.805000,-1.564220,-1.56 % -1627402828,FDX,297.500000,287.500000,279.829987,-5.939500,-5.94 % -1627402828,C,67.769997,67.080002,67.529999,-0.354139,-0.35 % -1627402828,AIG,47.709999,47.080002,47.314301,-0.829386,-0.83 % -1627402828,BAC,38.130001,37.720001,37.759998,-0.970365,-0.97 % -1627402828,BK,50.250000,49.639999,50.220001,-0.059701,-0.06 % -1627402828,PBF,9.570000,9.090000,8.840000,-7.628000,-7.63 % -1627402828,PBFX,13.580000,13.550000,13.490000,-0.662739,-0.66 % -1627402828,SYF,47.139999,46.650002,46.990002,-0.318201,-0.32 % -1627402828,WFC,45.009998,44.590000,44.930000,-0.177738,-0.18 % -1627402828,TEVA,8.940000,8.930000,8.790000,-1.677850,-1.68 % -1627402828,XOM,58.480000,58.009998,57.439999,-1.778390,-1.78 % -1627402828,MPC,54.660000,53.990002,53.810001,-1.555070,-1.56 % -1627402890,FDX,297.500000,287.500000,279.829987,-5.939500,-5.94 % -1627402890,C,67.769997,67.080002,67.559998,-0.309872,-0.31 % -1627402890,AIG,47.709999,47.080002,47.355900,-0.742192,-0.74 % -1627402890,BAC,38.130001,37.720001,37.759998,-0.970365,-0.97 % -1627402890,BK,50.250000,49.639999,50.222401,-0.054925,-0.05 % -1627402890,PBF,9.570000,9.090000,8.840000,-7.628000,-7.63 % -1627402890,PBFX,13.580000,13.550000,13.465000,-0.846834,-0.85 % -1627402890,SYF,47.139999,46.650002,46.990002,-0.318201,-0.32 % -1627402890,WFC,45.009998,44.590000,44.950001,-0.133304,-0.13 % -1627402890,TEVA,8.940000,8.930000,8.795000,-1.621920,-1.62 % -1627402890,XOM,58.480000,58.009998,57.439999,-1.778390,-1.78 % -1627402890,MPC,54.660000,53.990002,53.810001,-1.555070,-1.56 % -1627402952,FDX,297.500000,287.500000,279.598999,-6.017180,-6.02 % -1627402952,C,67.769997,67.080002,67.559998,-0.309872,-0.31 % -1627402952,AIG,47.709999,47.080002,47.355900,-0.742192,-0.74 % -1627402952,BAC,38.130001,37.720001,37.763000,-0.962497,-0.96 % -1627402952,BK,50.250000,49.639999,50.230000,-0.039801,-0.04 % -1627402952,PBF,9.570000,9.090000,8.815000,-7.889240,-7.89 % -1627402952,PBFX,13.580000,13.550000,13.465000,-0.846834,-0.85 % -1627402952,SYF,47.139999,46.650002,47.020000,-0.254561,-0.25 % -1627402952,WFC,45.009998,44.590000,44.950001,-0.133304,-0.13 % -1627402952,TEVA,8.940000,8.930000,8.800000,-1.566000,-1.57 % -1627402952,XOM,58.480000,57.160000,57.400002,-1.846790,-1.85 % -1627402952,MPC,54.660000,53.830002,53.770000,-1.628250,-1.63 % -1627403014,FDX,297.500000,287.500000,279.920013,-5.909240,-5.91 % -1627403014,C,67.769997,67.080002,67.610001,-0.236093,-0.24 % -1627403014,AIG,47.709999,47.080002,47.360001,-0.733599,-0.73 % -1627403014,BAC,38.130001,37.720001,37.794998,-0.878573,-0.88 % -1627403014,BK,50.250000,49.639999,50.230000,-0.039801,-0.04 % -1627403014,PBF,9.570000,9.090000,8.825000,-7.784740,-7.78 % -1627403014,PBFX,13.580000,13.550000,13.465000,-0.846834,-0.85 % -1627403014,SYF,47.139999,46.650002,46.986401,-0.325838,-0.33 % -1627403014,WFC,45.009998,44.590000,44.955002,-0.122195,-0.12 % -1627403014,TEVA,8.940000,8.930000,8.795000,-1.621920,-1.62 % -1627403014,XOM,58.480000,57.160000,57.466000,-1.733930,-1.73 % -1627403014,MPC,54.660000,53.830002,53.764999,-1.637390,-1.64 % -1627403076,FDX,297.500000,287.500000,279.809998,-5.946220,-5.95 % -1627403076,C,67.769997,67.080002,67.610001,-0.236093,-0.24 % -1627403076,AIG,47.709999,47.080002,47.360001,-0.733599,-0.73 % -1627403076,BAC,38.130001,37.720001,37.794998,-0.878573,-0.88 % -1627403076,BK,50.250000,49.639999,50.185001,-0.129353,-0.13 % -1627403076,PBF,9.570000,9.090000,8.830000,-7.732500,-7.73 % -1627403076,PBFX,13.580000,13.550000,13.470000,-0.810015,-0.81 % -1627403076,SYF,47.139999,46.650002,46.994999,-0.307594,-0.31 % -1627403076,WFC,45.009998,44.590000,44.950001,-0.133304,-0.13 % -1627403076,TEVA,8.940000,8.930000,8.785000,-1.733780,-1.73 % -1627403076,XOM,58.480000,58.009998,57.470001,-1.727090,-1.73 % -1627403076,MPC,54.660000,53.990002,53.764999,-1.637390,-1.64 % -1627403139,FDX,297.500000,287.500000,279.959991,-5.895800,-5.90 % -1627403139,C,67.769997,67.080002,67.595001,-0.258226,-0.26 % -1627403139,AIG,47.709999,47.080002,47.345001,-0.765039,-0.77 % -1627403139,BAC,38.130001,37.720001,37.772999,-0.936271,-0.94 % -1627403139,BK,50.250000,49.639999,50.185001,-0.129353,-0.13 % -1627403139,PBF,9.570000,9.090000,8.820000,-7.836990,-7.84 % -1627403139,PBFX,13.580000,13.550000,13.470000,-0.810015,-0.81 % -1627403139,SYF,47.139999,46.650002,46.965000,-0.371235,-0.37 % -1627403139,WFC,45.009998,44.590000,44.939999,-0.155521,-0.16 % -1627403139,TEVA,8.940000,8.930000,8.785000,-1.733780,-1.73 % -1627403139,XOM,58.480000,58.009998,57.459999,-1.744190,-1.74 % -1627403139,MPC,54.660000,53.990002,53.779999,-1.609950,-1.61 % -1627403201,FDX,297.500000,287.500000,279.920013,-5.909240,-5.91 % -1627403201,C,67.769997,67.080002,67.595001,-0.258226,-0.26 % -1627403201,AIG,47.709999,47.080002,47.330002,-0.796479,-0.80 % -1627403201,BAC,38.130001,37.720001,37.772999,-0.936271,-0.94 % -1627403201,BK,50.250000,49.639999,50.229198,-0.041393,-0.04 % -1627403201,PBF,9.570000,9.090000,8.815000,-7.889240,-7.89 % -1627403201,PBFX,13.580000,13.550000,13.470000,-0.810015,-0.81 % -1627403201,SYF,47.139999,46.650002,46.959999,-0.381841,-0.38 % -1627403201,WFC,45.009998,44.590000,44.939999,-0.155521,-0.16 % -1627403201,TEVA,8.940000,8.930000,8.785000,-1.733780,-1.73 % -1627403201,XOM,58.480000,58.009998,57.459999,-1.744190,-1.74 % -1627403201,MPC,54.660000,53.990002,53.779999,-1.609950,-1.61 % -1627403263,FDX,297.500000,287.500000,279.950012,-5.899160,-5.90 % -1627403263,C,67.769997,67.080002,67.605003,-0.243471,-0.24 % -1627403263,AIG,47.709999,47.080002,47.340000,-0.775519,-0.78 % -1627403263,BAC,38.130001,37.720001,37.790001,-0.891686,-0.89 % -1627403263,BK,50.250000,49.639999,50.230000,-0.039801,-0.04 % -1627403263,PBF,9.570000,9.090000,8.815000,-7.889240,-7.89 % -1627403263,PBFX,13.580000,13.550000,13.470000,-0.810015,-0.81 % -1627403263,SYF,47.139999,46.650002,46.959999,-0.381841,-0.38 % -1627403263,WFC,45.009998,44.590000,44.959999,-0.111086,-0.11 % -1627403263,TEVA,8.940000,8.930000,8.775000,-1.845640,-1.85 % -1627403263,XOM,58.480000,58.009998,57.415001,-1.821140,-1.82 % -1627403263,MPC,54.660000,53.990002,53.720001,-1.719720,-1.72 % -1627403325,FDX,297.500000,287.500000,279.970001,-5.892440,-5.89 % -1627403325,C,67.769997,67.080002,67.629997,-0.206581,-0.21 % -1627403325,AIG,47.709999,47.080002,47.349998,-0.754559,-0.75 % -1627403325,BAC,38.130001,37.720001,37.805000,-0.852347,-0.85 % -1627403325,BK,50.250000,49.639999,50.255001,0.009950,+0.01 % -1627403325,PBF,9.570000,9.090000,8.830000,-7.732500,-7.73 % -1627403325,PBFX,13.580000,13.550000,13.470000,-0.810015,-0.81 % -1627403325,SYF,47.139999,46.650002,47.014999,-0.265168,-0.27 % -1627403325,WFC,45.009998,44.590000,44.965000,-0.099978,-0.10 % -1627403325,TEVA,8.940000,8.930000,8.785000,-1.733780,-1.73 % -1627403325,XOM,58.480000,57.160000,57.439999,-1.778390,-1.78 % -1627403325,MPC,54.660000,53.830002,53.720001,-1.719720,-1.72 % -1627403388,FDX,297.500000,287.500000,279.924988,-5.907560,-5.91 % -1627403388,C,67.769997,67.080002,67.650002,-0.177069,-0.18 % -1627403388,AIG,47.709999,47.080002,47.380001,-0.691679,-0.69 % -1627403388,BAC,38.130001,37.720001,37.825001,-0.799895,-0.80 % -1627403388,BK,50.250000,49.639999,50.279999,0.059701,+0.06 % -1627403388,PBF,9.570000,9.090000,8.845000,-7.575760,-7.58 % -1627403388,PBFX,13.580000,13.550000,13.470000,-0.810015,-0.81 % -1627403388,SYF,47.139999,46.650002,47.044998,-0.201527,-0.20 % -1627403388,WFC,45.009998,44.590000,45.005001,-0.011109,-0.01 % -1627403388,TEVA,8.940000,8.930000,8.795000,-1.621920,-1.62 % -1627403388,XOM,58.480000,58.009998,57.459000,-1.745900,-1.75 % -1627403388,MPC,54.660000,53.990002,53.794998,-1.582510,-1.58 % -1627403450,FDX,297.500000,287.500000,279.989990,-5.885710,-5.89 % -1627403450,C,67.769997,67.080002,67.580002,-0.280360,-0.28 % -1627403450,AIG,47.709999,47.080002,47.394199,-0.661916,-0.66 % -1627403450,BAC,38.130001,37.720001,37.820000,-0.813008,-0.81 % -1627403450,BK,50.250000,49.639999,50.279999,0.059701,+0.06 % -1627403450,PBF,9.570000,9.090000,8.850000,-7.523510,-7.52 % -1627403450,PBFX,13.580000,13.550000,13.470000,-0.810015,-0.81 % -1627403450,SYF,47.139999,46.650002,47.035000,-0.222741,-0.22 % -1627403450,WFC,45.009998,44.590000,44.950001,-0.133304,-0.13 % -1627403450,TEVA,8.940000,8.930000,8.785000,-1.733780,-1.73 % -1627403450,XOM,58.480000,58.009998,57.459000,-1.745900,-1.75 % -1627403450,MPC,54.660000,53.990002,53.794998,-1.582510,-1.58 % -1627403512,FDX,297.500000,287.500000,279.730011,-5.973110,-5.97 % -1627403512,C,67.769997,67.080002,67.589996,-0.265604,-0.27 % -1627403512,AIG,47.709999,47.080002,47.380001,-0.691679,-0.69 % -1627403512,BAC,38.130001,37.720001,37.801102,-0.862575,-0.86 % -1627403512,BK,50.250000,49.639999,50.279999,0.059701,+0.06 % -1627403512,PBF,9.570000,9.090000,8.855000,-7.471260,-7.47 % -1627403512,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627403512,SYF,47.139999,46.650002,47.005001,-0.286381,-0.29 % -1627403512,WFC,45.009998,44.590000,44.950001,-0.133304,-0.13 % -1627403512,TEVA,8.940000,8.930000,8.785000,-1.733780,-1.73 % -1627403512,XOM,58.480000,58.009998,57.415001,-1.821140,-1.82 % -1627403512,MPC,54.660000,53.990002,53.730000,-1.701430,-1.70 % -1627403574,FDX,297.500000,287.500000,279.459991,-6.063870,-6.06 % -1627403574,C,67.769997,67.080002,67.570000,-0.295116,-0.30 % -1627403574,AIG,47.709999,47.080002,47.380001,-0.691679,-0.69 % -1627403574,BAC,38.130001,37.720001,37.785000,-0.904799,-0.90 % -1627403574,BK,50.250000,49.639999,50.250000,0.000000,+0.00 % -1627403574,PBF,9.570000,9.090000,8.830000,-7.732500,-7.73 % -1627403574,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627403574,SYF,47.139999,46.650002,46.977001,-0.345779,-0.35 % -1627403574,WFC,45.009998,44.590000,44.959999,-0.111086,-0.11 % -1627403574,TEVA,8.940000,8.930000,8.785000,-1.733780,-1.73 % -1627403574,XOM,58.480000,58.009998,57.445000,-1.769840,-1.77 % -1627403574,MPC,54.660000,53.990002,53.740002,-1.683130,-1.68 % -1627403637,FDX,297.500000,287.500000,279.399994,-6.084030,-6.08 % -1627403637,C,67.769997,67.080002,67.525002,-0.361517,-0.36 % -1627403637,AIG,47.709999,47.080002,47.320000,-0.817439,-0.82 % -1627403637,BAC,38.130001,37.720001,37.775002,-0.931025,-0.93 % -1627403637,BK,50.250000,49.639999,50.240002,-0.019901,-0.02 % -1627403637,PBF,9.570000,9.090000,8.830000,-7.732500,-7.73 % -1627403637,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627403637,SYF,47.139999,46.650002,46.970001,-0.360628,-0.36 % -1627403637,WFC,45.009998,44.590000,44.924999,-0.188847,-0.19 % -1627403637,TEVA,8.940000,8.930000,8.775000,-1.845640,-1.85 % -1627403637,XOM,58.480000,58.009998,57.430000,-1.795490,-1.80 % -1627403637,MPC,54.660000,53.990002,53.709999,-1.738020,-1.74 % -1627403699,FDX,297.500000,287.500000,279.679993,-5.989920,-5.99 % -1627403699,C,67.769997,67.080002,67.540001,-0.339383,-0.34 % -1627403699,AIG,47.709999,47.080002,47.340000,-0.775519,-0.78 % -1627403699,BAC,38.130001,37.720001,37.770000,-0.944138,-0.94 % -1627403699,BK,50.250000,49.639999,50.220001,-0.059701,-0.06 % -1627403699,PBF,9.570000,9.090000,8.820000,-7.836990,-7.84 % -1627403699,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627403699,SYF,47.139999,46.650002,46.955002,-0.392448,-0.39 % -1627403699,WFC,45.009998,44.590000,44.939999,-0.155521,-0.16 % -1627403699,TEVA,8.940000,8.930000,8.775000,-1.845640,-1.85 % -1627403699,XOM,58.480000,57.160000,57.400002,-1.846790,-1.85 % -1627403699,MPC,54.660000,53.830002,53.700001,-1.756310,-1.76 % -1627403761,FDX,297.500000,287.500000,280.140015,-5.835290,-5.84 % -1627403761,C,67.769997,67.080002,67.570000,-0.295116,-0.30 % -1627403761,AIG,47.709999,47.080002,47.340000,-0.775519,-0.78 % -1627403761,BAC,38.130001,37.720001,37.779999,-0.917912,-0.92 % -1627403761,BK,50.250000,49.639999,50.230000,-0.039801,-0.04 % -1627403761,PBF,9.570000,9.090000,8.830000,-7.732500,-7.73 % -1627403761,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627403761,SYF,47.139999,46.650002,46.965000,-0.371235,-0.37 % -1627403761,WFC,45.009998,44.590000,44.959999,-0.111086,-0.11 % -1627403761,TEVA,8.940000,8.930000,8.780000,-1.789710,-1.79 % -1627403761,XOM,58.480000,57.160000,57.419998,-1.812590,-1.81 % -1627403761,MPC,54.660000,53.830002,53.720001,-1.719720,-1.72 % -1627403824,FDX,297.500000,287.500000,280.459991,-5.727760,-5.73 % -1627403824,C,67.769997,67.080002,67.599998,-0.250848,-0.25 % -1627403824,AIG,47.709999,47.080002,47.340000,-0.775519,-0.78 % -1627403824,BAC,38.130001,37.720001,37.790001,-0.891686,-0.89 % -1627403824,BK,50.250000,49.639999,50.221199,-0.057313,-0.06 % -1627403824,PBF,9.570000,9.090000,8.825000,-7.784740,-7.78 % -1627403824,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627403824,SYF,47.139999,46.650002,46.980000,-0.339415,-0.34 % -1627403824,WFC,45.009998,44.590000,44.970001,-0.088869,-0.09 % -1627403824,TEVA,8.940000,8.930000,8.780000,-1.789710,-1.79 % -1627403824,XOM,58.480000,58.009998,57.455002,-1.752740,-1.75 % -1627403824,MPC,54.660000,53.990002,53.759998,-1.646540,-1.65 % -1627403886,FDX,297.500000,287.500000,280.950012,-5.563030,-5.56 % -1627403886,C,67.769997,67.080002,67.620003,-0.221337,-0.22 % -1627403886,AIG,47.709999,47.080002,47.380001,-0.691679,-0.69 % -1627403886,BAC,38.130001,37.720001,37.794998,-0.878573,-0.88 % -1627403886,BK,50.250000,49.639999,50.279999,0.059701,+0.06 % -1627403886,PBF,9.570000,9.090000,8.837200,-7.657260,-7.66 % -1627403886,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627403886,SYF,47.139999,46.650002,47.025002,-0.243954,-0.24 % -1627403886,WFC,45.009998,44.590000,44.970001,-0.088869,-0.09 % -1627403886,TEVA,8.940000,8.930000,8.790000,-1.677850,-1.68 % -1627403886,XOM,58.480000,58.009998,57.465000,-1.735640,-1.74 % -1627403886,MPC,54.660000,53.990002,53.750000,-1.664840,-1.66 % -1627403948,FDX,297.500000,287.500000,280.950012,-5.563030,-5.56 % -1627403948,C,67.769997,67.080002,67.599998,-0.250848,-0.25 % -1627403948,AIG,47.709999,47.080002,47.375000,-0.702159,-0.70 % -1627403948,BAC,38.130001,37.720001,37.794998,-0.878573,-0.88 % -1627403948,BK,50.250000,49.639999,50.279999,0.059701,+0.06 % -1627403948,PBF,9.570000,9.090000,8.837200,-7.657260,-7.66 % -1627403948,PBFX,13.580000,13.550000,13.470300,-0.807806,-0.81 % -1627403948,SYF,47.139999,46.650002,47.025002,-0.243954,-0.24 % -1627403948,WFC,45.009998,44.590000,44.970001,-0.088869,-0.09 % -1627403948,TEVA,8.940000,8.930000,8.790000,-1.677850,-1.68 % -1627403948,XOM,58.480000,58.009998,57.430099,-1.795310,-1.80 % -1627403948,MPC,54.660000,53.990002,53.720001,-1.719720,-1.72 % -1627404011,FDX,297.500000,287.500000,281.279999,-5.452100,-5.45 % -1627404011,C,67.769997,67.080002,67.589996,-0.265604,-0.27 % -1627404011,AIG,47.709999,47.080002,47.375000,-0.702159,-0.70 % -1627404011,BAC,38.130001,37.720001,37.776100,-0.928141,-0.93 % -1627404011,BK,50.250000,49.639999,50.250000,0.000000,+0.00 % -1627404011,PBF,9.570000,9.090000,8.805000,-7.993730,-7.99 % -1627404011,PBFX,13.580000,13.550000,13.470300,-0.807806,-0.81 % -1627404011,SYF,47.139999,46.650002,47.020000,-0.254561,-0.25 % -1627404011,WFC,45.009998,44.590000,44.950001,-0.133304,-0.13 % -1627404011,TEVA,8.940000,8.930000,8.790000,-1.677850,-1.68 % -1627404011,XOM,58.480000,57.160000,57.410000,-1.829690,-1.83 % -1627404011,MPC,54.660000,53.830002,53.689999,-1.774610,-1.77 % -1627404073,FDX,297.500000,287.500000,281.450012,-5.394960,-5.39 % -1627404073,C,67.769997,67.080002,67.530197,-0.353844,-0.35 % -1627404073,AIG,47.709999,47.080002,47.349998,-0.754559,-0.75 % -1627404073,BAC,38.130001,37.720001,37.759998,-0.970365,-0.97 % -1627404073,BK,50.250000,49.639999,50.169998,-0.159204,-0.16 % -1627404073,PBF,9.570000,9.090000,8.795000,-8.098220,-8.10 % -1627404073,PBFX,13.580000,13.550000,13.480000,-0.736377,-0.74 % -1627404073,SYF,47.139999,46.650002,46.990002,-0.318201,-0.32 % -1627404073,WFC,45.009998,44.590000,44.915001,-0.211064,-0.21 % -1627404073,TEVA,8.940000,8.930000,8.780000,-1.789710,-1.79 % -1627404073,XOM,58.480000,58.009998,57.375000,-1.889530,-1.89 % -1627404073,MPC,54.660000,53.990002,53.639999,-1.866080,-1.87 % -1627404136,FDX,297.500000,287.500000,281.725006,-5.302520,-5.30 % -1627404136,C,67.769997,67.080002,67.550102,-0.324480,-0.32 % -1627404136,AIG,47.709999,47.080002,47.349998,-0.754559,-0.75 % -1627404136,BAC,38.130001,37.720001,37.750000,-0.996591,-1.00 % -1627404136,BK,50.250000,49.639999,50.209999,-0.079602,-0.08 % -1627404136,PBF,9.570000,9.090000,8.805000,-7.993730,-7.99 % -1627404136,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627404136,SYF,47.139999,46.650002,47.035000,-0.222741,-0.22 % -1627404136,WFC,45.009998,44.590000,44.919998,-0.199956,-0.20 % -1627404136,TEVA,8.940000,8.930000,8.780000,-1.789710,-1.79 % -1627404136,XOM,58.480000,57.160000,57.415001,-1.821140,-1.82 % -1627404136,MPC,54.660000,53.830002,53.645000,-1.856930,-1.86 % -1627404199,FDX,297.500000,287.500000,281.725006,-5.302520,-5.30 % -1627404199,C,67.769997,67.080002,67.529999,-0.354139,-0.35 % -1627404199,AIG,47.709999,47.080002,47.369999,-0.712639,-0.71 % -1627404199,BAC,38.130001,37.720001,37.730000,-1.049040,-1.05 % -1627404199,BK,50.250000,49.639999,50.209999,-0.079602,-0.08 % -1627404199,PBF,9.570000,9.090000,8.810000,-7.941480,-7.94 % -1627404199,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627404199,SYF,47.139999,46.650002,47.029999,-0.233347,-0.23 % -1627404199,WFC,45.009998,44.590000,44.889999,-0.266607,-0.27 % -1627404199,TEVA,8.940000,8.930000,8.785000,-1.733780,-1.73 % -1627404199,XOM,58.480000,57.160000,57.430000,-1.795490,-1.80 % -1627404199,MPC,54.660000,53.830002,53.668400,-1.814120,-1.81 % -1627404262,FDX,297.500000,287.500000,281.276001,-5.453280,-5.45 % -1627404262,C,67.769997,67.080002,67.547798,-0.327874,-0.33 % -1627404262,AIG,47.709999,47.080002,47.369999,-0.712639,-0.71 % -1627404262,BAC,38.130001,37.720001,37.724998,-1.062160,-1.06 % -1627404262,BK,50.250000,49.639999,50.189999,-0.119403,-0.12 % -1627404262,PBF,9.570000,9.090000,8.825000,-7.784740,-7.78 % -1627404262,PBFX,13.580000,13.550000,13.500000,-0.589102,-0.59 % -1627404262,SYF,47.139999,46.650002,47.012100,-0.271319,-0.27 % -1627404262,WFC,45.009998,44.590000,44.910000,-0.222173,-0.22 % -1627404262,TEVA,8.940000,8.930000,8.785000,-1.733780,-1.73 % -1627404262,XOM,58.480000,58.009998,57.423000,-1.807460,-1.81 % -1627404262,MPC,54.660000,53.990002,53.669998,-1.811200,-1.81 % -1627404324,FDX,297.500000,287.500000,281.299011,-5.445710,-5.45 % -1627404324,C,67.769997,67.080002,67.550003,-0.324627,-0.32 % -1627404324,AIG,47.709999,47.080002,47.340000,-0.775519,-0.78 % -1627404324,BAC,38.130001,37.720001,37.730000,-1.049040,-1.05 % -1627404324,BK,50.250000,49.639999,50.195000,-0.109453,-0.11 % -1627404324,PBF,9.570000,9.090000,8.825000,-7.784740,-7.78 % -1627404324,PBFX,13.580000,13.550000,13.490000,-0.662739,-0.66 % -1627404324,SYF,47.139999,46.650002,47.020000,-0.254561,-0.25 % -1627404324,WFC,45.009998,44.590000,44.915001,-0.211064,-0.21 % -1627404324,TEVA,8.940000,8.930000,8.770000,-1.901570,-1.90 % -1627404324,XOM,58.480000,58.009998,57.450001,-1.761290,-1.76 % -1627404324,MPC,54.660000,53.990002,53.694801,-1.765830,-1.77 % -1627404387,FDX,297.500000,287.500000,281.250000,-5.462180,-5.46 % -1627404387,C,67.769997,67.080002,67.550003,-0.324627,-0.32 % -1627404387,AIG,47.709999,47.080002,47.369999,-0.712639,-0.71 % -1627404387,BAC,38.130001,37.720001,37.739899,-1.023080,-1.02 % -1627404387,BK,50.250000,49.639999,50.200001,-0.099502,-0.10 % -1627404387,PBF,9.570000,9.090000,8.825000,-7.784740,-7.78 % -1627404387,PBFX,13.580000,13.550000,13.490000,-0.662739,-0.66 % -1627404387,SYF,47.139999,46.650002,47.029999,-0.233347,-0.23 % -1627404387,WFC,45.009998,44.590000,44.919998,-0.199956,-0.20 % -1627404387,TEVA,8.940000,8.930000,8.777600,-1.816550,-1.82 % -1627404387,XOM,58.480000,58.009998,57.455002,-1.752740,-1.75 % -1627404387,MPC,54.660000,53.990002,53.689999,-1.774610,-1.77 % \ No newline at end of file diff --git a/usql/row.cpp b/usql/row.cpp index 9e77b33..7325bef 100644 --- a/usql/row.cpp +++ b/usql/row.cpp @@ -1,89 +1,177 @@ +#include #include "row.h" namespace usql { - Row::Row(int cols_count) { - m_columns.reserve(cols_count); - for (int i = 0; i < cols_count; i++) { - m_columns.push_back(std::make_unique()); - } - } +int ColNullValue::compare(ColValue &other) { + return other.isNull() ? 0 : -1; // null goes to end +} - Row::Row(const Row &other) { - m_columns.reserve(other.m_columns.size()); - // TODO fixme this is nonsense - for (int i = 0; i < other.m_columns.size(); i++) { - m_columns.push_back(std::make_unique()); - } +int ColIntegerValue::compare(ColValue &other) { + long r = m_integer - other.getIntValue(); + return other.isNull() ? 1 : r > 0 ? 1 : r == 0 ? 0 : -1; +} - for (int i = 0; i < other.m_columns.size(); i++) { - if (ColIntegerValue *other_v = dynamic_cast(other.m_columns[i].get())) { - setColumnValue(i, other_v->getIntValue()); - } - if (ColDoubleValue *other_v = dynamic_cast(other.m_columns[i].get())) { - setColumnValue(i, other_v->getDoubleValue()); - } - if (ColStringValue *other_v = dynamic_cast(other.m_columns[i].get())) { - setColumnValue(i, other_v->getStringValue()); - } - } - } +int ColDoubleValue::compare(ColValue &other) { + if (other.isNull()) return 1; // null goes to end - Row &Row::operator=(Row other) { - std::swap(m_columns, other.m_columns); - return *this; - } + double c = m_double - other.getDoubleValue(); + return c < 0 ? -1 : c == 0.0 ? 0 : 1; +} - void Row::setColumnNull(int col_index) { - m_columns[col_index] = std::make_unique(); - } +ColStringValue & ColStringValue::operator=(ColStringValue other) { + std::swap(m_string, other.m_string); + return *this; +} - void Row::setColumnValue(int col_index, long value) { - m_columns[col_index] = std::make_unique(value); - } +int ColStringValue::compare(ColValue &other) { + return other.isNull() ? 1 : m_string->compare(other.getStringValue()); // null goes to end +} - void Row::setColumnValue(int col_index, double value) { - m_columns[col_index] = std::make_unique(value); - } +int ColDateValue::compare(ColValue &other) { + long r = m_date - other.getIntValue(); + return other.isNull() ? 1 : r > 0 ? 1 : r == 0 ? 0 : -1; +} - void Row::setColumnValue(int col_index, const std::string &value) { - m_columns[col_index] = std::make_unique(value); - }; +int ColBooleanValue::compare(ColValue &other) { + if (other.isNull()) return 1; // null goes to end - void Row::setColumnValue(ColDefNode *col_def, ColValue *col_value) { - if (!col_value->isNull()) { - if (col_def->type == ColumnType::integer_type) - setColumnValue(col_def->order, col_value->getIntValue()); - else if (col_def->type == ColumnType::float_type) - setColumnValue(col_def->order, col_value->getDoubleValue()); - else if (col_def->type == ColumnType::varchar_type) - setColumnValue(col_def->order, col_value->getStringValue()); - } else { - setColumnNull(col_def->order); - } - } + return m_bool == other.getBoolValue() ? 0 : m_bool && !other.getBoolValue() ? -1 : 1; // true first +} - void Row::setColumnValue(ColDefNode *col_def, ValueNode *col_value) { - if (!col_value->isNull()) { - if (col_def->type == ColumnType::integer_type) - setColumnValue(col_def->order, col_value->getIntValue()); - else if (col_def->type == ColumnType::float_type) - setColumnValue(col_def->order, col_value->getDoubleValue()); - else if (col_def->type == ColumnType::varchar_type) - setColumnValue(col_def->order, col_value->getStringValue()); - } else { - setColumnNull(col_def->order); - } - } +Row::Row(const Row &other) : m_columns(other.m_columns.size()) { + for (int i = 0; i < other.m_columns.size(); i++) { + if (other[i].isNull()) + continue; // for null NOP - void Row::print() { - for (int ci = 0; ci < m_columns.size(); ci++) { - if (ci > 0) std::cout << ","; - auto v = m_columns[ci]->getStringValue(); - std::cout << v; - } - std::cout << std::endl; - } + ColumnType col_type = other[i].getColType(); + switch (col_type) { + case ColumnType::integer_type : + setIntColumnValue(i, other[i].getIntValue()); + break; + case ColumnType::float_type : + setFloatColumnValue(i, other[i].getDoubleValue()); + break; + case ColumnType::varchar_type : + setStringColumnValue(i, other[i].getStringValue()); + break; + case ColumnType::date_type : + setDateColumnValue(i, other[i].getDateValue()); + break; + case ColumnType::bool_type : + setBoolColumnValue(i, other[i].getBoolValue()); + break; + default: + throw Exception("unsupported column type"); + } + } +} -} \ No newline at end of file + +Row &Row::operator=(Row other) { + std::swap(m_columns, other.m_columns); + return *this; +} + +void Row::setColumnNull(int col_index) { + m_columns[col_index] = ColNullValue(); +} + +void Row::setIntColumnValue(int col_index, long value) { + m_columns[col_index] = ColIntegerValue(value); +} + +void Row::setFloatColumnValue(int col_index, double value) { + m_columns[col_index] = ColDoubleValue(value); +} + +void Row::setStringColumnValue(int col_index, const std::string &value) { + m_columns[col_index] = ColStringValue(value); +} + +void Row::setDateColumnValue(int col_index, long value) { + m_columns[col_index] = ColDateValue(value); +} + +void Row::setDateColumnValue(int col_index, const std::string &value) { + m_columns[col_index] = ColDateValue(Settings::string_to_date(value)); +} + +void Row::setBoolColumnValue(int col_index, bool value) { + m_columns[col_index] = ColBooleanValue(value); +} + +void Row::setBoolColumnValue(int col_index, const std::string &value) { + bool v = (value == "Y" || value == "1"); + m_columns[col_index] = ColBooleanValue(v); +} + +void Row::setColumnValue(ColDefNode *col_def, ColValue &col_value) { + if (!col_value.isNull()) { + if (col_def->type == ColumnType::integer_type) + setIntColumnValue(col_def->order, col_value.getIntValue()); + else if (col_def->type == ColumnType::float_type) + setFloatColumnValue(col_def->order, col_value.getDoubleValue()); + else if (col_def->type == ColumnType::varchar_type) + setStringColumnValue(col_def->order, col_value.getStringValue()); + else if (col_def->type == ColumnType::date_type) + setDateColumnValue(col_def->order, col_value.getDateValue()); + else if (col_def->type == ColumnType::bool_type) + setBoolColumnValue(col_def->order, col_value.getBoolValue()); + } else { + setColumnNull(col_def->order); + } +} + +void Row::setColumnValue(ColDefNode *col_def, ValueNode *col_value) { + if (!col_value->isNull()) { + if (col_def->type == ColumnType::integer_type) + setIntColumnValue(col_def->order, col_value->getIntegerValue()); + else if (col_def->type == ColumnType::float_type) + setFloatColumnValue(col_def->order, col_value->getDoubleValue()); + else if (col_def->type == ColumnType::varchar_type) + setStringColumnValue(col_def->order, col_value->getStringValue()); + else if (col_def->type == ColumnType::date_type) + setIntColumnValue(col_def->order, col_value->getDateValue()); + else if (col_def->type == ColumnType::bool_type) + setBoolColumnValue(col_def->order, col_value->getBooleanValue()); + else + throw Exception("unsupported data type"); + } else { + setColumnNull(col_def->order); + } +} + +int Row::compare(const Row &other) const { + for (int ci = 0; ci < m_columns.size(); ci++) { + int cmp = this->operator[](ci).compare(other[ci]); + if (cmp != 0) return cmp; + } + return 0; +} + +void Row::print(const std::vector &col_defs) { + std::string out{"| "}; + + for (int ci = 0; ci < m_columns.size(); ci++) { + auto & col_def = col_defs[ci]; + int col_size = print_get_column_size(col_def); + + if (col_def.type==ColumnType::integer_type || col_def.type==ColumnType::float_type || col_def.type==ColumnType::bool_type) + out.append(string_padd(this->operator[](ci).getStringValue(), col_size, ' ', false) + " | "); + else + out.append(string_padd(this->operator[](ci).getStringValue(), col_size, ' ', true) + " | "); + } + + std::cout << out << std::endl; +} + + +int Row::print_get_column_size(const ColDefNode &col_def) { + int col_size = col_def.type == ColumnType::varchar_type ? col_def.length : + col_def.type == ColumnType::float_type ? 16 : 10; + return col_size; +} + +} // namespace diff --git a/usql/row.h b/usql/row.h index a94d797..8437232 100644 --- a/usql/row.h +++ b/usql/row.h @@ -2,94 +2,174 @@ #include "exception.h" #include "parser.h" +#include "settings.h" +#include #include namespace usql { - struct ColValue { - virtual bool isNull() { return false; }; - virtual long getIntValue() { throw Exception("Not supported"); }; - virtual double getDoubleValue() { throw Exception("Not supported"); }; - virtual std::string getStringValue() { throw Exception("Not supported"); }; + virtual ColumnType getColType() = 0; + virtual long getIntValue() = 0; + virtual double getDoubleValue() = 0; + virtual std::string getStringValue() = 0; + virtual long getDateValue() = 0; + virtual bool getBoolValue() = 0; + + virtual int compare(ColValue &other) = 0; + + virtual ~ColValue() = default; + }; struct ColNullValue : ColValue { + bool isNull() override { return true; }; + ColumnType getColType() override { throw Exception("getColType not supported on ColNullValue"); } + long getIntValue() override { throw Exception("getIntValue not supported on ColNullValue"); }; + double getDoubleValue() override { throw Exception("getDoubleValue not supported on ColNullValue"); }; + std::string getStringValue() override { return "null"; }; + long getDateValue() override { throw Exception("getDateValue not supported on ColNullValue"); }; + bool getBoolValue() override { throw Exception("getDateValue not supported on ColNullValue"); }; - virtual bool isNull() { return true; }; - virtual std::string getStringValue() { return "null"; }; + int compare(ColValue &other) override; }; struct ColIntegerValue : ColValue { - - ColIntegerValue(long value) : m_integer(value) {}; + explicit ColIntegerValue(long value) : m_integer(value) {}; ColIntegerValue(const ColIntegerValue &other) : m_integer(other.m_integer) {}; - virtual long getIntValue() { return m_integer; }; - virtual double getDoubleValue() { return (double) m_integer; }; - virtual std::string getStringValue() { return std::to_string(m_integer); }; + ColumnType getColType() override { return ColumnType::integer_type; }; + long getIntValue() override { return m_integer; }; + double getDoubleValue() override { return (double) m_integer; }; + std::string getStringValue() override { return std::to_string(m_integer); }; + long getDateValue() override { return m_integer; }; + bool getBoolValue() override { throw Exception("Not supported on ColIntegerValue"); }; - int m_integer; + int compare(ColValue &other) override; + + long m_integer; }; struct ColDoubleValue : ColValue { - - ColDoubleValue(double value) : m_double(value) {}; + explicit ColDoubleValue(double value) : m_double(value) {}; ColDoubleValue(const ColDoubleValue &other) : m_double(other.m_double) {} - virtual long getIntValue() { return (long) m_double; }; - virtual double getDoubleValue() { return m_double; }; - virtual std::string getStringValue() { return std::to_string(m_double); }; + ColumnType getColType() override { return ColumnType::float_type; }; + long getIntValue() override { return (long) m_double; }; + double getDoubleValue() override { return m_double; }; + std::string getStringValue() override { return Settings::double_to_string(m_double); }; + long getDateValue() override { return (long) m_double; }; + bool getBoolValue() override { throw Exception("Not supported on ColDoubleValue"); }; + + int compare(ColValue &other) override; double m_double; }; struct ColStringValue : ColValue { + explicit ColStringValue(const std::string &value) : m_string(std::make_unique(value)) {}; + ColStringValue(const ColStringValue &other) : m_string(std::make_unique(*other.m_string)) {}; - ColStringValue(const std::string value) : m_string(value) {}; - ColStringValue(const ColStringValue &other) : m_string(other.m_string) {}; + ColStringValue & operator=(ColStringValue other); - virtual long getIntValue() { return std::stoi(m_string); }; - virtual double getDoubleValue() { return std::stod(m_string); }; - virtual std::string getStringValue() { return m_string; }; + ColumnType getColType() override { return ColumnType::varchar_type; }; + long getIntValue() override { return std::stoi(*m_string); }; + double getDoubleValue() override { return std::stod(*m_string); }; + std::string getStringValue() override { return *m_string; }; + long getDateValue() override { return std::stoi(*m_string); }; + bool getBoolValue() override { throw Exception("Not supported on ColStringValue"); }; - std::string m_string; + int compare(ColValue &other) override; + + std::unique_ptr m_string; }; + struct ColDateValue : ColValue { + explicit ColDateValue(long value) : m_date(value) {}; + ColDateValue(const ColDateValue &other) : m_date(other.m_date) {}; + + ColumnType getColType() override { return ColumnType::date_type; }; + long getIntValue() override { return m_date; }; + double getDoubleValue() override { return (double) m_date; }; + std::string getStringValue() override { return Settings::date_to_string(m_date); }; + long getDateValue() override { return m_date; }; + bool getBoolValue() override { throw Exception("Not supported on ColDateValue"); }; + + int compare(ColValue &other) override; + + long m_date; // seconds since epoch for now + }; + + struct ColBooleanValue : ColValue { + explicit ColBooleanValue(bool value) : m_bool(value) {}; + ColBooleanValue(const ColBooleanValue &other) : m_bool(other.m_bool) {}; + + ColumnType getColType() override { return ColumnType::bool_type; }; + long getIntValue() override { return (long) m_bool; }; + double getDoubleValue() override { return (double) m_bool; }; + std::string getStringValue() override { return m_bool ? "Y" : "N"; }; + long getDateValue() override { throw Exception("Not supported on ColBooleanValue"); }; + bool getBoolValue() override { return m_bool; }; + + int compare(ColValue &other) override; + + bool m_bool; + }; + + class Row { public: - Row(int cols_count); + explicit Row(int cols_count) : m_columns(cols_count) {}; Row(const Row &other); Row &operator=(Row other); + bool operator==(const Row &other) const {return this->compare(other) == 0; }; void setColumnNull(int col_index); - void setColumnValue(int col_index, long value); - void setColumnValue(int col_index, double value); - void setColumnValue(int col_index, const std::string &value); - void setColumnValue(ColDefNode *col_def, ColValue *col_value); + void setIntColumnValue(int col_index, long value); + void setFloatColumnValue(int col_index, double value); + void setStringColumnValue(int col_index, const std::string &value); + void setDateColumnValue(int col_index, long value); + void setDateColumnValue(int col_index, const std::string &value); + void setBoolColumnValue(int col_index, bool value); + void setBoolColumnValue(int col_index, const std::string &value); + void setColumnValue(ColDefNode *col_def, ColValue &col_value); void setColumnValue(ColDefNode *col_def, ValueNode *col_value); - ColValue &operator[](int i) { - return *m_columns[i]; + ColValue &operator[](int i) const { + auto type_index = m_columns[i].index(); + switch (type_index) { + case 0: + return (ColValue &) *std::get_if(&m_columns[i]); + case 1: + return (ColValue &) *std::get_if(&m_columns[i]); + case 2: + return (ColValue &) *std::get_if(&m_columns[i]); + case 3: + return (ColValue &) *std::get_if(&m_columns[i]); + case 4: + return (ColValue &) *std::get_if(&m_columns[i]); + case 5: + return (ColValue &) *std::get_if(&m_columns[i]); + } + throw Exception("should not happen"); } - ColValue * ith_column(int i) const { - return m_columns[i].get(); - } - - void print(); + int compare(const Row &other) const; + void print(const std::vector &col_defs); + static int print_get_column_size(const ColDefNode &col_def); private: - std::vector> m_columns; + // xx std::vector> m_columns; + std::vector> m_columns; }; } // namespace \ No newline at end of file diff --git a/usql/settings.cpp b/usql/settings.cpp new file mode 100644 index 0000000..6a72a5e --- /dev/null +++ b/usql/settings.cpp @@ -0,0 +1,51 @@ + +#include "settings.h" +#include "exception.h" +#include "ml_date.h" + +namespace usql { + +std::vector> Settings::m_settings = + { std::make_pair("DATE_FORMAT", "%Y-%m-%d"), + std::make_pair("BOOL_TRUE_LITERAL", "Y"), + std::make_pair("BOOL_FALSE_LITERAL", "N"), + std::make_pair("DOUBLE_FORMAT", "%.2f") }; + + +long Settings::string_to_date(const std::string &datestr) { + return ::string_to_date(datestr, get_setting("DATE_FORMAT")); +} + + +std::string Settings::date_to_string(long date) { + return ::date_to_string(date, get_setting("DATE_FORMAT")); +} + +std::string Settings::double_to_string(double d) { + char buffer[32]; + int r, buf_size = 32; + + r = snprintf(buffer, buf_size, get_setting("DOUBLE_FORMAT").c_str(), d); + if (r > 0 && r < buf_size) return std::string(buffer); + + return "ERROR"; +} + +std::string Settings::get_setting(const std::string &name) { + for(const auto& pair : m_settings) { + if (pair.first == name) return pair.second; + } + throw Exception("unsupported setting name: " + name); +} + +void Settings::set_setting(const std::string &name, const std::string &value) { + for (auto it = begin(m_settings); it != end(m_settings); ++it) { + if (it->first == name) { + *it = std::make_pair(name, value); + return; + } + } + throw Exception("unsupported setting name: " + name); +} + +} // namespace \ No newline at end of file diff --git a/usql/settings.h b/usql/settings.h new file mode 100644 index 0000000..a8ae9a8 --- /dev/null +++ b/usql/settings.h @@ -0,0 +1,23 @@ +#pragma once + +#include +#include + +namespace usql { + +class Settings { + +public: + static void set_setting(const std::string &name, const std::string &value); + static std::string get_setting(const std::string &name); + + static long string_to_date(const std::string &datestr); + static std::string date_to_string(long date); + static std::string double_to_string(double d); + // TODO add bool_to_string and use it in ColBooleanValue + +private: + static std::vector> m_settings; +}; + +} // namespace \ No newline at end of file diff --git a/usql/table.cpp b/usql/table.cpp index db175d1..02334d1 100644 --- a/usql/table.cpp +++ b/usql/table.cpp @@ -1,29 +1,49 @@ - #include "table.h" #include "csvreader.h" +#include "ml_string.h" +#include +#include namespace usql { -Table::Table(const std::string name, const std::vector columns) { +Table::Table(const std::string& name, const std::vector& columns) { m_name = name; m_col_defs = columns; - m_rows.clear(); + m_rows.reserve(256); +} + +Table::Table(const Table &other) { + m_name = other.m_name; + m_col_defs = other.m_col_defs; + m_rows.reserve(other.m_rows.size()); + for(const Row& orig_row : other.m_rows) { + commit_copy_of_row(orig_row); + } } ColDefNode Table::get_column_def(const std::string &col_name) { - auto name_cmp = [col_name](ColDefNode cd) { return cd.name == col_name; }; + auto name_cmp = [col_name](const ColDefNode& cd) { return cd.name == col_name; }; + auto col_def = std::find_if(begin(m_col_defs), end(m_col_defs), name_cmp); if (col_def != std::end(m_col_defs)) { return *col_def; } else { - throw Exception("column not exists (" + col_name + ")"); + throw Exception("column does not exist (" + col_name + ")"); } } +ColDefNode Table::get_column_def(int col_index) { + if (col_index >= 0 && col_index < columns_count()) { + return m_col_defs[col_index]; + } else { + throw Exception("column with this index does not exists (" + std::to_string(col_index) + ")"); + } +} -Row Table::create_empty_row() { - return Row(columns_count()); +Row& Table::create_empty_row() { + m_rows.emplace_back(columns_count()); + return m_rows.back(); } std::string Table::csv_string() { @@ -35,14 +55,14 @@ std::string Table::csv_string() { } // rows - for (auto it = m_rows.begin(); it != m_rows.end(); ++it) { + for (auto & m_row : m_rows) { std::string csv_line{"\n"}; for(int i = 0; i < m_col_defs.size(); i++) { if (i > 0) csv_line += ","; - auto col = it->ith_column(i); - if (!col->isNull()) { - csv_line += col->getStringValue(); // TODO handle enclosing commas etc + auto & col = m_row[i]; + if (!col.isNull()) { + csv_line += col.getStringValue(); // TODO handle enclosing commas etc } } out_string += csv_line; @@ -52,87 +72,150 @@ std::string Table::csv_string() { } int Table::load_csv_string(const std::string &content) { - int row_cnt = 0; - - CsvReader csvparser{}; - auto csv = csvparser.parseCSV(content); - std::vector &colDefs = m_col_defs; - for (auto it = csv.begin() + 1; it != csv.end(); ++it) { - std::vector csv_line = *it; - - // prepare empty new_row - Row new_row = create_empty_row(); - - // copy values - for (size_t i = 0; i < columns_count(); i++) { - ColDefNode col_def = get_column_def(colDefs[i].name); - - // TODO validate value - if (col_def.type == ColumnType::integer_type) { - new_row.setColumnValue(col_def.order, std::stol(csv_line[i])); - } else if (col_def.type == ColumnType::float_type) { - new_row.setColumnValue(col_def.order, std::stof(csv_line[i])); - } else { - new_row.setColumnValue(col_def.order, csv_line[i]); - } - } - - // append new_row - add_row(new_row); - - row_cnt++; - } + CsvReader csvparser{}; + int row_cnt = csvparser.parseCSV2(content, colDefs, *this); return row_cnt; } +int Table::load_csv_file(const std::string &filename) { + std::vector &colDefs = m_col_defs; + + // allocate enough space + int line_size = 128; + + std::ifstream in(filename, std::ifstream::ate | std::ifstream::binary); + auto file_size = in.tellg(); + + std::ifstream infile(filename); + if (infile.good()) { + std::string sLine; + std::getline(infile, sLine); + line_size = (int)sLine.size(); + } + infile.close(); + + if (file_size > 0) { + auto new_size = m_rows.size() + int(file_size / line_size * 1.20); + m_rows.reserve(new_size); + } + + // load rows + CsvReader csvparser{}; + int row_cnt = csvparser.parseCSV(filename, colDefs, *this); + + return row_cnt; +} + +void Table::create_row_from_vector(const std::vector &colDefs, const std::vector &csv_line) { + // prepare empty new_row + Row& new_row = create_empty_row(); + + // copy values + for (int i = 0; i < std::min(columns_count(), csv_line.size()); i++) { + const ColDefNode & col_def = colDefs[i]; + + if (csv_line[i].empty()) { + new_row.setColumnNull(col_def.order); + } else if (col_def.type == ColumnType::integer_type) { + new_row.setIntColumnValue(col_def.order, string_to_long(csv_line[i])); + } else if (col_def.type == ColumnType::float_type) { + new_row.setFloatColumnValue(col_def.order, string_to_double(csv_line[i])); + } else if (col_def.type == ColumnType::varchar_type) { + new_row.setStringColumnValue(col_def.order, csv_line[i]); + } else if (col_def.type == ColumnType::date_type) { + new_row.setDateColumnValue(col_def.order, csv_line[i]); + } else if (col_def.type == ColumnType::bool_type) { + new_row.setBoolColumnValue(col_def.order, csv_line[i]); + } else + throw Exception("unsupported column type"); + } + + // append new_row + commit_row(new_row); +} + +double Table::string_to_double(const std::string &s) { + try { + return std::stod(s); + } catch (std::invalid_argument &e) { + throw Exception("error parsing as double: " + s); + } +} + +long Table::string_to_long(const std::string &s) { + try { + return std::stol(s); + } catch (std::invalid_argument &e) { + throw Exception("error parsing as integer: " + s); + } +} + void Table::print() { - std::cout << "** " << m_name << " **" << std::endl; - for (auto row : m_rows) { - row.print(); + std::string out{"| "}; + std::string out2{"+-"}; + + for(const auto& col_def : m_col_defs) { + int col_size = Row::print_get_column_size(col_def); + + if (col_def.type==ColumnType::integer_type || col_def.type==ColumnType::float_type || col_def.type==ColumnType::bool_type) + out.append(string_padd(col_def.name, col_size, ' ', false) + " | "); + else + out.append(string_padd(col_def.name, col_size, ' ', true) + " | "); + + out2.append(string_padd("-", col_size, '-', true) + "-+ "); + } + + // std::cout << "** " << m_name << " **" << std::endl; + std::cout << out << std::endl; + std::cout << out2 << std::endl; + + for(auto& row : m_rows) { + row.print(m_col_defs); + } + std::cout << std::endl; +} + +void Table::commit_row(const Row &row) { + try { + validate_row(row); + } catch (Exception &e) { + m_rows.erase(m_rows.end() - 1); + throw e; } } -Table::Table(const Table &other) { - m_name = other.m_name; - m_col_defs = other.m_col_defs; - for(const Row& orig_row : other.m_rows) { - add_copy_of_row(orig_row); - } -} - -void Table::add_row(const Row &row) { - validate_row(row); - m_rows.push_back(row); -} - -void Table::add_copy_of_row(const Row &row) { - Row new_row = create_empty_row(); +void Table::commit_copy_of_row(const Row &row) { + Row& new_row = create_empty_row(); for(int i = 0; i < m_col_defs.size(); i++) { - ColValue *ct = row.ith_column(i); + ColValue &ct = row[i]; - if (ct->isNull()) { + if (ct.isNull()) { new_row.setColumnNull(i); } else { if (m_col_defs[i].type == ColumnType::integer_type) { - new_row.setColumnValue(i, row.ith_column(i)->getIntValue()); + new_row.setIntColumnValue(i, row[i].getIntValue()); } else if (m_col_defs[i].type == ColumnType::float_type) { - new_row.setColumnValue(i, row.ith_column(i)->getDoubleValue()); + new_row.setFloatColumnValue(i, row[i].getDoubleValue()); } else if (m_col_defs[i].type == ColumnType::varchar_type) { - new_row.setColumnValue(i, row.ith_column(i)->getStringValue()); - } + new_row.setStringColumnValue(i, row[i].getStringValue()); + } else if (m_col_defs[i].type == ColumnType::date_type) { + new_row.setDateColumnValue(i, row[i].getDateValue()); + } else if (m_col_defs[i].type == ColumnType::bool_type) { + new_row.setBoolColumnValue(i, row[i].getBoolValue()); + } else + throw Exception("unsupported column type"); } } validate_row(new_row); - m_rows.push_back(new_row); } void Table::validate_column(const ColDefNode *col_def, ValueNode *col_val) { - if (col_def->null == false && col_val->isNull()) { + if (!col_def->null && col_val->isNull()) { throw Exception("Column " + col_def->name + " cannot be null"); } if (col_def->type == ColumnType::varchar_type && !col_val->isNull() && col_val->getStringValue().size() > col_def->length) { @@ -140,22 +223,22 @@ void Table::validate_column(const ColDefNode *col_def, ValueNode *col_val) { } } -void Table::validate_column(const ColDefNode *col_def, ColValue *col_val) { - if (col_def->null == false && col_val->isNull()) { +void Table::validate_column(const ColDefNode *col_def, ColValue &col_val) { + if (!col_def->null && col_val.isNull()) { throw Exception("Column " + col_def->name + " cannot be null"); } - if (col_def->type == ColumnType::varchar_type && !col_val->isNull() && col_val->getStringValue().size() > col_def->length) { - throw Exception("Column value of " + col_def->name + " is too long (" + col_val->getStringValue() + ")"); + if (col_def->type == ColumnType::varchar_type && !col_val.isNull() && col_val.getStringValue().size() > col_def->length) { + throw Exception("Column value of " + col_def->name + " is too long (" + col_val.getStringValue() + ")"); } } void Table::validate_row(const Row &row) { for(int i = 0; i < m_col_defs.size(); i++) { ColDefNode col_def = m_col_defs[i]; - ColValue *col_val = row.ith_column(i); + ColValue &col_val = row[i]; validate_column(&col_def, col_val); } } -} // namespace \ No newline at end of file +} // namespace diff --git a/usql/table.h b/usql/table.h index b7b20ff..e7bcce0 100644 --- a/usql/table.h +++ b/usql/table.h @@ -4,35 +4,42 @@ #include "row.h" #include -#include namespace usql { struct Table { Table(const Table &other); - Table(const std::string name, const std::vector columns); + Table(const std::string& name, const std::vector& columns); ColDefNode get_column_def(const std::string &col_name); + ColDefNode get_column_def(int col_index); - int columns_count() const { return m_col_defs.size(); }; + [[nodiscard]] int columns_count() const { return (int) m_col_defs.size(); }; + [[nodiscard]] size_t rows_count() const { return m_rows.size(); }; - Row create_empty_row(); // TODO this means unnecessary copying - void add_row(const Row &row); - void add_copy_of_row(const Row &row); + Row& create_empty_row(); + void commit_row(const Row &row); + void commit_copy_of_row(const Row &row); - void validate_column(const ColDefNode *col_def, ValueNode *col_val); - void validate_column(const ColDefNode *col_def, ColValue *col_val); + static void validate_column(const ColDefNode *col_def, ValueNode *col_val); + static void validate_column(const ColDefNode *col_def, ColValue &col_val); void validate_row(const Row &row); std::string csv_string(); int load_csv_string(const std::string &content); + int load_csv_file(const std::string &filename); void print(); std::string m_name; std::vector m_col_defs; - std::list m_rows; + std::vector m_rows; + + static long string_to_long(const std::string &s) ; + static double string_to_double(const std::string &s) ; + + void create_row_from_vector(const std::vector &colDefs, const std::vector &csv_line); }; -} \ No newline at end of file +} diff --git a/usql/usql.cpp b/usql/usql.cpp index 7258ae9..8a4cfb9 100644 --- a/usql/usql.cpp +++ b/usql/usql.cpp @@ -1,6 +1,7 @@ #include "usql.h" #include "exception.h" #include "ml_date.h" +#include "ml_string.h" #include #include @@ -25,6 +26,8 @@ std::unique_ptr USql::execute(Node &node) { return execute_create_table(static_cast(node)); case NodeType::create_table_as_select: return execute_create_table_as_table(static_cast(node)); + case NodeType::drop_table: + return execute_drop(static_cast(node)); case NodeType::insert_into: return execute_insert_into_table(static_cast(node)); case NodeType::select_from: @@ -37,8 +40,10 @@ std::unique_ptr
USql::execute(Node &node) { return execute_load(static_cast(node)); case NodeType::save_table: return execute_save(static_cast(node)); - case NodeType::drop_table: - return execute_drop(static_cast(node)); + case NodeType::set: + return execute_set(static_cast(node)); + case NodeType::show: + return execute_show(static_cast(node)); default: return create_stmt_result_table(-1, "unknown statement", 0); } @@ -68,7 +73,7 @@ std::unique_ptr
USql::execute_create_table_as_table(CreateTableAsSelectNo // must be here, if rows are put into new_table, they are lost during m_tables.push_table Table *table = find_table(node.table_name); for( Row& orig_row : select->m_rows) { - table->add_copy_of_row(orig_row); + table->commit_copy_of_row(orig_row); } select.release(); // is it correct? hoping not to release select table here and then when releasing CreateTableAsSelectNode @@ -83,12 +88,14 @@ std::unique_ptr
USql::execute_load(LoadIntoTableNode &node) { Table *table_def = find_table(node.table_name); // read data - std::ifstream ifs(node.filename); - std::string content((std::istreambuf_iterator(ifs)), - (std::istreambuf_iterator())); - + // std::ifstream ifs(node.filename); + // std::string content((std::istreambuf_iterator(ifs)), + // (std::istreambuf_iterator())); // load rows - auto rows_cnt = table_def->load_csv_string(content); + // auto rows_cnt = table_def->load_csv_string(content); + + + auto rows_cnt = table_def->load_csv_file(node.filename); return create_stmt_result_table(0, "load succeeded", rows_cnt); } @@ -106,7 +113,7 @@ std::unique_ptr
USql::execute_save(SaveTableNode &node) { file << csv_string; file.close(); - return create_stmt_result_table(0, "save succeeded", 0); + return create_stmt_result_table(0, "save succeeded", table_def->rows_count()); } std::unique_ptr
USql::execute_drop(DropTableNode &node) { @@ -121,25 +128,36 @@ std::unique_ptr
USql::execute_drop(DropTableNode &node) { throw Exception("table not found (" + node.table_name + ")"); } -std::unique_ptr
USql::execute_insert_into_table(InsertIntoTableNode &node) { - // TODO check column names.size = values.size +std::unique_ptr
USql::execute_set(SetNode &node) { + Settings::set_setting(node.name, node.value); + return create_stmt_result_table(0, "set succeeded", 1); +} +std::unique_ptr
USql::execute_show(ShowNode &node) { + std::string value = Settings::get_setting(node.name); + return create_stmt_result_table(0, "show succeeded: " + value, 1); +} + +std::unique_ptr
USql::execute_insert_into_table(InsertIntoTableNode &node) { // find table Table *table_def = find_table(node.table_name); + if (node.cols_names.size() != node.cols_values.size()) + throw Exception("Incorrect number of values"); + // prepare empty new_row - Row new_row = table_def->create_empty_row(); + Row& new_row = table_def->create_empty_row(); // copy values for (size_t i = 0; i < node.cols_names.size(); i++) { - ColDefNode col_def = table_def->get_column_def(node.cols_names[i].name); + ColDefNode col_def = table_def->get_column_def(node.cols_names[i].col_name); auto col_value = eval_value_node(table_def, new_row, node.cols_values[i].get()); new_row.setColumnValue(&col_def, col_value.get()); } // append new_row - table_def->add_row(new_row); + table_def->commit_row(new_row); return create_stmt_result_table(0, "insert succeeded", 1); } @@ -149,14 +167,22 @@ std::unique_ptr
USql::execute_select(SelectFromTableNode &node) { // find source table Table *table = find_table(node.table_name); + // expand * + if (node.cols_names->size()==1 && node.cols_names->operator[](0).name == "*") { + node.cols_names->clear(); + node.cols_names->reserve(table->columns_count()); + for(const auto& col : table->m_col_defs) { + node.cols_names->emplace_back(SelectColNode{std::make_unique(col.name), col.name}); + } + } + // create result table std::vector result_tbl_col_defs{}; std::vector source_table_col_index{}; for (int i = 0; i < node.cols_names->size(); i++) { - auto [ src_tbl_col_index, rst_tbl_col_def ] = get_column_definition(table, - &node.cols_names->operator[](i), i); + auto [src_tbl_col_index, rst_tbl_col_def] = get_column_definition(table, &node.cols_names->operator[](i), i); source_table_col_index.push_back(src_tbl_col_index); result_tbl_col_defs.push_back(rst_tbl_col_def); @@ -168,72 +194,153 @@ std::unique_ptr
USql::execute_select(SelectFromTableNode &node) { for (auto row = begin(table->m_rows); row != end(table->m_rows); ++row) { // eval where for row if (eval_where(node.where.get(), table, *row)) { - // prepare empty row - Row new_row = result->create_empty_row(); + // prepare empty row and copy column values + Row& new_row = result->create_empty_row(); - // copy column values for (auto idx = 0; idx < result->columns_count(); idx++) { auto row_col_index = source_table_col_index[idx]; - if (row_col_index == -1) { // TODO introduce constant here - auto evaluated_value = eval_value_node(table, *row, node.cols_names->operator[]( - idx).value.get()); + if (row_col_index == FUNCTION_CALL) { + auto evaluated_value = eval_value_node(table, *row, node.cols_names->operator[](idx).value.get()); ValueNode *col_value = evaluated_value.get(); new_row.setColumnValue(&result_tbl_col_defs[idx], col_value); } else { - ColValue *col_value = row->ith_column(row_col_index); + ColValue &col_value = row->operator[](row_col_index); new_row.setColumnValue(&result_tbl_col_defs[idx], col_value); } } // add row to result - result->m_rows.push_back(new_row); + result->commit_row(new_row); } } - return std::move(result); + execute_distinct(node, result.get()); + + execute_order_by(node, table, result.get()); + + execute_offset_limit(node.offset_limit, result.get()); + + return result; +} + +void USql::execute_distinct(SelectFromTableNode &node, Table *result) { + if (!node.distinct) return; + + auto compare_rows = [](const Row &a, const Row &b) { return a.compare(b) >= 0; }; + std::sort(result->m_rows.begin(), result->m_rows.end(), compare_rows); + + result->m_rows.erase(std::unique(result->m_rows.begin(), result->m_rows.end()), result->m_rows.end()); +} + +void USql::execute_order_by(SelectFromTableNode &node, Table *table, Table *result) { + if (node.order_by.empty()) return; + + auto compare_rows = [&node, &result](const Row &a, const Row &b) { + for(const auto& order_by_col_def : node.order_by) { + // TODO validate index + ColDefNode col_def = result->get_column_def(order_by_col_def.col_index - 1); + ColValue &a_val = a[col_def.order]; + ColValue &b_val = b[col_def.order]; + + int compare = a_val.compare(b_val); + + if (compare < 0) return order_by_col_def.ascending; + if (compare > 0) return !order_by_col_def.ascending; + } + return false; + }; + + std::sort(result->m_rows.begin(), result->m_rows.end(), compare_rows); +} + +void USql::execute_offset_limit(OffsetLimitNode &node, Table *result) { + if (node.offset > 0) + result->m_rows.erase(result->m_rows.begin(), + result->rows_count() > node.offset ? result->m_rows.begin() + node.offset : result->m_rows.end()); + + if (node.limit > 0 && node.limit < result->rows_count()) + result->m_rows.erase(result->m_rows.begin() + node.limit, result->m_rows.end()); } std::tuple USql::get_column_definition(Table *table, SelectColNode *select_col_node, int col_order ) { - std::string new_col_name = select_col_node->name; + return get_node_definition(table, select_col_node->value.get(), select_col_node->name, col_order ); +} - if (select_col_node->value->node_type == NodeType::column_name) { - ColDefNode src_cdef = table->get_column_def(new_col_name); - ColDefNode cdef = ColDefNode{new_col_name, src_cdef.type, col_order, src_cdef.length, src_cdef.null}; - return std::make_tuple(src_cdef.order, cdef); +std::tuple USql::get_node_definition(Table *table, Node * node, const std::string & col_name, int col_order ) { + if (node->node_type == NodeType::database_value) { + auto dbval_node = static_cast(node); - } else if (select_col_node->value->node_type == NodeType::function) { - auto node = static_cast(select_col_node->value.get()); + ColDefNode src_col_def = table->get_column_def(dbval_node->col_name); + ColDefNode col_def = ColDefNode{col_name, src_col_def.type, col_order, src_col_def.length, src_col_def.null}; + return std::make_tuple(src_col_def.order, col_def); - if (node->function == "to_string") { - ColDefNode cdef = ColDefNode{new_col_name, ColumnType::varchar_type, col_order, 64, true}; - return std::make_tuple(-1, cdef); - } else if (node->function == "to_date") { - ColDefNode cdef = ColDefNode{new_col_name, ColumnType::integer_type, col_order, 1, true}; - return std::make_tuple(-1, cdef); + } else if (node->node_type == NodeType::function) { + auto func_node = static_cast(node); + + if (func_node->function == "to_string") { + ColDefNode col_def = ColDefNode{col_name, ColumnType::varchar_type, col_order, 32, true}; + return std::make_tuple(-1, col_def); + } else if (func_node->function == "to_date") { + ColDefNode col_def = ColDefNode{col_name, ColumnType::integer_type, col_order, 1, true}; + return std::make_tuple(-1, col_def); + } else if (func_node->function == "pp") { + ColDefNode col_def = ColDefNode{col_name, ColumnType::varchar_type, col_order, 10, true}; + return std::make_tuple(-1, col_def); } throw Exception("Unsupported function"); + + } else if (node->node_type == NodeType::arithmetical_operator) { + auto ari_node = static_cast(node); + + auto [left_col_index, left_tbl_col_def] = get_node_definition(table, ari_node->left.get(), col_name, col_order ); + auto [right_col_index, right_tbl_col_def] = get_node_definition(table, ari_node->right.get(), col_name, col_order ); + + ColumnType col_type; // TODO handle varchar and it len + if (left_tbl_col_def.type==ColumnType::float_type || right_tbl_col_def.type==ColumnType::float_type) + col_type = ColumnType::float_type; + else + col_type = ColumnType::integer_type; + + ColDefNode col_def = ColDefNode{col_name, col_type, col_order, 1, true}; + return std::make_tuple(-1, col_def); + + } else if (node->node_type == NodeType::logical_operator) { + ColDefNode col_def = ColDefNode{col_name, ColumnType::bool_type, col_order, 1, true}; + return std::make_tuple(-1, col_def); + + } else if (node->node_type == NodeType::int_value) { + ColDefNode col_def = ColDefNode{col_name, ColumnType::integer_type, col_order, 1, true}; + return std::make_tuple(-1, col_def); + + } else if (node->node_type == NodeType::float_value) { + ColDefNode col_def = ColDefNode{col_name, ColumnType::float_type, col_order, 1, true}; + return std::make_tuple(-1, col_def); + + } else if (node->node_type == NodeType::string_value) { + // TODO right len + ColDefNode col_def = ColDefNode{col_name, ColumnType::varchar_type, col_order, 64, true}; + return std::make_tuple(-1, col_def); } throw Exception("Unsupported node type"); } + std::unique_ptr
USql::execute_delete(DeleteFromTableNode &node) { // find source table Table *table = find_table(node.table_name); // execute access plan - int affected_rows = 0; - auto it = table->m_rows.begin(); - for (; it != table->m_rows.end();) { - if (eval_where(node.where.get(), table, *it)) { - it = table->m_rows.erase(it); - affected_rows++; - } else { - ++it; - } - } + auto affected_rows = table->rows_count(); + + table->m_rows.erase( + std::remove_if(table->m_rows.begin(), table->m_rows.end(), + [&node, table](Row &row){return eval_where(node.where.get(), table, row);}), + table->m_rows.end()); + + affected_rows -= table->rows_count(); return create_stmt_result_table(0, "delete succeeded", affected_rows); } @@ -250,12 +357,13 @@ std::unique_ptr
USql::execute_update(UpdateTableNode &node) { if (eval_where(node.where.get(), table, *row)) { int i = 0; for (const auto& col : node.cols_names) { - ColDefNode col_def = table->get_column_def(col.name); // TODO cache it like in select + // TODO cache it like in select + ColDefNode col_def = table->get_column_def(col.col_name); std::unique_ptr new_val = eval_arithmetic_operator(col_def.type, static_cast(*node.values[i]), table, *row); - table->validate_column(&col_def, new_val.get()); + usql::Table::validate_column(&col_def, new_val.get()); row->setColumnValue(&col_def, new_val.get()); i++; } @@ -268,8 +376,8 @@ std::unique_ptr
USql::execute_update(UpdateTableNode &node) { } -bool USql::eval_where(Node *where, Table *table, Row &row) const { - switch (where->node_type) { // no where clause +bool USql::eval_where(Node *where, Table *table, Row &row) { + switch (where->node_type) { case NodeType::true_node: return true; case NodeType::relational_operator: // just one condition @@ -284,22 +392,27 @@ bool USql::eval_where(Node *where, Table *table, Row &row) const { } -bool USql::eval_relational_operator(const RelationalOperatorNode &filter, Table *table, Row &row) const { +bool USql::eval_relational_operator(const RelationalOperatorNode &filter, Table *table, Row &row) { std::unique_ptr left_value = eval_value_node(table, row, filter.left.get()); std::unique_ptr right_value = eval_value_node(table, row, filter.right.get()); double comparator; if (left_value->node_type == NodeType::int_value && right_value->node_type == NodeType::int_value) { - comparator = left_value->getIntValue() - right_value->getIntValue(); + comparator = left_value->getIntegerValue() - right_value->getIntegerValue(); } else if ((left_value->node_type == NodeType::int_value && right_value->node_type == NodeType::float_value) || (left_value->node_type == NodeType::float_value && right_value->node_type == NodeType::int_value) || (left_value->node_type == NodeType::float_value && right_value->node_type == NodeType::float_value)) { comparator = left_value->getDoubleValue() - right_value->getDoubleValue(); } else if (left_value->node_type == NodeType::string_value || right_value->node_type == NodeType::string_value) { comparator = left_value->getStringValue().compare(right_value->getStringValue()); + } else if (left_value->node_type == NodeType::bool_value && right_value->node_type == NodeType::bool_value) { + bool bl = left_value->getBooleanValue(); + bool br = right_value->getBooleanValue(); + comparator = bl == br ? 0 : 1; + // date values are essentially int values so handled above } else { - // TODO throw exception + throw Exception("Undefined combination of types"); } switch (filter.op) { @@ -322,16 +435,16 @@ bool USql::eval_relational_operator(const RelationalOperatorNode &filter, Table std::unique_ptr USql::eval_value_node(Table *table, Row &row, Node *node) { - if (node->node_type == NodeType::database_value || node->node_type == NodeType::column_name) { // TODO sjednotit + if (node->node_type == NodeType::database_value) { return eval_database_value_node(table, row, node); - - } else if (node->node_type == NodeType::int_value || node->node_type == NodeType::float_value || node->node_type == NodeType::string_value) { + } else if (node->node_type == NodeType::int_value || node->node_type == NodeType::float_value || node->node_type == NodeType::string_value || node->node_type == NodeType::bool_value) { return eval_literal_value_node(table, row, node); - } else if (node->node_type == NodeType::function) { return eval_function_value_node(table, row, node); } else if (node->node_type == NodeType::null_value) { return std::make_unique(); + } else if (node->node_type == NodeType::arithmetical_operator) { + return eval_arithmetic_operator(ColumnType::float_type, static_cast(*node), table, row); } throw Exception("unsupported node type"); } @@ -340,17 +453,22 @@ std::unique_ptr USql::eval_value_node(Table *table, Row &row, Node *n std::unique_ptr USql::eval_database_value_node(Table *table, Row &row, Node *node) { auto *dvl = static_cast(node); ColDefNode col_def = table->get_column_def( dvl->col_name); // TODO optimize it to just get this def once - auto db_value = row.ith_column(col_def.order); + ColValue &db_value = row[col_def.order]; + + if (db_value.isNull()) + return std::make_unique(); + + if (col_def.type == ColumnType::integer_type) + return std::make_unique(db_value.getIntValue()); + if (col_def.type == ColumnType::float_type) + return std::make_unique(db_value.getDoubleValue()); + if (col_def.type == ColumnType::varchar_type) + return std::make_unique(db_value.getStringValue()); + if (col_def.type == ColumnType::bool_type) + return std::make_unique(db_value.getBoolValue()); + if (col_def.type == ColumnType::date_type) + return std::make_unique(db_value.getIntValue()); - if (col_def.type == ColumnType::integer_type) { - return std::make_unique(db_value->getIntValue()); - } - if (col_def.type == ColumnType::float_type) { - return std::make_unique(db_value->getDoubleValue()); - } - if (col_def.type == ColumnType::varchar_type) { - return std::make_unique(db_value->getStringValue()); - } throw Exception("unknown database value type"); } @@ -368,7 +486,11 @@ std::unique_ptr USql::eval_literal_value_node(Table *table, Row &row, auto *ivl = static_cast(node); return std::make_unique(ivl->value); + } else if (node->node_type == NodeType::bool_value) { + auto *ivl = static_cast(node); + return std::make_unique(ivl->value); } + // Date has no it's own value node (it is passed around as string) throw Exception("invalid type"); } @@ -382,6 +504,10 @@ std::unique_ptr USql::eval_function_value_node(Table *table, Row &row evaluatedPars.push_back(eval_value_node(table, row, param.get())); } + // at this moment no functions without parameter(s) or first param can be null + if (evaluatedPars.empty() || evaluatedPars[0]->isNull()) + return std::make_unique(); + // TODO use some enum if (fnc->function == "lower") { std::string str = evaluatedPars[0]->getStringValue(); @@ -398,31 +524,71 @@ std::unique_ptr USql::eval_function_value_node(Table *table, Row &row std::string date = evaluatedPars[0]->getStringValue(); std::string format = evaluatedPars[1]->getStringValue(); long epoch_time = string_to_date(date, format); - return std::make_unique(epoch_time); + return std::make_unique(epoch_time); // No DateValueNode for now } if (fnc->function == "to_string") { - long date = evaluatedPars[0]->getIntValue(); + long date = evaluatedPars[0]->getDateValue(); std::string format = evaluatedPars[1]->getStringValue(); - std::string formated_date = date_to_string(date, format); - return std::make_unique(formated_date); + std::string formatted_date = date_to_string(date, format); + return std::make_unique(formatted_date); } + if (fnc->function == "pp") { + auto &parsed_value = evaluatedPars[0]; + + if (parsed_value->node_type == NodeType::int_value || parsed_value->node_type == NodeType::float_value) { + std::string format = evaluatedPars.size() > 1 ? evaluatedPars[1]->getStringValue() : ""; + char buf[16] {0}; + double value = parsed_value->getDoubleValue(); + + if (format == "100%") + std::snprintf(buf, 20, "%.2f%%", value); + else if (value >= 1000000000000) + std::snprintf(buf, 20, "%7.2fT", value/1000000000000); + else if (value >= 1000000000) + std::sprintf(buf, "%7.2fB", value/1000000000); + else if (value >= 1000000) + std::snprintf(buf, 20, "%7.2fM", value/1000000); + else if (value >= 100000) + std::snprintf(buf, 20, "%7.2fM", value/100000); // 0.12M + else if (value <= -1000000000000) + std::snprintf(buf, 20, "%7.2fT", value/1000000000000); + else if (value <= -1000000000) + std::snprintf(buf, 20, "%7.2fB", value/1000000000); + else if (value <= -1000000) + std::snprintf(buf, 20, "%7.2fM", value/1000000); + else if (value <= -100000) + std::snprintf(buf, 20, "%7.2fM", value/100000); // 0.12M + else if (value == 0) + buf[0]='0'; + else + return std::make_unique(parsed_value->getStringValue().substr(0, 10)); + // TODO introduce constant for 10 + std::string s {buf}; + return std::make_unique(string_padd(s.erase(s.find_last_not_of(" ")+1), 10, ' ', false)); + } + + return std::make_unique(parsed_value->getStringValue()); + } + throw Exception("invalid function"); } -bool USql::eval_logical_operator(LogicalOperatorNode &node, Table *pTable, Row &row) const { - bool left = eval_relational_operator(static_cast(*node.left), pTable, row); +bool USql::eval_logical_operator(LogicalOperatorNode &node, Table *pTable, Row &row) { + //bool left = eval_relational_operator(static_cast(*node.left), pTable, row); + bool left = eval_where(&(*node.left), pTable, row); if ((node.op == LogicalOperatorType::and_operator && !left) || (node.op == LogicalOperatorType::or_operator && left)) return left; - bool right = eval_relational_operator(static_cast(*node.right), pTable, row); + //bool right = eval_relational_operator(static_cast(*node.right), pTable, row); + bool right = eval_where(&(*node.right), pTable, row); return right; } -std::unique_ptr USql::eval_arithmetic_operator(ColumnType outType, ArithmeticalOperatorNode &node, Table *table, Row &row) const { +std::unique_ptr USql::eval_arithmetic_operator(ColumnType outType, ArithmeticalOperatorNode &node, Table *table, Row &row) { if (node.op == ArithmeticalOperatorType::copy_value) { return eval_value_node(table, row, node.left.get()); } @@ -430,6 +596,9 @@ std::unique_ptr USql::eval_arithmetic_operator(ColumnType outType, Ar std::unique_ptr left = eval_value_node(table, row, node.left.get()); std::unique_ptr right = eval_value_node(table, row, node.right.get()); + if (left->isNull() || right->isNull()) + return std::make_unique(); + if (outType == ColumnType::float_type) { double l = ((ValueNode *) left.get())->getDoubleValue(); double r = ((ValueNode *) right.get())->getDoubleValue(); @@ -447,8 +616,8 @@ std::unique_ptr USql::eval_arithmetic_operator(ColumnType outType, Ar } } else if (outType == ColumnType::integer_type) { - long l = ((ValueNode *) left.get())->getIntValue(); - long r = ((ValueNode *) right.get())->getIntValue(); + long l = ((ValueNode *) left.get())->getIntegerValue(); + long r = ((ValueNode *) right.get())->getIntegerValue(); switch (node.op) { case ArithmeticalOperatorType::plus_operator: return std::make_unique(l + r); @@ -472,26 +641,27 @@ std::unique_ptr USql::eval_arithmetic_operator(ColumnType outType, Ar throw Exception("implement me!!"); } } + // TODO date node should support addition and subtraction throw Exception("implement me!!"); } -std::unique_ptr
USql::create_stmt_result_table(long code, const std::string &text, long affected_rows) { +std::unique_ptr
USql::create_stmt_result_table(long code, const std::string &text, size_t affected_rows) { std::vector result_tbl_col_defs{}; - result_tbl_col_defs.push_back(ColDefNode("code", ColumnType::integer_type, 0, 1, false)); - result_tbl_col_defs.push_back(ColDefNode("desc", ColumnType::varchar_type, 1, 255, false)); - result_tbl_col_defs.push_back(ColDefNode("affected_rows", ColumnType::integer_type, 0, 1, true)); + result_tbl_col_defs.emplace_back("code", ColumnType::integer_type, 0, 1, false); + result_tbl_col_defs.emplace_back("desc", ColumnType::varchar_type, 1, 48, false); + result_tbl_col_defs.emplace_back("affected_rows", ColumnType::integer_type, 0, 1, true); auto table_def = std::make_unique
("result", result_tbl_col_defs); - Row new_row = table_def->create_empty_row(); - new_row.setColumnValue(0, code); - new_row.setColumnValue(1, text); - new_row.setColumnValue(2, affected_rows); - table_def->add_row(new_row); + Row& new_row = table_def->create_empty_row(); + new_row.setIntColumnValue(0, code); + new_row.setStringColumnValue(1, text.size() <= 48 ? text : text.substr(0,48)); + new_row.setIntColumnValue(2, (long)affected_rows); + table_def->commit_row(new_row); - return std::move(table_def); + return table_def; } @@ -514,4 +684,5 @@ void USql::check_table_not_exists(const std::string &name) { } } -} // namespace \ No newline at end of file + +} // namespace diff --git a/usql/usql.h b/usql/usql.h index 3007014..cfda794 100644 --- a/usql/usql.h +++ b/usql/usql.h @@ -13,7 +13,6 @@ class USql { public: USql() = default; - std::unique_ptr
execute(const std::string &command); private: @@ -24,6 +23,8 @@ private: std::unique_ptr
execute_load(LoadIntoTableNode &node); std::unique_ptr
execute_save(SaveTableNode &node); std::unique_ptr
execute_drop(DropTableNode &node); + static std::unique_ptr
execute_set(SetNode &node); + static std::unique_ptr
execute_show(ShowNode &node); std::unique_ptr
execute_insert_into_table(InsertIntoTableNode &node); std::unique_ptr
execute_select(SelectFromTableNode &node); @@ -32,7 +33,7 @@ private: private: - bool eval_where(Node *where, Table *table, Row &row) const; + static bool eval_where(Node *where, Table *table, Row &row) ; static std::unique_ptr eval_value_node(Table *table, Row &row, Node *node); static std::unique_ptr eval_database_value_node(Table *table, Row &row, Node *node); @@ -40,13 +41,14 @@ private: static std::unique_ptr eval_function_value_node(Table *table, Row &row, Node *node); - bool eval_relational_operator(const RelationalOperatorNode &filter, Table *table, Row &row) const; - bool eval_logical_operator(LogicalOperatorNode &node, Table *pTable, Row &row) const; - std::unique_ptr eval_arithmetic_operator(ColumnType outType, ArithmeticalOperatorNode &node, Table *table, Row &row) const; + static bool eval_relational_operator(const RelationalOperatorNode &filter, Table *table, Row &row) ; + static bool eval_logical_operator(LogicalOperatorNode &node, Table *pTable, Row &row) ; + static std::unique_ptr eval_arithmetic_operator(ColumnType outType, ArithmeticalOperatorNode &node, Table *table, Row &row) ; - static std::unique_ptr
create_stmt_result_table(long code, const std::string &text, long affected_rows); + static std::unique_ptr
create_stmt_result_table(long code, const std::string &text, size_t affected_rows); static std::tuple get_column_definition(Table *table, SelectColNode *select_col_node, int col_order) ; + static std::tuple get_node_definition(Table *table, Node *select_col_node, const std::string & col_name, int col_order) ; Table *find_table(const std::string &name); void check_table_not_exists(const std::string &name); @@ -54,6 +56,10 @@ private: private: Parser m_parser; std::list
m_tables; + + static void execute_distinct(SelectFromTableNode &node, Table *result) ; + static void execute_order_by(SelectFromTableNode &node, Table *table, Table *result) ; + static void execute_offset_limit(OffsetLimitNode &node, Table *result) ; }; } // namespace \ No newline at end of file diff --git a/utils/local_install.sh b/utils/local_install.sh index cc911fc..4466385 100755 --- a/utils/local_install.sh +++ b/utils/local_install.sh @@ -1,7 +1,7 @@ #!/bin/sh gcc -std=c99 -c -O2 -o linenoise.o clib/linenoise.c -c++ -c -O2 -I/usr/local/opt/openssl/include -Iclib --std=c++17 ml.cpp ml_io.cpp ml_date.cpp ml_string.cpp ml_util.cpp ml_profiler.cpp ml_usql.cpp clib/json11.cpp clib/csvparser.cpp clib/sslclient.cpp clib/printf.cpp usql/exception.cpp usql/lexer.cpp usql/parser.cpp usql/usql.cpp usql/table.cpp usql/table.h usql/row.cpp usql/csvreader.cpp usql/usql.cpp +c++ -c -O2 -I/usr/local/opt/openssl/include -Iclib -I./ --std=c++17 ml.cpp ml_io.cpp ml_date.cpp ml_string.cpp ml_util.cpp ml_profiler.cpp ml_usql.cpp clib/json11.cpp clib/csvparser.cpp clib/sslclient.cpp clib/printf.cpp usql/exception.cpp usql/lexer.cpp usql/parser.cpp usql/usql.cpp usql/table.cpp usql/table.h usql/row.cpp usql/csvreader.cpp usql/usql.cpp usql/settings.cpp c++ -o ml -O2 -L/usr/local/lib -L/usr/local/opt/openssl/lib -lm -lstdc++ -lcrypto -lssl *.o cp stdlib/*.lsp /usr/local/var/mlisp/ diff --git a/utils/remote_install.sh b/utils/remote_install.sh index 3b40fc0..487dfda 100755 --- a/utils/remote_install.sh +++ b/utils/remote_install.sh @@ -24,7 +24,7 @@ fi echo "Building ml" ssh -p 5333 root@46.28.109.184 "cd /tmp/mlisp; gcc -std=c99 -c -O2 -o linenoise.o clib/linenoise.c" -ssh -p 5333 root@46.28.109.184 "cd /tmp/mlisp; c++ -c -O2 -I/usr/local/opt/openssl/include -Iclib --std=c++17 ml.cpp ml_io.cpp ml_date.cpp ml_string.cpp ml_util.cpp ml_profiler.cpp ml_usql.cpp clib/json11.cpp clib/csvparser.cpp clib/sslclient.cpp clib/printf.cpp usql/exception.cpp usql/lexer.cpp usql/parser.cpp usql/usql.cpp usql/table.cpp usql/table.h usql/row.cpp usql/csvreader.cpp usql/usql.cpp" +ssh -p 5333 root@46.28.109.184 "cd /tmp/mlisp; c++ -c -O2 -I/usr/local/opt/openssl/include -Iclib -I./ --std=c++17 ml.cpp ml_io.cpp ml_date.cpp ml_string.cpp ml_util.cpp ml_profiler.cpp ml_usql.cpp clib/json11.cpp clib/csvparser.cpp clib/sslclient.cpp clib/printf.cpp usql/exception.cpp usql/lexer.cpp usql/parser.cpp usql/usql.cpp usql/table.cpp usql/table.h usql/row.cpp usql/csvreader.cpp usql/usql.cpp usql/settings.cpp" ssh -p 5333 root@46.28.109.184 "cd /tmp/mlisp; c++ -o ml -O2 -L/usr/local/lib -L/usr/local/opt/openssl/lib -lm -lstdc++ -lcrypto -lssl *.o" diff --git a/utils/resetCLion.sh b/utils/resetCLion.sh new file mode 100644 index 0000000..75551f5 --- /dev/null +++ b/utils/resetCLion.sh @@ -0,0 +1,34 @@ +#!/bin/bash +#https://github.com/PythonicNinja/jetbrains-reset-trial-mac-osx/blob/master/runme.sh + +for product in CLion; do + echo "Closing $product" + ps aux | grep -i MacOs/$product | cut -d " " -f 5 | xargs kill -9 + + echo "Resetting trial period for $product" + + echo "removing evaluation key..." + rm -rf ~/Library/Preferences/$product*/eval + + # Above path not working on latest version. Fixed below + rm -rf ~/Library/Application\ Support/JetBrains/$product*/eval + + echo "removing all evlsprt properties in options.xml..." + sed -i '' '/evlsprt/d' ~/Library/Preferences/$product*/options/other.xml + + # Above path not working on latest version. Fixed below + sed -i '' '/evlsprt/d' ~/Library/Application\ Support/JetBrains/$product*/options/other.xml + + echo +done + +echo "removing additional plist files..." +rm -f ~/Library/Preferences/com.apple.java.util.prefs.plist +rm -f ~/Library/Preferences/com.jetbrains.*.plist +rm -f ~/Library/Preferences/jetbrains.*.*.plist + +echo "restarting cfprefsd" +killall cfprefsd + +echo +echo "That's it, enjoy ;)"