CX-Mind: A Pioneering Multimodal Large Language Model for Interleaved Reasoning in Chest X-ray via Curriculum-Guided Reinforcement Learning

MERN-X is a comprehensive full-stack framework designed to streamline the development of web applications using the popular MERN stack: MongoDB, Express.js, React, and Node.js. Built with simplicity and scalability in mind, MERN-X empowers developers to create robust and efficient applications from end to end

Vue minder based on baidu minder, Support Vue1.x Vue.2x ✨If you like it, Please star❤

Mind mapping App for OS X compatible with FreeMind

This is a preference pane for Mac OS X 10.7+ that enables hardware media keys (prev, play, next) to be routed to 3rd-party sandboxed applications in a nice way, without unwanted side effects. This has been specifically created with G-Ear, a native Google Music player for Mac in mind, but any suggestion or patch is welcome!

# big-o-performance A simple html app to demonstrate performance costs of data structures. - Clone the project - Navigate to the root of the project in a termina or command prompt - Run 'npm install' - Run 'npm start' - Go to the URL specified in the terminal or command prompt to try out the app. # This app was created from the Create React App NPM. Below are instructions from that project. Below you will find some information on how to perform common tasks. You can find the most recent version of this guide [here](https://github.com/facebookincubator/create-react-app/blob/master/template/README.md). ## Table of Contents - [Updating to New Releases](#updating-to-new-releases) - [Sending Feedback](#sending-feedback) - [Folder Structure](#folder-structure) - [Available Scripts](#available-scripts) - [npm start](#npm-start) - [npm run build](#npm-run-build) - [npm run eject](#npm-run-eject) - [Displaying Lint Output in the Editor](#displaying-lint-output-in-the-editor) - [Installing a Dependency](#installing-a-dependency) - [Importing a Component](#importing-a-component) - [Adding a Stylesheet](#adding-a-stylesheet) - [Post-Processing CSS](#post-processing-css) - [Adding Images and Fonts](#adding-images-and-fonts) - [Adding Bootstrap](#adding-bootstrap) - [Adding Flow](#adding-flow) - [Adding Custom Environment Variables](#adding-custom-environment-variables) - [Integrating with a Node Backend](#integrating-with-a-node-backend) - [Proxying API Requests in Development](#proxying-api-requests-in-development) - [Deployment](#deployment) - [Now](#now) - [Heroku](#heroku) - [Surge](#surge) - [GitHub Pages](#github-pages) - [Something Missing?](#something-missing) ## Updating to New Releases Create React App is divided into two packages: * `create-react-app` is a global command-line utility that you use to create new projects. * `react-scripts` is a development dependency in the generated projects (including this one). You almost never need to update `create-react-app` itself: it’s delegates all the setup to `react-scripts`. When you run `create-react-app`, it always creates the project with the latest version of `react-scripts` so you’ll get all the new features and improvements in newly created apps automatically. To update an existing project to a new version of `react-scripts`, [open the changelog](https://github.com/facebookincubator/create-react-app/blob/master/CHANGELOG.md), find the version you’re currently on (check `package.json` in this folder if you’re not sure), and apply the migration instructions for the newer versions. In most cases bumping the `react-scripts` version in `package.json` and running `npm install` in this folder should be enough, but it’s good to consult the [changelog](https://github.com/facebookincubator/create-react-app/blob/master/CHANGELOG.md) for potential breaking changes. We commit to keeping the breaking changes minimal so you can upgrade `react-scripts` painlessly. ## Sending Feedback We are always open to [your feedback](https://github.com/facebookincubator/create-react-app/issues). ## Folder Structure After creation, your project should look like this: ``` my-app/ README.md index.html favicon.ico node_modules/ package.json src/ App.css App.js index.css index.js logo.svg ``` For the project to build, **these files must exist with exact filenames**: * `index.html` is the page template; * `favicon.ico` is the icon you see in the browser tab; * `src/index.js` is the JavaScript entry point. You can delete or rename the other files. You may create subdirectories inside `src`. For faster rebuilds, only files inside `src` are processed by Webpack. You need to **put any JS and CSS files inside `src`**, or Webpack won’t see them. You can, however, create more top-level directories. They will not be included in the production build so you can use them for things like documentation. ## Available Scripts In the project directory, you can run: ### `npm start` Runs the app in the development mode.<br> Open [http://localhost:3000](http://localhost:3000) to view it in the browser. The page will reload if you make edits.<br> You will also see any lint errors in the console. ### `npm run build` Builds the app for production to the `build` folder.<br> It correctly bundles React in production mode and optimizes the build for the best performance. The build is minified and the filenames include the hashes.<br> Your app is ready to be deployed! ### `npm run eject` **Note: this is a one-way operation. Once you `eject`, you can’t go back!** If you aren’t satisfied with the build tool and configuration choices, you can `eject` at any time. This command will remove the single build dependency from your project. Instead, it will copy all the configuration files and the transitive dependencies (Webpack, Babel, ESLint, etc) right into your project so you have full control over them. All of the commands except `eject` will still work, but they will point to the copied scripts so you can tweak them. At this point you’re on your own. You don’t have to ever use `eject`. The curated feature set is suitable for small and middle deployments, and you shouldn’t feel obligated to use this feature. However we understand that this tool wouldn’t be useful if you couldn’t customize it when you are ready for it. ## Displaying Lint Output in the Editor >Note: this feature is available with `react-scripts@0.2.0` and higher. Some editors, including Sublime Text, Atom, and Visual Studio Code, provide plugins for ESLint. They are not required for linting. You should see the linter output right in your terminal as well as the browser console. However, if you prefer the lint results to appear right in your editor, there are some extra steps you can do. You would need to install an ESLint plugin for your editor first. >**A note for Atom `linter-eslint` users** >If you are using the Atom `linter-eslint` plugin, make sure that **Use global ESLint installation** option is checked: ><img src="http://i.imgur.com/yVNNHJM.png" width="300"> Then make sure `package.json` of your project ends with this block: ```js { // ... "eslintConfig": { "extends": "./node_modules/react-scripts/config/eslint.js" } } ``` Projects generated with `react-scripts@0.2.0` and higher should already have it. If you don’t need ESLint integration with your editor, you can safely delete those three lines from your `package.json`. Finally, you will need to install some packages *globally*: ```sh npm install -g eslint babel-eslint eslint-plugin-react eslint-plugin-import eslint-plugin-jsx-a11y eslint-plugin-flowtype ``` We recognize that this is suboptimal, but it is currently required due to the way we hide the ESLint dependency. The ESLint team is already [working on a solution to this](https://github.com/eslint/eslint/issues/3458) so this may become unnecessary in a couple of months. ## Installing a Dependency The generated project includes React and ReactDOM as dependencies. It also includes a set of scripts used by Create React App as a development dependency. You may install other dependencies (for example, React Router) with `npm`: ``` npm install --save <library-name> ``` ## Importing a Component This project setup supports ES6 modules thanks to Babel. While you can still use `require()` and `module.exports`, we encourage you to use [`import` and `export`](http://exploringjs.com/es6/ch_modules.html) instead. For example: ### `Button.js` ```js import React, { Component } from 'react'; class Button extends Component { render() { // ... } } export default Button; // Don’t forget to use export default! ``` ### `DangerButton.js` ```js import React, { Component } from 'react'; import Button from './Button'; // Import a component from another file class DangerButton extends Component { render() { return <Button color="red" />; } } export default DangerButton; ``` Be aware of the [difference between default and named exports](http://stackoverflow.com/questions/36795819/react-native-es-6-when-should-i-use-curly-braces-for-import/36796281#36796281). It is a common source of mistakes. We suggest that you stick to using default imports and exports when a module only exports a single thing (for example, a component). That’s what you get when you use `export default Button` and `import Button from './Button'`. Named exports are useful for utility modules that export several functions. A module may have at most one default export and as many named exports as you like. Learn more about ES6 modules: * [When to use the curly braces?](http://stackoverflow.com/questions/36795819/react-native-es-6-when-should-i-use-curly-braces-for-import/36796281#36796281) * [Exploring ES6: Modules](http://exploringjs.com/es6/ch_modules.html) * [Understanding ES6: Modules](https://leanpub.com/understandinges6/read#leanpub-auto-encapsulating-code-with-modules) ## Adding a Stylesheet This project setup uses [Webpack](https://webpack.github.io/) for handling all assets. Webpack offers a custom way of “extending” the concept of `import` beyond JavaScript. To express that a JavaScript file depends on a CSS file, you need to **import the CSS from the JavaScript file**: ### `Button.css` ```css .Button { padding: 20px; } ``` ### `Button.js` ```js import React, { Component } from 'react'; import './Button.css'; // Tell Webpack that Button.js uses these styles class Button extends Component { render() { // You can use them as regular CSS styles return <div className="Button" />; } } ``` **This is not required for React** but many people find this feature convenient. You can read about the benefits of this approach [here](https://medium.com/seek-ui-engineering/block-element-modifying-your-javascript-components-d7f99fcab52b). However you should be aware that this makes your code less portable to other build tools and environments than Webpack. In development, expressing dependencies this way allows your styles to be reloaded on the fly as you edit them. In production, all CSS files will be concatenated into a single minified `.css` file in the build output. If you are concerned about using Webpack-specific semantics, you can put all your CSS right into `src/index.css`. It would still be imported from `src/index.js`, but you could always remove that import if you later migrate to a different build tool. ## Post-Processing CSS This project setup minifies your CSS and adds vendor prefixes to it automatically through [Autoprefixer](https://github.com/postcss/autoprefixer) so you don’t need to worry about it. For example, this: ```css .App { display: flex; flex-direction: row; align-items: center; } ``` becomes this: ```css .App { display: -webkit-box; display: -ms-flexbox; display: flex; -webkit-box-orient: horizontal; -webkit-box-direction: normal; -ms-flex-direction: row; flex-direction: row; -webkit-box-align: center; -ms-flex-align: center; align-items: center; } ``` There is currently no support for preprocessors such as Less, or for sharing variables across CSS files. ## Adding Images and Fonts With Webpack, using static assets like images and fonts works similarly to CSS. You can **`import` an image right in a JavaScript module**. This tells Webpack to include that image in the bundle. Unlike CSS imports, importing an image or a font gives you a string value. This value is the final image path you can reference in your code. Here is an example: ```js import React from 'react'; import logo from './logo.png'; // Tell Webpack this JS file uses this image console.log(logo); // /logo.84287d09.png function Header() { // Import result is the URL of your image return <img src={logo} alt="Logo" />; } export default function Header; ``` This works in CSS too: ```css .Logo { background-image: url(./logo.png); } ``` Webpack finds all relative module references in CSS (they start with `./`) and replaces them with the final paths from the compiled bundle. If you make a typo or accidentally delete an important file, you will see a compilation error, just like when you import a non-existent JavaScript module. The final filenames in the compiled bundle are generated by Webpack from content hashes. If the file content changes in the future, Webpack will give it a different name in production so you don’t need to worry about long-term caching of assets. Please be advised that this is also a custom feature of Webpack. **It is not required for React** but many people enjoy it (and React Native uses a similar mechanism for images). However it may not be portable to some other environments, such as Node.js and Browserify. If you prefer to reference static assets in a more traditional way outside the module system, please let us know [in this issue](https://github.com/facebookincubator/create-react-app/issues/28), and we will consider support for this. ## Adding Bootstrap You don’t have to use [React Bootstrap](https://react-bootstrap.github.io) together with React but it is a popular library for integrating Bootstrap with React apps. If you need it, you can integrate it with Create React App by following these steps: Install React Bootstrap and Bootstrap from NPM. React Bootstrap does not include Bootstrap CSS so this needs to be installed as well: ``` npm install react-bootstrap --save npm install bootstrap@3 --save ``` Import Bootstrap CSS and optionally Bootstrap theme CSS in the ```src/index.js``` file: ```js import 'bootstrap/dist/css/bootstrap.css'; import 'bootstrap/dist/css/bootstrap-theme.css'; ``` Import required React Bootstrap components within ```src/App.js``` file or your custom component files: ```js import { Navbar, Jumbotron, Button } from 'react-bootstrap'; ``` Now you are ready to use the imported React Bootstrap components within your component hierarchy defined in the render method. Here is an example [`App.js`](https://gist.githubusercontent.com/gaearon/85d8c067f6af1e56277c82d19fd4da7b/raw/6158dd991b67284e9fc8d70b9d973efe87659d72/App.js) redone using React Bootstrap. ## Adding Flow Flow typing is currently [not supported out of the box](https://github.com/facebookincubator/create-react-app/issues/72) with the default `.flowconfig` generated by Flow. If you run it, you might get errors like this: ```js node_modules/fbjs/lib/Deferred.js.flow:60 60: Promise.prototype.done.apply(this._promise, arguments); ^^^^ property `done`. Property not found in 495: declare class Promise<+R> { ^ Promise. See lib: /private/tmp/flow/flowlib_34952d31/core.js:495 node_modules/fbjs/lib/shallowEqual.js.flow:29 29: return x !== 0 || 1 / (x: $FlowIssue) === 1 / (y: $FlowIssue); ^^^^^^^^^^ identifier `$FlowIssue`. Could not resolve name src/App.js:3 3: import logo from './logo.svg'; ^^^^^^^^^^^^ ./logo.svg. Required module not found src/App.js:4 4: import './App.css'; ^^^^^^^^^^^ ./App.css. Required module not found src/index.js:5 5: import './index.css'; ^^^^^^^^^^^^^ ./index.css. Required module not found ``` To fix this, change your `.flowconfig` to look like this: ```ini [libs] ./node_modules/fbjs/flow/lib [options] esproposal.class_static_fields=enable esproposal.class_instance_fields=enable module.name_mapper='^\(.*\)\.css$' -> 'react-scripts/config/flow/css' module.name_mapper='^\(.*\)\.\(jpg\|png\|gif\|eot\|otf\|webp\|svg\|ttf\|woff\|woff2\|mp4\|webm\)$' -> 'react-scripts/config/flow/file' suppress_type=$FlowIssue suppress_type=$FlowFixMe ``` Re-run flow, and you shouldn’t get any extra issues. If you later `eject`, you’ll need to replace `react-scripts` references with the `<PROJECT_ROOT>` placeholder, for example: ```ini module.name_mapper='^\(.*\)\.css$' -> '<PROJECT_ROOT>/config/flow/css' module.name_mapper='^\(.*\)\.\(jpg\|png\|gif\|eot\|otf\|webp\|svg\|ttf\|woff\|woff2\|mp4\|webm\)$' -> '<PROJECT_ROOT>/config/flow/file' ``` We will consider integrating more tightly with Flow in the future so that you don’t have to do this. ## Adding Custom Environment Variables >Note: this feature is available with `react-scripts@0.2.3` and higher. Your project can consume variables declared in your environment as if they were declared locally in your JS files. By default you will have `NODE_ENV` defined for you, and any other environment variables starting with `REACT_APP_`. These environment variables will be defined for you on `process.env`. For example, having an environment variable named `REACT_APP_SECRET_CODE` will be exposed in your JS as `process.env.REACT_APP_SECRET_CODE`, in addition to `process.env.NODE_ENV`. These environment variables can be useful for displaying information conditionally based on where the project is deployed or consuming sensitive data that lives outside of version control. First, you need to have environment variables defined, which can vary between OSes. For example, let's say you wanted to consume a secret defined in the environment inside a `<form>`: ```jsx render() { return ( <div> <small>You are running this application in <b>{process.env.NODE_ENV}</b> mode.</small> <form> <input type="hidden" defaultValue={process.env.REACT_APP_SECRET_CODE} /> </form> </div> ); } ``` The above form is looking for a variable called `REACT_APP_SECRET_CODE` from the environment. In order to consume this value, we need to have it defined in the environment: ### Windows (cmd.exe) ```cmd set REACT_APP_SECRET_CODE=abcdef&&npm start ``` (Note: the lack of whitespace is intentional.) ### Linux, OS X (Bash) ```bash REACT_APP_SECRET_CODE=abcdef npm start ``` > Note: Defining environment variables in this manner is temporary for the life of the shell session. Setting permanent environment variables is outside the scope of these docs. With our environment variable defined, we start the app and consume the values. Remember that the `NODE_ENV` variable will be set for you automatically. When you load the app in the browser and inspect the `<input>`, you will see its value set to `abcdef`, and the bold text will show the environment provided when using `npm start`: ```html <div> <small>You are running this application in <b>development</b> mode.</small> <form> <input type="hidden" value="abcdef" /> </form> </div> ``` Having access to the `NODE_ENV` is also useful for performing actions conditionally: ```js if (process.env.NODE_ENV !== 'production') { analytics.disable(); } ``` ## Integrating with a Node Backend Check out [this tutorial](https://www.fullstackreact.com/articles/using-create-react-app-with-a-server/) for instructions on integrating an app with a Node backend running on another port, and using `fetch()` to access it. You can find the companion GitHub repository [here](https://github.com/fullstackreact/food-lookup-demo). ## Proxying API Requests in Development >Note: this feature is available with `react-scripts@0.2.3` and higher. People often serve the front-end React app from the same host and port as their backend implementation. For example, a production setup might look like this after the app is deployed: ``` / - static server returns index.html with React app /todos - static server returns index.html with React app /api/todos - server handles any /api/* requests using the backend implementation ``` Such setup is **not** required. However, if you **do** have a setup like this, it is convenient to write requests like `fetch('/api/todos')` without worrying about redirecting them to another host or port during development. To tell the development server to proxy any unknown requests to your API server in development, add a `proxy` field to your `package.json`, for example: ```js "proxy": "http://localhost:4000", ``` This way, when you `fetch('/api/todos')` in development, the development server will recognize that it’s not a static asset, and will proxy your request to `http://localhost:4000/api/todos` as a fallback. Conveniently, this avoids [CORS issues](http://stackoverflow.com/questions/21854516/understanding-ajax-cors-and-security-considerations) and error messages like this in development: ``` Fetch API cannot load http://localhost:4000/api/todos. No 'Access-Control-Allow-Origin' header is present on the requested resource. Origin 'http://localhost:3000' is therefore not allowed access. If an opaque response serves your needs, set the request's mode to 'no-cors' to fetch the resource with CORS disabled. ``` Keep in mind that `proxy` only has effect in development (with `npm start`), and it is up to you to ensure that URLs like `/api/todos` point to the right thing in production. You don’t have to use the `/api` prefix. Any unrecognized request will be redirected to the specified `proxy`. Currently the `proxy` option only handles HTTP requests, and it won’t proxy WebSocket connections. If the `proxy` option is **not** flexible enough for you, alternatively you can: * Enable CORS on your server ([here’s how to do it for Express](http://enable-cors.org/server_expressjs.html)). * Use [environment variables](#adding-custom-environment-variables) to inject the right server host and port into your app. ## Deployment By default, Create React App produces a build assuming your app is hosted at the server root. To override this, specify the `homepage` in your `package.json`, for example: ```js "homepage": "http://mywebsite.com/relativepath", ``` This will let Create React App correctly infer the root path to use in the generated HTML file. ### Now See [this example](https://github.com/xkawi/create-react-app-now) for a zero-configuration single-command deployment with [now](https://zeit.co/now). ### Heroku Use the [Heroku Buildpack for Create React App](https://github.com/mars/create-react-app-buildpack). You can find instructions in [Deploying React with Zero Configuration](https://blog.heroku.com/deploying-react-with-zero-configuration). ### Surge Install the Surge CLI if you haven't already by running `npm install -g surge`. Run the `surge` command and log in you or create a new account. You just need to specify the *build* folder and your custom domain, and you are done. ```sh email: email@domain.com password: ******** project path: /path/to/project/build size: 7 files, 1.8 MB domain: create-react-app.surge.sh upload: [====================] 100%, eta: 0.0s propagate on CDN: [====================] 100% plan: Free users: email@domain.com IP Address: X.X.X.X Success! Project is published and running at create-react-app.surge.sh ``` Note that in order to support routers that use html5 `pushState` API, you may want to rename the `index.html` in your build folder to `200.html` before deploying to Surge. This [ensures that every URL falls back to that file](https://surge.sh/help/adding-a-200-page-for-client-side-routing). ### GitHub Pages >Note: this feature is available with `react-scripts@0.2.0` and higher. Open your `package.json` and add a `homepage` field: ```js "homepage": "http://myusername.github.io/my-app", ``` **The above step is important!** Create React App uses the `homepage` field to determine the root URL in the built HTML file. Now, whenever you run `npm run build`, you will see a cheat sheet with a sequence of commands to deploy to GitHub pages: ```sh git commit -am "Save local changes" git checkout -B gh-pages git add -f build git commit -am "Rebuild website" git filter-branch -f --prune-empty --subdirectory-filter build git push -f origin gh-pages git checkout - ``` You may copy and paste them, or put them into a custom shell script. You may also customize them for another hosting provider. Note that GitHub Pages doesn't support routers that use the HTML5 `pushState` history API under the hood (for example, React Router using `browserHistory`). This is because when there is a fresh page load for a url like `http://user.github.io/todomvc/todos/42`, where `/todos/42` is a frontend route, the GitHub Pages server returns 404 because it knows nothing of `/todos/42`. If you want to add a router to a project hosted on GitHub Pages, here are a couple of solutions: * You could switch from using HTML5 history API to routing with hashes. If you use React Router, you can switch to `hashHistory` for this effect, but the URL will be longer and more verbose (for example, `http://user.github.io/todomvc/#/todos/42?_k=yknaj`). [Read more](https://github.com/reactjs/react-router/blob/master/docs/guides/Histories.md#histories) about different history implementations in React Router. * Alternatively, you can use a trick to teach GitHub Pages to handle 404 by redirecting to your `index.html` page with a special redirect parameter. You would need to add a `404.html` file with the redirection code to the `build` folder before deploying your project, and you’ll need to add code handling the redirect parameter to `index.html`. You can find a detailed explanation of this technique [in this guide](https://github.com/rafrex/spa-github-pages). ## Something Missing? If you have ideas for more “How To” recipes that should be on this page, [let us know](https://github.com/facebookincubator/create-react-app/issues) or [contribute some!](https://github.com/facebookincubator/create-react-app/edit/master/template/README.md)

