C:\Users\user\AppData\Local\Temp\ccF9IWCB.s: Assembler messages:
C:\Users\user\AppData\Local\Temp\ccF9IWCB.s:343: Error: junk `(%rip)' after expression
C:\Users\user\AppData\Local\Temp\ccF9IWCB.s:343: Error: operand type mismatch for `lea'

-Wall -g -O0

Err http://ports.ubuntu.com xenial-updates/main armhf libpulse0 armhf 1:8.0-0ubuntu3.4
  404  Not Found

Err http://ports.ubuntu.com xenial-updates/main armhf libpulse0 armhf 1:8.0-0ubuntu3.4
  404  Not Found

setup(
    ...
    version = '0.1',
    ...
)

struct Lazy<T> {...}

impl<T> Lazy<T> {
	fn force(&mut self) -> &mut T {...}
}

struct InfLazyList<T> {
	head : T,
	tail : Lazy<InfLazyList<T>>
}

impl<T> InfLazyList<T> {
	fn index(&mut self, i : usize) -> &T {
		if i == 0 {
			&self.head
		} else {
			self.tail.force().index(i - 1)
		}
	}
}

	fn index(&mut self, i : usize) -> &T {
		let mut top : &mut InfLazyList<T> = &mut self;
		while i > 0 {
			top = top.tail.force();
		}
		&top.head
	}

setenv http_proxy user:pass@serverip:port
setenv HTTP_PROXY user:pass@serverip:port
setenv ftp_proxy user:pass@serverip:port
setenv FTP_PROXY user:pass@serverip:port

FETCH_ENV=http_proxy=user:pass@serverip:port
FETCH_ENV=HTTP_PROXY=user:pass@serverip:port
FETCH_ENV=ftp_proxy=user:pass@serverip:port
FETCH_ENV=FTP_PROXY=user:pass@serverip:port

ping distcache.FreeBSD.org
все ок
ping http://distcache.FreeBSD.org
cannot resolve unknown host

"nouveau.modeset=0 tpm_tis.interrupts=0 acpi_osi=! acpi_backlight=native i915.preliminary_hw_support=1 idle=nomwait".

set nouveau.modeset=0
set tpm_tis.interrupts=0
.....

#include <iostream>
#include <string>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <signal.h>
#include <thread>
#include <mutex>
#include <set>
#include <chrono>

using namespace std;

class server_exception : public exception {
public:
	string message;
	server_exception(string m) : message(m) {}
};


#define BUF_LEN 1024
#define WITH_MUTEX(mutex, action) {mutex.lock(); action; mutex.unlock();};

bool global_stop_signal = false;

class server {

private:

	bool opened = false;
	set<thread::id> client_threads;
	mutex client_mutex;
	int listener = -1;

	void client(int socket) {
		WITH_MUTEX(client_mutex, client_threads.insert(this_thread::get_id()));
		char buf[BUF_LEN];
		int bytes_readed;
		string message;
		do {
			bytes_readed = recv(socket, (void*)buf, BUF_LEN, 0);
			int signal_on = -1;
			for(int i=0; i<bytes_readed; ++i) {
				if(buf[i] == '\n') {
					signal_on = i;
					break;
				}
			}
			if(signal_on == -1)
				message += buf;
			else {
				if(signal_on != 0 && buf[signal_on - 1] == 13)
					signal_on--;
				for(int i=0; i<signal_on; ++i)
					message += buf[i];
				bytes_readed = 0;
			}
		} while (bytes_readed > 0);
		cout << "message received: \"" << message << "\"" << endl;
		sprintf(buf, "received %d len message\n", static_cast<int>(message.size()));
		send(socket, buf, strlen(buf), 0);
		close(socket);
		WITH_MUTEX(client_mutex, client_threads.erase(this_thread::get_id()));
	}

public:

	void run(unsigned short port) {
		opened = true;
		listener = socket(AF_INET, SOCK_STREAM, 0);
		if(listener < 0) {
			throw server_exception("listener not open");
		}
		sockaddr_in addr;
		bzero((char*)&addr, sizeof(addr));
		addr.sin_family = AF_INET;
		addr.sin_addr.s_addr = INADDR_ANY;
		addr.sin_port = htons(port);
		cout << "connect on " << INADDR_ANY << " " << port << endl;
		if(bind(listener, (sockaddr*) &addr, sizeof(addr)) < 0) {
			throw server_exception("bind error");
		}
		// now on port
		listen(listener, 10);
		for(;;) {
			if(global_stop_signal) {
				return;
			}
			// use accept4(listener, NULL, NULL, SOCK_NONBLOCK)
			int socket = accept(listener, NULL, NULL);
			if(socket < 0) {
				throw server_exception("accept error");
			} else {	
				thread client_thread(&server::client, this, socket);
				client_thread.detach();
			}
		}
	}
	~server() {
		if(opened)
			stop();
	}
	void stop() {
		if(!opened)
			return;
		opened = false;
		cerr << "close call" << endl;
		while(client_threads.size() > 0)
			this_thread::sleep_for(chrono::milliseconds(100));
		if(listener >= 0)
			close(listener);
	}
};

