C / C++ / MFC Discussion Boards

Re: How can I pass macros with commas into other macros?

Richard MacCutchan1-Mar-17 8:57

1-Mar-17 8:57

You have defined it as PIN_DEF(PORT, PIN), so it requires two parameters. Either change the definition, or provide the second parameter. You could try

C++

#define PA0  (GPIOA, GPIO_PIN0)

Re: How can I pass macros with commas into other macros?

leon de boer1-Mar-17 16:44

leon de boer

1-Mar-17 16:44

The generic answer is you can use __VA_ARGS__ its used to pass variable arguments thru macros, something like this is generally how it used to feed a multi variable function

#define LOG_DEBUG(...)	printf(__VA_ARGS__)

For what you are doing you pass the arguments thru two macros the first take any number of variables the second macro enforces it is using just two values.

#define PA0  GPIOA, GPIO_PIN0
#define PIN_DEF_A(A, B) \
GPIO_TypeDef* PORT;          \
uint16_t      PIN;
#define PIN_DEF(...) PIN_DEFA(__VA_ARGS__)

Your code doesn't make a lot of sense to me because I can't see the types. I am guessing GPIO_TypeDef* is a volatile to a 16 bit port and what you are trying to do is MACRO the output of a 16 bit value which would usually look actually like this

 *((volatile uint16_t*) 0xXXXXXXXXX = 0x????;
// So something like this ... send 0x1234 to port 0x3F000000
*((volatile uint16_t*) 0x3F000000) = 0x1234;

Using the above macro form for that would be

#define PA0 0x3F000000,0x1234
#define PIN_DEFA(A, B) *((volatile uint16_t*) (A)) = (B)
#define PIN_DEF(...) PIN_DEFA(__VA_ARGS__)

//USING IT
PIN_DEF(PA0);   // This expands to *((volatile uint16_t*) 0x3F000000) = 0x1234;

In vino veritas

modified 2-Mar-17 8:27am.

sha code

Member 118556971-Mar-17 2:10

Member 11855697

1-Mar-17 2:10

How to include run a program on devc++ when i have my own .h file..i have my own headerfile, but when i run my main.cpp it says, no such file or directory

Re: sha code

Afzaal Ahmad Zeeshan1-Mar-17 2:21

Afzaal Ahmad Zeeshan

1-Mar-17 2:21

For the header files that are not shipped with compiler as library, you need to specify where to look for. The code for,

C++

#include "myheader.h"

Looks for in the same directory, or the directory of your project to find the header files. Remember, Dev C++ primarily is a port of GCC compiler, so every concept of GCC can be applied here similarly. GCC works fine with

C++

* projectdirectory
|- program.c
|- myheader.h

// Program
#include "myheader.h"

int main() {
   // Code here.
}

Also, remember that the "own headerfile" should not be written in angle brackets, they should be in quotations. For more on this please read,
http://stackoverflow.com/questions/257795/header-files-in-dev-c
http://gcc.gnu.org/onlinedocs/cpp/Search-Path.html#Search-Path

The sh*t I complain about
It's like there ain't a cloud in the sky and it's raining out - Eminem
~! Firewall !~

Re: sha code

Jochen Arndt1-Mar-17 2:40

Jochen Arndt

1-Mar-17 2:40

Please edit your question adding some more information (code snippet and indication where the error occurs, exact error message).

So I can only guess that you have something like

C++

// File main.cpp
#include "myheader.h"

int main()
{
    // some code
    return 0;
}

If the error is something like "myheader.h: No such file or directory" you have to tell the compiler which directories should be searched for include files.

Because Dev-C++ uses the GCC compiler, it can be done using the command line option -I.

I don't use Dev-C++ but a quick research shows that there is a project option to specifiy additional pathes at Project - Options - Directories - Include.

Re: sha code

David Crow1-Mar-17 4:16

David Crow

1-Mar-17 4:16

Member 11855697 wrote:
...but when i run my main.cpp it says, no such file or directory

What in the world is this supposed to mean? How do you run a .cpp file?

"One man's wage rise is another man's price increase." - Harold Wilson

"Fireproof doesn't mean the fire will never come. It means when the fire comes that you will be able to withstand it." - Michael Simmons

"You can easily judge the character of a man by how he treats those who can do nothing for him." - James D. Miles

RegGetValue and SHRegGetValue

ForNow28-Feb-17 16:04

ForNow

28-Feb-17 16:04

Hi
while moving my code over from VS 2012 Windows 8.1 to Windows 10 VS 2015

I got the following error

C++

error C3861: 'RegGetValue': identifier not found

I have included WinReg.h yet intellisense points me to SHRegGetValue

Re: RegGetValue and SHRegGetValue

Richard MacCutchan28-Feb-17 21:37

Richard MacCutchan

28-Feb-17 21:37

Have you looked at Winreg.h to check that it is defined in there, and also not excluded by some #define block?

Re: RegGetValue and SHRegGetValue

Randor 7-Mar-17 10:31

Randor

7-Mar-17 10:31

ForNow wrote:
I have included WinReg.h yet intellisense points me to SHRegGetValue

define _WIN32_WINNT as 0x0600 or later.

Reading from a file in C++ Windows Application Forms

Member 1300044128-Feb-17 3:59

Member 13000441

28-Feb-17 3:59

Hello,

I am working on a windows Forms Application (C++) Programm in Visual Studio 2015.
I have figured out how to open a file. And read from it.
But what I can't figure out is how to only read the second line or the second row from my file (.cvs file).

What I am looking for is the syntax to use instead of RealAllText.
I looked up the Objectkatalog. But I can't get "ReadLine" to work.
My code is posted below.

I really hope someone can help me Smile | :)

Kind regards