The aim of this assignment is to have you do UDP socket client / server programming with a focus on two broad aspects : Setting up the exchange between the client and server in a secure way despite the lack of a formal connection (as in TCP) between the two, so that ‘outsider’ UDP datagrams (broadcast, multicast, unicast - fortuitously or maliciously) cannot intrude on the communication. Introducing application-layer protocol data-transmission reliability, flow control and congestion control in the client and server using TCP-like ARQ sliding window mechanisms. The second item above is much more of a challenge to implement than the first, though neither is particularly trivial. But they are not tightly interdependent; each can be worked on separately at first and then integrated together at a later stage. Apart from the material in Chapters 8, 14 & 22 (especially Sections 22.5 - 22.7), and the experience you gained from the preceding assignment, you will also need to refer to the following : ioctl function (Chapter 17). get_ifi_info function (Section 17.6, Chapter 17). This function will be used by the server code to discover its node’s network interfaces so that it can bind all its interface IP addresses (see Section 22.6). ‘Race’ conditions (Section 20.5, Chapter 20) You also need a thorough understanding of how the TCP protocol implements reliable data transfer, flow control and congestion control. Chapters 17- 24 of TCP/IP Illustrated, Volume 1 by W. Richard Stevens gives a good overview of TCP. Though somewhat dated for some things (it was published in 1994), it remains, overall, a good basic reference. Overview This assignment asks you to implement a primitive file transfer protocol for Unix platforms, based on UDP, and with TCP-like reliability added to the transfer operation using timeouts and sliding-window mechanisms, and implementing flow and congestion control. The server is a concurrent server which can handle multiple clients simultaneously. A client gives the server the name of a file. The server forks off a child which reads directly from the file and transfers the contents over to the client using UDP datagrams. The client prints out the file contents as they come in, in order, with nothing missing and with no duplication of content, directly on to stdout (via the receiver sliding window, of course, but with no other intermediate buffering). The file to be transferred can be of arbitrary length, but its contents are always straightforward ascii text. As an aside let me mention that assuming the file contents ascii is not as restrictive as it sounds. We can always pretend, for example, that binary files are base64 encoded (“ASCII armor”). A real file transfer protocol would, of course, have to worry about transferring files between heterogeneous platforms with different file structure conventions and semantics. The sender would first have to transform the file into a platform-independent, protocol-defined, format (using, say, ASN.1, or some such standard), and the receiver would have to transform the received file into its platform’s native file format. This kind of thing can be fairly time consuming, and is certainly very tedious, to implement, with little educational value - it is not part of this assignment. Arguments for the server You should provide the server with an input file server.in from which it reads the following information, in the order shown, one item per line : Well-known port number for server. Maximum sending sliding-window size (in datagram units). You will not be handing in your server.in file. We shall create our own when we come to test your code. So it is important that you stick strictly to the file name and content conventions specified above. The same applies to the client.in input file below. Arguments for the client The client is to be provided with an input file client.in from which it reads the following information, in the order shown, one item per line : IP address of server (not the hostname). Well-known port number of server. filename to be transferred. Receiving sliding-window size (in datagram units). Random generator seed value. Probability p of datagram loss. This should be a real number in the range [ 0.0 , 1.0 ] (value 0.0 means no loss occurs; value 1.0 means all datagrams all lost). The mean µ, in milliseconds, for an exponential distribution controlling the rate at which the client reads received datagram payloads from its receive buffer. Operation Server starts up and reads its arguments from file server.in. As we shall see, when a client communicates with the server, the server will want to know what IP address that client is using to identify the server (i.e. , the destination IP address in the incoming datagram). Normally, this can be done relatively straightforwardly using the IP_RECVDESTADDR socket option, and picking up the information using the ancillary data (‘control information’) capability of the recvmsg function. Unfortunately, Solaris 2.10 does not support the IP_RECVDESTADDR option (nor, incidentally, does it support the msg_flags option in msghdr - see p.390). This considerably complicates things. In the absence of IP_RECVDESTADDR, what the server has to do as part of its initialization phase is to bind each IP address it has (and, simultaneously, its well-known port number, which it has read in from server.in) to a separate UDP socket. The code in Section 22.6, which uses the get_ifi_info function, shows you how to do that. However, there are important differences between that code and the version you want to implement. The code of Section 22.6 binds the IP addresses and forks off a child for each address that is bound to. We do not want to do that. Instead you should have an array of socket descriptors. For each IP address, create a new socket and bind the address (and well-known port number) to the socket without forking off child processes. Creating child processes comes later, when clients arrive. The code of Section 22.6 also attempts to bind broadcast addresses. We do not want to do this. It binds a wildcard IP address, which we certainly do not want to do either. We should bind strictly only unicast addresses (including the loopback address). The get_ifi_info function (which the code in Section 22.6 uses) has to be modified so that it also gets the network masks for the IP addresses of the node, and adds these to the information stored in the linked list of ifi_info structures (see Figure 17.5, p.471) it produces. As you go binding each IP address to a distinct socket, it will be useful for later processing to build your own array of structures, where a structure element records the following information for each socket : sockfd IP address bound to the socket network mask for the IP address subnet address (obtained by doing a bit-wise and between the IP address and its network mask) Report, in a ReadMe file which you hand in with your code, on the modifications you had to introduce to ensure that only unicast addresses are bound, and on your implementation of the array of structures described above. You should print out on stdout, with an appropriate message and appropriately formatted in dotted decimal notation, the IP address, network mask, and subnet address for each socket in your array of structures (you do not need to print the sockfd). The server now uses select to monitor the sockets it has created for incoming datagrams. When it returns from select, it must use recvfrom or recvmsg to read the incoming datagram (see 6. below). When a client starts, it first reads its arguments from the file client.in. The client checks if the server host is ‘local’ to its (extended) Ethernet. If so, all its communication to the server is to occur as MSG_DONTROUTE (or SO_DONTROUTE socket option). It determines if the server host is ‘local’ as follows. The first thing the client should do is to use the modified get_ifi_info function to obtain all of its IP addresses and associated network masks. Print out on stdout, in dotted decimal notation and with an appropriate message, the IP addresses and network masks obtained. In the following, IPserver designates the IP address the client will use to identify the server, and IPclient designates the IP address the client will choose to identify itself. The client checks whether the server is on the same host. If so, it should use the loopback address 127.0.0.1 for the server (i.e. , IPserver = 127.0.0.1). IPclient should also be set to the loopback address. Otherwise it proceeds as follows: IPserver is set to the IP address for the server in the client.in file. Given IPserver and the (unicast) IP addresses and network masks for the client returned by get_ifi_info in the linked list of ifi_info structures, you should be able to figure out if the server node is ‘local’ or not. This will be discussed in class; but let me just remind you here that you should use ‘longest prefix matching’ where applicable. If there are multiple client addresses, and the server host is ‘local’, the client chooses an IP address for itself, IPclient, which matches up as ‘local’ according to your examination above. If the server host is not ‘local’, then IPclient can be chosen arbitrarily. Print out on stdout the results of your examination, as to whether the server host is ‘local’ or not, as well as the IPclient and IPserver addresses selected. Note that this manner of determining whether the server is local or not is somewhat clumsy and ‘over-engineered’, and, as such, should be viewed more in the nature of a pedagogical exercise. Ideally, we would like to look up the server IP address(es) in the routing table (see Section 18.3). This requires that a routing socket be created, for which we need superuser privilege. Alternatively, we might want to dump out the routing table, using the sysctl function for example (see Section 18.4), and examine it directly. Unfortunately, Solaris 2.10 does not support sysctl. Furthermore, note that there is a slight problem with the address 130.245.1.123/24 assigned to compserv3 (see rightmost column of file hosts, and note that this particular compserv3 address “overlaps” with the 130.245.1.x/28 addresses in that same column assigned to compserv1, compserv2 & comserv4). In particular, if the client is running on compserv3 and the server on any of the other three compservs, and if that server node is also being identified to the client by its /28 (rather than its /24) address, then the client will get a “false positive” when it tests as to whether the server node is local or not. In other words, the client will deem the server node to be local, whereas in fact it should not be considered local. Because of this, it is perhaps best simply not to use compserv3 to run the client (but it is o.k. to use it to run the server). Finally, using MSG_DONTROUTE where possible would seem to gain us efficiency, in as much as the kernel does not need to consult the routing table for every datagram sent. But, in fact, that is not so. Recall that one effect of connect with UDP sockets is that routing information is obtained by the kernel at the time the connect is issued. That information is cached and used for subsequent sends from the connected socket (see p.255). The client now creates a UDP socket and calls bind on IPclient, with 0 as the port number. This will cause the kernel to bind an ephemeral port to the socket. After the bind, use the getsockname function (Section 4.10) to obtain IPclient and the ephemeral port number that has been assigned to the socket, and print that information out on stdout, with an appropriate message and appropriately formatted. The client connects its socket to IPserver and the well-known port number of the server. After the connect, use the getpeername function (Section 4.10) to obtain IPserver and the well-known port number of the server, and print that information out on stdout, with an appropriate message and appropriately formatted. The client sends a datagram to the server giving the filename for the transfer. This send needs to be backed up by a timeout in case the datagram is lost. Note that the incoming datagram from the client will be delivered to the server at the socket to which the destination IP address that the datagram is carrying has been bound. Thus, the server can obtain that address (it is, of course, IPserver) and thereby achieve what IP_RECVDESTADDR would have given us had it been available. Furthermore, the server process can obtain the IP address (this will, of course, be IPclient) and ephemeral port number of the client through the recvfrom or recvmsg functions. The server forks off a child process to handle the client. The server parent process goes back to the select to listen for new clients. Hereafter, and unless otherwise stated, whenever we refer to the ‘server’, we mean the server child process handling the client’s file transfer, not the server parent process. Typically, the first thing the server child would be expected to do is to close all sockets it ‘inherits’ from its parent. However, this is not the case with us. The server child does indeed close the sockets it inherited, but not the socket on which the client request arrived. It leaves that socket open for now. Call this socket the ‘listening’ socket. The server (child) then checks if the client host is local to its (extended) Ethernet. If so, all its communication to the client is to occur as MSG_DONTROUTE (or SO_DONTROUTE socket option). If IPserver (obtained in 5. above) is the loopback address, then we are done. Otherwise, the server has to proceed with the following step. Use the array of structures you built in 1. above, together with the addresses IPserver and IPclient to determine if the client is ‘local’. Print out on stdout the results of your examination, as to whether the client host is ‘local’ or not. The server (child) creates a UDP socket to handle file transfer to the client. Call this socket the ‘connection’ socket. It binds the socket to IPserver, with port number 0 so that its kernel assigns an ephemeral port. After the bind, use the getsockname function (Section 4.10) to obtain IPserver and the ephemeral port number that has been assigned to the socket, and print that information out on stdout, with an appropriate message and appropriately formatted. The server then connects this ‘connection’ socket to the client’s IPclient and ephemeral port number. The server now sends the client a datagram, in which it passes it the ephemeral port number of its ‘connection’ socket as the data payload of the datagram. This datagram is sent using the ‘listening’ socket inherited from its parent, otherwise the client (whose socket is connected to the server’s ‘listening’ socket at the latter’s well-known port number) will reject it. This datagram must be backed up by the ARQ mechanism, and retransmitted in the event of loss. Note that if this datagram is indeed lost, the client might well time out and retransmit its original request message (the one carrying the file name). In this event, you must somehow ensure that the parent server does not mistake this retransmitted request for a new client coming in, and spawn off yet another child to handle it. How do you do that? It is potentially more involved than it might seem. I will be discussing this in class, as well as ‘race’ conditions that could potentially arise, depending on how you code the mechanisms I present. When the client receives the datagram carrying the ephemeral port number of the server’s ‘connection’ socket, it reconnects its socket to the server’s ‘connection’ socket, using IPserver and the ephemeral port number received in the datagram (see p.254). It now uses this reconnected socket to send the server an acknowledgment. Note that this implies that, in the event of the server timing out, it should retransmit two copies of its ‘ephemeral port number’ message, one on its ‘listening’ socket and the other on its ‘connection’ socket (why?). When the server receives the acknowledgment, it closes the ‘listening’ socket it inherited from its parent. The server can now commence the file transfer through its ‘connection’ socket. The net effect of all these binds and connects at server and client is that no ‘outsider’ UDP datagram (broadcast, multicast, unicast - fortuitously or maliciously) can now intrude on the communication between server and client. Starting with the first datagram sent out, the client behaves as follows. Whenever a datagram arrives, or an ACK is about to be sent out (or, indeed, the initial datagram to the server giving the filename for the transfer), the client uses some random number generator function random() (initialized by the client.in argument value seed) to decide with probability p (another client.in argument value) if the datagram or ACK should be discarded by way of simulating transmission loss across the network. (I will briefly discuss in class how you do this.) Adding reliability to UDP The mechanisms you are to implement are based on TCP Reno. These include : Reliable data transmission using ARQ sliding-windows, with Fast Retransmit. Flow control via receiver window advertisements. Congestion control that implements : SlowStart Congestion Avoidance (‘Additive-Increase/Multiplicative Decrease’ – AIMD) Fast Recovery (but without the window-inflation aspect of Fast Recovery) Only some, and by no means all, of the details for these are covered below. The rest will be presented in class, especially those concerning flow control and TCP Reno’s congestion control mechanisms in general : Slow Start, Congestion Avoidance, Fast Retransmit and Fast Recovery. Implement a timeout mechanism on the sender (server) side. This is available to you from Stevens, Section 22.5 . Note, however, that you will need to modify the basic driving mechanism of Figure 22.7 appropriately since the situation at the sender side is not a repetitive cycle of send-receive, but rather a straightforward progression of send-send-send-send- . . . . . . . . . . . Also, modify the RTT and RTO mechanisms of Section 22.5 as specified below. I will be discussing the details of these modifications and the reasons for them in class. Modify function rtt_stop (Fig. 22.13) so that it uses integer arithmetic rather than floating point. This will entail your also having to modify some of the variable and function parameter declarations throughout Section 22.5 from float to int, as appropriate. In the unprrt.h header file (Fig. 22.10) set : RTT_RXTMIN to 1000 msec. (1 sec. instead of the current value 3 sec.) RTT_RXTMAX to 3000 msec. (3 sec. instead of the current value 60 sec.) RTT_MAXNREXMT to 12 (instead of the current value 3) In function rtt_timeout (Fig. 22.14), after doubling the RTO in line 86, pass its value through the function rtt_minmax of Fig. 22.11 (somewhat along the lines of what is done in line 77 of rtt_stop, Fig. 22.13). Finally, note that with the modification to integer calculation of the smoothed RTT and its variation, and given the small RTT values you will experience on the cs / sbpub network, these calculations should probably now be done on a millisecond or even microsecond scale (rather than in seconds, as is the case with Stevens’ code). Otherwise, small measured RTTs could show up as 0 on a scale of seconds, yielding a negative result when we subtract the smoothed RTT from the measured RTT (line 72 of rtt_stop, Fig. 22.13). Report the details of your modifications to the code of Section 22.5 in the ReadMe file which you hand in with your code. We need to have a sender sliding window mechanism for the retransmission of lost datagrams; and a receiver sliding window in order to ensure correct sequencing of received file contents, and some measure of flow control. You should implement something based on TCP Reno’s mechanisms, with cumulative acknowledgments, receiver window advertisements, and a congestion control mechanism I will explain in detail in class. For a reference on TCP’s mechanisms generally, see W. Richard Stevens, TCP/IP Illustrated, Volume 1 , especially Sections 20.2 - 20.4 of Chapter 20 , and Sections 21.1 - 21.8 of Chapter 21 . Bear in mind that our sequence numbers should count datagrams, not bytes as in TCP. Remember that the sender and receiver window sizes have to be set according to the argument values in client.in and server.in, respectively. Whenever the sender window becomes full and so ‘locks’, the server should print out a message to that effect on stdout. Similarly, whenever the receiver window ‘locks’, the client should print out a message on stdout. Be aware of the potential for deadlock when the receiver window ‘locks’. This situation is handled by having the receiver process send a duplicate ACK which acts as a window update when its window opens again (see Figure 20.3 and the discussion about it in TCP/IP Illustrated). However, this is not enough, because ACKs are not backed up by a timeout mechanism in the event they are lost. So we will also need to implement a persist timer driving window probes in the sender process (see Sections 22.1 & 22.2 in Chapter 22 of TCP/IP Illustrated). Note that you do not have to worry about the Silly Window Syndrome discussed in Section 22.3 of TCP/IP Illustrated since the receiver process consumes ‘full sized’ 512-byte messages from the receiver buffer (see 3. below). Report on the details of the ARQ mechanism you implemented in the ReadMe file you hand in. Indeed, you should report on all the TCP mechanisms you implemented in the ReadMe file, both the ones discussed here, and the ones I will be discussing in class. Make your datagram payload a fixed 512 bytes, inclusive of the file transfer protocol header (which must, at the very least, carry: the sequence number of the datagram; ACKs; and advertised window notifications). The client reads the file contents in its receive buffer and prints them out on stdout using a separate thread. This thread sits in a repetitive loop till all the file contents have been printed out, doing the following. It samples from an exponential distribution with mean µ milliseconds (read from the client.in file), sleeps for that number of milliseconds; wakes up to read and print all in-order file contents available in the receive buffer at that point; samples again from the exponential distribution; sleeps; and so on. The formula -1 × µ × ln( random( ) ) , where ln is the natural logarithm, yields variates from an exponential distribution with mean µ, based on the uniformly-distributed variates over ( 0 , 1 ) returned by random(). Note that you will need to implement some sort of mutual exclusion/semaphore mechanism on the client side so that the thread that sleeps and wakes up to consume from the receive buffer is not updating the state variables of the buffer at the same time as the main thread reading from the socket and depositing into the buffer is doing the same. Furthermore, we need to ensure that the main thread does not effectively monopolize the semaphore (and thus lock out for prolonged periods of time) the sleeping thread when the latter wakes up. See the textbook, Section 26.7, ‘Mutexes: Mutual Exclusion’, pp.697-701. You might also find Section 26.8, ‘Condition Variables’, pp.701-705, useful. You will need to devise some way by which the sender can notify the receiver when it has sent the last datagram of the file transfer, without the receiver mistaking that EOF marker as part of the file contents. (Also, note that the last data segment could be a “short” segment of less than 512 bytes – your client needs to be able to handle this correctly somehow.) When the sender receives an ACK for the last datagram of the transfer, the (child) server terminates. The parent server has to take care of cleaning up zombie children. Note that if we want a clean closing, the client process cannot simply terminate when the receiver ACKs the last datagram. This ACK could be lost, which would leave the (child) server process ‘hanging’, timing out, and retransmitting the last datagram. TCP attempts to deal with this problem by means of the TIME_WAIT state. You should have your receiver process behave similarly, sticking around in something akin to a TIME_WAIT state in case in case it needs to retransmit the ACK. In the ReadMe file you hand in, report on how you dealt with the issues raised here: sender notifying receiver of the last datagram, clean closing, and so on. Output Some of the output required from your program has been described in the section Operation above. I expect you to provide further output – clear, well-structured, well-laid-out, concise but sufficient and helpful – in the client and server windows by means of which we can trace the correct evolution of your TCP’s behaviour in all its intricacies : information (e.g., sequence number) on datagrams and acks sent and dropped, window advertisements, datagram retransmissions (and why : dup acks or RTO); entering/exiting Slow Start and Congestion Avoidance, ssthresh and cwnd values; sender and receiver windows locking/unlocking; etc., etc. . . . . The onus is on you to convince us that the TCP mechanisms you implemented are working correctly. Too many students do not put sufficient thought, creative imagination, time or effort into this. It is not the TA’s nor my responsibility to sit staring at an essentially blank screen, trying to summon up our paranormal psychology skills to figure out if your TCP implementation is really working correctly in all its very intricate aspects, simply because the transferred file seems to be printing o.k. in the client window. Nor is it our responsibility to strain our eyes and our patience wading through a mountain of obscure, ill-structured, hyper-messy, debugging-style output because, for example, your effort-conserving concept of what is ‘suitable’ is to dump your debugging output on us, relevant, irrelevant, and everything in between.