void ctrl_c_event(int _) {
	global_stop_signal = true;
}

int main() {

	struct sigaction handler;

	handler.sa_handler = ctrl_c_event;
	sigemptyset(&handler.sa_mask);
	handler.sa_flags = 0;

	sigaction(SIGINT, &handler, NULL);

	server serv;
	try {
		serv.run(8080);
	} catch (server_exception exc) {
		cout << "exception: " << exc.message << endl;
	}
	serv.stop();

	return 0;
}

extern crate image;

use std::thread;
use std::sync::{Mutex, Arc};
use std::time;
use image::*;
use std::env;

fn calculate_point(x : f64, y : f64, depth : usize) -> f32 {
    let mut zx = 0.0;
    let mut zy = 0.0;
    let mut zx1;
    let mut zy1;
    for i in 0 .. depth {
        zx1 = (zx * zx) - (zy * zy) + x;
        zy1 = zx * zy * 2.0 + y;
        if zx1 * zx1 + zy1 * zy1 > 4.0 {
            return (i as f32) / (depth as f32);
        }
        else {
            zx = zx1;
            zy = zy1;
        }
    }
    return 1.0;//depth as f32;
}

fn get_color(colors : &Vec<[f32;3]>, buffer : &mut Vec<[f32;3]>, x : f32) -> Rgb<u8> {
    let mut len = colors.len() - 1;
    for i in 0 .. len {
        for j in 0 .. 3 {
            buffer[i][j] = colors[i][j] + (colors[i+1][j] - colors[i][j]) * x
        }
    }
    while len > 1 {
        for i in 0 .. len - 1 {
            for j in 0 .. 3 {
                buffer[i][j] = buffer[i][j] + (buffer[i+1][j] - buffer[i][j]) * x
            }
        }
        len -= 1;
    }
    return Rgb([buffer[0][0] as u8, buffer[0][1] as u8, buffer[0][2] as u8]);
}

fn make_pic_1th(width : u32, height : u32) -> RgbImage {
    let mut pic = ImageBuffer::new(width, height);
    let colors : Vec<[f32;3]> = vec![[0.0,0.0,0.0], [255.0,0.0,0.0], [255.0,255.0,0.0], [255.0,255.0,255.0]];
    let mut buffer = colors.clone();
    for i in 0 .. width {
        let x = (i as f64) / (width as f64) * 2.0 - 1.0;
        for j in 0 .. height {
            let y = (j as f64) / (height as f64) * 2.0 - 1.0;
            (*pic.get_pixel_mut(i,j)) = get_color(&colors, &mut buffer, calculate_point(x, y, 1000));
        }
    }
    pic
}

unsafe fn calc_rows(index : u32, step : u32, width : u32, height : u32, pic : SendPtr<RgbImage>, live_flag : Arc<Mutex<bool>>) {
    let colors : Vec<[f32;3]> = vec![[0.0,0.0,0.0], [255.0,0.0,0.0], [255.0,255.0,0.0], [255.0,255.0,255.0]];
    let mut buffer = colors.clone();
    let pic       : *mut RgbImage = match pic {SendPtr(a) => a};
    for i in 0 .. width {
        let x = (i as f64) / (width as f64) * 2.0 - 1.0;
        let mut j = index;
        while j < height {
            let y = (j as f64) / (height as f64) * 2.0 - 1.0;
            (*(*pic).get_pixel_mut(i,j)) = get_color(&colors, &mut buffer, calculate_point(x, y, 1000));
            j += step;
        }
    }
    (*live_flag.lock().unwrap()) = false;
}

struct SendPtr<A>(*mut A);
unsafe impl<A> Send for SendPtr<A> {}
unsafe impl<A> Sync for SendPtr<A> {}

fn make_pic_3th(width : u32, height : u32) -> RgbImage {
    let mut pic = ImageBuffer::new(width, height);
    let f1 = Arc::new(Mutex::new(true));
    let f2 = Arc::new(Mutex::new(true));
    let f3 = Arc::new(Mutex::new(true));
    unsafe {
        macro_rules! spawn {($i:expr,$m:expr,$flag:expr) => {
            let ppic  = SendPtr(&mut pic);
            let pflag = $flag.clone();
            thread::spawn(move|| {calc_rows($i, $m, width, height, ppic, pflag)});
        }};
        spawn!(0, 3, f1);
        spawn!(1, 3, f2);
        spawn!(2, 3, f3);
    }
    let dur = time::Duration::from_millis(50);
    loop {
        let a : bool = *f1.lock().unwrap();
        let b : bool = *f2.lock().unwrap();
        let c : bool = *f2.lock().unwrap();
        if a || b || c {
            thread::sleep(dur)
        } else {
            break
        }
    }
    pic
}

fn main() {
    let args : Vec<String> = env::args().collect();
    let pic = if args[1] == "1" {make_pic_1th(1000,1000)} else {make_pic_3th(1000, 1000)};
    match pic.save("out.png") {
        Ok(_) => (),
        Err(e) => {
            println!("error: {:?}", e)
        }
    }
}