private: System::Void button6_Click_1(System::Object^ sender, System::EventArgs^ e) {
Stream^ myStream;
OpenFileDialog^ openFileDialog1 = gcnew OpenFileDialog;

if (openFileDialog1->ShowDialog() == System::Windows::Forms::DialogResult::OK)
{
if( (myStream = openFileDialog1->OpenFile()) != nullptr )
{
String^ strfilename = openFileDialog1->InitialDirectory + openFileDialog1->FileName;
String^ Readfile = File::ReadAllText(strfilename);

Malz4->Text = Readfile;

myStream->Close();
}

}

Re: Reading from a file in C++ Windows Application Forms

Richard MacCutchan28-Feb-17 6:27

Richard MacCutchan

28-Feb-17 6:27

Use File.ReadAllLines Method (String) (System.IO)[^] which returns an array of strings. The string at index offset 1 is the second line of the file.

Re: Reading from a file in C++ Windows Application Forms

Member 1300044128-Feb-17 9:15

Member 13000441

28-Feb-17 9:15

Hey, thanks for your help but I still can't get my code to work.
I typed in your suggestion but maybe I am doing a sytax error?
I am a beginner so that might be the case Confused | :confused:

haha

And how would I get the second column out?

Re: Reading from a file in C++ Windows Application Forms

Richard MacCutchan28-Feb-17 21:27

Richard MacCutchan

28-Feb-17 21:27

Without seeing your code it is impossible to comment.

Re: Reading from a file in C++ Windows Application Forms

David Crow28-Feb-17 6:31

David Crow

28-Feb-17 6:31

If ReadAllText() returns a sequence, could you then call First() twice on that sequence?

Bitmap for dialog background questions

frqftgbdafr27-Feb-17 13:25

frqftgbdafr

27-Feb-17 13:25

I am using a bitmap for a dialog background, which works fine.
I am also doing some GDI drawing on top of the bitmap.
The problem is updating the GDI drawing causes the bitmap to blink. On a slower computer this may be a major annoyance.
The bitmap is loaded in the OnPaint() message handler, where the GDI drawing is also performed and updated.
I have tried loading the bitmap image only once, but when the GDI drawing is updated, the bitmap background is erased and not replaced.
Is it possible to load the bitmap once, and not have it erased in OnPaint() when the GDI drawing is updated?

Re: Bitmap for dialog background questions

_Flaviu27-Feb-17 20:21

_Flaviu

27-Feb-17 20:21

Have you tried to not call default OnEraseBackground ?
Something like that:

BOOL CYourDlg::OnEraseBkgnd(CDC* pDC) 
{
   return TRUE;
// return CDialog::OnEraseBkgnd(pDC);
}

Re: Bitmap for dialog background questions

frqftgbdafr28-Feb-17 2:06

frqftgbdafr

28-Feb-17 2:06

Yes, I found that in a book last night, and it works! Thank you

Ribbon UI, wrong ordering of ribbon elements ?

Maximilien27-Feb-17 8:02

Maximilien

27-Feb-17 8:02

I am trying to order a set of buttons in a ribbon bar.

The code below should create a ribbon with the layout (sorry bad paint drawing)

See expected layout : Ribbon Layout - Album on Imgur

But I get this : Ribbon Layout - Album on Imgur

Where the 3 buttons (zoom window, zoom in and zoom out) are placed on the right of the gallery.

I am not certain what I do wrong here, everything looks nicely coded !

Any insights, help, hints or tips ?

m_wndRibbonBar.Create(this);

CMFCRibbonCategory* category = m_wndRibbonBar.AddCategory(_TEXT("Test"), ITB_HOME_CATEGORY_16X16, ITB_HOME_CATEGORY_32X32 );

CMFCRibbonPanel* panel = category->AddPanel(_TEXT("Stuff"));

panel->Add(new CMFCRibbonButton(IDM_VIEW_ZOOM_ALL, _T("Zoom All"), 0, 0, FALSE));

panel->AddSeparator();

panel->Add(new CMFCRibbonButton(IDM_VIEW_ZOOM_WINDOW, _T("Zoom Window"), 1, -1, FALSE));
panel->Add(new CMFCRibbonButton(IDM_VIEW_ZOOM_IN, _T("Zoom In"), 26, -1, FALSE));
panel->Add(new CMFCRibbonButton(IDM_VIEW_ZOOM_OUT, _T("Zoom Out"), 27, -1, FALSE));

panel->AddSeparator();

CMFCRibbonGallery* viewRibbonGallery = new CMFCRibbonGallery(ID_HOME_VIEWS_RIBBON_BUTTON, _T("Views"), 7, 1, IDB_HOME_VIEWS_PALETTE_32X32, 32);
panel->Add(viewRibbonGallery);
panel->AddSeparator();

// shaded... 
CMFCRibbonButtonsGroup* viewTypeGroup = new CMFCRibbonButtonsGroup;
viewTypeGroup->AddButton(new CMFCRibbonButton(IDM_VIEW_MODE_NORMAL, _TEXT("Normal"), 20, FALSE));
viewTypeGroup->AddButton(new CMFCRibbonButton(IDM_VIEW_MODE_SHADED, _TEXT("Shaded"), 21, FALSE));
viewTypeGroup->AddButton(new CMFCRibbonButton(IDM_VIEW_MODE_WIREFRAME, _TEXT("Wireframe"), 22, FALSE));
panel->Add(viewTypeGroup);

CMFCRibbonButtonsGroup* wireFrameTypeGroup = new CMFCRibbonButtonsGroup;
wireFrameTypeGroup->AddButton(new CMFCRibbonButton(IDM_VIEW_WIREFRAME_BOUNDARY, _TEXT("Boundary"), 23, FALSE));
wireFrameTypeGroup->AddButton(new CMFCRibbonButton(IDM_VIEW_WIREFRAME_ISOLINE, _TEXT("Isoline"), 24, FALSE));
wireFrameTypeGroup->AddButton(new CMFCRibbonButton(IDM_VIEW_WIREFRAME_MESH, _TEXT("Mesh"), 25, FALSE));
panel->Add(wireFrameTypeGroup);

I'd rather be phishing!

Visual c++ android app development

Cwash26-Feb-17 23:37

Cwash

26-Feb-17 23:37

Hi everyone,
I have worked with basic knowledge of C++. I am struggling to understand how to develop an android app with the Visual C++ platform.I have installed all necessary software yet the sample codes look different from what I have learned. I really need advice, reference sheets or any related stuff that would help me on this path. Thank you.

Re: Visual c++ android app development

Richard MacCutchan27-Feb-17 0:26

Richard MacCutchan

27-Feb-17 0:26

Cwash wrote:
eference sheets or any related stuff

Google is the tool that will find such information for you.[^].

Boost Spirit: Parse an int into a string.

Maximilien21-Feb-17 2:54

Maximilien

21-Feb-17 2:54

I am trying to parse an expression like this:

F( 1, 2, 3)

and extract 1, 2 and 3 as a strings.

My test grammar and program parse properly, but the output is not "nice",

In the start, limit and increment variable contain strings like "\x1", "\x2" and "\x3"

This is part of my grammar. (the pre tag does not work "good" here)

I also tried to read the numerical value as an int and use a boost::variant to hold either an int or std:wstring, but that did not work.

Any thoughts, hints or tips ?

Thanks.

More friendly code here http://pastebin.com/2mmK9gns

struct RangeResult
{
    std::wstring start;
    std::wstring limit;
    std::wstring increment;
};

BOOST_FUSION_ADAPT_STRUCT(
    RangeGrammar::RangeResult,
    (std::wstring, start)
    (std::wstring, limit)
    (std::wstring, increment)
)

template <typename Iterator>
struct range_parser : boost::spirit::qi::grammar<Iterator, RangeResult(), iso8859_1::space_type>
{
    range_parser() : range_parser::base_type(start)
    {
            using qi::lit;
            using qi::lexeme;
            using qi::int_;
            using iso8859_1::char_;
            using iso8859_1::digit;

            variable_string %= lexeme["$(" >> +(char_ - ")") >> ")"];

            node = (int_ | variable_string);

            start %=
                lit("_RANGE")

<blockquote class="quote">
  <blockquote class="quote">
    '('
    node >> ',' >> node >> ',' >> node
    ")_"
                    ;
  </blockquote>
</blockquote>

            debug(variable_string);
            debug(start);

        }

        qi::rule<Iterator, std::wstring(), iso8859_1::space_type> variable_string;
        qi::rule<Iterator, std::wstring(), iso8859_1::space_type> node;
        qi::rule<Iterator, RangeResult(), iso8859_1::space_type> start;

};

My test program:

C++

void TestRangeGrammar()
{
    using boost::spirit::iso8859_1::space;
    typedef std::wstring::const_iterator iterator_type;
    typedef RangeGrammar::range_parser<iterator_type> range_parser;

<pre>
range_parser grammar; // Our grammar

std::array< std::wstring, 1 > testStrings =
{{
        _TEXT("_RANGE(1, 2, 3 )_")
}};

for (auto str : testStrings)

{
std::wstring::const_iterator iter = str.begin();
std::wstring::const_iterator end = str.end();

RangeGrammar::RangeResult emp;

bool r = phrase_parse(iter, end, grammar, space, emp);
if (r)
{
std::wcout << _TEXT("-------------------------\n");
std::wcout << _TEXT("Range Parsing succeeded\n");
std::wcout << _TEXT("Start: ") << emp.start << std::endl;
std::wcout << _TEXT("Start: ") << emp.limit << std::endl;
std::wcout << _TEXT("Start: ") << emp.increment << std::endl;
std::wcout << _TEXT("\n-------------------------\n");
}
else
{
std::wcout << _TEXT("-------------------------\n");
std::wcout << _TEXT("Range Parsing failed\n");
std::wcout << str << std::endl;
std::wcout << _TEXT("-------------------------\n");
}
}
}

I'd rather be phishing!

AES 128 block cipher problem running

Member 1300542516-Feb-17 19:27

Member 13005425

16-Feb-17 19:27

Hi, I'm still a beginner in coding, I need block cipher source code for my research paper where I need to get the run time for mode of operation, I already find a lot of source code but none of it seems working, example the crypto++ . I don't even know how to set it up. if anyone could help me at least on how to run the crypto++ . and fyi im using a quad core processor laptop, windows 10 and visual studio 2015. :((  :((  :((

this is the crypto++ I downloaded

Re: AES 128 block cipher problem running

CPallini16-Feb-17 20:55

CPallini

16-Feb-17 20:55

You could use Microsoft Crypto API. They provide documentation and examples: Using Cryptography (Windows)[^].

Re: AES 128 block cipher problem running

Razvan Cristian28-Feb-17 7:25

Razvan Cristian

28-Feb-17 7:25

Hi here you go:

The header file, aes.h:

C++

#ifndef AES_H
#define AES_H

#include <vector>
#include <iostream>

using namespace std;

class aes
{
public:
	aes(vector<unsigned char>& , vector<unsigned char>&, unsigned int);
	~aes();
	vector<unsigned char> encrypt();
	vector<unsigned char> dencrypt();
private:
	bool debugg = false;
	vector<unsigned char> str_key;
	vector<vector<unsigned char> > KEY;
	vector<vector<unsigned char> > KEY_SCHEDULE;
	vector<unsigned char> str_io;
	vector<vector<unsigned char> > INPUT, OUTPUT;
	unsigned int KEY_LENGHT;
	unsigned int ROUNDS;
	unsigned int GROUP_SIZE;
	unsigned int BLOCK_SIZE = 16;


	//variabile
	static const unsigned char sbox[256];
	static const unsigned char isbox[256];
	static const unsigned char srcon[256];
	static const unsigned char by_2[256];
	static const unsigned char by_3[256];
	static const unsigned char by_9[256];
	static const unsigned char by_11[256];
	static const unsigned char by_13[256];
	static const unsigned char by_14[256];

	//functii
	void getKeyFromString(vector<unsigned char>&);
	void gen_key_schedule(vector<vector<unsigned char> >&);
	vector<unsigned char> x_xor(vector<unsigned char>, vector<unsigned char>);
	vector<unsigned char> g(vector<unsigned char>&, unsigned int);
	void subytes(vector<vector<unsigned char> >&);
	void isubytes(vector<vector<unsigned char> >&);
	vector<unsigned char> subytesWord(vector<unsigned char>&);
	void debug(vector<vector<unsigned char> >&);

	void dgetInputFromString(vector<unsigned char>&);
	vector<vector<unsigned char> > beginEcryptForBlock(vector<vector<unsigned char> >&);//beginDEcryptForBlock
	vector<vector<unsigned char> > beginDEcryptForBlock(vector<vector<unsigned char> >&);
	void addRound(vector<vector<unsigned char> >&, vector<vector<unsigned char> >&);
	void getWFrmKeySched(unsigned int, vector<vector<unsigned char> >&);
	void shiftRows(vector<vector<unsigned char> >&, vector<unsigned char>&, vector<unsigned char>&, vector<unsigned char>&);
	void ishiftRows(vector<vector<unsigned char> >&, vector<unsigned char>& , vector<unsigned char>& , vector<unsigned char>& );
	void mixCol(vector<vector<unsigned char> >&);
	void imixCol(vector<vector<unsigned char> >&);
	unsigned int getNextByte(unsigned int, unsigned int);
	void populateVector4x4(vector<vector<unsigned char> >&);
};



#endif // AES_H

The cpp file , aes.cpp:

C++

#include "aes.h"
#include <vector>
#include <iostream>
#include <iomanip>

using namespace std;

const unsigned char aes::sbox[256] = {
	/* 0     1     2     3     4     5     6     7     8     9     a     b     c     d     e     f */
	/*0*/  0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
	/*1*/  0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
	/*2*/  0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
	/*3*/  0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
	/*4*/  0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
	/*5*/  0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
	/*6*/  0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
	/*7*/  0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
	/*8*/  0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
	/*9*/  0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
	/*a*/  0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
	/*b*/  0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
	/*c*/  0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
	/*d*/  0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
	/*e*/  0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
	/*f*/  0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 };

const unsigned char aes::isbox[256] = {
	/* 0     1     2     3     4     5     6     7     8     9     a     b     c     d     e     f */
	/*0*/  0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,
	/*1*/  0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,
	/*2*/  0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,
	/*3*/  0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25,
	/*4*/  0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92,
	/*5*/  0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,
	/*6*/  0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06,
	/*7*/  0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b,
	/*8*/  0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,
	/*9*/  0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e,
	/*a*/  0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b,
	/*b*/  0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,
	/*c*/  0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f,
	/*d*/  0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,
	/*e*/  0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
	/*f*/  0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d };

const unsigned char aes::srcon[256] = {
	0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a,
	0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72,
	0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a,
	0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8,
	0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef,
	0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc,
	0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b,
	0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3,
	0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94,
	0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20,
	0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35,
	0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f,
	0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04,
	0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63,
	0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd,
	0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d };

const unsigned char aes::by_2[256] = {
	0x00, 0x02, 0x04, 0x06, 0x08, 0x0a, 0x0c, 0x0e, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e,
	0x20, 0x22, 0x24, 0x26, 0x28, 0x2a, 0x2c, 0x2e, 0x30, 0x32, 0x34, 0x36, 0x38, 0x3a, 0x3c, 0x3e,
	0x40, 0x42, 0x44, 0x46, 0x48, 0x4a, 0x4c, 0x4e, 0x50, 0x52, 0x54, 0x56, 0x58, 0x5a, 0x5c, 0x5e,
	0x60, 0x62, 0x64, 0x66, 0x68, 0x6a, 0x6c, 0x6e, 0x70, 0x72, 0x74, 0x76, 0x78, 0x7a, 0x7c, 0x7e,
	0x80, 0x82, 0x84, 0x86, 0x88, 0x8a, 0x8c, 0x8e, 0x90, 0x92, 0x94, 0x96, 0x98, 0x9a, 0x9c, 0x9e,
	0xa0, 0xa2, 0xa4, 0xa6, 0xa8, 0xaa, 0xac, 0xae, 0xb0, 0xb2, 0xb4, 0xb6, 0xb8, 0xba, 0xbc, 0xbe,
	0xc0, 0xc2, 0xc4, 0xc6, 0xc8, 0xca, 0xcc, 0xce, 0xd0, 0xd2, 0xd4, 0xd6, 0xd8, 0xda, 0xdc, 0xde,
	0xe0, 0xe2, 0xe4, 0xe6, 0xe8, 0xea, 0xec, 0xee, 0xf0, 0xf2, 0xf4, 0xf6, 0xf8, 0xfa, 0xfc, 0xfe,
	0x1b, 0x19, 0x1f, 0x1d, 0x13, 0x11, 0x17, 0x15, 0x0b, 0x09, 0x0f, 0x0d, 0x03, 0x01, 0x07, 0x05,
	0x3b, 0x39, 0x3f, 0x3d, 0x33, 0x31, 0x37, 0x35, 0x2b, 0x29, 0x2f, 0x2d, 0x23, 0x21, 0x27, 0x25,
	0x5b, 0x59, 0x5f, 0x5d, 0x53, 0x51, 0x57, 0x55, 0x4b, 0x49, 0x4f, 0x4d, 0x43, 0x41, 0x47, 0x45,
	0x7b, 0x79, 0x7f, 0x7d, 0x73, 0x71, 0x77, 0x75, 0x6b, 0x69, 0x6f, 0x6d, 0x63, 0x61, 0x67, 0x65,
	0x9b, 0x99, 0x9f, 0x9d, 0x93, 0x91, 0x97, 0x95, 0x8b, 0x89, 0x8f, 0x8d, 0x83, 0x81, 0x87, 0x85,
	0xbb, 0xb9, 0xbf, 0xbd, 0xb3, 0xb1, 0xb7, 0xb5, 0xab, 0xa9, 0xaf, 0xad, 0xa3, 0xa1, 0xa7, 0xa5,
	0xdb, 0xd9, 0xdf, 0xdd, 0xd3, 0xd1, 0xd7, 0xd5, 0xcb, 0xc9, 0xcf, 0xcd, 0xc3, 0xc1, 0xc7, 0xc5,
	0xfb, 0xf9, 0xff, 0xfd, 0xf3, 0xf1, 0xf7, 0xf5, 0xeb, 0xe9, 0xef, 0xed, 0xe3, 0xe1, 0xe7, 0xe5 };

const unsigned char aes::by_3[256] = {
	0x00, 0x03, 0x06, 0x05, 0x0c, 0x0f, 0x0a, 0x09, 0x18, 0x1b, 0x1e, 0x1d, 0x14, 0x17, 0x12, 0x11,
	0x30, 0x33, 0x36, 0x35, 0x3c, 0x3f, 0x3a, 0x39, 0x28, 0x2b, 0x2e, 0x2d, 0x24, 0x27, 0x22, 0x21,
	0x60, 0x63, 0x66, 0x65, 0x6c, 0x6f, 0x6a, 0x69, 0x78, 0x7b, 0x7e, 0x7d, 0x74, 0x77, 0x72, 0x71,
	0x50, 0x53, 0x56, 0x55, 0x5c, 0x5f, 0x5a, 0x59, 0x48, 0x4b, 0x4e, 0x4d, 0x44, 0x47, 0x42, 0x41,
	0xc0, 0xc3, 0xc6, 0xc5, 0xcc, 0xcf, 0xca, 0xc9, 0xd8, 0xdb, 0xde, 0xdd, 0xd4, 0xd7, 0xd2, 0xd1,
	0xf0, 0xf3, 0xf6, 0xf5, 0xfc, 0xff, 0xfa, 0xf9, 0xe8, 0xeb, 0xee, 0xed, 0xe4, 0xe7, 0xe2, 0xe1,
	0xa0, 0xa3, 0xa6, 0xa5, 0xac, 0xaf, 0xaa, 0xa9, 0xb8, 0xbb, 0xbe, 0xbd, 0xb4, 0xb7, 0xb2, 0xb1,
	0x90, 0x93, 0x96, 0x95, 0x9c, 0x9f, 0x9a, 0x99, 0x88, 0x8b, 0x8e, 0x8d, 0x84, 0x87, 0x82, 0x81,
	0x9b, 0x98, 0x9d, 0x9e, 0x97, 0x94, 0x91, 0x92, 0x83, 0x80, 0x85, 0x86, 0x8f, 0x8c, 0x89, 0x8a,
	0xab, 0xa8, 0xad, 0xae, 0xa7, 0xa4, 0xa1, 0xa2, 0xb3, 0xb0, 0xb5, 0xb6, 0xbf, 0xbc, 0xb9, 0xba,
	0xfb, 0xf8, 0xfd, 0xfe, 0xf7, 0xf4, 0xf1, 0xf2, 0xe3, 0xe0, 0xe5, 0xe6, 0xef, 0xec, 0xe9, 0xea,
	0xcb, 0xc8, 0xcd, 0xce, 0xc7, 0xc4, 0xc1, 0xc2, 0xd3, 0xd0, 0xd5, 0xd6, 0xdf, 0xdc, 0xd9, 0xda,
	0x5b, 0x58, 0x5d, 0x5e, 0x57, 0x54, 0x51, 0x52, 0x43, 0x40, 0x45, 0x46, 0x4f, 0x4c, 0x49, 0x4a,
	0x6b, 0x68, 0x6d, 0x6e, 0x67, 0x64, 0x61, 0x62, 0x73, 0x70, 0x75, 0x76, 0x7f, 0x7c, 0x79, 0x7a,
	0x3b, 0x38, 0x3d, 0x3e, 0x37, 0x34, 0x31, 0x32, 0x23, 0x20, 0x25, 0x26, 0x2f, 0x2c, 0x29, 0x2a,
	0x0b, 0x08, 0x0d, 0x0e, 0x07, 0x04, 0x01, 0x02, 0x13, 0x10, 0x15, 0x16, 0x1f, 0x1c, 0x19, 0x1a};

const unsigned char aes::by_9[256] = {
	0x00, 0x09, 0x12, 0x1b, 0x24, 0x2d, 0x36, 0x3f, 0x48, 0x41, 0x5a, 0x53, 0x6c, 0x65, 0x7e, 0x77,
	0x90, 0x99, 0x82, 0x8b, 0xb4, 0xbd, 0xa6, 0xaf, 0xd8, 0xd1, 0xca, 0xc3, 0xfc, 0xf5, 0xee, 0xe7,
	0x3b, 0x32, 0x29, 0x20, 0x1f, 0x16, 0x0d, 0x04, 0x73, 0x7a, 0x61, 0x68, 0x57, 0x5e, 0x45, 0x4c,
	0xab, 0xa2, 0xb9, 0xb0, 0x8f, 0x86, 0x9d, 0x94, 0xe3, 0xea, 0xf1, 0xf8, 0xc7, 0xce, 0xd5, 0xdc,
	0x76, 0x7f, 0x64, 0x6d, 0x52, 0x5b, 0x40, 0x49, 0x3e, 0x37, 0x2c, 0x25, 0x1a, 0x13, 0x08, 0x01,
	0xe6, 0xef, 0xf4, 0xfd, 0xc2, 0xcb, 0xd0, 0xd9, 0xae, 0xa7, 0xbc, 0xb5, 0x8a, 0x83, 0x98, 0x91,
	0x4d, 0x44, 0x5f, 0x56, 0x69, 0x60, 0x7b, 0x72, 0x05, 0x0c, 0x17, 0x1e, 0x21, 0x28, 0x33, 0x3a,
	0xdd, 0xd4, 0xcf, 0xc6, 0xf9, 0xf0, 0xeb, 0xe2, 0x95, 0x9c, 0x87, 0x8e, 0xb1, 0xb8, 0xa3, 0xaa,
	0xec, 0xe5, 0xfe, 0xf7, 0xc8, 0xc1, 0xda, 0xd3, 0xa4, 0xad, 0xb6, 0xbf, 0x80, 0x89, 0x92, 0x9b,
	0x7c, 0x75, 0x6e, 0x67, 0x58, 0x51, 0x4a, 0x43, 0x34, 0x3d, 0x26, 0x2f, 0x10, 0x19, 0x02, 0x0b,
	0xd7, 0xde, 0xc5, 0xcc, 0xf3, 0xfa, 0xe1, 0xe8, 0x9f, 0x96, 0x8d, 0x84, 0xbb, 0xb2, 0xa9, 0xa0,
	0x47, 0x4e, 0x55, 0x5c, 0x63, 0x6a, 0x71, 0x78, 0x0f, 0x06, 0x1d, 0x14, 0x2b, 0x22, 0x39, 0x30,
	0x9a, 0x93, 0x88, 0x81, 0xbe, 0xb7, 0xac, 0xa5, 0xd2, 0xdb, 0xc0, 0xc9, 0xf6, 0xff, 0xe4, 0xed,
	0x0a, 0x03, 0x18, 0x11, 0x2e, 0x27, 0x3c, 0x35, 0x42, 0x4b, 0x50, 0x59, 0x66, 0x6f, 0x74, 0x7d,
	0xa1, 0xa8, 0xb3, 0xba, 0x85, 0x8c, 0x97, 0x9e, 0xe9, 0xe0, 0xfb, 0xf2, 0xcd, 0xc4, 0xdf, 0xd6,
	0x31, 0x38, 0x23, 0x2a, 0x15, 0x1c, 0x07, 0x0e, 0x79, 0x70, 0x6b, 0x62, 0x5d, 0x54, 0x4f, 0x46};

const unsigned char aes::by_11[256] = {
	0x00, 0x0b, 0x16, 0x1d, 0x2c, 0x27, 0x3a, 0x31, 0x58, 0x53, 0x4e, 0x45, 0x74, 0x7f, 0x62, 0x69,
	0xb0, 0xbb, 0xa6, 0xad, 0x9c, 0x97, 0x8a, 0x81, 0xe8, 0xe3, 0xfe, 0xf5, 0xc4, 0xcf, 0xd2, 0xd9,
	0x7b, 0x70, 0x6d, 0x66, 0x57, 0x5c, 0x41, 0x4a, 0x23, 0x28, 0x35, 0x3e, 0x0f, 0x04, 0x19, 0x12,
	0xcb, 0xc0, 0xdd, 0xd6, 0xe7, 0xec, 0xf1, 0xfa, 0x93, 0x98, 0x85, 0x8e, 0xbf, 0xb4, 0xa9, 0xa2,
	0xf6, 0xfd, 0xe0, 0xeb, 0xda, 0xd1, 0xcc, 0xc7, 0xae, 0xa5, 0xb8, 0xb3, 0x82, 0x89, 0x94, 0x9f,
	0x46, 0x4d, 0x50, 0x5b, 0x6a, 0x61, 0x7c, 0x77, 0x1e, 0x15, 0x08, 0x03, 0x32, 0x39, 0x24, 0x2f,
	0x8d, 0x86, 0x9b, 0x90, 0xa1, 0xaa, 0xb7, 0xbc, 0xd5, 0xde, 0xc3, 0xc8, 0xf9, 0xf2, 0xef, 0xe4,
	0x3d, 0x36, 0x2b, 0x20, 0x11, 0x1a, 0x07, 0x0c, 0x65, 0x6e, 0x73, 0x78, 0x49, 0x42, 0x5f, 0x54,
	0xf7, 0xfc, 0xe1, 0xea, 0xdb, 0xd0, 0xcd, 0xc6, 0xaf, 0xa4, 0xb9, 0xb2, 0x83, 0x88, 0x95, 0x9e,
	0x47, 0x4c, 0x51, 0x5a, 0x6b, 0x60, 0x7d, 0x76, 0x1f, 0x14, 0x09, 0x02, 0x33, 0x38, 0x25, 0x2e,
	0x8c, 0x87, 0x9a, 0x91, 0xa0, 0xab, 0xb6, 0xbd, 0xd4, 0xdf, 0xc2, 0xc9, 0xf8, 0xf3, 0xee, 0xe5,
	0x3c, 0x37, 0x2a, 0x21, 0x10, 0x1b, 0x06, 0x0d, 0x64, 0x6f, 0x72, 0x79, 0x48, 0x43, 0x5e, 0x55,
	0x01, 0x0a, 0x17, 0x1c, 0x2d, 0x26, 0x3b, 0x30, 0x59, 0x52, 0x4f, 0x44, 0x75, 0x7e, 0x63, 0x68,
	0xb1, 0xba, 0xa7, 0xac, 0x9d, 0x96, 0x8b, 0x80, 0xe9, 0xe2, 0xff, 0xf4, 0xc5, 0xce, 0xd3, 0xd8,
	0x7a, 0x71, 0x6c, 0x67, 0x56, 0x5d, 0x40, 0x4b, 0x22, 0x29, 0x34, 0x3f, 0x0e, 0x05, 0x18, 0x13,
	0xca, 0xc1, 0xdc, 0xd7, 0xe6, 0xed, 0xf0, 0xfb, 0x92, 0x99, 0x84, 0x8f, 0xbe, 0xb5, 0xa8, 0xa3};

const unsigned char aes::by_13[256] = {
	0x00, 0x0d, 0x1a, 0x17, 0x34, 0x39, 0x2e, 0x23, 0x68, 0x65, 0x72, 0x7f, 0x5c, 0x51, 0x46, 0x4b,
	0xd0, 0xdd, 0xca, 0xc7, 0xe4, 0xe9, 0xfe, 0xf3, 0xb8, 0xb5, 0xa2, 0xaf, 0x8c, 0x81, 0x96, 0x9b,
	0xbb, 0xb6, 0xa1, 0xac, 0x8f, 0x82, 0x95, 0x98, 0xd3, 0xde, 0xc9, 0xc4, 0xe7, 0xea, 0xfd, 0xf0,
	0x6b, 0x66, 0x71, 0x7c, 0x5f, 0x52, 0x45, 0x48, 0x03, 0x0e, 0x19, 0x14, 0x37, 0x3a, 0x2d, 0x20,
	0x6d, 0x60, 0x77, 0x7a, 0x59, 0x54, 0x43, 0x4e, 0x05, 0x08, 0x1f, 0x12, 0x31, 0x3c, 0x2b, 0x26,
	0xbd, 0xb0, 0xa7, 0xaa, 0x89, 0x84, 0x93, 0x9e, 0xd5, 0xd8, 0xcf, 0xc2, 0xe1, 0xec, 0xfb, 0xf6,
	0xd6, 0xdb, 0xcc, 0xc1, 0xe2, 0xef, 0xf8, 0xf5, 0xbe, 0xb3, 0xa4, 0xa9, 0x8a, 0x87, 0x90, 0x9d,
	0x06, 0x0b, 0x1c, 0x11, 0x32, 0x3f, 0x28, 0x25, 0x6e, 0x63, 0x74, 0x79, 0x5a, 0x57, 0x40, 0x4d,
	0xda, 0xd7, 0xc0, 0xcd, 0xee, 0xe3, 0xf4, 0xf9, 0xb2, 0xbf, 0xa8, 0xa5, 0x86, 0x8b, 0x9c, 0x91,
	0x0a, 0x07, 0x10, 0x1d, 0x3e, 0x33, 0x24, 0x29, 0x62, 0x6f, 0x78, 0x75, 0x56, 0x5b, 0x4c, 0x41,
	0x61, 0x6c, 0x7b, 0x76, 0x55, 0x58, 0x4f, 0x42, 0x09, 0x04, 0x13, 0x1e, 0x3d, 0x30, 0x27, 0x2a,
	0xb1, 0xbc, 0xab, 0xa6, 0x85, 0x88, 0x9f, 0x92, 0xd9, 0xd4, 0xc3, 0xce, 0xed, 0xe0, 0xf7, 0xfa,
	0xb7, 0xba, 0xad, 0xa0, 0x83, 0x8e, 0x99, 0x94, 0xdf, 0xd2, 0xc5, 0xc8, 0xeb, 0xe6, 0xf1, 0xfc,
	0x67, 0x6a, 0x7d, 0x70, 0x53, 0x5e, 0x49, 0x44, 0x0f, 0x02, 0x15, 0x18, 0x3b, 0x36, 0x21, 0x2c,
	0x0c, 0x01, 0x16, 0x1b, 0x38, 0x35, 0x22, 0x2f, 0x64, 0x69, 0x7e, 0x73, 0x50, 0x5d, 0x4a, 0x47,
	0xdc, 0xd1, 0xc6, 0xcb, 0xe8, 0xe5, 0xf2, 0xff, 0xb4, 0xb9, 0xae, 0xa3, 0x80, 0x8d, 0x9a, 0x97};

const unsigned char aes::by_14[256] = {
	0x00, 0x0e, 0x1c, 0x12, 0x38, 0x36, 0x24, 0x2a, 0x70, 0x7e, 0x6c, 0x62, 0x48, 0x46, 0x54, 0x5a,
	0xe0, 0xee, 0xfc, 0xf2, 0xd8, 0xd6, 0xc4, 0xca, 0x90, 0x9e, 0x8c, 0x82, 0xa8, 0xa6, 0xb4, 0xba,
	0xdb, 0xd5, 0xc7, 0xc9, 0xe3, 0xed, 0xff, 0xf1, 0xab, 0xa5, 0xb7, 0xb9, 0x93, 0x9d, 0x8f, 0x81,
	0x3b, 0x35, 0x27, 0x29, 0x03, 0x0d, 0x1f, 0x11, 0x4b, 0x45, 0x57, 0x59, 0x73, 0x7d, 0x6f, 0x61,
	0xad, 0xa3, 0xb1, 0xbf, 0x95, 0x9b, 0x89, 0x87, 0xdd, 0xd3, 0xc1, 0xcf, 0xe5, 0xeb, 0xf9, 0xf7,
	0x4d, 0x43, 0x51, 0x5f, 0x75, 0x7b, 0x69, 0x67, 0x3d, 0x33, 0x21, 0x2f, 0x05, 0x0b, 0x19, 0x17,
	0x76, 0x78, 0x6a, 0x64, 0x4e, 0x40, 0x52, 0x5c, 0x06, 0x08, 0x1a, 0x14, 0x3e, 0x30, 0x22, 0x2c,
	0x96, 0x98, 0x8a, 0x84, 0xae, 0xa0, 0xb2, 0xbc, 0xe6, 0xe8, 0xfa, 0xf4, 0xde, 0xd0, 0xc2, 0xcc,
	0x41, 0x4f, 0x5d, 0x53, 0x79, 0x77, 0x65, 0x6b, 0x31, 0x3f, 0x2d, 0x23, 0x09, 0x07, 0x15, 0x1b,
	0xa1, 0xaf, 0xbd, 0xb3, 0x99, 0x97, 0x85, 0x8b, 0xd1, 0xdf, 0xcd, 0xc3, 0xe9, 0xe7, 0xf5, 0xfb,
	0x9a, 0x94, 0x86, 0x88, 0xa2, 0xac, 0xbe, 0xb0, 0xea, 0xe4, 0xf6, 0xf8, 0xd2, 0xdc, 0xce, 0xc0,
	0x7a, 0x74, 0x66, 0x68, 0x42, 0x4c, 0x5e, 0x50, 0x0a, 0x04, 0x16, 0x18, 0x32, 0x3c, 0x2e, 0x20,
	0xec, 0xe2, 0xf0, 0xfe, 0xd4, 0xda, 0xc8, 0xc6, 0x9c, 0x92, 0x80, 0x8e, 0xa4, 0xaa, 0xb8, 0xb6,
	0x0c, 0x02, 0x10, 0x1e, 0x34, 0x3a, 0x28, 0x26, 0x7c, 0x72, 0x60, 0x6e, 0x44, 0x4a, 0x58, 0x56,
	0x37, 0x39, 0x2b, 0x25, 0x0f, 0x01, 0x13, 0x1d, 0x47, 0x49, 0x5b, 0x55, 0x7f, 0x71, 0x63, 0x6d,
	0xd7, 0xd9, 0xcb, 0xc5, 0xef, 0xe1, 0xf3, 0xfd, 0xa7, 0xa9, 0xbb, 0xb5, 0x9f, 0x91, 0x83, 0x8d};

aes::aes(vector <unsigned char>& IO, vector<unsigned char>& pass, unsigned int key_lenght)
{
	str_key = pass;
	KEY_LENGHT = key_lenght;
	getKeyFromString(str_key);
	gen_key_schedule(KEY);
	if (IO.size()<BLOCK_SIZE || IO.size() % BLOCK_SIZE != 0 )
	{
		vector<unsigned char> t(IO.size() + BLOCK_SIZE - IO.size() % BLOCK_SIZE,' ');
		str_io = t;
	}
	else
	{
		vector<unsigned char> t(IO.size());
		str_io = t;
	}
	for (unsigned int i = 0; i < IO.size(); i++)
	{
		str_io[i] = IO[i];
	}
}

vector<unsigned char> aes::encrypt()
{
	vector<unsigned char> buff(16), outCrypt(str_io.size());
	unsigned int nr = 0;
	for (unsigned int j = 0; j < str_io.size() / BLOCK_SIZE; j++)
	{
		unsigned int ii = 0;
		for (unsigned int i = j * BLOCK_SIZE; i < j * BLOCK_SIZE + BLOCK_SIZE; i++)
		{
			buff[ii] = str_io[i];
			ii++;
		}
		dgetInputFromString(buff);
		OUTPUT = beginEcryptForBlock(INPUT);
		for (int z = 0; z < 4; z++)
		{
			for (int zz = 0; zz < 4; zz++)
			{
				outCrypt[nr] = OUTPUT[z][zz];
				nr++;
			}
		}
	}

	return outCrypt;
}

vector<unsigned char> aes::dencrypt()
{
	vector<unsigned char> buff(16), outCrypt(str_io.size());
	unsigned int nr = 0;
	for (unsigned int j = 0; j < str_io.size() / BLOCK_SIZE; j++)
	{
		unsigned int ii = 0;
		for (unsigned int i = j * BLOCK_SIZE; i < j * BLOCK_SIZE + BLOCK_SIZE; i++)
		{
			buff[ii] = str_io[i];
			ii++;
		}
		dgetInputFromString(buff);
		OUTPUT = beginDEcryptForBlock(INPUT);
		for (int z = 0; z < 4; z++)
		{
			for (int zz = 0; zz < 4; zz++)
			{
				outCrypt[nr] = OUTPUT[z][zz];
				nr++;
			}
		}
	}

	return outCrypt;
}
vector<vector<unsigned char> > aes::beginEcryptForBlock(vector<vector<unsigned char> >& ynput)
{
	vector<vector<unsigned char> > temp_for_key_schedule(4, vector<unsigned char>(4));
	vector<unsigned char> temp(1, 0);
	vector<unsigned char> temp0(1, 0);
	vector<unsigned char> temp1(1, 0);

	getWFrmKeySched(0, temp_for_key_schedule);
	addRound(ynput, temp_for_key_schedule);
	for (unsigned int i = 1; i <= ROUNDS - 1; i++)
	{
		subytes(ynput);
		debug(ynput);
		shiftRows(ynput,temp,temp0,temp1);
		debug(ynput);
		//debug(ynput);
		mixCol(ynput);
		debug(ynput);
		getWFrmKeySched(i, temp_for_key_schedule);
		debug(temp_for_key_schedule);
		addRound(ynput, temp_for_key_schedule);
		debug(ynput);
	}
	subytes(ynput);
	shiftRows(ynput, temp, temp0, temp1);
	getWFrmKeySched(ROUNDS, temp_for_key_schedule);
	addRound(ynput, temp_for_key_schedule);
	return ynput;
}

vector<vector<unsigned char> > aes::beginDEcryptForBlock(vector<vector<unsigned char> >& ynput)
{
	vector<vector<unsigned char> > temp_for_key_schedule(4, vector<unsigned char>(4));
	vector<unsigned char> temp(1, 0);
	vector<unsigned char> temp0(1, 0);
	vector<unsigned char> temp1(1, 0);

	getWFrmKeySched(ROUNDS, temp_for_key_schedule);
	addRound(ynput, temp_for_key_schedule);
	ishiftRows(ynput, temp, temp0, temp1);
	isubytes(ynput);
	for (int i = ROUNDS - 1; i >= 1; i--)
	{
		getWFrmKeySched(i, temp_for_key_schedule);
		addRound(ynput, temp_for_key_schedule);
		imixCol(ynput);
		isubytes(ynput);
		ishiftRows(ynput, temp, temp0, temp1);
	}
	getWFrmKeySched(0, temp_for_key_schedule);
	addRound(ynput, temp_for_key_schedule);
	return ynput;
}
void aes::addRound(vector<vector<unsigned char> >& state, vector<vector<unsigned char> >& w)
{
	for (int i = 0; i < 4; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			state[j][i] = (state[j][i] ^ w[j][i]);
		}
	}
}

void aes::shiftRows(vector<vector<unsigned char> >& ynput, vector<unsigned char>& temp, vector<unsigned char>& temp0, vector<unsigned char>& temp1)
{
    //debug(ynput);
	temp[0]=(ynput[0][1]);
	ynput[0][1] = ynput[1][1];
	ynput[1][1] = ynput[2][1];
	ynput[2][1] = ynput[3][1];
	ynput[3][1] = temp[0];

	//vector<unsigned char> temp0(1,0);
	temp[0] = ynput[0][2];
	temp0[0]=(ynput[1][2]);
	ynput[0][2] = ynput[2][2];
	ynput[1][2] = ynput[3][2];
	ynput[2][2] = temp[0];
	ynput[3][2] = temp0[0];

	//vector<unsigned char> temp1(1,0);
	temp[0] = ynput[0][3];
	temp0[0] = ynput[1][3];
	temp1[0]=(ynput[2][3]);
	ynput[0][3] = ynput[3][3];
	ynput[1][3] = temp[0];
	ynput[2][3] = temp0[0];
	ynput[3][3] = temp1[0];
	//debug(ynput);
}
void aes::ishiftRows(vector<vector<unsigned char> >& ynput, vector<unsigned char>& temp, vector<unsigned char>& temp0, vector<unsigned char>& temp1)
{
	//vector<unsigned char> temp(1,0);
	temp[0] = (ynput[3][1]);
	ynput[3][1] = ynput[2][1];
	ynput[2][1] = ynput[1][1];
	ynput[1][1] = ynput[0][1];
	ynput[0][1] = temp[0];

	//vector<unsigned char> temp0(1,0);
	temp[0] = ynput[3][2];
	temp0[0] = (ynput[2][2]);
	ynput[3][2] = ynput[1][2];
	ynput[2][2] = ynput[0][2];
	ynput[1][2] = temp[0];
	ynput[0][2] = temp0[0];

	//vector<unsigned char> temp1(1,0);
	temp[0] = ynput[3][3];
	temp0[0] = ynput[2][3];
	temp1[0] = ynput[1][3];
	ynput[3][3] = ynput[0][3];
	ynput[2][3] = temp[0];
	ynput[1][3] = temp0[0];
	ynput[0][3] = temp1[0];
}
void aes::mixCol(vector<vector<unsigned char> >& ynput)
{
	//vector<vector<unsigned char> > buff;
	//vector<vector<unsigned char> > buff(4, vector<unsigned char>(4));
	//populateVector4x4(buff);
	unsigned char buff[4][4];
	for (int i = 0; i < 4; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			buff[i][j] = (by_2[(int)ynput[i][j]] ^ by_3[(int)ynput[i][getNextByte(3, j + 1)]] ^ ynput[i][getNextByte(3, j + 2)] ^ ynput[i][getNextByte(3, j + 3)]);
		}
	}
	for (int i = 0; i < 4; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			ynput[j][i] = buff[j][i];
		}
	}
}

void aes::imixCol(vector<vector<unsigned char> >& ynput)
{
	//vector<vector<unsigned char> > buff;
	//populateVector4x4(buff);
	//vector<vector<unsigned char> > buff(4, vector<unsigned char>(4));
	unsigned char buff[4][4];
	for (unsigned int i = 0; i < 4; i++)
	{
		for (unsigned int j = 0; j < 4; j++)
		{
			buff[i][j] = by_14[ynput[i][j]] ^ by_11[ynput[i][getNextByte(3, j + 1)]] ^ by_13[ynput[i][getNextByte(3, j + 2)]] ^ by_9[ynput[i][getNextByte(3, j + 3)]];
		}
	}
	for (int i = 0; i < 4; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			ynput[j][i] = buff[j][i];
		}
	}
}
void aes::getWFrmKeySched(unsigned int pas, vector<vector<unsigned char> >& temp_for_key_schedule)
{
	//vector<vector<unsigned char> > temp;
	//populateVector4x4(temp);
	//vector<vector<unsigned char> > temp_for_key_schedule(4, vector<unsigned char>(4));

	unsigned int nr = 0;
	for (unsigned int i = 4 * pas; i < (pas + 1) * 4; i++)//la fel 4==word_size oricum ar fi
	{
		for (unsigned int j = 0; j < 4; j++)
		{
			temp_for_key_schedule[nr][j] = KEY_SCHEDULE[i][j];
		}
		nr++;
	}
}
void aes::dgetInputFromString(vector<unsigned char>& str)
{
	unsigned int nr = 0;
	//populateVector4x4(INPUT);
	vector<vector<unsigned char> > t(4, vector<unsigned char>(4));
	INPUT = t;
	for (unsigned int i = 0; i < 4; i++)
	{
		for (unsigned int j = 0; j < 4; j++)
		{

			INPUT[i][j] = str[nr];
			nr++;
		}
	}
}
void aes::getKeyFromString(vector<unsigned char>& str_key)
{
	switch (KEY_LENGHT)
	{
	case 16:
		ROUNDS = 10;
		//KEY =  [4,4];
		KEY = { { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } };
		GROUP_SIZE = 4;
		break;
	case 24:
		ROUNDS = 12;
		KEY = { { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } };
		GROUP_SIZE = 6;
	case 32:
		ROUNDS = 14;
		KEY = { { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } };
		GROUP_SIZE = 8;
	default:
		break;
	}
	for (unsigned int i = 0; i < (ROUNDS +1)*4; i++)
	{
		vector<unsigned char> temp = { 0, 0, 0, 0 };
		KEY_SCHEDULE.push_back(temp);
	}
	int nr = 0;
	for (unsigned int i = 0; i < GROUP_SIZE; i++)
	{
		for (unsigned int j = 0; j < 4; j++)
		{
			KEY[i][j] = str_key[nr];
			nr++;
		}
	}
	//debug(KEY);
}
void aes::gen_key_schedule(vector<vector<unsigned char> >& KEY)
{
	for (unsigned int i = 0; i < GROUP_SIZE; i++)
	{
			KEY_SCHEDULE[i] = KEY[i];
	}
	for (unsigned int i = GROUP_SIZE; i < (ROUNDS + 1) * 4; i = i + GROUP_SIZE)
	{
		KEY_SCHEDULE[i] = x_xor(KEY_SCHEDULE[i - GROUP_SIZE], g(KEY_SCHEDULE[i - 1], (int)(i / GROUP_SIZE)));
		for (unsigned int ii = 1; ii < GROUP_SIZE; ii++)
		{
		     if ((i + ii) == 60) { break; }
                    if ((i + ii) % 8 == 4)
                    {
                        KEY_SCHEDULE[i + ii] = x_xor(subytesWord(KEY_SCHEDULE[i + ii - 1]), KEY_SCHEDULE[i + ii - GROUP_SIZE]);
                    }
                     else
                    {
                        KEY_SCHEDULE[i + ii] = x_xor(KEY_SCHEDULE[i + ii - 1], KEY_SCHEDULE[i + ii - GROUP_SIZE]);
                    }

		}
	}

	//debug
	if (debugg)
	{
		for (unsigned int i = 0; i < (ROUNDS + 1) * 4 ; i = i +GROUP_SIZE)
			{
				cout << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i][0] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 1][0] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 2][0] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 3][0] << endl;
				cout << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i][1] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 1][1] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 2][1] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 3][1] << endl;
				cout << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i][2] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 1][2] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 2][2] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 3][2] << endl;
				cout << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i][3] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 1][3] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 2][3] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 3][3] << endl;
				if (KEY_LENGHT >= 32)
				{
					if (i == 56) { break; }
					cout << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 4][0] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 5][0] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 6][0] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 7][0] << endl;
					cout << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 4][1] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 5][1] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 6][1] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 7][1] << endl;
					cout << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 4][2] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 5][2] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 6][2] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 7][2] << endl;
					cout << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 4][3] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 5][3] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 6][3] << " " << hex << setw(2) << setfill('0') << +KEY_SCHEDULE[i + 7][3] << endl;
				}
				cout << endl;
			}
	}

}