SEIS 665 Assignment 2: Linux & Git Overview This week we will focus on becoming familiar with launching a Linux server and working with some basic Linux and Git commands. We will use AWS to launch and host the Linux server. AWS might seem a little confusing at this point. Don’t worry, we will gain much more hands-on experience with AWS throughout the course. The goal is to get you comfortable working with the technology and not overwhelm you with all the details. Requirements You need to have a personal AWS account and GitHub account for this assignment. You should also read the Git Hands-on Guide and Linux Hands-on Guide before beginning this exercise. A word about grading One of the key DevOps practices we learn about in this class is the use of automation to increase the speed and repeatability of processes. Automation is utilized during the assignment grading process to review and assess your work. It’s important that you follow the instructions in each assignment and type in required files and resources with the proper names. All names are case sensitive, so a name like "Web1" is not the same as "web1". If you misspell a name, use the wrong case, or put a file in the wrong directory location you will lose points on your assignment. This is the easiest way to lose points, and also the most preventable. You should always double-check your work to make sure it accurately reflects the requirements specified in the assignment. You should always carefully review the content of your files before submitting your assignment. The assignment Let’s get started! Create GitHub repository The first step in the assignment is to setup a Git repository on GitHub. We will use a special solution called GitHub Classroom for this course which automates the process of setting up student assignment repositories. Here are the basic steps: Click on the following link to open Assignment 2 on the GitHub Classroom site: https://classroom.github.com/a/K4zcVmX- (Links to an external site.)Links to an external site. Click on the Accept this assignment button. GitHub Classroom will provide you with a URL (https) to access the assignment repository. Either copy this address to your clipboard or write it down somewhere. You will need to use this address to set up the repository on a Linux server. Example: https://github.com/UST-SEIS665/hw2-seis665-02-spring2019-<your github id>.git At this point your new repository to ready to use. The repository is currently empty. We will put some content in there soon! Launch Linux server The second step in the assignment is to launch a Linux server using AWS EC2. The server should have the following characteristics: Amazon Linux 2 AMI 64-bit (usually the first option listed) Located in a U.S. region (us-east-1) t2.micro instance type All default instance settings (storage, vpm, security group, etc.) I’ve shown you how to launch EC2 instances in class. You can review it on Canvas. Once you launch the new server, it may take a few minutes to provision. Log into server The next step is to log into the Linux server using a terminal program with a secure shell (SSH) support. You can use iTerm2 (Links to an external site.)Links to an external site. on a Mac and GitBash/PuTTY (Links to an external site.)Links to an external site. on a PC. You will need to have the private server key and the public IP address before attempting to log into the server. The server key is basically your password. If you lose it, you will need to terminate the existing instance and launch a new server. I recommend reusing the same key when launching new servers throughout the class. Note, I make this recommendation to make the learning process easier and not because it is a common security practice. I’ve shown you how to use a terminal application to log into the instance using a Windows desktop. Your personal computer or lab computer may be running a different OS version, but the process is still very similar. You can review the videos on the Canvas. Working with Linux If you’ve made it this far, congratulations! You’ve made it over the toughest hurdle. By the end of this course, I promise you will be able to launch and log into servers in your sleep. You should be looking at a login screen that looks something like this: Last login: Mon Mar 21 21:17:54 2016 from 174-20-199-194.mpls.qwest.net __| __|_ ) _| ( / Amazon Linux AMI ___|\___|___| https://aws.amazon.com/amazon-linux-ami/2015.09-release-notes/ 8 package(s) needed for security, out of 17 available Run "sudo yum update" to apply all updates. ec2-user@ip-172-31-15-26 ~]$ Your terminal cursor is sitting at the shell prompt, waiting for you to type in your first command. Remember the shell? It is a really cool program that lets you start other programs and manage services on the Linux system. The rest of this assignment will be spent working with the shell. Note, when you are asked to type in a command in the steps below, don’t type in the dollar-sign ($) character. This is just meant to represent the command prompt. The actual commands are represented by the characters to the right of the command prompt. Let’s start by asking the shell for some help. Type in: $ help The shell provides you with a list of commands you can run along with possible command options. Next, check out one of the pages in the built-in manual: $ man ls A man page will appear with information on how to use the ls command. This command is used to list the contents of file directories. Either space through the contents of the man page or hit q to exit. Most of the core Linux commands have man pages available. But honestly, some of these man pages are a bit hard to understand. Sometimes your best bet is to search on Google if you are trying to figure out how to use a specific command. When you initially log into Linux, the system places you in your home directory. Each user on the system has a separate home directory. Let’s see where your home directory is located: $ pwd The response should be /home/ec2-user. The pwd command is handy to remember if you ever forget what file directory you are currently located in. If you recall from the Linux Hands-on Guide, this directory is also your current working directory. Type in: $ cd / The cd command let’s you change to a new working directory on the server. In this case, we changed to the root (/) directory. This is the parent of all the other directories on the file system. Type in: $ ls The ls command lists the contents of the current directory. As you can see, root directory contains many other directories. You will become familiar with these directories over time. The ls command provides a very basic directory listing. You need to supply the command with some options if you want to see more detailed information. Type in: $ ls -la See how this command provides you with much more detailed information about the files and directories? You can use this detailed listing to see the owner, group, and access control list settings for each file or directory. Do you see any files listed? Remember, the first character in the access control list column denotes whether a listed item is a file or a directory. You probably see a couple files with names like .autofsck. How come you didn’t see this file when you typed in the lscommand without any options? (Try to run this command again to convince yourself.) Files names that start with a period are called hidden files. These files won’t appear on normal directory listings. Type in: $ cd /var Then, type in: $ ls You will see a directory listing for the /var directory. Next, type in: $ ls .. Huh. This directory listing looks the same as the earlier root directory listing. When you use two periods (..) in a directory path that means you are referring to the parent directory of the current directory. Just think of the two dots as meaning the directory above the current directory. Now, type in: $ cd ~ $ pwd Whoa. We’re back at our home directory again. The tilde character (~) is another one of those handy little directory path shortcuts. It always refers to our personal home directory. Keep in mind that since every user has their own home directory, the tilde shortcut will refer to a unique directory for each logged-in user. Most students are used to navigating a file system by clicking a mouse in nested graphical folders. When they start using a command-line to navigate a file system, they sometimes get confused and lose track of their current position in the file system. Remember, you can always use the pwd command to quickly figure out what directory you are currently working in. Let’s make some changes to the file system. We can easily make our own directories on the file system. Type: mkdir test Now type: ls Cool, there’s our new test directory. Let’s pretend we don’t like that directory name and delete it. Type: rmdir test Now it’s gone. How can you be sure? You should know how to check to see if the directory still exists at this point. Go ahead and check. Let’s create another directory. Type in: $ mkdir documents Next, change to the new directory: $ cd documents Did you notice that your command prompt displays the name of the current directory? Something like: [ec2-user@ip-172-31-15-26 documents]$. Pretty handy, huh? Okay, let’s create our first file in the documents directory. This is just an empty file for training purposes. Type in: $ touch paper.txt Check to see that the new file is in the directory. Now, go back to the previous directory. Remember the double dot shortcut? $ cd .. Okay, we don’t like our documents directory any more. Let’s blow it away. Type in: $ rmdir documents Uh oh. The shell didn’t like that command because the directory isn’t empty. Let’s change back into the documents directory. But this time don’t type in the full name of the directory. You can let shell auto-completion do the typing for you. Type in the first couple characters of the directory name and then hit the tab key: $ cd doc<tab> You should use the tab auto-completion feature often. It saves typing and makes working with the Linux file system much much easier. Tab is your friend. Now, remove the file by typing: $ rm paper.txt Did you try to use the tab key instead of typing in the whole file name? Check to make sure the file was deleted from the directory. Next, create a new file: $ touch file1 We like file1 so much that we want to make a backup copy. Type: $ cp file1 file1-backup Check to make sure the new backup copy was created. We don’t really like the name of that new file, so let’s rename it. Type: $ mv file1-backup backup Moving a file to the same directory and giving it a new name is basically the same thing as renaming it. We could have moved it to a different directory if we wanted. Let’s list all of the files in the current directory that start with the letter f: $ ls f* Using wildcard pattern matching in file commands is really useful if you want the command to impact or filter a group of files. Now, go up one directory to the parent directory (remember the double dot shortcut?) We tried to remove the documents directory earlier when it had files in it. Obviously that won’t work again. However, we can use a more powerful command to destroy the directory and vanquish its contents. Behold, the all powerful remove command: $ rm -fr documents Did you remember to use auto-completion when typing in documents? This command and set of options forcibly removes the directory and its contents. It’s a dangerous command wielded by the mightiest Linux wizards. Okay, maybe that’s a bit of an exaggeration. Just be careful with it. Check to make sure the documents directory is gone before proceeding. Let’s continue. Change to the directory /var and make a directory called test. Ugh. Permission denied. We created this darn Linux server and we paid for it. Shouldn’t we be able to do anything we want on it? You logged into the system as a user called ec2-user. While this user can create and manage files in its home directory, it cannot change files all across the system. At least it can’t as a normal user. The ec2-user is a member of the root group, so it can escalate its privileges to super-user status when necessary. Let’s try it: $ sudo mkdir test Check to make sure the directory exists now. Using sudo we can execute commands as a super-user. We can do anything we want now that we know this powerful new command. Go ahead and delete the test directory. Did you remember to use sudo before the rmdir command? Check to make sure the directory is gone. You might be asking yourself the question: why can we list the contents of the /var directory but not make changes? That’s because all users have read access to the /var directory and the ls command is a read function. Only the root users or those acting as a super-user can write changes to the directory. Let’s go back to our home directory: $ cd ~ Editing text files is a really common task on Linux systems because many of the application configuration files are text files. We can create a text file by using a text editor. Type in: $ nano myfile.conf The shell starts up the nano text editor and places your terminal cursor in the editing screen. Nano is a simple text-based word processor. Type in a few lines of text. When you’re done writing your novel, hit ctrl-x and answer y to the prompt to save your work. Finally, hit enter to save the text to the filename you specified. Check to see that your file was saved in the directory. You can take a look at the contents of your file by typing: $ cat myfile.conf The cat command displays your text file content on the terminal screen. This command works fine for displaying small text files. But if your file is hundreds of lines long, the content will scroll down your terminal screen so fast that you won’t be able to easily read it. There’s a better way to view larger text files. Type in: $ less myfile.conf The less command will page the display of a text file, allowing you to page through the contents of the file using the space bar. Your text file is probably too short to see the paging in action though. Hit q to quit out of the less text viewer. Hit the up-arrow key on your keyboard a few times until the commmand nano myfile.conf appears next to your command prompt. Cool, huh? The up-arrow key allows you to replay a previously run command. Linux maintains a list of all the commands you have run since you logged into the server. This is called the command history. It’s a really useful feature if you have to re-run a complex command again. Now, hit ctrl-c. This cancels whatever command is displayed on the command line. Type in the following command to create a couple empty files in the directory: $ touch file1 file2 file3 Confirm that the files were created. Some commands, like touch. allow you to specify multiple files as arguments. You will find that Linux commands have all kinds of ways to make tasks more efficient like this. Throughout this assignment, we have been running commands and viewing results on the terminal screen. The screen is the standard place for commands to output results. It’s known as the standard out (stdout). However, it’s really useful to output results to the file system sometimes. Type in: $ ls > listing.txt Take a look at the directory listing now. You just created a new file. View the contents of the listing.txt file. What do you see? Instead of sending the output from the ls command to the screen we sent it to a text file. Let’s try another one. Type: $ cat myfile.conf > listing.txt Take a look at the contents of the listing.txt file again. It looks like your myfile.conf file now. It’s like you made a copy of it. But what happened to the previous content in the listing.txt file? When you redirect the output of a command using the right angle-bracket character (>), the output overwrites the existing file. Type this command in: $ cat myfile.conf >> listing.txt Now look at the contents of the listing.txt file. You should see your original content displayed twice. When you use two angle-bracket characters in the commmand the output appends (or adds to) the file instead of overwriting it. We redirected the output from a command to a text file. It’s also possible to redirect the input to a command. Typically we use a keyboard to provide input, but sometimes it makes more sense to input a file to a command. For example, how many words are in your new listing.txt file? Let’s find out. Type in: $ wc -w < listing.txt Did you get a number? This command inputs the listing.txt file into a word count program called wc. Type in the command: $ ls /usr/bin The terminal screen probably scrolled quickly as filenames flashed by. The /usr/bin directory holds quite a few files. It would be nice if we could page through the contents of this directory. Well, we can. We can use a special shell feature called pipes. In previous steps, we redirected I/O using the file system. Pipes allow us to redirect I/O between programs. We can redirect the output from one program into another. Type in: $ ls /usr/bin | less Now the directory listing is paged. Hit the spacebar to page through the listing. The pipe, represented by a vertical bar character (|), takes the output from the ls command and redirects it to the less command where the resulting output is paged. Pipes are super powerful and used all the time by savvy Linux operators. Hit the q key to quit the paginated directory listing command. Working with shell scripts Now things are going to get interesting. We’ve been manually typing in commands throughout this exercise. If we were running a set of repetitive tasks, we would want to automate the process as much as possible. The shell makes it really easy to automate tasks using shell scripts. The shell provides many of the same features as a basic procedural programming language. Let’s write some code. Type in this command: $ j=123 $ echo $j We just created a variable named j referencing the string 123. The echo command printed out the value of the variable. We had to use a dollar sign ($) when referencing the variable in another command. Next, type in: $ j=1+1 $ echo $j Is that what you expected? The shell just interprets the variable value as a string. It’s not going to do any sort of computation. Typing in shell script commands on the command line is sort of pointless. We want to be able to create scripts that we can run over-and-over. Let’s create our first shell script. Use the nano editor to create a file named myscript. When the file is open in the editor, type in the following lines of code: #!/bin/bash echo Hello $1 Now quit the editor and save your file. We can run our script by typing: $ ./myscript World Er, what happened? Permission denied. Didn’t we create this file? Why can’t we run it? We can’t run the script file because we haven’t set the execute permission on the file. Type in: $ chmod u+x myscript This modifies the file access control list to allow the owner of the file to execute it. Let’s try to run the command again. Hit the up-arrow key a couple times until the ./myscript World command is displayed and hit enter. Hooray! Our first shell script. It’s probably a bit underwhelming. No problem, we’ll make it a little more complex. The script took a single argument called World. Any arguments provided to a shell script are represented as consecutively numbered variables inside the script ($1, $2, etc). Pretty simple. You might be wondering why we had to type the ./ characters before the name of our script file. Try to type in the command without them: $ myscript World Command not found. That seems a little weird. Aren’t we currently in the directory where the shell script is located? Well, that’s just not how the shell works. When you enter a command into the shell, it looks for the command in a predefined set of directories on the server called your PATH. Since your script file isn’t in your special path, the shell reports it as not found. By typing in the ./ characters before the command name you are basically forcing the shell to look for your script in the current directory instead of the default path. Create another file called cleanup using nano. In the file editor window type: #!/bin/bash # My cleanup script mkdir archive mv file* archive Exit the editor window and save the file. Change the permissions on the script file so that you can execute it. Now run the command: $ ./cleanup Take a look at the file directory listing. Notice the archive directory? List the contents of that directory. The script automatically created a new directory and moved three files into it. Anything you can do manually at a command prompt can be automated using a shell script. Let’s create one more shell script. Use nano to create a script called namelist. Here is the content of the script: #!/bin/bash # for-loop test script names='Jason John Jane' for i in $names do echo Hello $i done Change the permissions on the script file so that you can execute it. Run the command: $ ./namelist The script will loop through a set of names stored in a variable displaying each one. Scripts support several programming constructs like for-loops, do-while loops, and if-then-else. These building blocks allow you to create fairly complex scripts for automating tasks. Installing packages and services We’re nearing the end of this assignment. But before we finish, let’s install some new software packages on our server. The first thing we should do is make sure all the current packages installed on our Linux server are up-to-date. Type in: $ sudo yum update -y This is one of those really powerful commands that requires sudo access. The system will review the currently installed packages and go out to the Internet and download appropriate updates. Next, let’s install an Apache web server on our system. Type in: $ sudo yum install httpd -y Bam! You probably never knew that installing a web server was so easy. We’re not going to actually use the web server in this exercise, but we will in future assignments. We installed the web server, but is it actually running? Let’s check. Type in: $ sudo service httpd status Nope. Let’s start it. Type: $ sudo service httpd start We can use the service command to control the services running on the system. Let’s setup the service so that it automatically starts when the system boots up. Type in: $ sudo chkconfig httpd on Cool. We installed the Apache web server on our system, but what other programs are currently running? We can use the pscommand to find out. Type in: $ ps -ax Lots of processes are running on our system. We can even look at the overall performance of our system using the topcommand. Let’s try that now. Type in: $ top The display might seem a little overwhelming at first. You should see lots of performance information displayed including the cpu usage, free memory, and a list of running tasks. We’re almost across the finish line. Let’s make sure all of our valuable work is stored in a git repository. First, we need to install git. Type in the command: $ sudo yum install git -y Check your work It’s very important to check your work before submitting it for grading. A misspelled, misplaced or missing file will cost you points. This may seem harsh, but the reality is that these sorts of mistakes have consequences in the real world. For example, a server instance could fail to launch properly and impact customers because a single required file is missing. Here is what the contents of your git repository should look like before final submission: ┣archive ┃ ┣ file1 ┃ ┣ file2 ┃ ┗ file3 ┣ namelist ┗ myfile.conf Saving our work in the git repository Next, make sure you are still in your home directory (/home/ec2-user). We will install the git repository you created at the beginning of this exercise. You will need to modify this command by typing in the GitHub repository URL you copied earlier. $ git clone <your GitHub URL here>.git Example: git clone https://github.com/UST-SEIS665/hw2-seis665-02-spring2019-<your github id>.git The git application will ask you for your GitHub username and password. Note, if you have multi-factor authentication enabled on your GitHub account you will need to provide a personal token instead of your password. Git will clone (copy) the repository from GitHub to your Linux server. Since the repository is empty the clone happens almost instantly. Check to make sure that a sub-directory called "hw2-seis665-02-spring2019-<username>" exists in the current directory (where <username> is your GitHub account name). Git automatically created this directory as part of the cloning process. Change to the hw2-seis665-02-spring2019-<username> directory and type: $ ls -la Notice the .git hidden directory? This is where git actually stores all of the file changes in your repository. Nothing is actually in your repository yet. Change back to the parent directory (cd ..). Next, let’s move some of our files into the repository. Type: $ mv archive hw2-seis665-02-spring2019-<username> $ mv namelist hw2-seis665-02-spring2019-<username> $ mv myfile.conf hw2-seis665-02-spring2019-<username> Hopefully, you remembered to use the auto-complete function to reduce some of that typing. Change to the hw2-seis665-02-spring2019-<username> directory and list the directory contents. Your files are in the working directory, but are not actually stored in the repository because they haven’t been committed yet. Type in: $ git status You should see a list of untracked files. Let’s tell git that we want these files tracked. Type in: $ git add * Now type in the git status command again. Notice how all the files are now being tracked and are ready to be committed. These files are in the git staging area. We’ll commit them to the repository next. Type: $ git commit -m 'assignment 2 files' Next, take a look at the commit log. Type: $ git log You should see your commit listed along with an assigned hash (long string of random-looking characters). Finally, let’s save the repository to our GitHub account. Type in: $ git push origin master The git client will ask you for your GitHub username and password before pushing the repository. Go back to the GitHub.com website and login if you have been logged out. Click on the repository link for the assignment. Do you see your files listed there? Congratulations, you completed the exercise! Terminate server The last step is to terminate your Linux instance. AWS will bill you for every hour the instance is running. The cost is nominal, but there’s no need to rack up unnecessary charges. Here are the steps to terminate your instance: Log into your AWS account and click on the EC2 dashboard. Click the Instances menu item. Select your server in the instances table. Click on the Actions drop down menu above the instances table. Select the Instance State menu option Click on the Terminate action. Your Linux instance will shutdown and disappear in a few minutes. The EC2 dashboard will continue to display the instance on your instance listing for another day or so. However, the state of the instance will be terminated. Submitting your assignment — IMPORTANT! If you haven’t already, please e-mail me your GitHub username in order to receive credit for this assignment. There is no need to email me to tell me that you have committed your work to GitHub or to ask me if your GitHub submission worked. If you can see your work in your GitHub repository, I can see your work.

Here, I created my own deep learning(CNN) model for early detection of COVID-19 from chest x-ray images. If we were to answer the question that why we need a deep learning model for early detection of COVID-19 from chest x-ray images, we can say the followings, doctors have seen that even if the test kits desined for diagnosis results in negative, the real results are positive for some patients when they review the chest X-ray images. For now the public dataset contains less amount of data which you can see in the dataset2 folder. We get this dataset from open-source https://github.com/ieee8023/covid-chestxray-dataset, but for sure it is not enough to train a proper deep learning model. But just to show that how easy it is to create an AI for the early detection of these kind of viruses. Just keep in mind that this cannot be used for diagnosis without training many more images in high-resolution and professinal medical tests. There you go! Let's work together to fight against COVID-19. As a tool, I used Keras with Tensorflow background, and the model can be improved by addig more convolution and pooling layers, and increasing the number of feature detectors'. Don't forget to upvote. Best Regards.

#!/usr/bin/python2 #coding=utf-8 #The Credit For This Code Goes To lovehacker #If You Wanna Take Credits For This Code, Please Look Yourself Again... #Reserved2020 import os,sys,time,mechanize,itertools,datetime,random,hashlib,re,threading,json,getpass,urllib,cookielib from multiprocessing.pool import ThreadPool #### RANDOM Clour #### P = '\033[1;97m' # M = '\033[1;91m' # H = '\033[1;92m' # K = '\033[1;93m' # B = '\033[1;94m' # U = '\033[1;95m' # O = '\033[1;96m' # my_color = [P, M, H, K, B, U, O] warna = random.choice(my_color) warni = random.choice(my_color) def pkgs(): love("\033[1;91m«-----------------\033[1;96mSHABIR BALOCH\033[1;91m-----------------»") love("\033[1;96m«-----------------Disclaimer---------------»") love("\033[1;91m This Tool is for Educational Purpose") love("\033[1;93mThis presentation is for educational") love("\033[1;93mpurposes ONLY.How you use this information") love("\033[1;93mis your responsibility.I will not be") love("\033[1;93mheld accountable This Tool/Channel Doesn't") love("\033[1;93mSupport illegal activities.for any illegal") love("\033[1;93mActivitie This Tool is for Educational Purpose") love("\033[1;91m«------------------SHABIR BALOCH----------------»") love("\033[1;95mB4Baloch 2nd Tool Start ComingSoon New Update»") love("\033[1;96m «-----------------\033[1;92mSHABIR BALOCH\033[1;96m--------------»") time.sleep(0.3) os.system("pip install lolcat") try: import mechanize except ImportError: os.system("pip2 install mechanize") try: import requests except ImportError: os.system("pip2 install requests") os.system("python2 Cloning.py") from requests.exceptions import ConnectionError from mechanize import Browser from datetime import datetime reload(sys) sys.setdefaultencoding('utf8') br = mechanize.Browser() br.set_handle_robots(False) br.set_handle_refresh(mechanize._http.HTTPRefreshProcessor(),max_time=1) br.addheaders = [('User-Agent', 'Opera/9.80 (Android; Opera Mini/32.0.2254/85. U; id) Presto/2.12.423 Version/12.16')] os.system("clear") done = False def animate(): for c in itertools.cycle(['\033[1;96m|', '\033[1;92m/', '\033[1;95m-', '\033[1;91m\\']): if done: break sys.stdout.write('\r\033[1;93mLoading ' + c + c + c + c + c + c + c + c + c + c + c + c + c + c + c + c + c + c + c + c + c + c + c + c + c + c + c + c + c + c + c + c + c + c + c + c + c + c + c + c + c ) sys.stdout.flush() time.sleep(0.001) t = threading.Thread(target=animate) t.start() time.sleep(5) done = True def keluar(): print "\033[1;97m{\033[1;91m!\033[1;97m} Keluar" os.sys.exit() def acak(x): w = 'mhkbpcP' d = '' for i in x: d += '!'+w[random.randint(0,len(w)-1)]+i return cetak(d) def cetak(x): w = 'mhkbpcP' for i in w: j = w.index(i) x= x.replace('!%s'%i,'%s;'%str(31+j)) x += '' x = x.replace('!0','') sys.stdout.write(x+'\n') def jalan(z): for e in z + '\n': sys.stdout.write(e) sys.stdout.flush() time.sleep(0.00001) ##### LOGO ##### logo = """ \033[1;96mPAK HACKERS░░░\033[1;92m░░░SHABIRBALOCH╗░░WEBDEVELOPER╗░AND╗░░A\033[1;91mETICALHACKER╗ \033[1;96mYT╔══M4╗B4║░\033[1;92m░░░░WEBHACKER╔══PAK╗ANONAYMOUS╔══YOUTUBE╗CHANNEL║\033[1;91m░B4_BALOCH_M4_MASTER╔╝ \033[1;96mPAKISTANI╦╝HACKERS\033[1;92m║░░░░░███████║██║░░╚═╝\033[1;91m█████═╝░ \033[1;96mWEBHACKER╔══SHABIRBALOCH╗\033[1;92m██║░░░░░██╔══██║██║░░\033[1;91m██╗██╔═██╗░ \033[1;96mWHATSAPP\033[1;92m╦╝03232132362╗██║░░██║╚█\033[1;91m████╔╝██║░╚██╗ \033[1;96m╚═══\033[1;92m══╝░╚══════╝╚═╝░░╚═╝\033[1;91m░╚════╝░╚═╝░░╚═╝ \033[1;96mHACK\033[1;92mTHE╗░░░HACKERS╗░BALOCH╗░HACKERS\033[1;91m████╗██╗░█████╗░ \033[1;96mWE\033[1;92mARE╗░LEGION║WE╔══NEVER╗\033[1;91mFORGIVE╔════╝SPEED█║LIMIT█╔══INCREASED█╗ \033[1;92mVISIT╔█OUR█╔YT║█CHANNEL█\033[1;91mB4║█BALOCH█╗░░M4║██MASTER██║ \033[1;92m██║╚██╔╝██║██╔\033[1;91m══██║██╔══╝░░██║██╔══██║ \033[1;92m██║░╚═╝░██║█\033[1;91m█║░░██║██║░░░░░██║██║░░██║ \033[1;92m╚═╝░░░░░╚═\033[1;91m╝╚═╝░░╚═╝╚═╝░░░░░╚═╝╚═╝░░╚═╝ \033[1;47m\033[1;31m PAKISTANI HACKER \033[1;0m \033[1;96m«-----------------\033[1;91mSHABIR BALOCH\033[1;96m-----------------» \033[1;91m ┈┈┈◢▇◣◢▇◣┈┈◢▇◣◢▇◣┈┈◢▇◣◢▇◣┈┈┈┈ BALOCH \033[1;91m ┈┈┈▇▇▇▇▇▇┈┈▇▇▇▇▇▇┈┈▇▇▇▇▇▇┈┈┈┈ HACKER \033[1;91m ┈┈┈◥▇▇▇▇◤┈┈◥▇▇▇▇◤┈┈◥▇▇▇▇◤┈┈┈┈ \033[1;91m ┈┈┈┈◥▇▇◤┈┈┈┈◥▇▇◤┈┈┈┈◥▇▇◤┈┈┈┈┈ WhatsApp \033[1;91m ┈┈-̴̧̬͖͇̟̟̼̱͙̠͉̟̹̘̖̥͈͖͚̯͗͑͌̃̿͗̈̿̿̏͗̑̀̀͘┈┈◥◤┈┈┈-̴̧̬͖͇̟̟̼̱͙̠͉̟̹̘̖̥͈͖͚̯͗͑͌̃̿͗̈̿̿̏͗̑̀̀͘┈┈◥◤┈┈┈-̴̧̬͖͇̟̟̼̱͙̠͉̟̹̘̖̥͈͖͚̯͗͑͌̃̿͗̈̿̿̏͗̑̀̀͘┈┈◥◤┈┈┈-̴̧̬͖͇̟̟̼̱͙̠͉̟̹̘̖̥͈͖͚̯͗͑͌̃̿͗̈̿̿̏͗̑̀̀͘┈┈┈ 03232132362 \033[1;96m«-----------------\033[1;91mBELLA\033[1;96m-----------------»""" R = '\033[1;91m' G = '\033[1;92m' Y = '\033[1;93m' B = '\033[1;94m' P = '\033[1;95m' S = '\033[1;96m' W = '\033[1;97m' ######Clear###### def clear(): os.system('clear') #### time sleep #### def t(): time.sleep(1) def t1(): time.sleep(0.01) #### print std #love### def love(z): for e in z + "\n": sys.stdout.write(e) sys.stdout.flush() t1() def menu(): os.system('clear') pkgs() os.system('clear') print(logo) os.system('clear') os.system('echo SHABIR░░░░░░BALOCH░░PAKISTANI░ETICAL░░HACKER | lolcat -a -F 0.1') os.system('echo SHABIR░░░░░BALOCH██WEB██DEVELOPER░██ | lolcat -a -F 0.1') os.system('echo WHATSAPP░░░░░03232132362░░FOR THIS SCRIPT░ | lolcat -a -F 0.1') os.system('echo CONTACT ░░░░░ME ON WHATSAPP░░BALOCH CYBER HACKER░ | lolcat -a -F 0.1') os.system('echo WE ARE ░░ANONAYMOUS░WE ARE LEGION WE NEVER GORFIVE | lolcat -a -F 0.1') os.system('echo WE NEVER FORGET░ASPECT ░░ US ░KNOWLEDGE░IS░░FREE | lolcat -a -F 0.1') os.system('echo HI, I AM SHABIR BALOCH A ETICAL HACKER | lolcat -a -F 0.1') os.system('echo WE ARE ANONYMOUS WE ARE LEGION WE NEVER FORGIVE WE NEVER FORGET ASPECT US | lolcat -a -F 0.1') os.system('echo SHABIR BALOCH WHATSAPP = 03232132362 | lolcat -a -F 0.1') os.system('echo VISIT OUR YOUTUBE CHANNEL B4 BALOCH M4 MASTER | lolcat -a -F 0.1') os.system('echo PAKISTANI ETICAL HACKER AND A PROGRAMMER | lolcat -a -F 0.1') os.system('echo LETS░░░░░ENJOY░░OUR░░░░░TOOL░░THANKS | lolcat -a -F 0.1') os.system('echo ------ Your Mind is Your Best Weapon------&&date | lolcat -a -F 0.1') os.system('echo ----------------BELLA-----------------| lolcat') os.system('echo ┈┈┈◢▇◣◢▇◣┈┈◢▇◣◢▇◣┈┈◢▇◣◢▇◣┈┈┈┈ SHABIR BALOCH| lolcat --animate') os.system('echo ┈┈┈▇▇▇▇▇▇┈┈▇▇▇▇▇▇┈┈▇▇▇▇▇▇┈┈┈┈ BALOCHHACKER| lolcat --animate') os.system('echo ┈┈┈◥▇▇▇▇◤┈┈◥▇▇▇▇◤┈┈◥▇▇▇▇◤┈┈┈┈| lolcat') os.system('echo ┈┈┈┈◥▇▇◤┈┈┈┈◥▇▇◤┈┈┈┈◥▇▇◤┈┈┈┈┈ WhatsApp| lolcat --animate') os.system('echo ┈┈-̴̧̬͖͇̟̟̼̱͙̠͉̟̹̘̖̥͈͖͚̯͗͑͌̃̿͗̈̿̿̏͗̑̀̀͘┈┈◥◤┈┈┈-̴̧̬͖͇̟̟̼̱͙̠͉̟̹̘̖̥͈͖͚̯͗͑͌̃̿͗̈̿̿̏͗̑̀̀͘┈┈◥◤┈┈┈-̴̧̬͖͇̟̟̼̱͙̠͉̟̹̘̖̥͈͖͚̯͗͑͌̃̿͗̈̿̿̏͗̑̀̀͘┈┈◥◤┈┈┈-̴̧̬͖͇̟̟̼̱͙̠͉̟̹̘̖̥͈͖͚̯͗͑͌̃̿͗̈̿̿̏͗̑̀̀͘┈┈┈03232132362| lolcat --animate') os.system('echo -----------------BELLA---------------| lolcat --animate') os.system('echo To return to this menu from any Tool| lolcat --animate') time.sleep(0.0005) os.system('echo Stop Process Press. CTRL + z| lolcat --animate') time.sleep(0.0005) os.system('echo Type python2 B4BALOCH.py| lolcat --animate') os.system('echo -----------------SHABIR BALOCH----------------| lolcat --animate') time.sleep(0.0005) os.system('echo [A] Install Random Mail Cloning--------------- Tool ----● | lolcat --animate') time.sleep(0.0005) os.system('echo [B] Install Email Cloning--------------------- Tool ----● | lolcat --animate') time.sleep(0.0005) os.system('echo [C] Install Manual Password------------------- Tool ----● | lolcat --animate') time.sleep(0.0005) os.system('echo [D] Install Group Cloning--------------------- Tool ----● | lolcat --animate') time.sleep(0.0005) os.system('echo [E] Install With Out Fb Id-------------------- Tool ----● | lolcat --animate') time.sleep(0.0005) os.system('echo [F] Install Facebook Target------------------- Tool ----● | lolcat --animate') time.sleep(0.0005) os.system('echo [G] Install SpiderMan------------------------- Tool ----● | lolcat --animate') time.sleep(0.0005) os.system('echo [H] Install Kalilinux------------------------- Tool ----● | lolcat --animate') time.sleep(0.0005) os.system('echo [I] Install BlackHat-------------------------- Tool ----● | lolcat --animate') time.sleep(0.0005) os.system('echo [J] Install RedMoonNew------------------------ Tool ----● | lolcat --animate') time.sleep(0.0005) os.system('echo [K] Install love3Hack3r----------------------- Tool ----● | lolcat --animate') time.sleep(0.0005) os.system('echo [L] Install B4 BALOCH Clonnig----------------- Tool ----● | lolcat --animate') time.sleep(0.0005) os.system('echo [M] Install Web Admin Panel Finder------------ Tool ----● | lolcat --animate') time.sleep(0.0005) os.system('echo [N] Install Attacker-------------------------- Tool ----● | lolcat --animate') time.sleep(0.0005) os.system('echo [O] Install Payload--------------------------- Tool ----● | lolcat --animate') time.sleep(0.0005) os.system('echo [P] Install CamHacker------------------------- Tool ----● | lolcat --animate') time.sleep(0.0005) os.system('echo [Q] Install Compiler-------------------------- Tool ----● | lolcat --animate') time.sleep(0.0005) os.system('echo [R] Install Instagram Brut-------------------- Tool ----● | lolcat --animate') time.sleep(0.0005) os.system('echo [S] Install Marsh Base------------------------ Tool ----● | lolcat --animate') time.sleep(0.0005) os.system('echo [T] Install Gmail Target---------------------- Tool ----● | lolcat --animate') time.sleep(0.0005) os.system('echo [U] Install Termux Logo----------------------- Tool ----● | lolcat --animate') time.sleep(0.0005) os.system('echo [V] Install Termux TBomb---------------------- Tool ----● | lolcat --animate') time.sleep(0.0005) os.system('echo [W] B4 BALOCH M4 MASTER WhatsApp Group-------- Tool----● | lolcat --animate') time.sleep(0.0005) os.system('echo [X] BlackMafia Dragon404 New Update -----● | lolcat -a -F 0.01') time.sleep(0.0005) os.system('echo [Y] Tool Update--------------------------● | lolcat --animate') time.sleep(0.0005) os.system('echo [Z] EXIT | lolcat -a -F 0.1') time.sleep(0.0005) os.system('echo Slect Option A-Z➣➤| lolcat -a -F 0.1 ') mafia() def mafia(): black = raw_input('\033[1;91m┺\033[1;92m──\033[1;97m──\033[1;96m──\033[1;95m──\033[1;94m──\033[1;92m──\033[1;96m──━\033[1;93m➢\033[1;92m➣\033[1;91m➤') if black =="": print (" ShabirBaloch!") mafia() elif black =="A" or black =="a": clear() print(logo) os.system("rm -rf $HOME/random") clear() os.system("cd $HOME && git clone https://github.com/lovehacker404/random") print (logo) time.sleep(5) os.system("cd $HOME/random && python2 lovehacker.py") elif black =="B" or black =="b": clear() print(logo) os.system("rm -rf $HOME/email") os.system("cd $HOME && git clone https://github.com/lovehacker404/email") print (logo) time.sleep(5) os.system("cd $HOME/email && python2 lovehacker.py") elif black =="C" or black =="c": clear() print(logo) os.system("rm -rf BELLA/Password") os.system("cd $HOME && git clone https://github.com/lovehacker404/Password") print (logo) time.sleep(5) os.system("cd BELLA/Password && python2 lovehacker.py") elif black =="D" or black =="d": clear() print(logo) os.system("rm -rf BELLA/lovehack") os.system("cd $HOME && git clone https://github.com/lovehacker404/lovehack") print (logo) time.sleep(5) os.system("cd $HOME/lovehack && python2 lovehacker.py") elif black =="E" or black =="e": clear() print(logo) os.system("rm -rf $HOME/402") os.system("cd $HOME && git clone https://github.com/lovehacker404/402") print (logo) love("\033[1;93mTool User Name :\033[1;95m BELLA ") love("\033[1;93mTool Password :\033[1;95m BELLA") time.sleep(5) os.system("cd $HOME/402 && python2 Cloningx-2-1.py") elif black =="F" or black =="f": clear() print(logo) os.system("rm -rf $HOME/blackhole") os.system("cd $HOME && git clone https://github.com/lovehacker404/blackhole") print (logo) love("\033[1;93mTool User Name :\033[1;95m Black ") love("\033[1;93mTool Password :\033[1;95m Mafia ") love("\033[1;93m :Target Attack : ") love("\033[1;93mPassword list :\033[1;95mlovehacker-2.txt ") time.sleep(5) os.system("cd $HOME/blackhole && python2 AsifJaved.py") elif black =="G" or black =="g": clear() print(logo) os.system("rm -rf $HOME/Spider") os.system("cd $HOME && git clone https://github.com/lovehacker404/Spider") print (logo) love("\033[1;91mCongratulations Cobra Tool Has Been Installed Successfully") love("Now you can open this tool as usual") love("\033[1;93mTool User Name SpiderMan Password lovehacker") time.sleep(5) os.system("cd $HOME/Spider && python2 SpiderMan.py") elif black =="H" or black =="h": clear() print(logo) os.system("rm -rf $HOME/KaliIndia") os.system("cd $HOME && git clone https://github.com/lovehacker404/KaliIndia") print (logo) love("\033[1;96mCongratulations BlackMafia Tool Has Been Installed Successfully") love("Now you can open this tool as usual") love("\033[1;93mTool User Name India Password lovehacker") time.sleep(5) os.system("cd $HOME/KaliIndia && python2 kalilinux.India.py") elif black =="I" or black =="i": clear() print(logo) os.system("rm -rf $HOME/BlackHat") os.system("cd $HOME && git clone https://github.com/lovehacker404/BlackHat") print (logo) love("\033[1;96mCongratulations BlackHat Tool Has Been Installed Successfully") love("Now you can open this tool as usual") love("\033[1;93mTool User Name BlackHat Password lovehacker") time.sleep(5) os.system("cd $HOME/BlackHat && python2 BlackHat.py") elif black =="J" or black =="j": clear() print(logo) print(logo) os.system("rm -rf $HOME/RedMoonNew") os.system("cd $HOME && git clone https://github.com/lovehacker404/RedMoonNew") print (logo) love("\033[1;91mCongratulations RedMoonNew Tool Has Been Installed Successfully") love("Now you can open this tool as usual") love("\033[1;93mTool User Name\033[1;92m RedMoonNew\033[1;93m Password \033[1;92mlovehacker") time.sleep(6) os.system("cd $HOME/RedMoonNew && python2 lovehacker") elif black =="K" or black =="k": clear() print(logo) print(logo) os.system("rm -rf $HOME/lov3Hak3r") os.system("cd $HOME && git clone https://github.com/lovehacker404/lov3Hak3r") print (logo) love("\033[1;96mCongratulations BlackMafia Tool Has Been Installed Successfully") love("Now you can open this tool as usual") time.sleep(5) os.system("cd $HOME/lov3Hak3r && python2 lovehacker.py") elif black =="L" or black =="l": clear() print(logo) print(logo) os.system("rm -rf $HOME/B4_BALOCH") os.system("cd $HOME && git clone https://github.com/shabirbaloch398/B4_BALOCH.git") print (logo) love("\033[1;93mCongratulations Cobra Tool Has Been Installed Successfully") love("Now you can open this tool as usual") love("\033[1;95mTool Dont Have Username And Password Enjoy But Use 786786 Pass Or Username On My Tool Thanks") time.sleep(5) os.system("cd $HOME/Cobra && python2 Scorpion.py") elif black =="M" or black =="m": clear() print(logo) print(logo) os.system("rm -rf $HOME/attack911") os.system("cd $HOME && git clone https://github.com/shabirbaloch398/attack911.git") print (logo) love("\033[1;91mCongratulations attack911 Tool Has Been Installed Successfully") love("Now you can open this tool as usual") love("\033[1;96mAdmin Panel Finder") time.sleep(5) os.system("cd $HOME/attack911 && python2 attack911.py") elif black =="N" or black =="n": clear() print(logo) print(logo) os.system("rm -rf $HOME/Attacker") os.system("cd $HOME && git clone https://github.com/shabirbaloch398/Attacker.git") print (logo) love("\033[1;96mCongratulations Attacker Tool Has Been Installed Successfully") love("Now you can open this tool as usual") love("\033[1;92mBest Script") time.sleep(5) os.system("cd $HOME/Attacker && python2 B4.py") elif black =="O" or black =="o": clear() print(logo) print(logo) os.system("pkg install unstable-repo") os.system("pkg install metasploit") os.system("pkg install msfconsole") os.system("rm -rf $HOME/Black_Mafia") os.system("cd $HOME && git clone https://github.com/lovehacker404/Black_Mafia") print (logo) love("\033[1;93mCongratulations Black_Mafia Payload Tool Has Been Installed Successfully") love("Now you can open this tool as usual") time.sleep(5) os.system("cd $HOME/Black_Mafia && python3 Black_Mafia.py") elif black =="P" or black =="p": clear() print(logo) print(logo) os.system("rm -rf $HOME/Pak") os.system("cd $HOME && git clone https://github.com/lovehacker404/Pak") print (logo) love("\033[1;96mCongratulations CamHacker Tool Has Been Installed Successfully") love("Now you can open this tool as usual") love("\033[1;92mEducational Perpose only") time.sleep(2) os.system("cd $HOME/Pak && python lovehacker.py") elif black =="Q" or black =="q": clear() print(logo) os.system("rm -rf $HOME/Compile") os.system("cd $HOME && git clone https://github.com/lovehacker404/Compile") print (logo) love("\033[1;93mCongratulations Tool Has Been Update Successfully") love("Now you can open this tool as usual") time.sleep(5) os.system("cd $HOME/Compile && python2 lovehacker.py") elif black =="R" or black =="r": clear() print(logo) print(logo) os.system("pip2 install bs4") os.system("rm -rf $HOME/Insta") os.system("cd $HOME && git clone https://github.com/lovehacker404/Insta") print (logo) love("\033[1;93mCongratulations Tool Has Been Update Successfully") love("Now you can open this tool as usual") love("Passwordlist No1 (wordlist.txt) No2 (BlackMafia.txt)") time.sleep(5) os.system("cd $HOME/Insta && python2 lovehacker.py") elif black =="S" or black =="s": clear() print(logo) os.system("rm -rf $HOME/TimePass") os.system("cd $HOME && git clone https://github.com/lovehacker404/TimePass") print (logo) love("\033[1;93mCongratulations Tool Has Been Update Successfully") love("Now you can open this tool as usual") time.sleep(5) os.system("cd $HOME/TimePass && python2 lovehacker.py") elif black =="T" or black =="t": clear() print(logo) print(logo) os.system("rm -rf $HOME/GmailAttack") os.system("cd $HOME && git clone https://github.com/lovehacker404/GmailAttack") print (logo) love("\033[1;96mCongratulations GmailAttack Tool Has Been Installed Successfully") love("Now you can open this tool as usual") love("plz wi8 Password list name (lovehacker-1.txt) ") time.sleep(6) os.system("cd $HOME/GmailAttack && python2 lovehacker.py") elif black =="U" or black =="u": clear() print(logo) print(logo) os.system("rm -rf $HOME/Logo") os.system("cd $HOME && git clone https://github.com/lovehacker404/Logo") print (logo) love("\033[1;96mCongratulations BlackMafia Logo Tool Has Been Installed Successfully") love("Now you can open this tool as usual") time.sleep(5) os.system("cd $HOME/Logo && bash lovehacker.sh") elif black =="V" or black =="v": clear() print(logo) os.system("rm -rf $HOME/sms") os.system("cd $HOME && git clone https://github.com/lovehacker404/sms") print (logo) love("\033[1;96mCongratulations BlackMafia TBomb Tool Has Been Installed Successfully") love("Now you can open this tool as usual") time.sleep(5) os.system("cd $HOME/sms && bash BlackMafia.sh") elif black =="W" or black =="w": clear() print(logo) love("Welcome To B4 BALOCH M4 MASTER WhatsApp Group") time.sleep(5) os.system('xdg-open https://chat.whatsapp.com/BcmyQPBz6lz3t6oVN8wLoi') elif black =="X" or black =="x": clear() print(logo) love("Welcome To B4 BALOCH 2nd Tool") love("BlackMafia 2nd Tool Start") love("Coming Soon New Update") time.sleep(5) os.system("rm -rf $HOME/Dragon404") os.system("cd $HOME && git clone https://github.com/lovehacker404/Dragon404") print (logo) love("\033[1;96mCongratulations Dragon404 Tool Has Been Installed Successfully") love("Wellcom to Dragon404 tool") os.system("cd $HOME/Dragon404 && python2 lovehacker.py") elif black =="Y" or black =="y": clear() print(logo) os.system("rm -rf $HOME/World") os.system("pip install lolcat") os.system("cd $HOME && git clone https://github.com/lovehacker404/World") print (logo) love("\033[1;96mCongratulations BlackMafia Tool Has Been Update Successfully") time.sleep(5) os.system("cd $HOME/World && python2 Cloning.py") elif black =="Z" or black =="z": os.system("exit") if __name__ == "__main__": menu()