vector<unsigned char> aes::x_xor(vector<unsigned char> a , vector<unsigned char> b)
{
	if (a.size()==b.size())
	{
		vector<unsigned char> return_vector;
		for (unsigned int i = 0; i < a.size(); i++)
		{
			return_vector.push_back(a[i] ^ b[i]);
		}
		return return_vector;
	}
	else
	{
		cout << "the words are not the same lenght!!!" << endl;
		return { 0 };
	}
}
vector<unsigned char> aes::g(vector<unsigned char>& arr, unsigned int pas)
{
	//rotatie la stanga a unui vector liniar 
        // roation to the left of a vector
	vector<unsigned char> temp_vect(4, 0);
	temp_vect[0] = arr[1];
	temp_vect[1] = arr[2];
	temp_vect[2] = arr[3];
	temp_vect[3] = arr[0];

	//substitutie
	for (unsigned int i = 0; i < 4; i++)
	{
		temp_vect[i] = sbox[(unsigned int)temp_vect[i]];
	}
	vector<unsigned char> rcon_temp;
	rcon_temp.push_back(srcon[pas]);
	for (unsigned int i = 0; i < 3; i++)
	{
		rcon_temp.push_back(0x00);
	}

	return x_xor(temp_vect, rcon_temp);
}

void aes::subytes(vector<vector<unsigned char> >& arr)
{
	for (int i = 0; i < 4; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			arr[j][i] = sbox[(unsigned int)arr[j][i]];
		}
	}
}