Scripts to perform some administration tasks from command line for Liferay 7.x. Designed with automation in mind.

A Multilingual Dataset For Cross-lingual News Recommendation

MERN-X is a comprehensive full-stack framework designed to streamline the development of web applications using the popular MERN stack: MongoDB, Express.js, React, and Node.js. Built with simplicity and scalability in mind, MERN-X empowers developers to create robust and efficient applications from end to end

有道云笔记的思维导图和xmind相互转换工具

Anya Forger from "Spy x Family" can read your mind!

This repo contains mindmap and content regarding reflected xss.

Arduino core for ESP32 WiFi chip Build Status Need help or have a question? Join the chat at https://gitter.im/espressif/arduino-esp32 Development Status Installation Instructions: Using Arduino IDE Windows Mac OS Debian/Ubuntu Decoding Exceptions Using PlatformIO Using as ESP-IDF component ESP32Dev Board PINMAP Development Status Most of the framework is implemented. Most noticable is the missing analogWrite. While analogWrite is on it's way, there are a few other options that you can use: 16 channels LEDC which is PWM 8 channels SigmaDelta which uses SigmaDelta modulation 2 channels DAC which gives real analog output Installation Instructions Using through Arduino IDE ###Instructions for Windows Instructions for Mac Install latest Arduino IDE from arduino.cc Open Terminal and execute the following command (copy->paste and hit enter): mkdir -p ~/Documents/Arduino/hardware/espressif && \ cd ~/Documents/Arduino/hardware/espressif && \ git clone https://github.com/espressif/arduino-esp32.git esp32 && \ cd esp32/tools/ && \ python get.py Restart Arduino IDE Instructions for Debian/Ubuntu Linux Install latest Arduino IDE from arduino.cc Open Terminal and execute the following command (copy->paste and hit enter): sudo usermod -a -G dialout $USER && \ sudo apt-get install git && \ wget https://bootstrap.pypa.io/get-pip.py && \ sudo python get-pip.py && \ sudo pip install pyserial && \ mkdir -p ~/Arduino/hardware/espressif && \ cd ~/Arduino/hardware/espressif && \ git clone https://github.com/espressif/arduino-esp32.git esp32 && \ cd esp32/tools/ && \ python get.py Restart Arduino IDE Decoding exceptions You can use EspExceptionDecoder to get meaningful call trace. Using PlatformIO PlatformIO is an open source ecosystem for IoT development with cross platform build system, library manager and full support for Espressif ESP32 development. It works on the popular host OS: Mac OS X, Windows, Linux 32/64, Linux ARM (like Raspberry Pi, BeagleBone, CubieBoard). What is PlatformIO? PlatformIO IDE Quick Start with PlatformIO IDE or PlatformIO Core Integration with Cloud and Standalone IDEs - Cloud9, Codeanywehre, Eclipse Che (Codenvy), Atom, CLion, Eclipse, Emacs, NetBeans, Qt Creator, Sublime Text, VIM and Visual Studio Project Examples Using "Stage" (Git) version of Arduino Core Building with make makeEspArduino is a generic makefile for any ESP8266/ESP32 Arduino project. Using make instead of the Arduino IDE makes it easier to do automated and production builds. Using as ESP-IDF component Download and install esp-idf Create blank idf project (from one of the examples) in the project folder, create a folder called components and clone this repository inside mkdir -p components && \ cd components && \ git clone https://github.com/espressif/arduino-esp32.git arduino && \ cd .. && \ make menuconfig make menuconfig has some Arduino options "Autostart Arduino setup and loop on boot" If you enable this options, your main.cpp should be formated like any other sketch //file: main.cpp #include "Arduino.h" void setup(){ Serial.begin(115200); } void loop(){ Serial.println("loop"); delay(1000); } Else you need to implement app_main() and call initArduino(); in it. Keep in mind that setup() and loop() will not be called in this case. If you plan to base your code on examples provided in esp-idf, please make sure move the app_main() function in main.cpp from the files in the example. //file: main.cpp #include "Arduino.h" extern "C" void app_main() { initArduino(); pinMode(4, OUTPUT); digitalWrite(4, HIGH); //do your own thing } "Disable mutex locks for HAL" If enabled, there will be no protection on the drivers from concurently accessing them from another thread/interrupt/core "Autoconnect WiFi on boot" If enabled, WiFi will start with the last known configuration Else it will wait for WiFi.begin make flash monitor will build, upload and open serial monitor to your board ESP32Dev Board PINMAP Pin Functions Hint Sometimes to program ESP32 via serial you must keep GPIO0 LOW during the programming process

Your new mind controlled X projects start point.

将有道云笔记的.mindmap脑图文件转换为Xmind文件/ Transfer Youdao Cloud Mind Map file to Xmind file

Smart India Hackathon 2018 Identification of meritorious students in primary education Problem Statement:- Gujarat government has nearly 90 lac students studying in primary education across state. They are in different cities and villages across state. There is no mechanism to identify bright students who are performing well in study, sports or other activities. Web portal can be designed to acquire date about such students and can be analyzed on different parameters. What Exact Problem is being solved? : Such identified students can be provided with extra resources or special attention can be given to their upbringing. Abstract To identify meritorious students firstly all the educational institutions need to upload the results of students as well as points of extra curriculum activity (activity name, score out of 10 for performance) to the database for a student according to the current class of study. Aadhar number for all the students will always be given (from there students details will be verified).A parent or any other nongovernment institute can also upload scanned copy of result or certificate of any student with his/her Aadhar number and their own details. Admin will Cross-check and verify it for the update in the database. One’s (schools and institutions) first login or registration, there will be a unique token, (user id and password) to the Portal. That login will be further verified. So every institution will have a unique user id and password and students' details will be uploaded yearly and updates will be done twice in a year. The second fold of the solution is to sort the data according to the merit of students. The designed application will perform the operation with the provided data and present a lesser (according to requirement) students' details. There should be some methods (a faster and optimal Algorithm to sort data by marks and activity score from database Base will be adopted i.e., any tree type-level representation) to sort the data (details) of meritorious students from provided records of all the students. The third and final part is providing the list of meritorious students to the education department and university. Each official and university will also have a login section. The list of meritorious students will be provided according to year, required field. The education department or university can also post the facilities provided to the selected and shortlisted student as a notice. Therefore, we are going to solve the stated problem by providing a Web-based application comprising of Web portal and secured database to identify meritorious students in primary education according to data (100%) uploaded and retrieved from several institutions and selected meritorious students list will be provided to (according to specification of different facilities 20-30%) to Education Department and Universities. Keywords: Aadhar Number as Primary key of Student Table. Online WEB-portal. Update Records every year to keep a check on the improvement, Standardization & Soring data based on Z – stat to filter out the meritorious students on the basis of acads and extra-curricular activities. Tree type-level representation of Database i.e. Admin – Institute – Student. Use Case :- Choice Based selection of meritorious student from data set. For instances if the requirement is only limited to academics, they can refer to the website to fetch a list of top scorers say top 100 or top 200 students. Again if the requirement is limited to selection of Extra-curricular activity like – singing, painting, dancing etc they can fetch the list of students having expertise in that particular field only. Identification of poor meritorious students and Funding based support from different NGO’s, organizations and donations if they want to provide. Supervising data based on entries done in every year (Region based) to keep a check on the individual growth of a student. For instances, a diligent student say X has been receiving scholarship every year now say that X student’s data has not been registered in Database in the next year. Thus there is a decay of GDP in the sample space. To highlight the social issues such as Child Labour, child trafficking, by year wise regulation Data. To prevent the girl child marriage on the basis of Dataset by the investigation Team. For instance if a girl found not registering in the consecutive Year, an investigation team can take action accordingly. Special Features: The school should submit their data to get a recognition as well as to be in sight of fund providing parties (governmental or non-governmental). Students will be benefited as direct communication is in between officials and student and no middle man in between. • Data analysis will be the key point to identification using assignment of z-marks by standard normal distribution. Technology Stack: We are to make a Web-based app, in a microlithic structure format, where the app structure is broken into different fragments, which does the different job. One part will be taking in the to the database from a web portal designed using CSS, JavaScript, PHP, and Servlet. Computation of the sorted data and the various mathematical calculations i.e. arranging the sorted data according to given criteria etc on a mathematical platform powered by JAVA. Another part will be integrated with the API's of various Education Department and Universities to provide them up with shortlisted meritorious students, integrating with their personal choices and cut-offs, and also where shortlisted students will be notified by notice posted. Keeping in mind the ease of obtaining marks and details which has increased throughout the years. In the web app, after one's first login or registration, each part of the education department, university and institution have a unique token, (user id and password) to the database. Coming to the part of its database, My SQL or Oracle or Mongo DB can be used with a firmed dashboard powered by python or JavaScript on a network frame. Since the app will be containing huge academic details of many students, so a strong encryption algorithm is to be used for data integrity and data security. AES-256 or MD5 would be best to use to protect the data in the database and for authentication Biometric data will also be preserved.