void aes::isubytes(vector<vector<unsigned char> >& arr)
{
	for (int i = 0; i < 4; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			arr[j][i] = isbox[(unsigned int)arr[j][i]];
		}
	}
}
vector<unsigned char> aes::subytesWord(vector<unsigned char>& vect)
{
	vector<unsigned char> buffer;
	for (unsigned int i = 0;  i < 4;  i++)
	{
		buffer.push_back(sbox[(unsigned int)vect[i]]);
	}
	return buffer;
}

unsigned int aes::getNextByte(unsigned int maxIDFrom0, unsigned int x)
{
	if (x > maxIDFrom0)
	{
		x = x - maxIDFrom0;
		return x - 1;
	}
	else
	{
		return x;
	}
}

void aes::populateVector4x4(vector<vector<unsigned char> >& vec)
{

	//A(dimension, vector<int>(dimension))
	vector<vector<unsigned char> > vec_temp(4,vector<unsigned char>(4));
	vec = vec_temp;

}

void aes::debug(vector<vector<unsigned char> >& arr)
{
	if (debugg)
	{
		for (unsigned int i = 0; i < arr.size(); i++)
		{
			cout << hex << setw(2) << setfill('0') << +arr[0][i] << " " << hex << setw(2) << setfill('0') << +arr[1][i] << " " << hex << setw(2) << setfill('0') << +arr[2][i] << " " << hex << setw(2) << setfill('0') << +arr[3][i] << endl;
		}
		cout << endl;
	}

}
aes::~aes(){}

Books on learning wxWidgets and understanding terminology?

Member 1297423513-Feb-17 11:34

Member 12974235

13-Feb-17 11:34

If I do some C++ programming and I get to the point where I wish to make some graphical programs, I'm kind of leaning in the direction of using wxWidgets. Was wondering though if there are some books out there that explain things.

I hate to look at code and not know what this word means or this symbol.

For example if I see that something reads:

wxFrame* window = new wxFrame(NULL, -1)

I can't stand not knowing what each part of that means.

So my question is are there any books that do a good job of explaining things like that which I will undoubtedly run into?

I do recognize some of that since I've done some Java which always uses classes so.

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.