Markov Text Generation Problem Description The Infinite Monkey Theorem1 (IFT) says that if a monkey hits keys at random on a typewriter it will almost surely, given an infinite amount of time, produce a chosen text (like the Declaration of Independence, Hamlet, or a script for ... Planet of the Apes). The probability of this actually happening is, of course, very small but the IFT claims that it is still possible. Some people have tested this hypotheis in software and, after billions and billions of simulated years, one virtual monkey was able to type out a sequence of 19 letters that can be found in Shakespeare’s The Two Gentlemen of Verona. (See the April 9, 2007 edition of The New Yorker if you’re interested; but, hypothesis testing with real monkeys2 is far more entertaining.) The IFT might lead to some interesting conversations with Rust Cohle, but the practical applications are few. It does, however, bring up the idea of automated text generation, and there the ideas and applications are not only interesting but also important. Claude Shannon essentially founded the field of information theory with the publication of his landmark paper A Mathematical Theory of Computation3 in 1948. Shannon described a method for using Markov chains to produce a reasonable imitation of a known text with sometimes startling results. For example, here is a sample of text generated from a Markov model of the script for the 1967 movie Planet of the Apes. "PLANET OF THE APES" Screenplay by Michael Wilson Based on Novel By Pierre Boulle DISSOLVE TO: 138 EXT. GROVE OF FRUIT TREES - ESTABLISHING SHOT - DAY Zira run back to the front of Taylor. The President, I believe the prosecutor's charge of this man. ZIRA Well, whoever owned them was in pretty bad shape. He picks up two of the strain. You got what you wanted, kid. How does it taste? Silence. Taylor and cuffs him. Over this we HEAR from a distance is a crude horse-drawn wagon is silhouetted-against the trunks and branches of great trees and bushes on the horse's rump. Taylor lifts his right arm to ward off the blow, and the room and lands at the feet of Cornelius and Lucius are sorting out equipment falls to his knees, buries his head silently at the Ranch). DISSOLVE TO: 197 INT. CAGES - CLOSE SHOT - FEATURING LANDON - FROM TAYLOR'S VOICE (o.s.) I've got a fine veternary surgeons under my direction? ZIRA Taylor! ZIRA There is a small lake, looking like a politician. TAYLOR Dodge takes a pen and notebook from the half-open door of a guard room. Taylor bursts suddenly confronted by his 1https://en.wikipedia.org/wiki/Infinite_monkey_theorem2https://web.archive.org/web/20130120215600/http://www.vivaria.net/experiments/notes/publication/NOTES_ EN.pdf3http://ieeexplore.ieee.org/xpl/articleDetails.jsp?arnumber=6773024 1 original pursuer (the dismounted cop coming up with a cigar butt and places it in the drawer beside them. TAYLOR What's the best there is a. loud RAP at the doll was found beside the building. Zira waits at the third table. TAYLOR Good question. Is he a man? CORNELIUS (impatiently. DODGE Blessed are the vegetation. These SHOTS are INTERCUT with: 94 WHAT THE ASTRONAUTS They examine the remnants of the cage. ZIRA (plunging on) Their speech organs are adequate. The flaw lies not in anatomy but in the back of his left sleeve. TAYLOR (taking off his shirt. 80 DODGE AND LANDON You don't sound happy in your work. GALEN (defensively) Gorilla hunter stands over a dead man, one fo Besides a few spelling errors and some rather odd things that make you wonder about the author, this passage is surprisingly human-like. This is a simple example of natural language generation, a sub-area of natural language processing—a very active area of research in computer science. The particular approach we’re using in this assignment was famously implemented as the fictitious Mark V. Shaney4 and the Emacs command Disassociated Press5. Approach So, here’s the basic idea: Imagine taking a book (say, Tom Sawyer) and determining the probability with which each character occurs. You would probably find that spaces are the most common, that the character ‘e’ is fairly common, and that the character ‘q’ is rather uncommon. After completing this “level 0” analysis, you would be able to produce random Tom Sawyer text based on character probabilities. It wouldn’t have much in common with the real thing, but at least the characters would tend to occur in the proper propor- tion. In fact, here’s an example of what you might produce: Level 0 rla bsht eS ststofo hhfosdsdewno oe wee h .mr ae irii ela iad o r te u t mnyto onmalysnce, ifu en c fDwn oee iteo Now imagine doing a slightly more sophisticated level 1 analysis by determining the probability with which each character follows every other character. You would probably discover that ‘h’ follows ‘t’ more frequently than ‘x’ does, and you would probably discover that a space follows ‘.’ more frequently than ‘,’ does. You could now produce some randomly generated Tom Sawyer text by picking a character to begin with and then always choosing the next character based on the previous one and the probabilities revealed by the analysis. Here’s an example: Level 1 "Shand tucthiney m?" le ollds mind Theybooure He, he s whit Pereg lenigabo Jodind alllld ashanthe ainofevids tre lin-p asto oun theanthadomoere Now imagine doing a level k analysis by determining the probability with which each character follows every possible sequence of characters of length k (kgrams). A level 5 analysis of Tom Sawyer for example, would reveal that ‘r’ follows “Sawye” more frequently than any other character. After a level k analysis, you would be able to produce random Tom Sawyer by always choosing the next character based on the previous k characters (a kgram) and the probabilities revealed by the analysis. 4https://en.wikipedia.org/wiki/Mark_V._Shaney5https://en.wikipedia.org/wiki/Dissociated_press Page 2 of 5 At only a moderate level of analysis (say, levels 5-7), the randomly generated text begins to take on many of the characteristics of the source text. It probably won’t make complete sense, but you’ll be able to tell that it was derived from Tom Sawyer as opposed to, say, The Sound and the Fury. Here are some more examples of text that is generated from increasing levels of analysis of Tom Sawyer. (These “levels of analysis” are called order K Markov models.) K = 2 "Yess been." for gothin, Tome oso; ing, in to weliss of an’te cle - armit. Papper a comeasione, and smomenty, fropeck hinticer, sid, a was Tom, be suck tied. He sis tred a youck to themen K = 4 en themself, Mr. Welshman, but him awoke, the balmy shore. I’ll give him that he couple overy because in the slated snufflindeed structure’s kind was rath. She said that the wound the door a fever eyes that WITH him. K = 6 people had eaten, leaving. Come - didn’t stand it better judgment; His hands and bury it again, tramped herself! She’d never would be. He found her spite of anything the one was a prime feature sunset, and hit upon that of the forever. K = 8 look-a-here - I told you before, Joe. I’ve heard a pin drop. The stillness was complete, how- ever, this is awful crime, beyond the village was sufficient. He would be a good enough to get that night, Tom and Becky. K = 10 you understanding that they don’t come around in the cave should get the word "beauteous" was over-fondled, and that together" and decided that he might as we used to do - it’s nobby fun. I’ll learn you." To create an order K Markov model of a given source text, you would need to identify all kgrams in the source text and associate with each kgram all the individual characters that follow it. This association or mapping must also capture the frequency with which a given character follows a given kgram. For example, suppose that k = 2 and the sample text is: agggcagcgggcg The Markov model would have to represent all the character strings of length two (2-grams) in the source text, and associate with them the characters that follow them, and in the correct proportion. The following table shows one way of representing this information. kgram Characters that follow ag gc gg gcgc gc agg ca g cg g Once you have created an order K Markov model of a given source text, you can generate new text based on this model as follows. Page 3 of 5 1. Randomly pick k consecutive characters that appear in the sample text and use them as the initial kgram. 2. Append the kgram to the output text being generated. 3. Repeat the following steps until the output text is sufficiently long. (a) Select a character c that appears in the sample text based on the probability of that character following the current kgram. (b) Append this character to the output text. (c) Update the kgram by removing its first character and adding the character just chosen (c) as its last character. If this process encounters a situation in which there are no characters to choose from (which can happen if the only occurrence of the current kgram is at the exact end of the source), simply pick a new kgram at random and continue. As an example, suppose that k = 2 and the sample text is that from above: agggcagcgggcg Here are four different output text strings of length 10 that could have been the result of the process described above, using the first two characters (’ag’) as the initial kgram. agcggcagcg aggcaggcgg agggcaggcg agcggcggca For another example, suppose that k = 2 and the sample text is: the three pirates charted that course the other day Here is how the first three characters of new text might be generated: •A two-character sequence is chosen at random to become the initial kgram. Let’s suppose that “th” is chosen. So, kgram = th and output = th. •The first character must be chosen based on the probability that it follows the kgram (currently “th”) in the source. The source contains five occurrences of “th”. Three times it is followed by ’e’, once it is followed by ’r’, and once it is followed by ’a’. Thus, the next character must be chosen so that there is a 3/5 chance that an ’e’ will be chosen, a 1/5 chance that an ’r’ will be chosen, and a 1/5 chance that an ’a’ will be chosen. Let’s suppose that we choose an ’e’ this time. So, kgram = he and output = the. •The next character must be chosen based on the probability that it follows the kgram (currently “he”) in the source. The source contains three occurrences of “he”. Twice it is followed by a space and once it is followed by ’r’. Thus, the next character must be chosen so that there is a 2/3 chance that a space will be chosen and a 1/3 chance that an ’r’ will be chosen. Let’s suppose that we choose an ’r’ this time. So, kgram = er and output = ther. •The next character must be chosen based on the probability that it follows the kgram (currently “er”) in the source. The source contains only one occurrence of “er”, and it is followed by a space. Thus, the next character must be a space. So, kgram = r_ and output = ther_, where ’_’ represents a blank space. Page 4 of 5 Implementation Details You are provided with two Java files that you must use to develop your solution: MarkovModel.java and TextGenerator.java. The constructors of MarkovModel build the order-k model of the source text. You are required to represent the model with the provided HashMap field. The main method of TextGenerator must process the following three command line arguments (in the args array): •A non-negative integer k •A non-negative integer length. •The name of an input file source that contains more than k characters. Your program must validate the command line arguments by making sure that k and length are non- negative and that source contains at least k characters and can be opened for reading. If any of the command line arguments are invalid, your program must write an informative error message to System.out and terminate. If there are not enough command line arguments, your program must write an informative error message to System.out and terminate. With valid command line arguments, your program must use the methods of the MarkovModel class to create an order k Markov model of the sample text, select the initial kgram, and make each character selection. You must implement the MarkovModel methods according to description of the Markov modeling process in the section above. A few sample texts have been provided, but Project Gutenberg (http://www.gutenberg.org) maintains a large collection of public domain literary works that you can use as source texts for fun and practice. Acknowledgments This assignment is based on the ideas of many people, Jon Bentley and Owen Astrachan in particular.

Mind-X is my intelligent alter ego that understands me the best. It assists with and resolves my bothersome tasks, growing in real-time as a next-generation PersonAI system.

Vanguard Comercio īnC is a trusted authority in the digital currency investment domain. Our platform allows potential investors to build their investment portfolio consisting of cryptocurrencies. Leverage years of experience of our experts and kickstart your crypto investment endeavours with Vanguard Comercio īnC… We tend to successfully implement our vision every day by integrating environmental, social, and economic considerations into all our business decisions, through partnerships with different countries’ governments, as well as their people, and respectfully interact with all the parties, which are interested. To grow through successful exploration and accretive acquisitions of development-stage precious metals properties. Successfully finance and build mines. Generating "dramatic growth" in Vanguard Comercio Īnc Platform which is associated with bitcoin mining company . Our company has clear, confident development prospects due to the use of modern technologies, mining machines, effective management, and consistent implementation. Our company is one of the fastest growing mining and trading companies in the current industry. our goal is to promote the financial status of our clients through our uncompromised…financial automated forex and binary software. This Trading platform is an Award winning forex Automated trader, providing trading services and financial support for both retail and institutional clients through its policy of providing the best trading signals, software and strategies for investors, we offer both professionals and new beginners opportunity to invest and earn from Forex and Binary options trade. But I most explain to you how all this mistaken idea of denouncing pleasure and praising pain was born and i will give you a complete account of the system and expound we continue to recognize that responsible environmental stewardship and social responsibility are integral components of business in today’s world. Instant Withdrawals Withdrawals are processed in no time upon request.. 24/7 Support Our well trained agents are online to assist you Business Benefits Strategy To grow through successful exploration and accretive acquisitions of development-stage Vanguard Comercio ĪnC properties. Successfully finance and build mines. Generating "dramatic growth " in Bitcoin Mining/Investment and cash flow. To invest is Vanguard Comercio īnC sir/ma’am No need to talk much about our company we pay in due time and there’s no hidden fee or charges We have a mining farm where we generate coin Once you Invest with us an ant-miner will be assigned to your mining profile account which helps to generate coin once you make deposit that’s how we earn profits for you.. What is a Bitmain Antiminers and Where Are They Manufactured? To understand how to get started bitcoin mining, you need to know about Antminers.  Bitmain Antminers are mining hardware created by the Chinese company Bitmain. Bitmain was founded by Micree Zhan and Jihan Wu in 2013.  Micree Zhan is a chip design expert, who together with Jihan launched Bitmain with the goal of focusing on mining as a way to make money. The Bitmain team soon became one of the world’s leading Bitcoin miners. Look: Bitmain first created the Antminer in 2013, a product which has helped many companies to dominate the new hyper-competitive mining industry. Presently, Bitmain Antminers are responsible for around 70% of all Bitcoin mining.  Antminers are simply Bitcoin mining hardware. They are considered to be the most powerful mining hardware in the world. There are Antminers for different cryptocurrencies, such as Bitcoin, Litecoin, ZEC, and Etherium.  Antminers do not charge a Bitcoin mining fee for Pay Per Last N Shares (PPLNS). However, they hold on to every transaction fee on the block. How much power do they need? Antminers consume a lot of power, and this consumption is one of the main factors that affect mining ROIs.  Antminer S9 for Mining Bitcoin The latest Antminer is the Bitmain Antminer S9 and uses around 1,375W. With this in mind, it is clear that running the S9 will cost you between 15 and 30 cents every hour.  This figure may be higher or lower based on the electricity costs in your area. The S9 operates without the need for a separate host computer. To operate the S9, you need a power supply specifically the APW5/APW3, that is sold separately.  S9s has an efficacy, power consumption and hashrate of 098 J/GH±7%, 1323W±7%, and 13.5TH/s±7% respectively. At the moment, the Antminer has an output of 14TH/s, making it the most powerful Bitcoin mining hardware on the planet.  So what does this mean? Based on its technical specifications, the S9 will have the capacity to mine 0.03600399 Bitcoin per month. This figure does not factor in the cost of hardware, power, pool fees and others.  If you run the Antminer for a month, expect to get a profit of 0.02138775 Bitcoin, which is equivalent to $178.78. However, this profit depends on the cost of electricity, which in this instance is assumed to be $0.1 per kWh To begin with, me and my team collected all of the important information about Vanguard Comercio inc in one article, and we hope that you will find what you came for. Vanguard Comercio inc appeared on the trading market in 2014. Since then they have continuously created the new and improved the old, so that your trading on the platform is seamless and lucrative. And that’s just the beginning. Vanguard Comercio inc don’t just give traders a chance to earn, but they also teach them how. Broker’s team has world-class analysts. They develop original trading strategies and teach traders how to use them intelligently in open webinars, and they consult one-on-one with traders. Education is conducted in all the languages that our traders speak. Trading platform Broker’s opportunities for successful trading Presently Vanguard Comercio inc has entered the top of existing brokers by achieving traders needs and latest trends. Broker made a big work trying to make platform reliable, simple and unique. Currently millions of traders around the world are using this platform for trading and their number continues to grow. Our company was registered ® United Kingdom 🇬🇧 we are verified by the Great Britain - [x] ® INVESTMENT PLAN AMATEUR PLANS. $50 earns $500 $100 wins $1,000 $200 wins $2,000 $300 earns $3,000 $400 wins $4,000 REGULAR PLANS $500 wins $5,000 $600 wins $6,000 $700 wins $7,000 $800 wins $8,000 $900 wins $9,000 TEACHER PLANS $1,000 wins $10,000 $2,000 wins $20,000 $3,000 wins $30,000 $4,000 wins $40,000 $5,000 earns $50,000 DURATION: 24 HOURS OF COMMERCIAL you receive your profit with your wallet account

Backshop is a blend of Commerce 1.x and 2.x written specifically with Backdrop's target market in mind.

No description available

Real-time "x-ray vision" into LLMs' minds

In this Python repository for everybody, you will learn Python programming basics and advanced concepts from scratch. Bear in mind that all of the codes in this repository are mostly compatible with Python 3.X.

🧠x🤖 Tutorials for the Mind ex Machina cluster

Fast XS implementation of MaxMind DB reader

new MindustryX repo temporary for jitpack